@powersync/service-core 1.27.2 → 1.28.0

package/test/src/sync/BucketChecksumState.test.ts

@@ -20,9 +20,9 @@ import {
   ParameterLookupDefinitionId,
   ParameterLookupRows,
   ParameterLookupScope,
+  parseSyncConfig,
   ScopedParameterLookup,
   SourceTableRef,
-  SqlSyncRules,
   TablePattern,
   versionedHydrationState
 } from '@powersync/service-sync-rules';
@@ -58,7 +58,7 @@ describe('BucketChecksumState', () => {
 
   // Single global[] bucket.
   // We don't care about data in these tests
-  const SYNC_RULES_GLOBAL = SqlSyncRules.fromYaml(
+  const SYNC_RULES_GLOBAL = parseSyncConfig(
     `
 bucket_definitions:
   global:
@@ -68,7 +68,7 @@ bucket_definitions:
   ).config.hydrate({ hydrationState: versionedHydrationState(1), sqlite: nodeSqlite(sqlite) });
 
   // global[1] and global[2]
-  const SYNC_RULES_GLOBAL_TWO = SqlSyncRules.fromYaml(
+  const SYNC_RULES_GLOBAL_TWO = parseSyncConfig(
     `
 bucket_definitions:
   global:
@@ -81,7 +81,7 @@ bucket_definitions:
   ).config.hydrate({ hydrationState: versionedHydrationState(2), sqlite: nodeSqlite(sqlite) });
 
   // by_project[n]
-  const SYNC_RULES_DYNAMIC = SqlSyncRules.fromYaml(
+  const SYNC_RULES_DYNAMIC = parseSyncConfig(
     `
 bucket_definitions:
   by_project:
@@ -698,7 +698,7 @@ config:
 `;
       }
 
-      const rules = SqlSyncRules.fromYaml(source, {
+      const rules = parseSyncConfig(source, {
         defaultSchema: 'public'
       }).config.hydrate({ hydrationState: versionedHydrationState(1), sqlite: nodeSqlite(sqlite) });
 
@@ -1137,7 +1137,7 @@ config:
     });
 
     test('throws error with breakdown when too many parameters were fetched', async () => {
-      const syncRules = SqlSyncRules.fromYaml(
+      const syncRules = parseSyncConfig(
         `
 config:
   edition: 3
@@ -1241,7 +1241,7 @@ streams:
     });
 
     test('throws error when too many lookups are requested at once', async () => {
-      const syncRules = SqlSyncRules.fromYaml(
+      const syncRules = parseSyncConfig(
         `
 config:
   edition: 3
@@ -1309,7 +1309,7 @@ streams:
     test('throws error with breakdown when bucket limit is exceeded', async () => {
       // These streams are designed to return buckets without consuming too many parameters (as exceeding that limit is
       // a different error).
-      const SYNC_RULES_MULTI = SqlSyncRules.fromYaml(
+      const SYNC_RULES_MULTI = parseSyncConfig(
         `
 config:
   edition: 3
@@ -1387,7 +1387,7 @@ streams:
     });
 
     test('labels the bucket breakdown as bucket definitions for legacy sync rules', async () => {
-      const legacySyncRules = SqlSyncRules.fromYaml(
+      const legacySyncRules = parseSyncConfig(
         `
 bucket_definitions:
   projects:
@@ -1445,7 +1445,7 @@ streams:
         yamlDefinitions += `    query: SELECT * FROM tbl WHERE b = auth.parameter('${i}')\n`;
       }
 
-      const SYNC_RULES_MANY = SqlSyncRules.fromYaml(yamlDefinitions, { defaultSchema: 'public' }).config.hydrate({
+      const SYNC_RULES_MANY = parseSyncConfig(yamlDefinitions, { defaultSchema: 'public' }).config.hydrate({
         hydrationState: versionedHydrationState(5),
         sqlite: nodeSqlite(sqlite)
       });

package/test/src/sync/stream_response.test.ts

@@ -0,0 +1,389 @@
+import {
+  BucketChecksumState,
+  CHECKPOINT_INVALIDATE_ALL,
+  ChecksumCache,
+  ChecksumMap,
+  FetchPartialBucketChecksum,
+  JwtPayload,
+  RequestTracker,
+  streamResponse,
+  SyncRulesBucketStorage
+} from '@/index.js';
+import { DEFAULT_HYDRATION_STATE, HydratedSyncConfig, nodeSqlite, SqlSyncRules } from '@powersync/service-sync-rules';
+import * as sqlite from 'node:sqlite';
+import { describe, expect, test, vi } from 'vitest';
+import { mockServiceContext } from '../routes/mocks.js';
+
+const syncRules = SqlSyncRules.fromYaml(
+  `
+config:
+  edition: 3
+streams:
+  test:
+    query: SELECT * FROM test
+`,
+  { defaultSchema: 'public' }
+).config.hydrate({ hydrationState: DEFAULT_HYDRATION_STATE, sqlite: nodeSqlite(sqlite) });
+
+function response(
+  storage: Partial<SyncRulesBucketStorage>,
+  signal: AbortSignal,
+  config: HydratedSyncConfig = syncRules
+) {
+  const context = mockServiceContext(storage);
+  return streamResponse({
+    syncContext: context.syncContext,
+    bucketStorage: storage as SyncRulesBucketStorage,
+    syncRules: config,
+    params: { streams: { subscriptions: [{ stream: 'test', parameters: null, override_priority: null }] } },
+    token: new JwtPayload({ sub: 'test-user', exp: Date.now() / 1000 + 3600 }),
+    tracker: new RequestTracker(context.metricsEngine),
+    isEncodingAsBson: false,
+    signal
+  })[Symbol.asyncIterator]();
+}
+
+describe('streamResponse cancellation', () => {
+  test('preserves a checksum failure before cancellation', async () => {
+    const failure = new Error('checksum query failed');
+    const iterator = response(
+      {
+        watchCheckpointChanges: async function* () {
+          yield {
+            base: { checkpoint: 1n, lsn: null, getParameterSets: vi.fn() },
+            writeCheckpoint: null,
+            update: CHECKPOINT_INVALIDATE_ALL
+          };
+        },
+        getChecksums: async () => {
+          throw failure;
+        }
+      },
+      new AbortController().signal
+    );
+    await expect(iterator.next()).rejects.toBe(failure);
+  });
+
+  test('a data fetch failure cancels an overlapping checkpoint calculation', async () => {
+    const controller = new AbortController();
+    const started = Promise.withResolvers<void>();
+    const fetch = Promise.withResolvers<ChecksumMap>();
+    const failure = new Error('data fetch failed');
+    let closed = false;
+    const iterator = response(
+      {
+        watchCheckpointChanges: async function* () {
+          try {
+            for (const checkpoint of [1n, 2n]) {
+              yield {
+                base: { checkpoint, lsn: null, getParameterSets: vi.fn() },
+                writeCheckpoint: null,
+                update: CHECKPOINT_INVALIDATE_ALL
+              };
+            }
+          } finally {
+            closed = true;
+          }
+        },
+        getChecksums: async (checkpoint, buckets) => {
+          if (checkpoint.checkpoint === 2n) {
+            started.resolve();
+            return fetch.promise;
+          }
+          return new Map(buckets.map(({ bucket }) => [bucket, { bucket, checksum: 1, count: 1000 }]));
+        },
+        getBucketDataBatch: async function* (_checkpoint, buckets) {
+          yield {
+            chunkData: {
+              bucket: buckets[0].bucket,
+              data: Array.from({ length: 1000 }, (_, i) => ({ op: 'PUT' as const, op_id: String(i + 1), checksum: 1 })),
+              has_more: true,
+              after: '0',
+              next_after: '1000'
+            },
+            targetOp: null
+          };
+          await started.promise;
+          throw failure;
+        }
+      },
+      controller.signal
+    );
+    const consume = async () => {
+      while (!(await iterator.next()).done) {}
+    };
+    let finished = false;
+    const completion = expect(
+      consume().finally(() => {
+        finished = true;
+      })
+    ).rejects.toBe(failure);
+    await started.promise;
+    await new Promise<void>((resolve) => setImmediate(resolve));
+    expect(finished).toBe(false);
+    fetch.resolve(new Map());
+    await completion;
+    expect(controller.signal.aborted).toBe(false);
+    expect(closed).toBe(true);
+  });
+
+  test('checks cancellation after an incremental checksum read finishes', async () => {
+    const controller = new AbortController();
+    const started = Promise.withResolvers<void>();
+    const fetch = Promise.withResolvers<ChecksumMap>();
+    const getChecksums = vi
+      .fn<SyncRulesBucketStorage['getChecksums']>()
+      .mockImplementation(
+        async (_cp, buckets) => new Map(buckets.map(({ bucket }) => [bucket, { bucket, checksum: 1, count: 1 }]))
+      );
+    const context = mockServiceContext({});
+    const state = new BucketChecksumState({
+      syncContext: context.syncContext,
+      bucketStorage: { getChecksums },
+      syncRules,
+      syncRequest: { streams: { subscriptions: [{ stream: 'test', parameters: null, override_priority: null }] } },
+      tokenPayload: new JwtPayload({ sub: 'test-user' })
+    });
+    const base = { checkpoint: 1n, lsn: null, getParameterSets: vi.fn() };
+    const first = (await state.buildNextCheckpointLine({
+      base,
+      writeCheckpoint: null,
+      update: CHECKPOINT_INVALIDATE_ALL
+    }))!;
+    first.advance();
+    getChecksums.mockImplementation(() => {
+      started.resolve();
+      return fetch.promise;
+    });
+
+    const pending = state.buildNextCheckpointLine(
+      {
+        base: { ...base, checkpoint: 2n },
+        writeCheckpoint: null,
+        update: {
+          ...CHECKPOINT_INVALIDATE_ALL,
+          invalidateDataBuckets: false,
+          updatedDataBuckets: new Set(first.bucketsToFetch.map((b) => b.bucket))
+        }
+      },
+      undefined,
+      controller.signal
+    );
+    const reason = new Error('client disconnected during checkpoint diff');
+    const completion = expect(pending).rejects.toBe(reason);
+    await started.promise;
+    controller.abort(reason);
+    fetch.resolve(new Map());
+    await completion;
+  });
+
+  test('finishes a pending parameter read before cancellation, without starting checksum work', async () => {
+    const config = SqlSyncRules.fromYaml(
+      `
+config:
+  edition: 3
+streams:
+  test:
+    query: SELECT * FROM test WHERE id IN (SELECT id FROM memberships WHERE user_id = auth.user_id())
+`,
+      { defaultSchema: 'public' }
+    ).config.hydrate({ hydrationState: DEFAULT_HYDRATION_STATE, sqlite: nodeSqlite(sqlite) });
+    const controller = new AbortController();
+    const started = Promise.withResolvers<void>();
+    const read = Promise.withResolvers<never[]>();
+    const getChecksums = vi.fn();
+    let closed = false;
+    const iterator = response(
+      {
+        watchCheckpointChanges: async function* () {
+          try {
+            yield {
+              base: {
+                checkpoint: 1n,
+                lsn: null,
+                getParameterSets: () => {
+                  started.resolve();
+                  return read.promise;
+                }
+              },
+              writeCheckpoint: null,
+              update: CHECKPOINT_INVALIDATE_ALL
+            };
+          } finally {
+            closed = true;
+          }
+        },
+        getChecksums
+      },
+      controller.signal,
+      config
+    );
+    const next = iterator.next();
+    await started.promise;
+    controller.abort();
+    await new Promise<void>((resolve) => setImmediate(resolve));
+    expect(closed).toBe(false);
+    read.resolve([]);
+    await expect(next).resolves.toEqual({ done: true, value: undefined });
+    expect(closed).toBe(true);
+    expect(getChecksums).not.toHaveBeenCalled();
+  });
+
+  test.each(['success', 'failure'] as const)(
+    'waits for a shared checksum fetch to finish with %s before closing',
+    async (outcome) => {
+      const started = Promise.withResolvers<void>();
+      const fetch = Promise.withResolvers<ChecksumMap>();
+      const fetchChecksums = vi.fn((_batch: FetchPartialBucketChecksum[]) => fetch.promise);
+      const cache = new ChecksumCache({ fetchChecksums });
+      const controller = new AbortController();
+      const checkpoint = { checkpoint: 1n, lsn: null, getParameterSets: vi.fn() };
+      let closed = false;
+      let shared: Promise<PromiseSettledResult<ChecksumMap>>;
+      const iterator = response(
+        {
+          watchCheckpointChanges: async function* () {
+            try {
+              yield { base: checkpoint, writeCheckpoint: null, update: CHECKPOINT_INVALIDATE_ALL };
+            } finally {
+              closed = true;
+            }
+          },
+          getChecksums: (_checkpoint, buckets) => {
+            const first = cache.getChecksumMap(1n, buckets);
+            // A second connection shares this fetch and must survive the first disconnecting.
+            shared = Promise.allSettled([cache.getChecksumMap(1n, buckets)]).then(([result]) => result);
+            started.resolve();
+            return first;
+          }
+        },
+        controller.signal
+      );
+
+      const next = Promise.allSettled([iterator.next()]).then(([result]) => result);
+      await started.promise;
+      controller.abort(new Error('client disconnected'));
+      // In-flight storage work finishes normally before cancellation is observed.
+      await new Promise<void>((resolve) => setImmediate(resolve));
+      expect(closed).toBe(false);
+      expect(fetchChecksums).toHaveBeenCalledTimes(1);
+
+      if (outcome === 'success') {
+        const bucket = fetchChecksums.mock.calls[0][0][0].bucket;
+        const checksums = new Map([[bucket, { bucket, checksum: 42, count: 1 }]]);
+        fetch.resolve(checksums);
+        await expect(shared!).resolves.toEqual({ status: 'fulfilled', value: checksums });
+        await expect(next).resolves.toEqual({ status: 'fulfilled', value: { done: true, value: undefined } });
+      } else {
+        const error = new Error('checksum query failed after disconnect');
+        fetch.reject(error);
+        await expect(shared!).resolves.toEqual({ status: 'rejected', reason: error });
+        const result = await next;
+        expect(result.status).toBe('rejected');
+        if (result.status === 'rejected') {
+          const errors = result.reason instanceof AggregateError ? result.reason.errors : [result.reason];
+          expect(errors).toContain(error);
+        }
+      }
+      expect(closed).toBe(true);
+    }
+  );
+
+  test.each([
+    { reason: new Error('client disconnected') },
+    { reason: 'client disconnected' },
+    { reason: 0 },
+    { reason: false },
+    { reason: '' },
+    { reason: null },
+    { reason: NaN },
+    { reason: undefined }
+  ])('ends without error for abort reason $reason, before and during a read', async ({ reason }) => {
+    const watch = vi.fn(async function* () {});
+    const preAborted = response({ watchCheckpointChanges: watch }, AbortSignal.abort(reason));
+    await expect(preAborted.next()).resolves.toEqual({ done: true, value: undefined });
+    expect(watch).not.toHaveBeenCalled();
+
+    const started = Promise.withResolvers<void>();
+    const controller = new AbortController();
+    let closed = false;
+    const iterator = response(
+      {
+        watchCheckpointChanges: async function* ({ signal }) {
+          try {
+            started.resolve();
+            await new Promise<void>((_resolve, reject) => {
+              signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+            });
+          } finally {
+            closed = true;
+          }
+        }
+      },
+      controller.signal
+    );
+    const next = iterator.next();
+    const completion = expect(next).resolves.toEqual({ done: true, value: undefined });
+    await started.promise;
+    controller.abort(reason);
+    await completion;
+    expect(closed).toBe(true);
+  });
+
+  test('does not suppress cleanup failures alongside cancellation', async () => {
+    const started = Promise.withResolvers<void>();
+    const controller = new AbortController();
+    const reason = new Error('client disconnected');
+    const cleanupError = new Error('watcher cleanup failed');
+    const iterator = response(
+      {
+        watchCheckpointChanges: async function* ({ signal }) {
+          try {
+            started.resolve();
+            await new Promise<void>((_resolve, reject) => {
+              signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+            });
+          } finally {
+            throw cleanupError;
+          }
+        }
+      },
+      controller.signal
+    );
+    const outcome = iterator.next().catch((error) => error);
+    await started.promise;
+    controller.abort(reason);
+    const error = await outcome;
+    expect(error).toBeInstanceOf(AggregateError);
+    const failures = error.errors.flatMap((failure: unknown) =>
+      failure instanceof AggregateError ? failure.errors : [failure]
+    );
+    expect(failures).toContain(cleanupError);
+  });
+
+  test('does not suppress an unrelated failure when the signal is also aborted', async () => {
+    const controller = new AbortController();
+    const failure = new Error('storage failed');
+    const iterator = response(
+      {
+        watchCheckpointChanges: async function* () {
+          try {
+            throw failure;
+          } finally {
+            // The source error starts shutdown before the caller cancels in the same turn.
+            queueMicrotask(() => controller.abort(new Error('client disconnected')));
+          }
+        }
+      },
+      controller.signal
+    );
+    const outcome = await iterator.next().catch((error) => error);
+    expect(controller.signal.aborted).toBe(true);
+    expect(outcome).toBeInstanceOf(Error);
+    if (outcome instanceof AggregateError) {
+      expect(outcome.errors).toContain(failure);
+    } else {
+      expect(outcome).toBe(failure);
+    }
+  });
+});

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

@@ -1,17 +1,28 @@
 import { acquireSemaphoreAbortable, isAbortError } from '@/index.js';
 import { Semaphore, SemaphoreInterface } from 'async-mutex';
-import { AbortError } from 'ix/aborterror.js';
+import { setTimeout } from 'node:timers/promises';
 import { describe, expect, test, vi } from 'vitest';
 
 describe('isAbortError', () => {
-  test('recognizes ix and native abort errors', () => {
+  test('recognizes DOM and Node abort errors', () => {
     const controller = new AbortController();
     controller.abort();
 
-    expect(isAbortError(new AbortError())).toBe(true);
+    expect(isAbortError(new DOMException('Cancelled', 'AbortError'))).toBe(true);
+    expect(isAbortError(Object.assign(new Error('Cancelled'), { name: 'AbortError' }))).toBe(true);
     expect(isAbortError(controller.signal.reason)).toBe(true);
     expect(isAbortError(new Error('not aborted'))).toBe(false);
   });
+
+  test('recognizes timer cancellation with the original reason as its cause', async () => {
+    const controller = new AbortController();
+    const reason = new Error('cancelled');
+    const timer = setTimeout(60_000, undefined, { signal: controller.signal });
+    controller.abort(reason);
+    const error = await timer.catch((error) => error);
+    expect(isAbortError(error)).toBe(true);
+    expect(error.cause).toBe(reason);
+  });
 });
 
 describe('acquireSemaphoreAbortable', () => {