@powersync/service-core 1.21.0 → 1.23.0

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/error-handler.integration.test.ts

@@ -0,0 +1,275 @@
+import { errors } from '@powersync/lib-services-framework';
+import Fastify, { FastifyInstance } from 'fastify';
+import { Readable } from 'node:stream';
+import * as zlib from 'node:zlib';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { registerFastifyErrorHandler } from '../../../src/routes/route-register.js';
+
+describe('Fastify error handler', () => {
+  let app: FastifyInstance;
+
+  beforeEach(() => {
+    app = Fastify();
+    registerFastifyErrorHandler(app);
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+
+  describe('errors thrown in route before sending a response', () => {
+    it('returns a JSON error body with no content-encoding when none was set', async () => {
+      app.get('/boom', async () => {
+        throw new errors.ServiceError({
+          status: 503,
+          code: 'PSYNC_S2003' as any,
+          description: 'Service unavailable'
+        });
+      });
+      await app.ready();
+
+      const response = await app.inject({ method: 'GET', url: '/boom' });
+
+      expect(response.statusCode).toBe(503);
+      expect(response.headers['content-type']).toMatch(/application\/json/);
+      expect(response.headers['content-encoding']).toBeUndefined();
+      expect(JSON.parse(response.payload)).toMatchObject({
+        error: { code: 'PSYNC_S2003', status: 503 }
+      });
+    });
+
+    it('gzip-encodes the error body when content-encoding=gzip was set before the throw', async () => {
+      app.get('/boom', async (_request, reply) => {
+        reply.header('content-encoding', 'gzip');
+        throw new Error('kaboom');
+      });
+      await app.ready();
+
+      const response = await app.inject({ method: 'GET', url: '/boom' });
+
+      expect(response.statusCode).toBe(500);
+      expect(response.headers['content-encoding']).toBe('gzip');
+      const decoded = zlib.gunzipSync(response.rawPayload).toString('utf8');
+      expect(JSON.parse(decoded).error.code).toBe('PSYNC_S2001');
+    });
+
+    it('zstd-encodes the error body when content-encoding=zstd was set before the throw', async () => {
+      app.get('/boom', async (_request, reply) => {
+        reply.header('content-encoding', 'zstd');
+        throw new Error('kaboom');
+      });
+      await app.ready();
+
+      const response = await app.inject({ method: 'GET', url: '/boom' });
+
+      expect(response.statusCode).toBe(500);
+      expect(response.headers['content-encoding']).toBe('zstd');
+      const decoded = zlib.zstdDecompressSync(response.rawPayload).toString('utf8');
+      expect(JSON.parse(decoded).error.code).toBe('PSYNC_S2001');
+    });
+  });
+
+  describe('errors after responding with a stream, before any data is sent', () => {
+    it('still returns a JSON error response with no encoding', async () => {
+      app.get('/stream', async (_request, reply) => {
+        const stream = new Readable({
+          read() {
+            process.nextTick(() => this.destroy(new Error('pre-data failure')));
+          }
+        });
+        reply.header('content-type', 'application/x-ndjson');
+        return reply.send(stream);
+      });
+      await app.ready();
+
+      const response = await app.inject({ method: 'GET', url: '/stream' });
+
+      expect(response.statusCode).toBe(500);
+      expect(response.headers['content-encoding']).toBeUndefined();
+      expect(response.headers['content-type']).toMatch(/application\/json/);
+      expect(JSON.parse(response.payload).error.code).toBe('PSYNC_S2001');
+    });
+
+    it('still returns a gzip-encoded JSON error response when encoding was set first', async () => {
+      app.get('/stream', async (_request, reply) => {
+        reply.header('content-encoding', 'gzip');
+        reply.header('content-type', 'application/x-ndjson');
+        const stream = new Readable({
+          read() {
+            process.nextTick(() => this.destroy(new Error('pre-data failure')));
+          }
+        });
+        return reply.send(stream);
+      });
+      await app.ready();
+
+      const response = await app.inject({ method: 'GET', url: '/stream' });
+
+      expect(response.statusCode).toBe(500);
+      expect(response.headers['content-encoding']).toBe('gzip');
+      const decoded = zlib.gunzipSync(response.rawPayload).toString('utf8');
+      expect(JSON.parse(decoded).error.code).toBe('PSYNC_S2001');
+    });
+  });
+
+  describe('errors after a stream has sent data', () => {
+    it('lets fastify tear the response down without raising an uncaught exception', async () => {
+      app.get('/stream', async (_request, reply) => {
+        let chunks = 0;
+        const stream = new Readable({
+          read() {
+            if (chunks++ === 0) {
+              this.push('first chunk\n');
+            } else {
+              this.destroy(new Error('mid-stream failure'));
+            }
+          }
+        });
+        reply.header('content-type', 'application/x-ndjson');
+        return reply.send(stream);
+      });
+      await app.ready();
+
+      const uncaught: Error[] = [];
+      const onUncaught = (err: Error) => uncaught.push(err);
+      const onUnhandled = (err: any) => uncaught.push(err);
+      process.on('uncaughtException', onUncaught);
+      process.on('unhandledRejection', onUnhandled);
+
+      try {
+        await expect(app.inject({ method: 'GET', url: '/stream' })).rejects.toThrow(/destroyed/);
+        await new Promise((resolve) => setImmediate(resolve));
+      } finally {
+        process.off('uncaughtException', onUncaught);
+        process.off('unhandledRejection', onUnhandled);
+      }
+
+      expect(uncaught).toEqual([]);
+    });
+  });
+
+  describe('handler inheritance into child scopes', () => {
+    it('handles errors thrown in routes registered inside a child scope', async () => {
+      await app.register(async (child) => {
+        child.get('/boom', async () => {
+          throw new Error('child scope failure');
+        });
+      });
+      await app.ready();
+
+      const response = await app.inject({ method: 'GET', url: '/boom' });
+
+      expect(response.statusCode).toBe(500);
+      expect(response.headers['content-type']).toMatch(/application\/json/);
+      const body = JSON.parse(response.payload);
+      expect(body.error?.code).toBe('PSYNC_S2001');
+    });
+  });
+
+  describe('built-in Fastify errors', () => {
+    it('preserves the 400 status code for an invalid JSON body', async () => {
+      app.post('/echo', async (request) => ({ received: request.body }));
+      await app.ready();
+
+      const response = await app.inject({
+        method: 'POST',
+        url: '/echo',
+        headers: { 'content-type': 'application/json' },
+        payload: '{ not json'
+      });
+
+      expect(response.statusCode).toBe(400);
+      const body = JSON.parse(response.payload);
+      expect(body.error.status).toBe(400);
+      expect(body.error.code).toBe('FST_ERR_CTP_INVALID_JSON_BODY');
+    });
+
+    it('preserves the 400 status code for an empty JSON body', async () => {
+      app.post('/echo', async (request) => ({ received: request.body }));
+      await app.ready();
+
+      const response = await app.inject({
+        method: 'POST',
+        url: '/echo',
+        headers: { 'content-type': 'application/json' },
+        payload: ''
+      });
+
+      expect(response.statusCode).toBe(400);
+      const body = JSON.parse(response.payload);
+      expect(body.error.status).toBe(400);
+      expect(body.error.code).toBe('FST_ERR_CTP_EMPTY_JSON_BODY');
+    });
+
+    it('preserves the 400 status code for a schema validation failure', async () => {
+      app.post(
+        '/schema',
+        {
+          schema: {
+            body: {
+              type: 'object',
+              required: ['name'],
+              properties: { name: { type: 'string' } }
+            }
+          }
+        },
+        async () => ({ ok: true })
+      );
+      await app.ready();
+
+      const response = await app.inject({
+        method: 'POST',
+        url: '/schema',
+        headers: { 'content-type': 'application/json' },
+        payload: JSON.stringify({})
+      });
+
+      expect(response.statusCode).toBe(400);
+      const body = JSON.parse(response.payload);
+      expect(body.error.status).toBe(400);
+      expect(body.error.code).toBe('FST_ERR_VALIDATION');
+    });
+
+    it('preserves the 413 status code when the body exceeds the limit', async () => {
+      const tinyApp = Fastify({ bodyLimit: 16 });
+      registerFastifyErrorHandler(tinyApp);
+      tinyApp.post('/echo', async (request) => ({ received: request.body }));
+      await tinyApp.ready();
+
+      try {
+        const response = await tinyApp.inject({
+          method: 'POST',
+          url: '/echo',
+          headers: { 'content-type': 'application/json' },
+          payload: JSON.stringify({ data: 'x'.repeat(64) })
+        });
+
+        expect(response.statusCode).toBe(413);
+        const body = JSON.parse(response.payload);
+        expect(body.error.status).toBe(413);
+        expect(body.error.code).toBe('FST_ERR_CTP_BODY_TOO_LARGE');
+      } finally {
+        await tinyApp.close();
+      }
+    });
+
+    it('preserves the 415 status code for an unsupported media type', async () => {
+      app.post('/json-only', async (request) => ({ received: request.body }));
+      // Drop the default text/plain parser so non-JSON content types are rejected.
+      app.removeContentTypeParser('text/plain');
+      await app.ready();
+
+      const response = await app.inject({
+        method: 'POST',
+        url: '/json-only',
+        headers: { 'content-type': 'text/plain' },
+        payload: 'hello'
+      });
+
+      expect(response.statusCode).toBe(415);
+      const body = JSON.parse(response.payload);
+      expect(body.error.status).toBe(415);
+      expect(body.error.code).toBe('FST_ERR_CTP_INVALID_MEDIA_TYPE');
+    });
+  });
+});

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/test/src/routes/stream.test.ts

@@ -1,6 +1,12 @@
 import { BasicRouterRequest, Context, JwtPayload, SyncRulesBucketStorage } from '@/index.js';
-import { RouterResponse, ServiceError, logger } from '@powersync/lib-services-framework';
-import { DEFAULT_HYDRATION_STATE, SqlSyncRules } from '@powersync/service-sync-rules';
+import { logger, RouterResponse, ServiceError } from '@powersync/lib-services-framework';
+import {
+  DEFAULT_HYDRATION_STATE,
+  HydrateSyncConfigParams,
+  nodeSqlite,
+  SqlSyncRules
+} from '@powersync/service-sync-rules';
+import * as sqlite from 'node:sqlite';
 import { Readable, Writable } from 'stream';
 import { pipeline } from 'stream/promises';
 import { describe, expect, it } from 'vitest';
@@ -10,6 +16,11 @@ import { DEFAULT_PARAM_LOGGING_FORMAT_OPTIONS, limitParamsForLogging } from '../
 import { mockServiceContext } from './mocks.js';
 
 describe('Stream Route', () => {
+  const defaultHydrationOptions: HydrateSyncConfigParams = {
+    hydrationState: DEFAULT_HYDRATION_STATE,
+    sqlite: nodeSqlite(sqlite)
+  };
+
   describe('compressed stream', () => {
     it('handles missing sync rules', async () => {
       const context: Context = {
@@ -45,7 +56,7 @@ describe('Stream Route', () => {
 
       const storage = {
         getParsedSyncRules() {
-          return new SqlSyncRules('bucket_definitions: {}').hydrate({ hydrationState: DEFAULT_HYDRATION_STATE });
+          return new SqlSyncRules('bucket_definitions: {}').hydrate(defaultHydrationOptions);
         },
         watchCheckpointChanges: async function* (options) {
           throw new Error('Simulated storage error');
@@ -83,7 +94,7 @@ describe('Stream Route', () => {
     it('logs the application metadata', async () => {
       const storage = {
         getParsedSyncRules() {
-          return new SqlSyncRules('bucket_definitions: {}').hydrate({ hydrationState: DEFAULT_HYDRATION_STATE });
+          return new SqlSyncRules('bucket_definitions: {}').hydrate(defaultHydrationOptions);
         },
         watchCheckpointChanges: async function* (options) {
           throw new Error('Simulated storage error');

package/test/src/storage/SourceTable.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, test } from 'vitest';
+import * as storage from '../../../src/storage/storage-index.js';
+
+/**
+ * Build a SourceTable with the current `ref`-based options shape.
+ * Data/parameter sources are not relevant to the storeCurrentData behaviour, so they default to empty.
+ */
+function makeTable(options: Partial<storage.SourceTableOptions> = {}): storage.SourceTable {
+  return new storage.SourceTable({
+    id: 'test-id',
+    ref: { connectionTag: 'test', schema: 'public', name: 'test_table' },
+    objectId: 123,
+    replicaIdColumns: [{ name: 'id' }],
+    snapshotComplete: true,
+    bucketDataSources: [],
+    parameterLookupSources: [],
+    ...options
+  });
+}
+
+describe('SourceTable', () => {
+  describe('storeCurrentData property', () => {
+    test('defaults to true', () => {
+      const table = makeTable();
+      expect(table.storeCurrentData).toBe(true);
+    });
+
+    test('can be set to false', () => {
+      const table = makeTable();
+      table.storeCurrentData = false;
+      expect(table.storeCurrentData).toBe(false);
+    });
+
+    test('is preserved when cloning', () => {
+      const table = makeTable();
+      table.storeCurrentData = false;
+      const cloned = table.clone();
+
+      expect(cloned.storeCurrentData).toBe(false);
+      expect(cloned).not.toBe(table);
+    });
+
+    test('clone preserves all properties including storeCurrentData', () => {
+      const table = makeTable({
+        replicaIdColumns: [{ name: 'id', type: 'int4' }],
+        snapshotComplete: false
+      });
+
+      table.syncData = false;
+      table.syncParameters = false;
+      table.syncEvent = false;
+      table.storeCurrentData = false;
+      table.snapshotStatus = {
+        totalEstimatedCount: 100,
+        replicatedCount: 50,
+        lastKey: Buffer.from('test')
+      };
+
+      const cloned = table.clone();
+
+      expect(cloned.syncData).toBe(false);
+      expect(cloned.syncParameters).toBe(false);
+      expect(cloned.syncEvent).toBe(false);
+      expect(cloned.storeCurrentData).toBe(false);
+      expect(cloned.snapshotStatus).toEqual(table.snapshotStatus);
+    });
+  });
+
+  describe('integration with other properties', () => {
+    test('storeCurrentData does not affect syncAny', () => {
+      const table = makeTable();
+
+      table.storeCurrentData = false;
+      table.syncData = true;
+      table.syncParameters = false;
+      table.syncEvent = false;
+
+      expect(table.syncAny).toBe(true); // Should still be true
+    });
+
+    test('storeCurrentData is independent of snapshot status', () => {
+      const table = makeTable({ snapshotComplete: false });
+
+      table.storeCurrentData = false;
+      expect(table.snapshotComplete).toBe(false);
+      expect(table.storeCurrentData).toBe(false);
+    });
+  });
+});