@syncular/client 0.0.6-100 → 0.0.6-101

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/client",
-  "version": "0.0.6-100",
+  "version": "0.0.6-101",
   "description": "Client-side sync engine with offline-first support, outbox, and conflict resolution",
   "license": "Apache-2.0",
   "author": "Benjamin Kniffler",
@@ -46,8 +46,8 @@
     "release": "bunx syncular-publish"
   },
   "dependencies": {
-    "@syncular/core": "0.0.6-100",
-    "@syncular/transport-http": "0.0.6-100"
+    "@syncular/core": "0.0.6-101",
+    "@syncular/transport-http": "0.0.6-101"
   },
   "peerDependencies": {
     "kysely": "*"

package/src/engine/SyncEngine.test.ts

@@ -3,6 +3,7 @@ import {
   createDatabase,
   type SyncChange,
   type SyncTransport,
+  SyncTransportError,
 } from '@syncular/core';
 import type { Kysely } from 'kysely';
 import { sql } from 'kysely';
@@ -251,4 +252,154 @@ describe('SyncEngine WS inline apply', () => {
       await coldDb.destroy();
     }
   });
+
+  it('classifies missing snapshot chunk pull failures as non-retryable', async () => {
+    const missingChunkTransport: SyncTransport = {
+      async sync() {
+        throw new SyncTransportError('snapshot chunk not found', 404);
+      },
+      async fetchSnapshotChunk() {
+        return new Uint8Array();
+      },
+    };
+
+    const handlers: ClientHandlerCollection<TestDb> = [
+      {
+        table: 'tasks',
+        async applySnapshot() {},
+        async clearAll() {},
+        async applyChange() {},
+      },
+    ];
+
+    const engine = new SyncEngine<TestDb>({
+      db,
+      transport: missingChunkTransport,
+      handlers,
+      actorId: 'u1',
+      clientId: 'client-missing-chunk',
+      subscriptions: [
+        {
+          id: 'sub-1',
+          table: 'tasks',
+          scopes: {},
+        },
+      ],
+      stateId: 'default',
+      pollIntervalMs: 60_000,
+      maxRetries: 3,
+    });
+
+    await engine.start();
+    engine.stop();
+
+    const state = engine.getState();
+    expect(state.error?.code).toBe('SNAPSHOT_CHUNK_NOT_FOUND');
+    expect(state.error?.retryable).toBe(false);
+    expect(state.retryCount).toBe(1);
+    expect(state.isRetrying).toBe(false);
+  });
+
+  it('repairs rebootstrap-missing-chunks by clearing synced state and data', async () => {
+    const outboxId = 'outbox-1';
+    const now = Date.now();
+
+    await db
+      .insertInto('tasks')
+      .values({
+        id: 't2',
+        title: 'to-clear',
+        server_version: 2,
+      })
+      .execute();
+
+    await db
+      .insertInto('sync_outbox_commits')
+      .values({
+        id: outboxId,
+        client_commit_id: 'client-commit-1',
+        status: 'pending',
+        operations_json: '[]',
+        last_response_json: null,
+        error: null,
+        created_at: now,
+        updated_at: now,
+        acked_commit_seq: null,
+      })
+      .execute();
+
+    await db
+      .insertInto('sync_conflicts')
+      .values({
+        id: 'conflict-1',
+        outbox_commit_id: outboxId,
+        client_commit_id: 'client-commit-1',
+        op_index: 0,
+        result_status: 'conflict',
+        message: 'forced conflict',
+        code: 'TEST_CONFLICT',
+        server_version: 1,
+        server_row_json: '{}',
+        created_at: now,
+        resolved_at: null,
+        resolution: null,
+      })
+      .execute();
+
+    const handlers: ClientHandlerCollection<TestDb> = [
+      {
+        table: 'tasks',
+        async applySnapshot() {},
+        async clearAll(ctx) {
+          await sql`delete from ${sql.table('tasks')}`.execute(ctx.trx);
+        },
+        async applyChange() {},
+      },
+    ];
+
+    const engine = new SyncEngine<TestDb>({
+      db,
+      transport: noopTransport,
+      handlers,
+      actorId: 'u1',
+      clientId: 'client-repair',
+      subscriptions: [],
+      stateId: 'default',
+    });
+
+    const result = await engine.repair({
+      mode: 'rebootstrap-missing-chunks',
+      clearOutbox: true,
+      clearConflicts: true,
+    });
+
+    expect(result.deletedSubscriptionStates).toBe(1);
+    expect(result.deletedOutboxCommits).toBe(1);
+    expect(result.deletedConflicts).toBe(1);
+    expect(result.clearedTables).toEqual(['tasks']);
+
+    const tasksCount = await db
+      .selectFrom('tasks')
+      .select(({ fn }) => fn.countAll().as('total'))
+      .executeTakeFirst();
+    expect(Number(tasksCount?.total ?? 0)).toBe(0);
+
+    const subscriptionsCount = await db
+      .selectFrom('sync_subscription_state')
+      .select(({ fn }) => fn.countAll().as('total'))
+      .executeTakeFirst();
+    expect(Number(subscriptionsCount?.total ?? 0)).toBe(0);
+
+    const outboxCount = await db
+      .selectFrom('sync_outbox_commits')
+      .select(({ fn }) => fn.countAll().as('total'))
+      .executeTakeFirst();
+    expect(Number(outboxCount?.total ?? 0)).toBe(0);
+
+    const conflictsCount = await db
+      .selectFrom('sync_conflicts')
+      .select(({ fn }) => fn.countAll().as('total'))
+      .executeTakeFirst();
+    expect(Number(conflictsCount?.total ?? 0)).toBe(0);
+  });
 });

