@powersync/service-core 1.22.0 → 1.23.0

package/test/src/diagnostics.test.ts

@@ -1,6 +1,6 @@
 import { DiagnosticsOptions, getSyncRulesStatus } from '@/api/diagnostics.js';
 import { RouteAPI, SlotWalBudgetInfo } from '@/api/RouteAPI.js';
-import { BucketStorageFactory, PersistedSyncRules, storage } from '@/index.js';
+import { ParsedSyncConfigSet, storage } from '@/index.js';
 import { SqlSyncRules } from '@powersync/service-sync-rules';
 import { describe, expect, test } from 'vitest';
 
@@ -13,53 +13,56 @@ bucket_definitions:
       - SELECT id FROM test_table
 `;
 
-function makeSyncRulesContent(overrides?: { slot_name?: string }): storage.PersistedSyncRulesContent {
+function makeSyncRulesContent(overrides?: {
+  slot_name?: string;
+  status?: storage.PersistedSyncConfigStatus;
+}): storage.PersistedSyncConfigContent {
   // We don't implement the entire interface correctly here - just enough to test the diagnostics logic.
   return {
-    id: 1,
-    slot_name: overrides?.slot_name ?? 'test_slot',
+    replicationStreamId: 1,
+    syncConfigId: null,
+    replicationStreamName: overrides?.slot_name ?? 'test_slot',
     sync_rules_content: MINIMAL_SYNC_RULES,
     compiled_plan: null,
-    active: true,
     storageVersion: 1,
-    last_checkpoint_lsn: 'some_lsn',
-    last_fatal_error: null,
-    last_fatal_error_ts: null,
-    last_keepalive_ts: new Date(),
-    last_checkpoint_ts: new Date(),
     parsed(options?: any) {
       const syncRules = SqlSyncRules.fromYaml(MINIMAL_SYNC_RULES, {
         ...options,
         defaultSchema: 'public'
       });
       return {
-        syncConfigWithErrors: syncRules
-      } as PersistedSyncRules;
+        syncConfigs: [syncRules]
+      } as ParsedSyncConfigSet;
     },
-    lock() {
-      throw new Error('Not implemented in mock');
-    },
-    current_lock: null,
     logger: null as any,
     asUpdateOptions: null as any,
-    getStorageConfig: null as any
-  } as storage.PersistedSyncRulesContent;
+    getStorageConfig: null as any,
+    async getSyncConfigStatus() {
+      return (
+        overrides?.status ?? {
+          id: '1',
+          replicationStreamId: 1,
+          state: storage.SyncRuleState.ACTIVE,
+          last_checkpoint_lsn: 'some_lsn',
+          last_fatal_error: null,
+          last_fatal_error_ts: null,
+          last_keepalive_ts: new Date(),
+          last_checkpoint_ts: new Date()
+        }
+      );
+    }
+  } as storage.PersistedSyncConfigContent;
 }
 
-function makeBucketStorage() {
+function makeSystemStorage() {
   return {
-    getInstance() {
+    async getStatus() {
       return {
-        async getStatus() {
-          return {
-            snapshot_done: true,
-            checkpoint_lsn: 'some_lsn',
-            active: true
-          };
-        }
+        snapshotDone: true,
+        resumeLsn: 'some_lsn'
       };
     }
-  } as unknown as BucketStorageFactory;
+  } as storage.SyncRulesBucketStorage;
 }
 
 function makeRouteAPI(walBudget?: SlotWalBudgetInfo | undefined): RouteAPI {
@@ -92,7 +95,8 @@ function makeRouteAPI(walBudget?: SlotWalBudgetInfo | undefined): RouteAPI {
 const OPTIONS: DiagnosticsOptions = {
   live_status: true,
   check_connection: true,
-  include_content: false
+  include_content: false,
+  active: true
 };
 
 describe('getSyncRulesStatus WAL budget warnings', () => {
@@ -102,7 +106,7 @@ describe('getSyncRulesStatus WAL budget warnings', () => {
       safe_wal_size: 4 * GB,
       max_slot_wal_keep_size: 10 * GB
     });
-    const result = await getSyncRulesStatus(makeBucketStorage(), api, makeSyncRulesContent(), OPTIONS);
+    const result = await getSyncRulesStatus(api, makeSyncRulesContent(), OPTIONS, makeSystemStorage());
     const walWarnings = result!.errors.filter((e) => e.message.includes('WAL budget'));
     expect(walWarnings).toHaveLength(1);
     expect(walWarnings[0].level).toBe('warning');
@@ -115,7 +119,7 @@ describe('getSyncRulesStatus WAL budget warnings', () => {
       safe_wal_size: 8 * GB,
       max_slot_wal_keep_size: 10 * GB
     });
-    const result = await getSyncRulesStatus(makeBucketStorage(), api, makeSyncRulesContent(), OPTIONS);
+    const result = await getSyncRulesStatus(api, makeSyncRulesContent(), OPTIONS, makeSystemStorage());
     const walWarnings = result!.errors.filter((e) => e.message.includes('WAL budget'));
     expect(walWarnings).toHaveLength(0);
   });
@@ -126,7 +130,7 @@ describe('getSyncRulesStatus WAL budget warnings', () => {
       safe_wal_size: -2.4 * GB,
       max_slot_wal_keep_size: 1 * 1024 * 1024 // 1MB
     });
-    const result = await getSyncRulesStatus(makeBucketStorage(), api, makeSyncRulesContent(), OPTIONS);
+    const result = await getSyncRulesStatus(api, makeSyncRulesContent(), OPTIONS, makeSystemStorage());
     const walWarnings = result!.errors.filter((e) => e.message.includes('WAL budget'));
     expect(walWarnings).toHaveLength(1);
     expect(walWarnings[0].message).toContain('0%');
@@ -137,7 +141,7 @@ describe('getSyncRulesStatus WAL budget warnings', () => {
     const api = makeRouteAPI({
       wal_status: 'lost'
     });
-    const result = await getSyncRulesStatus(makeBucketStorage(), api, makeSyncRulesContent(), OPTIONS);
+    const result = await getSyncRulesStatus(api, makeSyncRulesContent(), OPTIONS, makeSystemStorage());
     const walErrors = result!.errors.filter(
       (e) => e.message.includes('WAL budget') || e.message.includes('PSYNC_S1146')
     );
@@ -146,10 +150,33 @@ describe('getSyncRulesStatus WAL budget warnings', () => {
 
   test('no WAL error when getSlotWalBudget is not defined', async () => {
     const api = makeRouteAPI();
-    const result = await getSyncRulesStatus(makeBucketStorage(), api, makeSyncRulesContent(), OPTIONS);
+    const result = await getSyncRulesStatus(api, makeSyncRulesContent(), OPTIONS, makeSystemStorage());
     const walErrors = result!.errors.filter(
       (e) => e.message.includes('WAL budget') || e.message.includes('PSYNC_S1146')
     );
     expect(walErrors).toHaveLength(0);
   });
+
+  test('uses sync config status for status-derived diagnostics fields', async () => {
+    const configStatus: storage.PersistedSyncConfigStatus = {
+      id: 'config-a',
+      replicationStreamId: 1,
+      state: storage.SyncRuleState.ACTIVE,
+      last_checkpoint_lsn: 'config_lsn',
+      last_fatal_error: 'config failed',
+      last_fatal_error_ts: new Date('2026-01-01T00:00:00.000Z'),
+      last_keepalive_ts: new Date('2026-01-01T00:01:00.000Z'),
+      last_checkpoint_ts: new Date('2026-01-01T00:02:00.000Z')
+    };
+    const result = await getSyncRulesStatus(
+      makeRouteAPI(),
+      makeSyncRulesContent({ status: configStatus }),
+      OPTIONS,
+      makeSystemStorage()
+    );
+
+    expect(result!.connections[0].last_checkpoint_ts).toBe('2026-01-01T00:02:00.000Z');
+    expect(result!.connections[0].last_keepalive_ts).toBe('2026-01-01T00:01:00.000Z');
+    expect(result!.errors.some((error) => error.message == 'config failed')).toBe(true);
+  });
 });

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

@@ -1,4 +1,11 @@
-import { AbstractModule, loadModules, ServiceContextContainer, TearDownOptions } from '@/index.js';
+import {
+  AbstractModule,
+  loadModules,
+  ModuleManager,
+  ServiceContextContainer,
+  storage,
+  TearDownOptions
+} from '@/index.js';
 import { describe, expect, it } from 'vitest';
 
 interface MockConfig {
@@ -27,6 +34,19 @@ class MockPostgresStorageModule extends AbstractModule {
   async initialize(context: ServiceContextContainer): Promise<void> {}
   async teardown(options: TearDownOptions): Promise<void> {}
 }
+class RecordingModule extends AbstractModule {
+  teardownOptions: TearDownOptions | undefined;
+
+  constructor(name: string) {
+    super({ name });
+  }
+
+  async initialize(context: ServiceContextContainer): Promise<void> {}
+
+  async teardown(options: TearDownOptions): Promise<void> {
+    this.teardownOptions = options;
+  }
+}
 const mockLoaders = {
   connection: {
     mysql: async () => {
@@ -99,4 +119,16 @@ describe('module loader', () => {
 
     await expect(loadModules(config as any, loaders)).rejects.toThrowError('Failed to load MySQL module');
   });
+
+  it('passes replication streams through teardown options', async () => {
+    const module = new RecordingModule('RecordingModule');
+    const moduleManager = new ModuleManager();
+    const replicationStreams = [{ replicationStreamId: 1 }] as storage.PersistedReplicationStream[];
+
+    moduleManager.register([module]);
+    await moduleManager.tearDown({ replicationStreams, syncRules: replicationStreams });
+
+    expect(module.teardownOptions?.replicationStreams).toBe(replicationStreams);
+    expect(module.teardownOptions?.syncRules).toBe(replicationStreams);
+  });
 });

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

@@ -1,27 +1,90 @@
-import { BasicRouterRequest, Context, JwtPayload } from '@/index.js';
+import { BasicRouterRequest, Context, JwtPayload, ParsedSyncConfigSet, storage } from '@/index.js';
 import { logger } from '@powersync/lib-services-framework';
-import { describe, expect, it } from 'vitest';
-import { validate } from '../../../src/routes/endpoints/admin.js';
+import { SqlSyncRules } from '@powersync/service-sync-rules';
+import { describe, expect, it, vi } from 'vitest';
+import { diagnostics, reprocess, validate } from '../../../src/routes/endpoints/admin.js';
 import { mockServiceContext } from './mocks.js';
 
 describe('admin routes', () => {
+  const request: BasicRouterRequest = {
+    headers: {},
+    hostname: '',
+    protocol: 'http'
+  };
+
+  function makeContext(activeBucketStorage?: any): Context {
+    const service_context = mockServiceContext(null);
+    if (activeBucketStorage != null) {
+      (service_context.storageEngine as any).activeBucketStorage = activeBucketStorage;
+    }
+
+    return {
+      logger: logger,
+      service_context,
+      token_payload: new JwtPayload({
+        sub: '',
+        exp: 0,
+        iat: 0
+      })
+    };
+  }
+
+  function makeSyncConfigContent(options: {
+    id?: number;
+    syncConfigId?: string;
+    active?: boolean;
+    content?: string;
+  }): storage.PersistedSyncConfigContent {
+    const id = options.id ?? 1;
+    const syncConfigId = options.syncConfigId ?? String(id);
+    const active = options.active ?? true;
+    const state = active ? storage.SyncRuleState.ACTIVE : storage.SyncRuleState.PROCESSING;
+    const lastKeepaliveTs = new Date('2026-01-01T00:00:00.000Z');
+    const lastCheckpointTs = new Date('2026-01-01T00:00:00.000Z');
+    const content = {
+      replicationStreamId: id,
+      syncConfigId,
+      replicationStreamName: `slot_${id}`,
+      sync_rules_content:
+        options.content ??
+        `
+bucket_definitions:
+  global:
+    data:
+      - SELECT id FROM test
+`,
+      compiled_plan: null,
+      storageVersion: storage.LEGACY_STORAGE_VERSION,
+      parsed(options?: any) {
+        const syncRules = SqlSyncRules.fromYaml(content.sync_rules_content, {
+          ...options,
+          defaultSchema: 'public'
+        });
+        return {
+          syncConfigs: [syncRules]
+        } as ParsedSyncConfigSet;
+      },
+      asUpdateOptions: vi.fn(),
+      getStorageConfig: vi.fn(),
+      async getSyncConfigStatus() {
+        return {
+          id: syncConfigId,
+          replicationStreamId: id,
+          state,
+          last_checkpoint_lsn: null,
+          last_fatal_error: null,
+          last_fatal_error_ts: null,
+          last_keepalive_ts: lastKeepaliveTs,
+          last_checkpoint_ts: lastCheckpointTs
+        };
+      }
+    };
+    return content as unknown as storage.PersistedSyncConfigContent;
+  }
+
   describe('validate', () => {
     it('reports errors with source location', async () => {
-      const context: Context = {
-        logger: logger,
-        service_context: mockServiceContext(null),
-        token_payload: new JwtPayload({
-          sub: '',
-          exp: 0,
-          iat: 0
-        })
-      };
-
-      const request: BasicRouterRequest = {
-        headers: {},
-        hostname: '',
-        protocol: 'http'
-      };
+      const context = makeContext();
 
       const response = await validate.handler({
         context,
@@ -45,4 +108,103 @@ bucket_definitions:
       ]);
     });
   });
+
+  describe('diagnostics', () => {
+    it('returns deploying config status', async () => {
+      const active = makeSyncConfigContent({ id: 1, syncConfigId: 'active-config' });
+      const deploying = makeSyncConfigContent({ id: 2, syncConfigId: 'deploying-config', active: false });
+      const getInstance = vi.fn(() => ({
+        async getStatus() {
+          return {
+            snapshotDone: false,
+            resumeLsn: null
+          };
+        }
+      }));
+      const activeBucketStorage = {
+        getActiveSyncConfig: vi.fn(async () => ({
+          content: active,
+          replicationStream: {},
+          storage: getInstance()
+        })),
+        getDeployingSyncConfig: vi.fn(async () => ({
+          content: deploying,
+          replicationStream: {},
+          storage: getInstance()
+        }))
+      };
+
+      const response = await diagnostics.handler({
+        context: makeContext(activeBucketStorage),
+        params: {},
+        request
+      });
+
+      expect(response.deploying_sync_rules?.connections[0].slot_name).toBe('slot_2');
+      expect(response.active_sync_rules?.connections[0].slot_name).toBe('slot_1');
+    });
+  });
+
+  describe('reprocess', () => {
+    it('reprocesses the active sync config', async () => {
+      const active = makeSyncConfigContent({ id: 7, syncConfigId: 'active-config' });
+      const updateSyncRules = vi.fn(async () => ({
+        replicationStreamId: 8,
+        replicationStreamName: 'new_slot',
+        state: storage.SyncRuleState.PROCESSING,
+        storageVersion: storage.LEGACY_STORAGE_VERSION,
+        replicationJobId: '8',
+        current_lock: null
+      }));
+      const activeBucketStorage = {
+        getDeployingSyncConfig: vi.fn(async () => null),
+        getActiveSyncConfig: vi.fn(async () => ({
+          content: active,
+          replicationStream: {},
+          storage: {}
+        })),
+        getSyncConfigContent: vi.fn(),
+        updateSyncRules
+      };
+
+      const response = await reprocess.handler({
+        context: makeContext(activeBucketStorage),
+        params: {},
+        request
+      });
+
+      expect(activeBucketStorage.getActiveSyncConfig).toHaveBeenCalledTimes(1);
+      expect(activeBucketStorage.getSyncConfigContent).not.toHaveBeenCalled();
+      expect(updateSyncRules).toHaveBeenCalledTimes(1);
+      expect(response.connections[0].slot_name).toBe('new_slot');
+    });
+
+    it('rejects reprocess while a sync config is deploying', async () => {
+      const activeBucketStorage = {
+        getDeployingSyncConfig: vi.fn(async () => ({
+          content: makeSyncConfigContent({ id: 2, active: false }),
+          replicationStream: {},
+          storage: {}
+        })),
+        getActiveSyncConfig: vi.fn(),
+        updateSyncRules: vi.fn()
+      };
+
+      await expect(
+        reprocess.handler({
+          context: makeContext(activeBucketStorage),
+          params: {},
+          request
+        })
+      ).rejects.toMatchObject({
+        errorData: {
+          status: 409,
+          code: 'PSYNC_S4106',
+          description: 'Busy processing sync config - cannot reprocess'
+        }
+      });
+      expect(activeBucketStorage.getActiveSyncConfig).not.toHaveBeenCalled();
+      expect(activeBucketStorage.updateSyncRules).not.toHaveBeenCalled();
+    });
+  });
 });

package/test/src/routes/mocks.ts

@@ -18,8 +18,12 @@ export function mockServiceContext(storage: Partial<SyncRulesBucketStorage> | nu
 
   const storageEngine: StorageEngine = {
     activeBucketStorage: {
-      async getActiveStorage() {
-        return storage;
+      async getActiveSyncConfig() {
+        return storage == null
+          ? null
+          : {
+              storage
+            };
       }
     } as Partial<BucketStorageFactory>
   } as any;

package/tsconfig.json

@@ -2,10 +2,7 @@
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
     "rootDir": "src",
-    "outDir": "dist",
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "sourceMap": true
+    "outDir": "dist"
   },
   "include": ["src"],
   "references": [