@powersync/service-core 1.16.3 → 1.18.0

package/test/src/module-loader.test.ts

@@ -0,0 +1,102 @@
+import { AbstractModule, loadModules, ServiceContextContainer, TearDownOptions } from '@/index.js';
+import { describe, expect, it, vi } from 'vitest';
+
+interface MockConfig {
+  connections?: { type: string }[];
+  storage: { type: string };
+}
+
+class MockMySQLModule extends AbstractModule {
+  constructor() {
+    super({ name: 'MySQLModule' });
+  }
+  async initialize(context: ServiceContextContainer): Promise<void> {}
+  async teardown(options: TearDownOptions): Promise<void> {}
+}
+class MockPostgresModule extends AbstractModule {
+  constructor() {
+    super({ name: 'PostgresModule' });
+  }
+  async initialize(context: ServiceContextContainer): Promise<void> {}
+  async teardown(options: TearDownOptions): Promise<void> {}
+}
+class MockPostgresStorageModule extends AbstractModule {
+  constructor() {
+    super({ name: 'PostgresStorageModule' });
+  }
+  async initialize(context: ServiceContextContainer): Promise<void> {}
+  async teardown(options: TearDownOptions): Promise<void> {}
+}
+const mockLoaders = {
+  connection: {
+    mysql: async () => {
+      return new MockMySQLModule();
+    },
+    postgresql: async () => {
+      return new MockPostgresModule();
+    }
+  },
+  storage: {
+    postgresql: async () => {
+      return new MockPostgresStorageModule();
+    }
+  }
+};
+
+describe('module loader', () => {
+  it('should load all modules defined in connections and storage', async () => {
+    const config: MockConfig = {
+      connections: [{ type: 'mysql' }, { type: 'postgresql' }],
+      storage: { type: 'postgresql' }
+    };
+
+    const modules = await loadModules(config as any, mockLoaders);
+
+    expect(modules.length).toBe(3);
+    expect(modules[0]).toBeInstanceOf(MockMySQLModule);
+    expect(modules[1]).toBeInstanceOf(MockPostgresModule);
+    expect(modules[2]).toBeInstanceOf(MockPostgresStorageModule);
+  });
+
+  it('should handle duplicate connection types (e.g., mysql used twice)', async () => {
+    const config: MockConfig = {
+      connections: [{ type: 'mysql' }, { type: 'postgresql' }, { type: 'mysql' }], // mysql duplicated
+      storage: { type: 'postgresql' }
+    };
+
+    const modules = await loadModules(config as any, mockLoaders);
+
+    // Expect 3 modules: mysql, postgresql, postgresql-storage
+    expect(modules.length).toBe(3);
+    expect(modules.filter((m) => m instanceof MockMySQLModule).length).toBe(1);
+    expect(modules.filter((m) => m instanceof MockPostgresModule).length).toBe(1);
+    expect(modules.filter((m) => m instanceof MockPostgresStorageModule).length).toBe(1);
+  });
+
+  it('should throw an error if any modules are not found in ModuleMap', async () => {
+    const config: MockConfig = {
+      connections: [{ type: 'mysql' }, { type: 'redis' }],
+      storage: { type: 'postgresql' }
+    };
+
+    await expect(loadModules(config as any, mockLoaders)).rejects.toThrowError();
+  });
+
+  it('should throw an error if one dynamic connection module import fails', async () => {
+    const config: MockConfig = {
+      connections: [{ type: 'mysql' }],
+      storage: { type: 'postgresql' }
+    };
+
+    const loaders = {
+      connection: {
+        mysql: async () => {
+          throw new Error('Failed to load MySQL module');
+        }
+      },
+      storage: mockLoaders.storage
+    };
+
+    await expect(loadModules(config as any, loaders)).rejects.toThrowError('Failed to load MySQL module');
+  });
+});

package/test/src/routes/stream.test.ts

@@ -1,10 +1,12 @@
 import { BasicRouterRequest, Context, SyncRulesBucketStorage } from '@/index.js';
