@powersync/service-core 1.27.0 → 1.27.1

package/test/src/routes/admin.test.ts

@@ -1,8 +1,9 @@
 import { BasicRouterRequest, Context, JwtPayload, ParsedSyncConfigSet, storage } from '@/index.js';
-import { logger } from '@powersync/lib-services-framework';
-import { SqlSyncRules } from '@powersync/service-sync-rules';
+import { ErrorCode, logger } from '@powersync/lib-services-framework';
+import { PrecompiledSyncConfig, SqlSyncRules } from '@powersync/service-sync-rules';
 import { describe, expect, it, vi } from 'vitest';
 import { diagnostics, reprocess, validate } from '../../../src/routes/endpoints/admin.js';
+import { deploySyncRules, reprocessSyncRules, validateSyncRules } from '../../../src/routes/endpoints/sync-rules.js';
 import { mockServiceContext } from './mocks.js';
 
 describe('admin routes', () => {
@@ -86,7 +87,136 @@ bucket_definitions:
     return content as unknown as storage.PersistedSyncConfigContent;
   }
 
+  it.each([false, true])(
+    'continues sync-config diagnostics after capability failure (table failure: %s)',
+    async (tableFailure) => {
+      const context = makeContext();
+      const api = context.service_context.routerEngine.getAPI();
+      vi.spyOn(context.service_context.routerEngine, 'getAPI').mockReturnValue(api);
+      api.validateSourceCapabilities = async () => {
+        throw new Error('Unsupported capability');
+      };
+      const tables = vi.spyOn(api, 'getDebugTablesInfo').mockImplementation(async () => {
+        if (tableFailure) throw new Error('Table inspection failed');
+        return [{ schema: 'public', pattern: 'items', wildcard: false, tables: [] }];
+      });
+      const response = await validateSyncRules.handler({
+        context,
+        request,
+        params: {
+          content: /* yaml */ `
+            # sync config fixture.
+            config:
+              edition: 3
+            streams:
+              items:
+                query: SELECT * FROM items
+          `
+        }
+      });
+      const body = JSON.parse(response.data);
+      expect(body.valid).toBe(false);
+      expect(body.errors).toEqual(
+        tableFailure ? ['Unsupported capability', 'Table inspection failed'] : ['Unsupported capability']
+      );
+      expect(tables).toHaveBeenCalledOnce();
+      expect(body.source_tables).toHaveLength(tableFailure ? 0 : 1);
+      expect(body.data_tables).toBeDefined();
+    }
+  );
+
+  it('keeps advisory capability diagnostics visible without invalidating the config', async () => {
+    const context = makeContext();
+    const api = context.service_context.routerEngine.getAPI();
+    vi.spyOn(context.service_context.routerEngine, 'getAPI').mockReturnValue(api);
+    api.validateSourceCapabilities = async () => [{ level: 'warning', message: 'Source advisory' }];
+    const response = await validateSyncRules.handler({
+      context,
+      request,
+      params: {
+        content: /* yaml */ `
+          # sync config fixture.
+          config:
+            edition: 3
+          streams:
+            items:
+              query: SELECT * FROM items
+        `
+      }
+    });
+    expect(JSON.parse(response.data)).toMatchObject({ valid: true, warnings: ['Source advisory'] });
+  });
+
+  it.each([true, false])('deployment checks source capabilities before persistence (allowed: %s)', async (allowed) => {
+    const updateSyncRules = vi.fn(async () => ({ replicationStreamName: 'new-slot' }));
+    const context = makeContext({ updateSyncRules });
+    context.service_context.configuration = {
+      sync_rules: { present: false }
+    } as typeof context.service_context.configuration;
+    const api = context.service_context.routerEngine.getAPI();
+    vi.spyOn(context.service_context.routerEngine, 'getAPI').mockReturnValue(api);
+    api.validateSourceCapabilities = async (config) => {
+      expect((config as PrecompiledSyncConfig).plan.sourceTableConfig?.orders?.mongodb_filter_expression).toEqual({
+        $eq: ['$$doc.active', true]
+      });
+      return allowed
+        ? [{ level: 'warning', message: 'Advisory source warning' }]
+        : [{ level: 'fatal', message: 'MongoDB pre-filtering is not available for this connection.' }];
+    };
+    const result = deploySyncRules.handler({
+      context,
+      request,
+      params: {
+        content: /* yaml */ `
+          # sync config fixture.
+          config:
+            edition: 3
+            source_table_options:
+              orders:
+                mongodb_filter_expression: { $eq: ['$$doc.active', true] }
+          streams:
+            orders:
+              query: SELECT * FROM orders
+        `
+      }
+    });
+    if (allowed) {
+      await expect(result).resolves.toEqual({ slot_name: 'new-slot' });
+      expect(updateSyncRules).toHaveBeenCalledOnce();
+    } else {
+      await expect(result).rejects.toThrow();
+      expect(updateSyncRules).not.toHaveBeenCalled();
+    }
+  });
+
   describe('validate', () => {
+    it('uses the service parser and includes its diagnostics', async () => {
+      const context = makeContext();
+      const api = context.service_context.routerEngine.getAPI();
+      vi.spyOn(context.service_context.routerEngine, 'getAPI').mockReturnValue(api);
+      api.validateSourceCapabilities = async () => {
+        throw new Error('Rejected by module validation.');
+      };
+      const response = await validate.handler({
+        context,
+        request,
+        params: {
+          sync_rules: /* yaml */ `
+            # sync config fixture.
+            config:
+              edition: 3
+            streams: {}
+          `
+        }
+      });
+      expect(response.errors).toContainEqual(
+        expect.objectContaining({
+          level: 'fatal',
+          message: 'Rejected by module validation.'
+        })
+      );
+    });
+
     it('reports errors with source location', async () => {
       const context = makeContext();
 
@@ -103,13 +233,59 @@ bucket_definitions:
         request
       });
 
-      expect(response.errors).toEqual([
+      expect(response.errors).toContainEqual(
         expect.objectContaining({
           level: 'warning',
           location: { start_offset: 70, end_offset: 83 },
           message: 'Table public.missing_table not found'
         })
-      ]);
+      );
+    });
+
+    it('warns that bucket_definitions are deprecated', async () => {
+      const context = makeContext();
+
+      const response = await validate.handler({
+        context,
+        params: {
+          sync_rules: `
+bucket_definitions:
+  mybucket:
+    data:
+      - SELECT * FROM missing_table
+`
+        },
+        request
+      });
+
+      expect(response.errors).toContainEqual(
+        expect.objectContaining({
+          level: 'warning',
+          message: expect.stringContaining('Sync Rules (`bucket_definitions`) are deprecated')
+        })
+      );
+    });
+
+    it('does not report the deprecation warning for a Sync Streams config', async () => {
+      const context = makeContext();
+
+      const response = await validate.handler({
+        context,
+        params: {
+          sync_rules: `
+config:
+  edition: 3
+streams:
+  mystream:
+    query: SELECT * FROM missing_table
+`
+        },
+        request
+      });
+
+      expect(response.errors).not.toContainEqual(
+        expect.objectContaining({ message: expect.stringContaining('are deprecated') })
+      );
     });
   });
 
