@syncular/client 0.0.6-158 → 0.0.6-165

package/src/engine/SyncEngine.test.ts

@@ -15,6 +15,7 @@ import { ensureClientSyncSchema } from '../migrate';
 import { enqueueOutboxCommit } from '../outbox';
 import type { SyncClientDb } from '../schema';
 import { SyncEngine } from './SyncEngine';
+import type { RealtimeTransportLike } from './types';
 
 interface TasksTable {
   id: string;
@@ -1016,6 +1017,83 @@ describe('SyncEngine WS inline apply', () => {
     }
   });
 
+  it('stops realtime reconnect and fallback polling after auth failures', async () => {
+    let syncAttempts = 0;
+    let disconnectCalls = 0;
+    let reconnectCalls = 0;
+
+    const authFailingRealtimeTransport: RealtimeTransportLike = {
+      async sync() {
+        syncAttempts += 1;
+        throw new SyncTransportError('unauthorized', 401);
+      },
+      async fetchSnapshotChunk() {
+        return new Uint8Array();
+      },
+      connect(_args, _onEvent, onStateChange) {
+        onStateChange?.('disconnected');
+        return () => {
+          disconnectCalls += 1;
+        };
+      },
+      getConnectionState() {
+        return 'disconnected';
+      },
+      reconnect() {
+        reconnectCalls += 1;
+      },
+    };
+
+    const handlers: ClientHandlerCollection<TestDb> = [
+      {
+        table: 'tasks',
+        async applySnapshot() {},
+        async clearAll() {},
+        async applyChange() {},
+      },
+    ];
+
+    const engine = new SyncEngine<TestDb>({
+      db,
+      transport: authFailingRealtimeTransport,
+      handlers,
+      actorId: 'u1',
+      clientId: 'client-auth-failed-realtime',
+      subscriptions: [
+        {
+          id: 'sub-1',
+          table: 'tasks',
+          scopes: {},
+        },
+      ],
+      stateId: 'default',
+      realtimeFallbackPollMs: 10,
+      pollIntervalMs: 60_000,
+    });
+
+    await engine.start();
+
+    try {
+      const state = engine.getState();
+      expect(state.error?.code).toBe('AUTH_FAILED');
+      expect(state.error?.retryable).toBe(false);
+      expect(state.connectionState).toBe('disconnected');
+
+      const health = engine.getTransportHealth();
+      expect(health.mode).toBe('disconnected');
+      expect(health.connected).toBe(false);
+      expect(health.fallbackReason).toBe('auth');
+
+      const attemptsAfterStart = syncAttempts;
+      await new Promise<void>((resolve) => setTimeout(resolve, 40));
+      expect(syncAttempts).toBe(attemptsAfterStart);
+      expect(disconnectCalls).toBeGreaterThanOrEqual(1);
+      expect(reconnectCalls).toBe(0);
+    } finally {
+      engine.destroy();
+    }
+  });
+
   it('repairs rebootstrap-missing-chunks by clearing synced state and data', async () => {
     const outboxId = 'outbox-1';
     const now = Date.now();

package/src/engine/SyncEngine.ts

@@ -1901,6 +1901,25 @@ export class SyncEngine<DB extends SyncClientDb = SyncClientDb> {
       this.handleError(error);
       await this.emitNewConflictsSafe('sync error');
 
+      if (error.code === 'AUTH_FAILED') {
+        if (
+          this.state.transportMode === 'realtime' &&
+          isRealtimeTransport(this.config.transport)
+        ) {
+          this.stopRealtime();
+          this.setConnectionState('disconnected');
+          this.updateTransportHealth({
+            mode: 'disconnected',
+            connected: false,
+            fallbackReason: 'auth',
+          });
+        } else {
+          this.updateTransportHealth({
+            fallbackReason: 'auth',
+          });
+        }
+      }
+
       const durationMs = Math.max(0, Date.now() - startedAtMs);
       countSyncMetric('sync.client.sync.results', 1, {
         attributes: {

package/src/handlers/collection.ts

@@ -1,3 +1,4 @@
+import { createTableLookup } from '@syncular/core';
 import type { ClientTableHandler } from './types';
 
 export type ClientHandlerCollection<DB> = ClientTableHandler<DB>[];
@@ -5,15 +6,10 @@ export type ClientHandlerCollection<DB> = ClientTableHandler<DB>[];
 export function createClientHandlerCollection<DB>(
   handlers: ClientTableHandler<DB>[]
 ): ClientHandlerCollection<DB> {
-  const tables = new Set<string>();
-  for (const handler of handlers) {
-    if (tables.has(handler.table)) {
-      throw new Error(
-        `Client table handler already registered: ${handler.table}`
-      );
-    }
-    tables.add(handler.table);
-  }
+  createTableLookup(
+    handlers,
+    (table) => `Client table handler already registered: ${table}`
+  );
   return handlers;
 }
 

package/src/handlers/create-handler.ts

@@ -13,9 +13,9 @@ import type {
 } from '@syncular/core';
 import {
   applyCodecsToDbRow,
+  createTableColumnCodecsResolver,
   isRecord,
   normalizeScopes,
-  toTableColumnCodecs,
 } from '@syncular/core';
 import { sql } from 'kysely';
 import type { SyncClientDb } from '../schema';
@@ -176,25 +176,13 @@ export function createClientHandler<
     options.primaryKey ?? ('id' as keyof DB[TableName] & string);
   const versionColumn = options.versionColumn;
   const codecDialect = options.codecDialect ?? 'sqlite';
-  const codecCache = new Map<string, ReturnType<typeof toTableColumnCodecs>>();
-  const resolveTableCodecs = (row: Record<string, unknown>) => {
-    const codecs = options.codecs;
-    if (!codecs) return {};
-    const columns = Object.keys(row);
-    if (columns.length === 0) return {};
-    const cacheKey = columns.slice().sort().join('\u0000');
-    const cached = codecCache.get(cacheKey);
-    if (cached) return cached;
-    const resolved = toTableColumnCodecs(table, codecs, columns, {
-      dialect: codecDialect,
-    });
-    codecCache.set(cacheKey, resolved);
-    return resolved;
-  };
+  const resolveRowCodecs = createTableColumnCodecsResolver(options.codecs, {
+    dialect: codecDialect,
+  });
+  const resolveTableCodecs = (row: Record<string, unknown>) =>
+    resolveRowCodecs(table, row);
 
-  // Normalize scopes to pattern map (stored for metadata)
-  const scopeColumnMap = normalizeScopes(scopeDefs);
-  const scopePatterns = Object.keys(scopeColumnMap);
+  const scopePatterns = Object.keys(normalizeScopes(scopeDefs));
 
   // Default applySnapshot: upsert all rows
   const defaultApplySnapshot = async (

package/src/mutations.ts

@@ -23,9 +23,9 @@ import type {
 } from '@syncular/core';
 import {
   applyCodecsToDbRow,
+  createTableColumnCodecsResolver,
   isRecord,
   randomId,
-  toTableColumnCodecs,
 } from '@syncular/core';
 import type { Insertable, Kysely, Transaction, Updateable } from 'kysely';
 import { sql } from 'kysely';
@@ -469,38 +469,10 @@ export function createOutboxCommit<DB extends SyncClientDb>(
       .transaction()
       .execute(async (trx) => {
         const txTableCache = new Map<string, any>();
-        const tableCodecCache = new Map<
-          string,
-          Map<string, ReturnType<typeof toTableColumnCodecs>>
-        >();
-        const resolveTableCodecs = (
-          table: string,
-          row: Record<string, unknown>
-        ) => {
-          const codecs = config.codecs;
-          if (!codecs) return {};
-          const columns = Object.keys(row);
-          if (columns.length === 0) return {};
-
-          let tableCache = tableCodecCache.get(table);
-          if (!tableCache) {
-            tableCache = new Map<
-              string,
-              ReturnType<typeof toTableColumnCodecs>
-            >();
-            tableCodecCache.set(table, tableCache);
-          }
-
-          const cacheKey = columns.slice().sort().join('\u0000');
-          const cached = tableCache.get(cacheKey);
-          if (cached) return cached;
-
-          const resolved = toTableColumnCodecs(table, codecs, columns, {
-            dialect: codecDialect,
-          });
-          tableCache.set(cacheKey, resolved);
-          return resolved;
-        };
+        const resolveTableCodecs = createTableColumnCodecsResolver(
+          config.codecs,
+          { dialect: codecDialect }
+        );
 
         const makeTxTable = (table: string) => {
           const cached = txTableCache.get(table);

package/src/pull-engine.ts

@@ -3,6 +3,7 @@
  */
 
 import type {
+  ScopeValues,
   SyncBootstrapState,
   SyncPullRequest,
   SyncPullResponse,
@@ -307,12 +308,15 @@ async function computeSha256Hex(
 
 async function fetchSnapshotChunkStream(
   transport: SyncTransport,
-  chunkId: string
+  request: {
+    chunkId: string;
+    scopeValues?: ScopeValues;
+  }
 ): Promise<ReadableStream<Uint8Array>> {
   if (transport.fetchSnapshotChunkStream) {
-    return transport.fetchSnapshotChunkStream({ chunkId });
+    return transport.fetchSnapshotChunkStream(request);
   }
-  const bytes = await transport.fetchSnapshotChunk({ chunkId });
+  const bytes = await transport.fetchSnapshotChunk(request);
   return bytesToReadableStream(bytes);
 }
 
@@ -404,7 +408,10 @@ async function materializeChunkedSnapshots(
             async (chunk) => {
               const promise =
                 chunkCache.get(chunk.id) ??
-                transport.fetchSnapshotChunk({ chunkId: chunk.id });
+                transport.fetchSnapshotChunk({
+                  chunkId: chunk.id,
+                  scopeValues: sub.scopes,
+                });
               chunkCache.set(chunk.id, promise);
 
               const raw = await promise;
@@ -451,6 +458,7 @@ async function applyChunkedSnapshot<DB extends SyncClientDb>(
   handler: Pick<ClientTableHandler<DB>, 'applySnapshot'>,
   trx: Transaction<DB>,
   snapshot: SyncSnapshot,
+  scopeValues: ScopeValues,
   sha256Override?: (bytes: Uint8Array) => Promise<string>
 ): Promise<void> {
   const chunks = snapshot.chunks ?? [];
@@ -465,7 +473,10 @@ async function applyChunkedSnapshot<DB extends SyncClientDb>(
     const chunk = chunks[chunkIndex];
     if (!chunk) continue;
 
-    const rawStream = await fetchSnapshotChunkStream(transport, chunk.id);
+    const rawStream = await fetchSnapshotChunkStream(transport, {
+      chunkId: chunk.id,
+      scopeValues,
+    });
     const decodedStream = await maybeGunzipStream(rawStream);
     let applyStream = decodedStream;
     let chunkHashPromise: Promise<string> | null = null;
@@ -777,6 +788,27 @@ export async function applyPullResponse<DB extends SyncClientDb>(
 
     const subsById = new Map<string, (typeof options.subscriptions)[number]>();
     for (const s of options.subscriptions ?? []) subsById.set(s.id, s);
+    const latestStateRows = await sql<{
+      subscription_id: string;
+      cursor: number | string | null;
+    }>`
+      select
+        ${sql.ref('subscription_id')} as subscription_id,
+        ${sql.ref('cursor')} as cursor
+      from ${sql.table('sync_subscription_state')}
+      where ${sql.ref('state_id')} = ${sql.val(stateId)}
+    `.execute(trx);
+    const latestCursorBySubscriptionId = new Map<string, number | null>();
+    for (const row of latestStateRows.rows) {
+      const raw = row.cursor;
+      const cursor =
+        typeof raw === 'number'
+          ? raw
+          : raw === null || raw === undefined
+            ? null
+            : Number(raw);
+      latestCursorBySubscriptionId.set(row.subscription_id, cursor);
+    }
 
     for (const sub of responseToApply.subscriptions) {
       const def = subsById.get(sub.id);
@@ -788,13 +820,7 @@ export async function applyPullResponse<DB extends SyncClientDb>(
           : prevCursorRaw === null || prevCursorRaw === undefined
             ? null
             : Number(prevCursorRaw);
-      const latestStateResult = await sql<{ cursor: number | string | null }>`
-        select ${sql.ref('cursor')} as cursor
-        from ${sql.table('sync_subscription_state')}
-        where ${sql.ref('state_id')} = ${sql.val(stateId)}
-          and ${sql.ref('subscription_id')} = ${sql.val(sub.id)}
-      `.execute(trx);
-      const latestCursorRaw = latestStateResult.rows[0]?.cursor;
+      const latestCursorRaw = latestCursorBySubscriptionId.get(sub.id);
       const latestCursor =
         typeof latestCursorRaw === 'number'
           ? latestCursorRaw
@@ -841,10 +867,11 @@ export async function applyPullResponse<DB extends SyncClientDb>(
         }
 
         await sql`
-	          delete from ${sql.table('sync_subscription_state')}
-	          where ${sql.ref('state_id')} = ${sql.val(stateId)}
-	            and ${sql.ref('subscription_id')} = ${sql.val(sub.id)}
-	        `.execute(trx);
+		          delete from ${sql.table('sync_subscription_state')}
+		          where ${sql.ref('state_id')} = ${sql.val(stateId)}
+		            and ${sql.ref('subscription_id')} = ${sql.val(sub.id)}
+		        `.execute(trx);
+        latestCursorBySubscriptionId.delete(sub.id);
         continue;
       }
 
@@ -870,6 +897,7 @@ export async function applyPullResponse<DB extends SyncClientDb>(
               handler,
               trx,
               snapshot,
+              sub.scopes,
               options.sha256
             );
           } else {
@@ -919,7 +947,7 @@ export async function applyPullResponse<DB extends SyncClientDb>(
 
       const table = def?.table ?? 'unknown';
       await sql`
-	        insert into ${sql.table('sync_subscription_state')} (
+		        insert into ${sql.table('sync_subscription_state')} (
 	          ${sql.join([
               sql.ref('state_id'),
               sql.ref('subscription_id'),
@@ -953,9 +981,10 @@ export async function applyPullResponse<DB extends SyncClientDb>(
 	          ${sql.ref('params_json')} = ${sql.val(paramsJson)},
 	          ${sql.ref('cursor')} = ${sql.val(sub.nextCursor)},
 	          ${sql.ref('bootstrap_state_json')} = ${sql.val(bootstrapStateJson)},
-	          ${sql.ref('status')} = ${sql.val('active')},
-	          ${sql.ref('updated_at')} = ${sql.val(now)}
-	      `.execute(trx);
+		          ${sql.ref('status')} = ${sql.val('active')},
+		          ${sql.ref('updated_at')} = ${sql.val(now)}
+		      `.execute(trx);
+      latestCursorBySubscriptionId.set(sub.id, sub.nextCursor);
     }
   });
 

package/src/sync.ts

@@ -6,6 +6,7 @@ import type {
   ScopeValuesFromPatterns,
   SyncSubscriptionRequest,
 } from '@syncular/core';
+import { registerTableOrThrow } from '@syncular/core';
 import {
   type CreateClientHandlerOptions,
   createClientHandler,
@@ -116,11 +117,11 @@ export function defineClientSync<
         Identity
       >
     ) {
-      if (registeredTables.has(handlerOptions.table)) {
-        throw new Error(
-          `Client table handler already registered: ${handlerOptions.table}`
-        );
-      }
+      registerTableOrThrow(
+        registeredTables,
+        handlerOptions.table,
+        (table) => `Client table handler already registered: ${table}`
+      );
 
       handlers.push(
         createClientHandler({
@@ -139,7 +140,6 @@ export function defineClientSync<
           Identity
         >['subscribe']
       );
-      registeredTables.add(handlerOptions.table);
       return sync;
     },
     subscriptions(