Fix nuxt tests

Author: simolus3

packages/common/src/utils/Logger.ts

@@ -76,7 +76,9 @@ export function createPowerSyncLogger(options?: Partial<CreateLoggerOptions>): P
       if (level < this.minLevel) return;
 
       let emitter = console.log;
-      if (level >= LogLevels.error) {
+      if (level >= LogLevels.info) {
+        emitter = console.info;
+      } else if (level >= LogLevels.error) {
         emitter = console.error;
       } else if (level >= LogLevels.warn) {
         emitter = console.warn;

packages/nuxt/src/runtime/composables/useDiagnosticsLogger.ts

@@ -42,7 +42,8 @@ export const useDiagnosticsLogger = (additional?: PowerSyncLogger) => {
         date: new Date(),
         tag: record.tag,
         message: record.message,
-        error: record.error
+        error: record.error,
+        level: nameOfLogLevel(record.level)
       };
       const key = `log:${logObject.date.toISOString()}`;
       await logsStorage.set(key, logObject);
@@ -55,3 +56,19 @@ export const useDiagnosticsLogger = (additional?: PowerSyncLogger) => {
 
   return { logger, logsStorage, emitter };
 };
+
+const levelNames: [string, number][] = [
+  ['ERROR', LogLevels.error],
+  ['WARNING', LogLevels.warn],
+  ['INFO', LogLevels.info],
+  ['DEBUG', LogLevels.debug],
+  ['TRACE', LogLevels.trace]
+];
+
+function nameOfLogLevel(level: number): string | undefined {
+  for (const [name, minLevel] of levelNames) {
+    if (level >= minLevel) return name;
+  }
+
+  return undefined;
+}

packages/nuxt/tests/composables/NuxtPowerSyncDatabase.test.ts

@@ -19,49 +19,49 @@ describe('NuxtPowerSyncDatabase', () => {
   it('should use default sync implementation when diagnostics is disabled', async () => {
     const db = openPowerSync(false);
     const connector = createMockConnector();
-    
+
     // Spy on the parent class method to verify it's called
     const superGenerateSpy = vi.spyOn(
       Object.getPrototypeOf(Object.getPrototypeOf(db)),
       'generateSyncStreamImplementation'
     );
-    
+
     await db.init();
     await db.connect(connector);
-    
+
     // When diagnostics is disabled, should call super.generateSyncStreamImplementation
     // We can't directly test this, but we can verify the sync implementation exists
     expect(db.syncStreamImplementation).toBeDefined();
-    
+
     await db.disconnect();
   });
 
   it('should use diagnostics sync implementation when diagnostics is enabled', async () => {
     setUseDiagnostics(true);
     const db = openPowerSync(true);
     const connector = createMockConnector();
-    
+
     await db.init();
     await db.connect(connector);
-    
+
     // When diagnostics is enabled, should use SharedWebStreamingSyncImplementation
     // (because enableMultiTabs is set to true)
     const syncImpl = db.syncStreamImplementation;
     expect(syncImpl).toBeDefined();
     expect(syncImpl).toBeInstanceOf(SharedWebStreamingSyncImplementation);
-    
+
     await db.disconnect();
   });
 
   it('should extend schema with diagnostics tables when diagnostics is enabled', () => {
     setUseDiagnostics(true);
     const db = openPowerSync(true);
-    
+
     // Verify that diagnostics schema tables are included
     // The schema should include both the app schema and diagnostics schema
     const schema = db.dbOptions.schema;
     expect(schema).toBeDefined();
-    
+
     // Check that diagnostics tables are present
     const tableNames = schema.tables.map((t: any) => t.name);
     // Diagnostics schema includes local_bucket_data and local_schema
@@ -74,7 +74,7 @@ describe('NuxtPowerSyncDatabase', () => {
   it('should set enableMultiTabs and broadcastLogs flags when diagnostics is enabled', () => {
     setUseDiagnostics(true);
     const db = openPowerSync(true);
-    
+
     // Verify flags are set
     const flags = db.dbOptions.flags;
     expect(flags?.enableMultiTabs).toBe(true);
@@ -84,28 +84,26 @@ describe('NuxtPowerSyncDatabase', () => {
   it('should use diagnostics logger when diagnostics is enabled', () => {
     setUseDiagnostics(true);
     const db = openPowerSync(true);
-    
+
     // Verify logger is set (it should be the diagnostics logger, not default)
     const logger = db.dbOptions.logger;
     expect(logger).toBeDefined();
-    // The diagnostics logger should have DEBUG level
-    expect(logger?.getLevel()).toBeDefined();
   });
 
   it('should store connector and connectionOptions internally', async () => {
     const db = openPowerSync(false);
     const connector = createMockConnector();
     const connectionOptions = { clientImplementation: undefined };
-    
+
     await db.init();
     await db.connect(connector, connectionOptions);
-    
+
     // Verify connector is stored
     expect(db.connector).toBe(connector);
     expect(db.connectionOptions).toBe(connectionOptions);
-    
+
     await db.disconnect();
-    
+
     // After disconnect, should be cleared
     expect(db.connector).toBeNull();
     expect(db.connectionOptions).toBeNull();
@@ -115,29 +113,29 @@ describe('NuxtPowerSyncDatabase', () => {
     setUseDiagnostics(true);
     const db = openPowerSync(true);
     const connector = createMockConnector();
-    
+
     await db.init();
     await db.connect(connector);
-    
+
     // When diagnostics is enabled, enableMultiTabs is set to true,
     // so it should use SharedWebStreamingSyncImplementation
     const syncImpl = db.syncStreamImplementation;
     expect(syncImpl).toBeInstanceOf(SharedWebStreamingSyncImplementation);
-    
+
     await db.disconnect();
   });
 
   it('should clear connector and connectionOptions on disconnectAndClear', async () => {
     const db = openPowerSync(false);
     const connector = createMockConnector();
-    
+
     await db.init();
     await db.connect(connector);
-    
+
     expect(db.connector).toBe(connector);
-    
+
     await db.disconnectAndClear();
-    
+
     expect(db.connector).toBeNull();
     expect(db.connectionOptions).toBeNull();
   });

packages/nuxt/tests/composables/useDiagnosticsLogger.test.ts

@@ -1,7 +1,7 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach, vi, type Mock } from 'vitest';
 import { useDiagnosticsLogger } from '../../src/runtime/composables/useDiagnosticsLogger';
-import { LogLevel, type ILogHandler } from '@powersync/web';
 import { withSetup } from '../utils';
+import { LogLevels, type LogRecord, type PowerSyncLogger } from '@powersync/common';
 
 describe('useDiagnosticsLogger', () => {
   beforeEach(() => {
@@ -17,8 +17,7 @@ describe('useDiagnosticsLogger', () => {
     const [{ logger, logsStorage }] = withSetup(() => useDiagnosticsLogger());
 
     const testMessage = 'Test log message for storage';
-    const extraPayload = { name: 'TestContext', level: { name: 'INFO' } };
-    await logger.log(testMessage, extraPayload as any);
+    await logger.log({ level: LogLevels.info, message: testMessage, tag: 'TestContext' });
 
     // Wait for async storage operations
     await new Promise((resolve) => setTimeout(resolve, 150));
@@ -30,87 +29,64 @@ describe('useDiagnosticsLogger', () => {
     expect(logKeys.length).toBeGreaterThan(0);
 
     // Find the log that contains our message (key order may vary)
-    let storedLog: { args?: unknown[] } | null = null;
+    let storedLog: { message: string } | null = null;
     for (const key of logKeys) {
-      const log = (await logsStorage.getItem(key)) as { args?: unknown[] } | null;
-      const args = log?.args;
-      if (args?.some((arg) => typeof arg === 'string' && arg.includes(testMessage))) {
+      const log = (await logsStorage.getItem(key)) as { message: string };
+      if (log.message.indexOf(testMessage) >= 0) {
         storedLog = log;
         break;
       }
     }
 
-    expect(storedLog).toBeDefined();
-    expect(storedLog).toHaveProperty('args');
-    expect(Array.isArray(storedLog?.args)).toBe(true);
-    const logArgs = storedLog?.args as any[];
-    expect(logArgs[0]).toBe(testMessage);
-    // args[1] is stored as-is (object, not "[object Object]")
-    expect(logArgs[1]).toBeDefined();
-    expect(logArgs[1]).toHaveProperty('name', 'TestContext');
-    expect(logArgs[2]).toBeDefined();
-    expect(logArgs[2]).toHaveProperty('level');
+    expect(storedLog).toMatchObject({
+      tag: 'TestContext',
+      level: 'INFO',
+      message: testMessage
+    });
   });
 
   it('should emit log events with correct payload structure', async () => {
     const logEvents: any[] = [];
     const [{ logger, emitter }] = withSetup(() => useDiagnosticsLogger());
-    
+
     // Listen for log events
     emitter.on('log', (event) => {
       logEvents.push(event);
     });
-    
+
     const testMessage = 'Test event message';
-    await logger.log(testMessage, { 
-      name: 'TestContext', 
-      level: { name: 'WARN' } 
+    await logger.log({
+      message: testMessage,
+      tag: 'TestContext',
+      level: LogLevels.warn
     } as any);
-    
+
     // Wait for async operations
-    await new Promise(resolve => setTimeout(resolve, 150));
-    
+    await new Promise((resolve) => setTimeout(resolve, 150));
+
     // Verify event was emitted with correct structure
     expect(logEvents.length).toBeGreaterThan(0);
     const event = logEvents[0];
-    expect(event).toHaveProperty('key');
-    expect(event).toHaveProperty('value');
-    expect(typeof event.key).toBe('string');
-    expect(event.key).toMatch(/^log:/);
-    expect(event.value).toBeDefined();
-    expect(event.value).toHaveProperty('args');
+    expect(event.value).toMatchObject({
+      tag: 'TestContext',
+      message: testMessage,
+      level: 'WARNING'
+    });
   });
 
   it('should call custom handler with correct messages and context', async () => {
-    const customHandler = vi.fn<ILogHandler>();
-    const [{ logger }] = withSetup(() => useDiagnosticsLogger(customHandler));
+    const log = vi.fn((_record: LogRecord) => {});
+    const [{ logger }] = withSetup(() => useDiagnosticsLogger({ log }));
 
-    const testMessages = ['Message 1', 'Message 2'];
-    const testContext = { name: 'TestContext', level: { name: 'ERROR' } } as any;
-
-    await logger.log(testMessages, testContext);
+    await logger.log({ level: LogLevels.warn, message: 'Message 1', tag: 'TestContext' });
 
     // Wait for async handler
     await new Promise((resolve) => setTimeout(resolve, 150));
 
-    expect(customHandler).toHaveBeenCalledTimes(1);
-    const [messages, context] = customHandler.mock.calls[0];
-
-    const messagesArray = Array.from(messages);
-    expect(messagesArray.length).toBeGreaterThan(0);
-    // First argument to log() is what we passed (array or string)
-    const firstArg = messagesArray[0];
-    const hasMessage1 =
-      (Array.isArray(firstArg) && firstArg.includes('Message 1')) ||
-      (typeof firstArg === 'string' && firstArg.includes('Message 1'));
-    expect(hasMessage1).toBe(true);
-    // When two args passed to log(), second is in messages (js-logger passes all log args)
-    if (messagesArray.length > 1 && typeof messagesArray[1] === 'object' && messagesArray[1]?.name) {
-      expect(messagesArray[1].name).toBe('TestContext');
-      expect(messagesArray[1].level?.name).toBe('ERROR');
-    }
-    expect(context).toBeDefined();
-    expect(context.level?.name).toBeDefined();
+    expect(log).toHaveBeenCalledTimes(1);
+    const [record] = log.mock.calls[0];
+
+    expect(record).toStrictEqual({ level: LogLevels.warn, message: 'Message 1', tag: 'TestContext' });
   });
 
   it('should format messages with PowerSync prefix to console', async () => {
@@ -120,46 +96,15 @@ describe('useDiagnosticsLogger', () => {
     const [{ logger }] = withSetup(() => useDiagnosticsLogger());
 
     const testMessage = 'Test formatted message';
-    await logger.log([testMessage, 'Extra data'], {
-      name: 'PowerSyncTest',
-      level: { name: 'INFO' }
-    } as any);
+    await logger.log({ message: testMessage, level: LogLevels.info, tag: 'tag' });
 
     await new Promise((resolve) => setTimeout(resolve, 150));
 
     expect(consoleSpy).toHaveBeenCalled();
-    const hasPowerSyncPrefix = consoleSpy.mock.calls.some((call) => {
-      const firstArg = call[0];
-      return typeof firstArg === 'string' && firstArg.includes('[PowerSync]');
-    });
-    expect(hasPowerSyncPrefix).toBe(true);
+    expect(consoleSpy.mock.calls.map((call) => call[0])).toEqual(
+      expect.arrayContaining([expect.stringContaining('[PowerSync.tag]')])
+    );
 
     consoleSpy.mockRestore();
   });
-
-  it('should store object as extra arg (not "[object Object]")', async () => {
-    const [{ logger, logsStorage }] = withSetup(() => useDiagnosticsLogger());
-
-    const payload = { userId: 'u1', synced: true };
-    await logger.log('User is logged in', payload);
-
-    await new Promise((resolve) => setTimeout(resolve, 150));
-
-    const allKeys = await logsStorage.getKeys();
-    const logKeys = allKeys.filter((key: string) => key.startsWith('log:'));
-    expect(logKeys.length).toBeGreaterThan(0);
-
-    const storedLog = (await logsStorage.getItem(logKeys[0])) as { args?: unknown[] } | null;
-    const args = storedLog?.args;
-    expect(args).toBeDefined();
-    expect(args?.length).toBeGreaterThanOrEqual(2);
-    expect(args?.[1]).toEqual(payload);
-    expect(args?.[1]).not.toBe('[object Object]');
-  });
-
-  it('should configure logger with DEBUG level', () => {
-    const [{ logger }] = withSetup(() => useDiagnosticsLogger());
-
-    expect(logger.getLevel()).toBe(LogLevel.DEBUG);
-  });
 });