@@ -151,6 +327,39 @@ bucket_definitions:
   });
 
   describe('reprocess', () => {
+    it.each([reprocess, reprocessSyncRules].flatMap((route) => [false, true].map((throws) => ({ route, throws }))))(
+      'returns 422 for rejected reprocessing at $route.path (adapter throws: $throws)',
+      async ({ route, throws }) => {
+        const active = makeSyncConfigContent({ id: 7 });
+        const updateSyncRules = vi.fn();
+        const context = makeContext({
+          getDeployingSyncConfig: vi.fn(async () => null),
+          getActiveSyncConfig: vi.fn(async () => ({ content: active })),
+          updateSyncRules
+        });
+        const api = context.service_context.routerEngine.getAPI();
+        vi.spyOn(context.service_context.routerEngine, 'getAPI').mockReturnValue(api);
+        api.validateSourceCapabilities = async () => {
+          if (throws) {
+            throw new Error('Unsupported source');
+          }
+          return [
+            { level: 'warning', message: 'Advisory' },
+            { level: 'fatal', message: 'Unsupported source' }
+          ];
+        };
+        await expect(route.handler({ context, params: {}, request })).rejects.toMatchObject({
+          errorData: {
+            status: 422,
+            code: ErrorCode.PSYNC_R0001,
+            description: 'Source capability validation failed',
+            details: 'Unsupported source'
+          }
+        });
+        expect(updateSyncRules).not.toHaveBeenCalled();
+      }
+    );
+
     it('reprocesses the active sync config', async () => {
       const active = makeSyncConfigContent({ id: 7, syncConfigId: 'active-config', version_label: 'v6' });
       const updateSyncRules = vi.fn(async () => ({
@@ -214,5 +423,27 @@ bucket_definitions:
       expect(activeBucketStorage.getActiveSyncConfig).not.toHaveBeenCalled();
       expect(activeBucketStorage.updateSyncRules).not.toHaveBeenCalled();
     });
+
+    it('logs that bucket_definitions are deprecated', async () => {
+      const warnSpy = vi.spyOn(logger, 'warn');
+      const activeBucketStorage = {
+        getDeployingSyncConfig: vi.fn(async () => null),
+        getActiveSyncConfig: vi.fn(async () => ({
+          content: makeSyncConfigContent({}),
+          replicationStream: {},
+          storage: {}
+        })),
+        updateSyncRules: vi.fn(async () => ({ replicationStreamName: 'new_slot' }))
+      };
+
+      await reprocess.handler({
+        context: makeContext(activeBucketStorage),
+        params: {},
+        request
+      });
+
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Sync Rules (`bucket_definitions`) are deprecated'));
+      warnSpy.mockRestore();
+    });
   });
 });

package/test/src/routes/sync-rules.test.ts

@@ -0,0 +1,124 @@
+import { BasicRouterRequest, Context, JwtPayload } from '@/index.js';
+import { logger } from '@powersync/lib-services-framework';
+import { describe, expect, it, vi } from 'vitest';
+import { deploySyncRules, validateSyncRules } from '../../../src/routes/endpoints/sync-rules.js';
+import { mockServiceContext } from './mocks.js';
+
+describe('sync-rules routes', () => {
+  const request: BasicRouterRequest = {
+    headers: {},
+    hostname: '',
+    protocol: 'http'
+  };
+
+  function makeContext(): Context {
+    const service_context = mockServiceContext(null);
+    (service_context.storageEngine as any).activeBucketStorage = {
+      updateSyncRules: vi.fn(async () => ({ replicationStreamName: 'new_slot' }))
+    };
+    // Deploying through the API requires the sync config to not be set in the service config.
+    (service_context as any).configuration = { sync_rules: { present: false } };
+
+    return {
+      logger: logger,
+      service_context,
+      token_payload: new JwtPayload({
+        sub: '',
+        exp: 0,
+        iat: 0
+      })
+    };
+  }
+
+  describe('filter connection validation', () => {
+    const FILTERED_CONFIG = /* yaml */ `
+      # sync config fixture.
+      config:
+        edition: 3
+        source_table_options:
+          orders:
+            mongodb_filter_expression: { $eq: ['$$doc.active', true] }
+      streams:
+        orders:
+          query: SELECT * FROM orders
+    `;
+
+    it.each(['postgresql', 'mongodb', undefined])('reports connection-type validation for %s', async (type) => {
+      const context = makeContext();
+      const adapter = context.service_context.routerEngine.getAPI();
+      vi.spyOn(context.service_context.routerEngine, 'getAPI').mockReturnValue(adapter);
+      vi.spyOn(adapter, 'getParseSyncRulesOptions').mockReturnValue({
+        defaultSchema: 'public',
+        connections: type === undefined ? undefined : { default: { type } }
+      });
+      const response = await validateSyncRules.handler({ context, params: { content: FILTERED_CONFIG }, request });
+      const result = JSON.parse(response.data);
+      expect(result.valid).toBe(type !== 'postgresql');
+      if (type === 'postgresql') {
+        expect(result.errors).toEqual([expect.stringContaining('only supported by MongoDB sources')]);
+      } else if (type === undefined) {
+        expect(result.warnings).toEqual([expect.stringContaining('without connection type information')]);
+      } else {
+        expect(result.warnings).toBeUndefined();
+      }
+    });
+
+    it('rejects deployment during parsing before persisting a non-MongoDB filter', async () => {
+      const context = makeContext();
+      const adapter = context.service_context.routerEngine.getAPI();
+      vi.spyOn(context.service_context.routerEngine, 'getAPI').mockReturnValue(adapter);
+      vi.spyOn(adapter, 'getParseSyncRulesOptions').mockReturnValue({
+        defaultSchema: 'public',
+        connections: { default: { type: 'postgresql' } }
+      });
+      await expect(deploySyncRules.handler({ context, params: { content: FILTERED_CONFIG }, request })).rejects.toThrow(
+        'Sync config parsing failed'
+      );
+      expect(context.service_context.storageEngine.activeBucketStorage.updateSyncRules).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('deploy', () => {
+    it('logs that bucket_definitions are deprecated', async () => {
+      const warnSpy = vi.spyOn(logger, 'warn');
+
+      const response = await deploySyncRules.handler({
+        context: makeContext(),
+        params: {
+          content: `
+bucket_definitions:
+  global:
+    data:
+      - SELECT id FROM test
+`
+        },
+        request
+      });
+
+      expect(response).toEqual({ slot_name: 'new_slot' });
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Sync Rules (`bucket_definitions`) are deprecated'));
+      warnSpy.mockRestore();
+    });
+
+    it('does not log a warning for a Sync Streams config', async () => {
+      const warnSpy = vi.spyOn(logger, 'warn');
+
+      await deploySyncRules.handler({
+        context: makeContext(),
+        params: {
+          content: `
+config:
+  edition: 3
+streams:
+  global:
+    query: SELECT id FROM test
+`
+        },
+        request
+      });
+
+      expect(warnSpy).not.toHaveBeenCalledWith(expect.stringContaining('Sync config warning'));
+      warnSpy.mockRestore();
+    });
+  });
+});

package/test/src/source_table_config.test.ts

@@ -0,0 +1,104 @@
+import { isCompatible, parsePersistedSyncConfigContent, updateSyncRulesFromConfig } from '@/storage/storage-index.js';
+import { logger } from '@powersync/lib-services-framework';
+import { PrecompiledSyncConfig, SqlSyncRules } from '@powersync/service-sync-rules';
+import { describe, expect, test } from 'vitest';
+
+const CONFIGURED = /* yaml */ `
+  # sync config fixture.
+  config:
+    edition: 3
+    source_table_options:
+      orders:
+        mongodb_filter_expression: { $eq: ['$$doc.active', true] }
+  streams:
+    orders:
+      query: SELECT * FROM orders
+`;
+
+describe('source-table options', () => {
+  test('preserves filters through compiled storage', () => {
+    const parsed = SqlSyncRules.fromYaml(CONFIGURED, { defaultSchema: 'app' });
+    const update = updateSyncRulesFromConfig(parsed);
+    const restored = parsePersistedSyncConfigContent({
+      content: CONFIGURED,
+      compiledPlan: update.config.plan!,
+      storageVersion: 2,
+      parseOptions: { defaultSchema: 'app' }
+    });
+    expect((restored.config as PrecompiledSyncConfig).plan.sourceTableConfig).toEqual({
+      orders: { mongodb_filter_expression: { $eq: ['$$doc.active', true] } }
+    });
+  });
+  test('reports invalid expressions before storage', () => {
+    expect(() =>
+      SqlSyncRules.fromYaml(CONFIGURED.replace('$$doc.active', '$doc.active'), {
+        defaultSchema: 'app'
+      })
+    ).toThrow('Expected a source field');
+  });
+  test.each([
+    ['a..orders: {}', 'Source table patterns must use'],
+    ['Users: {}, users: {}', 'resolve to the same pattern']
+  ])('persists fatal diagnostics for invalid source-table options: %s', (options, message) => {
+    const yaml = /* yaml */ `
+      # sync config fixture.
+      config:
+        edition: 3
+        source_table_options: { ${options} }
+      streams:
+        orders:
+          query: SELECT * FROM orders
+    `;
+    const parsed = SqlSyncRules.fromYaml(yaml, { defaultSchema: 'app', throwOnError: false });
+    expect(parsed.errors).toContainEqual(
+      expect.objectContaining({ type: 'fatal', message: expect.stringContaining(message) })
+    );
+    const diagnostic = parsed.errors.find((error) => error.type === 'fatal' && error.message.includes(message))!;
+    const offendingKey = options.startsWith('a..') ? 'a..orders' : 'users';
+    expect(yaml.slice(diagnostic.location.start, diagnostic.location.end)).toContain(offendingKey);
+    const update = updateSyncRulesFromConfig(parsed);
+    expect(update.config.yaml).toBe(yaml);
+    const restored = parsePersistedSyncConfigContent({
+      content: update.config.yaml,
+      compiledPlan: update.config.plan!,
+      storageVersion: 2,
+      parseOptions: { defaultSchema: 'app' }
+    });
+    expect(restored.errors.map(({ message, type, location }) => ({ message, type, location }))).toEqual(
+      parsed.errors.map(({ message, type, location }) => ({ message, type, location }))
+    );
+    expect((restored.config as PrecompiledSyncConfig).plan.sourceTableConfig ?? {}).toEqual({});
+  });
+
+  test('keeps valid filters on a partial plan with an unrelated SQL error', () => {
+    const yaml = CONFIGURED.replace('SELECT * FROM orders', 'SELECT FROM');
+    const parsed = SqlSyncRules.fromYaml(yaml, { defaultSchema: 'app', throwOnError: false });
+    expect(parsed.errors.some((error) => error.type === 'fatal')).toBe(true);
+    const update = updateSyncRulesFromConfig(parsed);
+    expect(update.config.plan!.plan.sourceTableConfig).toEqual({
+      orders: { mongodb_filter_expression: { $eq: ['$$doc.active', true] } }
+    });
+  });
+  test('requires replacement processing when filters change or are removed', () => {
+    const deploy = (yaml: string) => updateSyncRulesFromConfig(SqlSyncRules.fromYaml(yaml, { defaultSchema: 'app' }));
+    const first = deploy(CONFIGURED);
+    const same = deploy(CONFIGURED.replace('SELECT *', 'SELECT id'));
+    const changed = deploy(CONFIGURED.replace('true', 'false'));
+    const removed = deploy(
+      CONFIGURED.replace(
+        "mongodb_filter_expression: { $eq: ['$$doc.active', true] }",
+        'mongodb_filter_expression: disabled'
+      )
+    );
+    expect(isCompatible([first.config.plan], same.config, logger)).toBe(true);
+    expect(isCompatible([first.config.plan], changed.config, logger)).toBe(false);
+    expect(isCompatible([first.config.plan], removed.config, logger)).toBe(false);
+  });
+  test('requires replacement processing when saved source-table options no longer validate', () => {
+    const update = updateSyncRulesFromConfig(SqlSyncRules.fromYaml(CONFIGURED, { defaultSchema: 'app' }));
+    const existing = structuredClone(update.config.plan!);
+    // A saved expression can become unsupported after a module or version change.
+    Object.assign(existing.plan.sourceTableConfig!.orders!, { mongodb_filter_expression: { $unsupported: [] } });
+    expect(isCompatible([existing], update.config, logger)).toBe(false);
+  });
+});

package/test/src/storage/BucketStorageFactory.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test, vi } from 'vitest';
+import * as storage from '../../../src/storage/storage-index.js';
+
+describe('logSyncConfigErrors', () => {
+  function makeLogger() {
+    return { warn: vi.fn(), error: vi.fn() };
+  }
+
+  test('logs fatal errors and warnings when the sync config is not validated', () => {
+    // Without validation, as at startup with exit_on_error: false, parsing doesn't throw on fatal errors.
+    const updateOptions = storage.updateSyncRulesFromYaml(
+      `
+bucket_definitions:
+  mybucket:
+    data:
+      - SELECT FROM
+`,
+      { validate: false }
+    );
+    const log = makeLogger();
+
+    storage.logSyncConfigErrors(updateOptions.config.parsed, log as any);
+
+    expect(log.error).toHaveBeenCalledWith(expect.stringContaining('Sync config error:'));
+    expect(log.warn).toHaveBeenCalledWith(expect.stringContaining('Sync Rules (`bucket_definitions`) are deprecated'));
+  });
+
+  test('logs nothing for a valid Sync Streams config', () => {
+    const updateOptions = storage.updateSyncRulesFromYaml(
+      `
+config:
+  edition: 3
+streams:
+  global:
+    query: SELECT id FROM test
+`,
+      { validate: true }
+    );
+    const log = makeLogger();
+
+    storage.logSyncConfigErrors(updateOptions.config.parsed, log as any);
+
+    expect(log.error).not.toHaveBeenCalled();
+    expect(log.warn).not.toHaveBeenCalled();
+  });
+});