package/src/pull-engine.test.ts

@@ -148,4 +148,145 @@ describe('applyPullResponse chunk streaming', () => {
     expect(Number(countResult.rows[0]?.count ?? 0)).toBe(rows.length);
     expect(streamFetchCount).toBe(1);
   });
+
+  it('rolls back partial chunked bootstrap when a later chunk fails', async () => {
+    const firstRows = Array.from({ length: 1500 }, (_, index) => ({
+      id: `${index + 1}`,
+      name: `Item ${index + 1}`,
+    }));
+    const secondRows = Array.from({ length: 1500 }, (_, index) => ({
+      id: `${index + 1501}`,
+      name: `Item ${index + 1501}`,
+    }));
+
+    const firstChunk = new Uint8Array(gzipSync(encodeSnapshotRows(firstRows)));
+    const secondChunk = new Uint8Array(
+      gzipSync(encodeSnapshotRows(secondRows))
+    );
+
+    let failSecondChunk = true;
+    const transport: SyncTransport = {
+      async sync() {
+        return {};
+      },
+      async fetchSnapshotChunk() {
+        throw new Error('fetchSnapshotChunk should not be used');
+      },
+      async fetchSnapshotChunkStream({ chunkId }) {
+        if (chunkId === 'chunk-2' && failSecondChunk) {
+          throw new Error('chunk-2 missing');
+        }
+        if (chunkId === 'chunk-1') {
+          return createStreamFromBytes(firstChunk, 317);
+        }
+        if (chunkId === 'chunk-2') {
+          return createStreamFromBytes(secondChunk, 503);
+        }
+        throw new Error(`Unexpected chunk id: ${chunkId}`);
+      },
+    };
+
+    const handlers: ClientHandlerCollection<TestDb> = [
+      createClientHandler({
+        table: 'items',
+        scopes: ['items:{id}'],
+      }),
+    ];
+
+    const options = {
+      clientId: 'client-1',
+      subscriptions: [
+        {
+          id: 'items-sub',
+          table: 'items',
+          scopes: {},
+        },
+      ],
+      stateId: 'default',
+    };
+
+    const response: SyncPullResponse = {
+      ok: true,
+      subscriptions: [
+        {
+          id: 'items-sub',
+          status: 'active',
+          scopes: {},
+          bootstrap: true,
+          bootstrapState: null,
+          nextCursor: 12,
+          commits: [],
+          snapshots: [
+            {
+              table: 'items',
+              rows: [],
+              chunks: [
+                {
+                  id: 'chunk-1',
+                  byteLength: firstChunk.length,
+                  sha256: '',
+                  encoding: 'json-row-frame-v1',
+                  compression: 'gzip',
+                },
+                {
+                  id: 'chunk-2',
+                  byteLength: secondChunk.length,
+                  sha256: '',
+                  encoding: 'json-row-frame-v1',
+                  compression: 'gzip',
+                },
+              ],
+              isFirstPage: true,
+              isLastPage: true,
+            },
+          ],
+        },
+      ],
+    };
+
+    const firstPullState = await buildPullRequest(db, options);
+    await expect(
+      applyPullResponse(
+        db,
+        transport,
+        handlers,
+        options,
+        firstPullState,
+        response
+      )
+    ).rejects.toThrow('chunk-2 missing');
+
+    const countAfterFailure = await sql<{ count: number }>`
+      select count(*) as count
+      from ${sql.table('items')}
+    `.execute(db);
+    expect(Number(countAfterFailure.rows[0]?.count ?? 0)).toBe(0);
+
+    const stateAfterFailure = await db
+      .selectFrom('sync_subscription_state')
+      .select(({ fn }) => fn.countAll().as('total'))
+      .where('state_id', '=', 'default')
+      .where('subscription_id', '=', 'items-sub')
+      .executeTakeFirst();
+    expect(Number(stateAfterFailure?.total ?? 0)).toBe(0);
+
+    failSecondChunk = false;
+    const retryPullState = await buildPullRequest(db, options);
+    await applyPullResponse(
+      db,
+      transport,
+      handlers,
+      options,
+      retryPullState,
+      response
+    );
+
+    const countAfterRetry = await sql<{ count: number }>`
+      select count(*) as count
+      from ${sql.table('items')}
+    `.execute(db);
+    expect(Number(countAfterRetry.rows[0]?.count ?? 0)).toBe(
+      firstRows.length + secondRows.length
+    );
+  });
 });