-import { logger, RouterResponse, ServiceError } from '@powersync/lib-services-framework';
+import { RouterResponse, ServiceError, logger } from '@powersync/lib-services-framework';
 import { SqlSyncRules } from '@powersync/service-sync-rules';
 import { Readable, Writable } from 'stream';
 import { pipeline } from 'stream/promises';
 import { describe, expect, it } from 'vitest';
+import winston from 'winston';
 import { syncStreamed } from '../../../src/routes/endpoints/sync-stream.js';
+import { DEFAULT_PARAM_LOGGING_FORMAT_OPTIONS, limitParamsForLogging } from '../../../src/util/param-logging.js';
 import { mockServiceContext } from './mocks.js';
 
 describe('Stream Route', () => {
@@ -77,6 +79,97 @@ describe('Stream Route', () => {
       const r = await drainWithTimeout(stream).catch((error) => error);
       expect(r.message).toContain('Simulated storage error');
     });
+
+    it('logs the application metadata', async () => {
+      const storage = {
+        getParsedSyncRules() {
+          return new SqlSyncRules('bucket_definitions: {}');
+        },
+        watchCheckpointChanges: async function* (options) {
+          throw new Error('Simulated storage error');
+        }
+      } as Partial<SyncRulesBucketStorage>;
+      const serviceContext = mockServiceContext(storage);
+
+      // Create a custom format to capture log info objects (which include defaultMeta)
+      const capturedLogs: any[] = [];
+      const captureFormat = winston.format((info) => {
+        // Capture the info object which includes defaultMeta merged in
+        capturedLogs.push({ ...info });
+        return info;
+      });
+
+      // Create a test logger with the capture format
+      const testLogger = winston.createLogger({
+        format: winston.format.combine(captureFormat(), winston.format.json()),
+        transports: [new winston.transports.Console()]
+      });
+
+      const context: Context = {
+        logger: testLogger,
+        service_context: serviceContext,
+        token_payload: {
+          exp: new Date().getTime() / 1000 + 10000,
+          iat: new Date().getTime() / 1000 - 10000,
+          sub: 'test-user'
+        }
+      };
+
+      const request: BasicRouterRequest = {
+        headers: {
+          'accept-encoding': 'gzip'
+        },
+        hostname: '',
+        protocol: 'http'
+      };
+
+      const inputMeta = {
+        test: 'test',
+        long_meta: 'a'.repeat(1000)
+      };
+
+      const response = await (syncStreamed.handler({
+        context,
+        params: {
+          app_metadata: inputMeta,
+          parameters: {
+            user_name: 'bob',
+            nested_object: {
+              nested_key: 'b'.repeat(1000)
+            }
+          }
+        },
+        request
+      }) as Promise<RouterResponse>);
+      expect(response.status).toEqual(200);
+      const stream = response.data as Readable;
+      const r = await drainWithTimeout(stream).catch((error) => error);
+      expect(r.message).toContain('Simulated storage error');
+
+      // Find the "Sync stream started" log entry
+      const syncStartedLog = capturedLogs.find((log) => log.message === 'Sync stream started');
+      expect(syncStartedLog).toBeDefined();
+
+      // Verify that app_metadata from defaultMeta is present in the log
+      expect(syncStartedLog?.app_metadata).toBeDefined();
+      expect(syncStartedLog?.app_metadata).toEqual(limitParamsForLogging(inputMeta));
+      // Should trim long metadata
+      expect(syncStartedLog?.app_metadata.long_meta.length).toEqual(
+        DEFAULT_PARAM_LOGGING_FORMAT_OPTIONS.maxStringLength
+      );
+
+      // Verify the explicit log parameters
+      expect(syncStartedLog?.client_params).toEqual(
+        expect.objectContaining({
+          user_name: 'bob'
+        })
+      );
+
+      expect(typeof syncStartedLog?.client_params.nested_object).toEqual('string');
+      expect(syncStartedLog?.client_params.nested_object.length).toEqual(
+        DEFAULT_PARAM_LOGGING_FORMAT_OPTIONS.maxStringLength
+      );
+    });
   });
 });