@syncular/client 0.0.1 → 0.0.2-126

package/src/create-client.ts

@@ -9,6 +9,8 @@
  */
 
 import type {
+  ColumnCodecDialect,
+  ColumnCodecSource,
   ScopeDefinition,
   ScopeValues,
   SyncTransport,
@@ -57,10 +59,19 @@ function deriveDefaultSubscriptionScopes<DB>(args: {
 function createAutoHandler<
   DB extends SyncClientDb,
   TableName extends keyof DB & string,
->(table: string, scopes: string[]): ClientTableHandler<DB, TableName> {
+>(
+  table: string,
+  scopes: string[],
+  options: {
+    columnCodecs?: ColumnCodecSource;
+    codecDialect?: ColumnCodecDialect;
+  }
+): ClientTableHandler<DB, TableName> {
   return createClientHandler<DB, TableName>({
     table: table as TableName,
     scopes: scopes as ScopeDefinition[],
+    columnCodecs: options.columnCodecs,
+    codecDialect: options.codecDialect,
   });
 }
 
@@ -132,6 +143,12 @@ interface CreateClientOptions<DB extends SyncClientDb> {
   /** Optional: State ID for multi-tenant scenarios */
   stateId?: string;
 
+  /** Optional: Column codec resolver */
+  columnCodecs?: ColumnCodecSource;
+
+  /** Optional: Codec dialect override (default: 'sqlite') */
+  codecDialect?: ColumnCodecDialect;
+
   /** Optional: Auto-start sync (default: true) */
   autoStart?: boolean;
 }
@@ -194,6 +211,8 @@ export async function createClient<DB extends SyncClientDb>(
     blobStorage,
     plugins,
     stateId,
+    columnCodecs,
+    codecDialect,
     autoStart = true,
   } = options;
 
@@ -209,7 +228,10 @@ export async function createClient<DB extends SyncClientDb>(
   const handlers =
     providedHandlers ??
     tables!.map((table) =>
-      createAutoHandler<DB, keyof DB & string>(table, scopes!)
+      createAutoHandler<DB, keyof DB & string>(table, scopes!, {
+        columnCodecs,
+        codecDialect,
+      })
     );
 
   // Build registry from handlers array
@@ -247,13 +269,17 @@ export async function createClient<DB extends SyncClientDb>(
         });
         return {
           id: handler.table,
-          shape: handler.table,
+          table: handler.table,
           scopes,
           params: {},
         };
       }
       // Custom subscription config
-      const scopes: ScopeValues = sub.scopes ?? {};
+      const scopes: ScopeValues = {};
+      for (const [scopeKey, scopeValue] of Object.entries(sub.scopes ?? {})) {
+        if (scopeValue === undefined) continue;
+        scopes[scopeKey] = scopeValue;
+      }
       if (Object.keys(scopes).length === 0) {
         throw new Error(
           `Handler "${handler.table}" subscription scopes cannot be empty. ` +
@@ -262,7 +288,7 @@ export async function createClient<DB extends SyncClientDb>(
       }
       return {
         id: handler.table,
-        shape: handler.table,
+        table: handler.table,
         scopes,
         params: sub.params ?? {},
       };
@@ -280,6 +306,8 @@ export async function createClient<DB extends SyncClientDb>(
     blobStorage,
     plugins,
     stateId,
+    columnCodecs,
+    codecDialect,
     realtimeEnabled: sync.realtime ?? true,
     pollIntervalMs: sync.pollIntervalMs,
   });

package/src/engine/SyncEngine.test.ts

@@ -0,0 +1,157 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import type { SyncChange, SyncTransport } from '@syncular/core';
+import type { Kysely } from 'kysely';
+import { sql } from 'kysely';
+import { createBunSqliteDb } from '../../../dialect-bun-sqlite/src';
+import { ClientTableRegistry } from '../handlers/registry';
+import { ensureClientSyncSchema } from '../migrate';
+import type { SyncClientDb } from '../schema';
+import { SyncEngine } from './SyncEngine';
+
+interface TasksTable {
+  id: string;
+  title: string;
+  server_version: number;
+}
+
+interface TestDb extends SyncClientDb {
+  tasks: TasksTable;
+}
+
+const noopTransport: SyncTransport = {
+  async sync() {
+    return {};
+  },
+  async fetchSnapshotChunk() {
+    return new Uint8Array();
+  },
+};
+
+describe('SyncEngine WS inline apply', () => {
+  let db: Kysely<TestDb>;
+
+  beforeEach(async () => {
+    db = createBunSqliteDb<TestDb>({ path: ':memory:' });
+    await ensureClientSyncSchema(db);
+
+    await db.schema
+      .createTable('tasks')
+      .addColumn('id', 'text', (col) => col.primaryKey())
+      .addColumn('title', 'text', (col) => col.notNull())
+      .addColumn('server_version', 'integer', (col) =>
+        col.notNull().defaultTo(0)
+      )
+      .execute();
+
+    await db
+      .insertInto('tasks')
+      .values({
+        id: 't1',
+        title: 'old',
+        server_version: 1,
+      })
+      .execute();
+
+    await db
+      .insertInto('sync_subscription_state')
+      .values({
+        state_id: 'default',
+        subscription_id: 'sub-1',
+        table: 'tasks',
+        scopes_json: '{}',
+        params_json: '{}',
+        cursor: 0,
+        bootstrap_state_json: null,
+        status: 'active',
+        created_at: Date.now(),
+        updated_at: Date.now(),
+      })
+      .execute();
+  });
+
+  afterEach(async () => {
+    await db.destroy();
+  });
+
+  it('rolls back row updates and cursor when any inline WS change fails', async () => {
+    const handlers = new ClientTableRegistry<TestDb>().register({
+      table: 'tasks',
+      async applySnapshot() {},
+      async clearAll() {},
+      async applyChange(ctx, change) {
+        if (change.row_id === 'fail') {
+          throw new Error('forced apply failure');
+        }
+        const rowJson =
+          change.row_json && typeof change.row_json === 'object'
+            ? change.row_json
+            : null;
+        const title =
+          rowJson && 'title' in rowJson ? String(rowJson.title ?? '') : '';
+        await sql`
+          update ${sql.table('tasks')}
+          set
+            ${sql.ref('title')} = ${sql.val(title)},
+            ${sql.ref('server_version')} = ${sql.val(Number(change.row_version ?? 0))}
+          where ${sql.ref('id')} = ${sql.val(change.row_id)}
+        `.execute(ctx.trx);
+      },
+    });
+
+    const engine = new SyncEngine<TestDb>({
+      db,
+      transport: noopTransport,
+      handlers,
+      actorId: 'u1',
+      clientId: 'client-1',
+      subscriptions: [],
+      stateId: 'default',
+    });
+
+    const changes: SyncChange[] = [
+      {
+        table: 'tasks',
+        row_id: 't1',
+        op: 'upsert',
+        row_json: { id: 't1', title: 'new' },
+        row_version: 2,
+        scopes: {},
+      },
+      {
+        table: 'tasks',
+        row_id: 'fail',
+        op: 'upsert',
+        row_json: { id: 'fail', title: 'bad' },
+        row_version: 1,
+        scopes: {},
+      },
+    ];
+
+    const applyWsDeliveredChanges = Reflect.get(
+      engine,
+      'applyWsDeliveredChanges'
+    );
+    if (typeof applyWsDeliveredChanges !== 'function') {
+      throw new Error('Expected applyWsDeliveredChanges to be callable');
+    }
+    const applied = await applyWsDeliveredChanges.call(engine, changes, 10);
+
+    expect(applied).toBe(false);
+
+    const task = await db
+      .selectFrom('tasks')
+      .select(['title', 'server_version'])
+      .where('id', '=', 't1')
+      .executeTakeFirstOrThrow();
+    expect(task.title).toBe('old');
+    expect(task.server_version).toBe(1);
+
+    const state = await db
+      .selectFrom('sync_subscription_state')
+      .select(['cursor'])
+      .where('state_id', '=', 'default')
+      .where('subscription_id', '=', 'sub-1')
+      .executeTakeFirstOrThrow();
+    expect(state.cursor).toBe(0);
+  });
+});