@powersync/service-core 1.26.1 → 1.27.1

package/test/src/broadcast_iterable.test.ts

@@ -4,10 +4,16 @@ import { delayEach } from 'ix/asynciterable/operators/delayeach.js';
 import { take } from 'ix/asynciterable/operators/take.js';
 import { wrapWithAbort } from 'ix/asynciterable/operators/withabort.js';
 import { toArray } from 'ix/asynciterable/toarray.js';
-import * as timers from 'timers/promises';
-import { describe, expect, it } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+// The global setTimeout, not the one from timers/promises: vi.useFakeTimers() only replaces the global timers
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 
 describe('BroadcastIterable', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
   it('should iterate', async () => {
     const range = AsyncIterableX.from([1, 2, 3]);
     const broadcast = new BroadcastIterable(() => range);
@@ -47,6 +53,7 @@ describe('BroadcastIterable', () => {
   });
 
   it('should handle indefinite sources', async () => {
+    vi.useFakeTimers();
     const source: IterableSource<number> = (signal) => {
       return wrapWithAbort(interval(1), signal);
     };
@@ -55,7 +62,9 @@ describe('BroadcastIterable', () => {
 
     const delayed = delayEach(10)(broadcast);
     expect(broadcast.active).toBe(false);
-    const results = await toArray(take(5)(delayed));
+    const resultsPromise = toArray(take(5)(delayed));
+    await vi.advanceTimersByTimeAsync(100);
+    const results = await resultsPromise;
 
     expect(results.length).toEqual(5);
     expect(results[0]).toEqual(0);
@@ -66,6 +75,7 @@ describe('BroadcastIterable', () => {
   });
 
   it('should handle multiple subscribers', async () => {
+    vi.useFakeTimers();
     let sourceIndex = 0;
     const source = async function* (signal: AbortSignal) {
       // Test value out by 1000 means it may have used the wrong iteration of the source
@@ -75,7 +85,7 @@ describe('BroadcastIterable', () => {
       });
       for (let i = 0; !signal.aborted; i++) {
         yield base + i;
-        await Promise.race([abortedPromise, timers.setTimeout(1)]);
+        await Promise.race([abortedPromise, sleep(1)]);
       }
       // Test value out by 100 means this wasn't reached
       sourceIndex += 100;
@@ -88,6 +98,7 @@ describe('BroadcastIterable', () => {
     expect(broadcast.active).toBe(false);
     const results1Promise = toArray(take(5)(delayed1));
     const results2Promise = toArray(take(5)(delayed2));
+    await vi.advanceTimersByTimeAsync(100);
     const [results1, results2] = [await results1Promise, await results2Promise];
 
     expect(broadcast.active).toBe(false);
@@ -104,7 +115,9 @@ describe('BroadcastIterable', () => {
 
     // This starts a new source
     const delayed3 = delayEach(10)(broadcast);
-    const results3 = await toArray(take(5)(delayed3));
+    const results3Promise = toArray(take(5)(delayed3));
+    await vi.advanceTimersByTimeAsync(100);
+    const results3 = await results3Promise;
     expect(results3.length).toEqual(5);
     expect(results3[0]).toEqual(2100);
     expect(results3[4]).toBeGreaterThan(2110);
@@ -112,6 +125,7 @@ describe('BroadcastIterable', () => {
   });
 
   it('should handle errors on multiple subscribers', async () => {
+    vi.useFakeTimers();
     let sourceIndex = 0;
     const source = async function* (signal: AbortSignal) {
       // Test value out by 1000 means it may have used the wrong iteration of the source
@@ -124,7 +138,7 @@ describe('BroadcastIterable', () => {
           throw new Error('simulated failure');
         }
         yield base + i;
-        await Promise.race([abortedPromise, timers.setTimeout(1)]);
+        await Promise.race([abortedPromise, sleep(1)]);
       }
       // Test value out by 100 means this wasn't reached
       sourceIndex += 100;
@@ -138,7 +152,9 @@ describe('BroadcastIterable', () => {
     const results1Promise = toArray(take(5)(delayed1)) as Promise<number[]>;
     const results2Promise = toArray(take(5)(delayed2)) as Promise<number[]>;
 
-    const [r1, r2] = await Promise.allSettled([results1Promise, results2Promise]);
+    const settled = Promise.allSettled([results1Promise, results2Promise]);
+    await vi.advanceTimersByTimeAsync(100);
+    const [r1, r2] = await settled;
 
     expect(r1).toEqual({ status: 'rejected', reason: new Error('simulated failure') });
     expect(r2).toEqual({ status: 'rejected', reason: new Error('simulated failure') });
@@ -147,7 +163,9 @@ describe('BroadcastIterable', () => {
 
     // This starts a new source
     const delayed3 = delayEach(10)(broadcast);
-    const results3 = await toArray(take(5)(delayed3));
+    const results3Promise = toArray(take(5)(delayed3));
+    await vi.advanceTimersByTimeAsync(100);
+    const results3 = await results3Promise;
     expect(results3.length).toEqual(5);
     expect(results3[0]).toEqual(2000);
     expect(results3[4]).toBeGreaterThan(2010);

package/test/src/diagnostics.test.ts

@@ -205,4 +205,132 @@ describe('getSyncRulesStatus WAL budget warnings', () => {
     expect(result!.version_label).toBe('v6');
     expect(result!.errors).toEqual([expect.objectContaining({ level: 'fatal', message: 'Invalid sync config' })]);
   });
+
+  test('reports each sync config error with its source location when parsing fails', async () => {
+    const yaml = `
+config:
+  edition: 3
+streams:
+  global:
+    query: SELECT id FROM test_table
+    unknown_key: true
+`;
+    const content = makeSyncRulesContent();
+    content.parsed = (options?: any) => {
+      SqlSyncRules.fromYaml(yaml, { ...options, defaultSchema: 'public', throwOnError: true });
+      throw new Error('Expected parsing to fail');
+    };
+
+    const result = await getSyncRulesStatus(makeRouteAPI(), content, OPTIONS, makeSystemStorage());
+
+    expect(result!.errors).toHaveLength(1);
+    const [error] = result!.errors;
+    expect(error.level).toBe('fatal');
+    expect(error.message).not.toContain('Expected parsing to fail');
+    expect(yaml.slice(error.location!.start_offset, error.location!.end_offset)).toBe('unknown_key');
+  });
+});
+
+describe('source capability validation', () => {
+  test('exposes stored replication errors when source checks cannot run', async () => {
+    const content = makeSyncRulesContent({
+      status: {
+        id: '1',
+        replicationStreamId: 1,
+        state: storage.SyncRuleState.PROCESSING,
+        last_checkpoint_lsn: null,
+        last_fatal_error: 'Source capability unavailable',
+        last_fatal_error_ts: new Date(),
+        last_keepalive_ts: null,
+        last_checkpoint_ts: null
+      }
+    });
+    const result = await getSyncRulesStatus(
+      makeRouteAPI(),
+      content,
+      {
+        ...OPTIONS,
+        check_connection: false,
+        active: false,
+        include_content: true
+      },
+      makeSystemStorage()
+    );
+    expect(result?.content).toBe(MINIMAL_SYNC_RULES);
+    expect(result?.errors).toContainEqual(
+      expect.objectContaining({
+        level: 'fatal',
+        message: 'Source capability unavailable'
+      })
+    );
+  });
+
+  test('reports capability failures alongside table diagnostics', async () => {
+    const api = makeRouteAPI();
+    api.validateSourceCapabilities = async () => [
+      { level: 'fatal', message: 'Source capability unavailable' },
+      { level: 'warning', message: 'Source advisory', location: { start_offset: 1, end_offset: 4 } }
+    ];
+    api.getDebugTablesInfo = async () => [
+      {
+        schema: 'public',
+        pattern: 'items',
+        wildcard: false,
+        table: {
+          schema: 'public',
+          name: 'items',
+          data_queries: true,
+          parameter_queries: false,
+          replication_id: [],
+          errors: [{ level: 'warning', message: 'Index missing' }]
+        }
+      }
+    ];
+    const result = await getSyncRulesStatus(api, makeSyncRulesContent(), OPTIONS, makeSystemStorage());
+    expect(result!.errors).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ level: 'fatal', message: 'Source capability unavailable' }),
+        expect.objectContaining({ level: 'warning', message: 'Index missing' }),
+        expect.objectContaining({
+          level: 'warning',
+          message: 'Source advisory',
+          location: { start_offset: 1, end_offset: 4 }
+        })
+      ])
+    );
+    expect(result!.connections[0].tables).toHaveLength(1);
+  });
+
+  test('preserves both validation failures and continues independent diagnostics', async () => {
+    const api = makeRouteAPI({
+      wal_status: 'extended',
+      safe_wal_size: 4 * GB,
+      max_slot_wal_keep_size: 10 * GB
+    });
+    api.validateSourceCapabilities = async () => {
+      throw new Error('Source capability unavailable');
+    };
+    api.getDebugTablesInfo = async () => {
+      throw new Error('Table metadata unavailable');
+    };
+    const result = await getSyncRulesStatus(api, makeSyncRulesContent(), OPTIONS, makeSystemStorage());
+    expect(result!.errors).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ level: 'fatal', message: 'Source capability unavailable' }),
+        expect.objectContaining({ level: 'fatal', message: 'Table metadata unavailable' }),
+        expect.objectContaining({ level: 'warning', message: expect.stringContaining('WAL budget') })
+      ])
+    );
+  });
+
+  test('does not check capabilities when connection checks are disabled', async () => {
+    const api = makeRouteAPI();
+    let called = false;
+    api.validateSourceCapabilities = async () => {
+      called = true;
+      return [];
+    };
+    await getSyncRulesStatus(api, makeSyncRulesContent(), { ...OPTIONS, check_connection: false }, makeSystemStorage());
+    expect(called).toBe(false);
+  });
 });

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();
+    });
+  });
+});