@powersync/service-core 1.25.0 → 1.26.1

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

@@ -34,6 +34,7 @@ describe('admin routes', () => {
     syncConfigId?: string;
     active?: boolean;
     content?: string;
+    version_label?: string;
   }): storage.PersistedSyncConfigContent {
     const id = options.id ?? 1;
     const syncConfigId = options.syncConfigId ?? String(id);
@@ -66,6 +67,7 @@ bucket_definitions:
       compiled_plan: null,
       storageVersion: storage.LEGACY_STORAGE_VERSION,
       syncConfigState: syncConfigStatus.state,
+      version_label: options.version_label,
       parsed(options?: any) {
         const syncRules = SqlSyncRules.fromYaml(content.sync_rules_content, {
           ...options,
@@ -113,7 +115,7 @@ bucket_definitions:
 
   describe('diagnostics', () => {
     it('returns deploying config status', async () => {
-      const active = makeSyncConfigContent({ id: 1, syncConfigId: 'active-config' });
+      const active = makeSyncConfigContent({ id: 1, syncConfigId: 'active-config', version_label: 'v5' });
       const deploying = makeSyncConfigContent({ id: 2, syncConfigId: 'deploying-config', active: false });
       const getInstance = vi.fn(() => ({
         async getStatus() {
@@ -144,12 +146,13 @@ bucket_definitions:
 
       expect(response.deploying_sync_rules?.connections[0].slot_name).toBe('slot_2');
       expect(response.active_sync_rules?.connections[0].slot_name).toBe('slot_1');
+      expect(response.active_sync_rules?.version_label).toBe('v5');
     });
   });
 
   describe('reprocess', () => {
     it('reprocesses the active sync config', async () => {
-      const active = makeSyncConfigContent({ id: 7, syncConfigId: 'active-config' });
+      const active = makeSyncConfigContent({ id: 7, syncConfigId: 'active-config', version_label: 'v6' });
       const updateSyncRules = vi.fn(async () => ({
         replicationStreamId: 8,
         replicationStreamName: 'new_slot',
@@ -178,6 +181,9 @@ bucket_definitions:
       expect(activeBucketStorage.getActiveSyncConfig).toHaveBeenCalledTimes(1);
       expect(activeBucketStorage.getSyncConfigContent).not.toHaveBeenCalled();
       expect(updateSyncRules).toHaveBeenCalledTimes(1);
+      expect(updateSyncRules).toHaveBeenCalledWith(
+        expect.objectContaining({ version_label: 'v6', forceNewReplicationStream: true })
+      );
       expect(response.connections[0].slot_name).toBe('new_slot');
     });
 

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

@@ -1,4 +1,12 @@
-import { BasicRouterRequest, Context, JwtPayload, SyncRulesBucketStorage } from '@/index.js';
+import {
+  BasicRouterRequest,
+  CHECKPOINT_INVALIDATE_ALL,
+  Context,
+  JwtPayload,
+  RequestTracker,
+  streamResponse,
+  SyncRulesBucketStorage
+} from '@/index.js';
 import { logger, RouterResponse, ServiceError } from '@powersync/lib-services-framework';
 import {
   DEFAULT_HYDRATION_STATE,
@@ -9,7 +17,7 @@ import {
 import * as sqlite from 'node:sqlite';
 import { Readable, Writable } from 'stream';
 import { pipeline } from 'stream/promises';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } 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';
@@ -182,6 +190,119 @@ describe('Stream Route', () => {
       );
     });
   });
+
+  it('closes after a data fetch error while waiting for a new checkpoint', async () => {
+    // After 1,000 operations, the sync stream concurrently calls next() on the
+    // checkpoint watcher. This test then fails the next data fetch without
+    // producing another checkpoint. Before the fix, awaiting watcher.return()
+    // during cleanup queued it behind that pending next(), leaving the response
+    // open until an unrelated checkpoint was written.
+    const syncRules = SqlSyncRules.fromYaml(
+      `
+bucket_definitions:
+  global:
+    data: []
+      `,
+      { defaultSchema: 'public' }
+    ).config.hydrate(defaultHydrationOptions);
+
+    let checkpointWatcherAborted = false;
+    let dataFetches = 0;
+    const storage = {
+      watchCheckpointChanges: async function* ({ signal }) {
+        yield {
+          base: {
+            checkpoint: 1n,
+            lsn: '1',
+            getParameterSets: async () => []
+          },
+          writeCheckpoint: null,
+          update: CHECKPOINT_INVALIDATE_ALL
+        };
+
+        await new Promise<void>((_resolve, reject) => {
+          // There is intentionally no next checkpoint: cleanup must abort this
+          // pending wait rather than wait for it to complete naturally.
+          signal.addEventListener(
+            'abort',
+            () => {
+              checkpointWatcherAborted = true;
+              reject(new Error('Checkpoint watcher aborted'));
+            },
+            { once: true }
+          );
+        });
+      },
+      getChecksums: async (_checkpoint, buckets) =>
+        new Map(buckets.map(({ bucket }) => [bucket, { bucket, checksum: 1, count: 1000 }])),
+      getBucketDataBatch: async function* () {
+        if (dataFetches++ > 0) {
+          throw new Error('Simulated data fetch failure');
+        }
+
+        yield {
+          chunkData: {
+            bucket: 'global[]',
+            data: Array.from({ length: 1000 }, () => ({ op: 'PUT' })),
+            has_more: true,
+            after: '0',
+            next_after: '1000'
+          },
+          targetOp: null
+        };
+        yield { hasMore: true };
+      }
+    } as Partial<SyncRulesBucketStorage>;
+    const serviceContext = mockServiceContext(storage);
+    const controller = new AbortController();
+    const checkpointLogger = logger.child({});
+    const checkpointLogSpy = vi.spyOn(checkpointLogger, 'info');
+
+    const response = (async () => {
+      for await (const _line of streamResponse({
+        syncContext: serviceContext.syncContext,
+        bucketStorage: storage as SyncRulesBucketStorage,
+        syncRules,
+        params: { client_id: 'test-client', raw_data: true },
+        token: new JwtPayload({ sub: 'test-user', exp: Date.now() / 1000 + 10_000 }),
+        tracker: new RequestTracker(serviceContext.metricsEngine),
+        isEncodingAsBson: false,
+        signal: controller.signal,
+        logger: checkpointLogger
+      })) {
+        // Consume the response until the simulated data fetch error is propagated.
+      }
+    })();
+
+    let timeout: NodeJS.Timeout | undefined;
+    const outcome = await Promise.race([
+      response.then(
+        () => new Error('Sync stream unexpectedly completed'),
+        (error) => error
+      ),
+      new Promise((resolve) => {
+        timeout = setTimeout(() => resolve(new Error('Sync stream did not close')), 500);
+      })
+    ]);
+    clearTimeout(timeout);
+
+    // Capture this before aborting below, which would set it regardless of the stream cleanup.
+    const abortedByCleanup = checkpointWatcherAborted;
+
+    controller.abort();
+    await response.catch(() => {});
+
+    expect(outcome).toBeInstanceOf(Error);
+    expect((outcome as Error).message).toContain('Simulated data fetch failure');
+    expect(abortedByCleanup).toBe(true);
+    expect(checkpointLogSpy).toHaveBeenCalledWith('checkpoint_interrupted: 1', {
+      checkpoint: 1n,
+      user_id: 'test-user',
+      operations_synced: 1000,
+      data_synced_bytes: 0,
+      ms: expect.any(Object)
+    });
+  });
 });
 
 export async function drainWithTimeout(readable: Readable, ms = 2_000) {

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

@@ -43,7 +43,8 @@ describe('SourceTable', () => {
     test('clone preserves all properties including storeCurrentData', () => {
       const table = makeTable({
         replicaIdColumns: [{ name: 'id', type: 'int4' }],
-        snapshotComplete: false
+        snapshotComplete: false,
+        eventDefinitionIds: new Set(['event-1'])
       });
 
       table.syncData = false;
@@ -63,6 +64,8 @@ describe('SourceTable', () => {
       expect(cloned.syncEvent).toBe(false);
       expect(cloned.storeCurrentData).toBe(false);
       expect(cloned.snapshotStatus).toEqual(table.snapshotStatus);
+      expect(cloned.eventDefinitionIds).toEqual(new Set(['event-1']));
+      expect(cloned.eventDefinitionIds).not.toBe(table.eventDefinitionIds);
     });
   });
 

package/test/src/storage-metrics.test.ts

@@ -0,0 +1,148 @@
+import { MetricsEngine } from '@/metrics/MetricsEngine.js';
+import {
+  MetricMetadata,
+  MetricsFactory,
+  ObservableGauge,
+  ObservableGaugeObservation
+} from '@/metrics/metrics-interfaces.js';
+import { BucketStorageFactory, StorageMetrics, StorageSyncConfigMetrics } from '@/storage/BucketStorageFactory.js';
+import { createCoreStorageMetrics, initializeCoreStorageMetrics } from '@/storage/storage-metrics.js';
+import { StorageMetric } from '@powersync/service-types';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+type ValueProvider = () => Promise<number | ObservableGaugeObservation[] | undefined>;
+
+function testEngine() {
+  const providers = new Map<string, ValueProvider>();
+  const factory: MetricsFactory = {
+    createCounter: () => ({ add: () => {} }),
+    createUpDownCounter: () => ({ add: () => {} }),
+    createObservableGauge: (metadata: MetricMetadata): ObservableGauge => ({
+      setValueProvider: (valueProvider) => providers.set(metadata.name, valueProvider)
+    })
+  };
+  const engine = new MetricsEngine({ factory, disable_telemetry_sharing: true });
+  createCoreStorageMetrics(engine);
+  return { engine, providers };
+}
+
+function syncConfigMetrics(id: string, state: string, bytes: number, versionLabel?: string): StorageSyncConfigMetrics {
+  return {
+    sync_config_id: id,
+    sync_config_state: state,
+    version_label: versionLabel,
+    attributed_bucket_data_bytes: bytes,
+    attributed_parameter_indexes_bytes: bytes,
+    attributed_source_records_bytes: bytes,
+    attributed_object_storage_bytes: bytes
+  };
+}
+
+function storageMetrics(sync_config_metrics: StorageSyncConfigMetrics[]): StorageMetrics {
+  return {
+    operations_size_bytes: 0,
+    parameters_size_bytes: 0,
+    replication_size_bytes: 0,
+    object_storage_size_bytes: 0,
+    sync_config_metrics
+  };
+}
+
+describe('storage metrics', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('reports retired sync configs as zero, then stops reporting them', async () => {
+    let current = storageMetrics([syncConfigMetrics('config-a', 'ACTIVE', 100)]);
+    const storage = {
+      getStorageMetrics: async () => current
+    } as unknown as BucketStorageFactory;
+
+    const { engine, providers } = testEngine();
+    initializeCoreStorageMetrics(engine, storage);
+    const provider = providers.get(StorageMetric.ATTRIBUTED_BUCKET_DATA_BYTES)!;
+
+    expect(await provider()).toEqual([
+      { value: 100, attributes: { sync_config_id: 'config-a', sync_config_state: 'ACTIVE' } }
+    ]);
+
+    // The sync config is pruned. Its series must go to zero rather than keep its last value,
+    // since the SDK carries the last reported value forward under cumulative temporality.
+    current = storageMetrics([syncConfigMetrics('config-b', 'ACTIVE', 50)]);
+    vi.setSystemTime(61_000);
+
+    expect(await provider()).toEqual([
+      { value: 50, attributes: { sync_config_id: 'config-b', sync_config_state: 'ACTIVE' } },
+      { value: 0, attributes: { sync_config_id: 'config-a', sync_config_state: 'ACTIVE' } }
+    ]);
+
+    // Once every reader has had a chance to observe the zero, stop reporting it entirely.
+    vi.setSystemTime(61_000 + 16 * 60_000);
+
+    expect(await provider()).toEqual([
+      { value: 50, attributes: { sync_config_id: 'config-b', sync_config_state: 'ACTIVE' } }
+    ]);
+  });
+
+  it('treats a state transition as a retired attribute set', async () => {
+    let current = storageMetrics([syncConfigMetrics('config-a', 'PROCESSING', 100, 'v1')]);
+    const storage = {
+      getStorageMetrics: async () => current
+    } as unknown as BucketStorageFactory;
+
+    const { engine, providers } = testEngine();
+    initializeCoreStorageMetrics(engine, storage);
+    const provider = providers.get(StorageMetric.ATTRIBUTED_SOURCE_RECORDS_BYTES)!;
+
+    await provider();
+
+    current = storageMetrics([syncConfigMetrics('config-a', 'ACTIVE', 120, 'v1')]);
+    vi.setSystemTime(61_000);
+
+    expect(await provider()).toEqual([
+      {
+        value: 120,
+        attributes: { sync_config_id: 'config-a', sync_config_state: 'ACTIVE', version_label: 'v1' }
+      },
+      {
+        value: 0,
+        attributes: { sync_config_id: 'config-a', sync_config_state: 'PROCESSING', version_label: 'v1' }
+      }
+    ]);
+  });
+
+  it('does not report anything as retired when reading the metrics fails', async () => {
+    let fail = false;
+    const storage = {
+      getStorageMetrics: async () => {
+        if (fail) {
+          throw new Error('storage unavailable');
+        }
+        return storageMetrics([syncConfigMetrics('config-a', 'ACTIVE', 100)]);
+      }
+    } as unknown as BucketStorageFactory;
+
+    const { engine, providers } = testEngine();
+    initializeCoreStorageMetrics(engine, storage);
+    const provider = providers.get(StorageMetric.ATTRIBUTED_OBJECT_STORAGE_BYTES)!;
+
+    await provider();
+
+    fail = true;
+    vi.setSystemTime(61_000);
+    expect(await provider()).toBeUndefined();
+
+    // The failure must not be interpreted as the sync config having been pruned.
+    fail = false;
+    vi.setSystemTime(122_000);
+    expect(await provider()).toEqual([
+      { value: 100, attributes: { sync_config_id: 'config-a', sync_config_state: 'ACTIVE' } }
+    ]);
+  });
+});

package/test/src/sync/util.test.ts

@@ -15,6 +15,25 @@ describe('isAbortError', () => {
 });
 
 describe('acquireSemaphoreAbortable', () => {
+  test('waits for an available slot without a signal', async () => {
+    const semaphore = new Semaphore(1);
+    const [, release] = await semaphore.acquire();
+    const resolved = vi.fn();
+    const waiting = acquireSemaphoreAbortable(semaphore).then((result) => {
+      resolved();
+      return result;
+    });
+    await Promise.resolve();
+    expect(resolved).not.toHaveBeenCalled();
+
+    release();
+    const acquired = await waiting;
+    expect(acquired).not.toBe('aborted');
+    expect(semaphore.getValue()).toBe(0);
+    (acquired as [number, SemaphoreInterface.Releaser])[1]();
+    expect(semaphore.getValue()).toBe(1);
+  });
+
   test('can acquire', async () => {
     const semaphore = new Semaphore(1);
     const controller = new AbortController();
@@ -43,4 +62,19 @@ describe('acquireSemaphoreAbortable', () => {
     // Releasing the semaphore should not invoke resolve again
     release();
   });
+
+  test('does not wait when the signal is already aborted', async () => {
+    const semaphore = new Semaphore(1);
+    const controller = new AbortController();
+
+    // Hold the only slot, so acquiring would block indefinitely.
+    const result = await acquireSemaphoreAbortable(semaphore, controller.signal);
+    expect(result).not.toBe('aborted');
+    const [, release] = result as [number, SemaphoreInterface.Releaser];
+
+    controller.abort();
+    expect(await acquireSemaphoreAbortable(semaphore, controller.signal)).toBe('aborted');
+
+    release();
+  });
 });

package/test/src/util/utils.test.ts

@@ -0,0 +1,23 @@
+import { formatBytes } from '@/index.js';
+import { describe, expect, test } from 'vitest';
+
+describe('formatBytes', () => {
+  test('formats bytes', () => {
+    expect(formatBytes(500)).toBe('500B');
+  });
+
+  test('formats kilobytes', () => {
+    expect(formatBytes(1024)).toBe('1.0KB');
+    expect(formatBytes(1536)).toBe('1.5KB');
+  });
+
+  test('formats megabytes', () => {
+    expect(formatBytes(1024 * 1024)).toBe('1.0MB');
+    expect(formatBytes(1.5 * 1024 * 1024)).toBe('1.5MB');
+  });
+
+  test('formats gigabytes', () => {
+    expect(formatBytes(1024 * 1024 * 1024)).toBe('1.0GB');
+    expect(formatBytes(10.5 * 1024 * 1024 * 1024)).toBe('10.5GB');
+  });
+});