@pylonsync/sync 0.7.0 → 0.8.1

package/dist/index.d.ts

@@ -472,6 +472,9 @@ export declare class SyncEngine {
      *  will broadcast applied changes that our followers-mirror path
      *  picks up. */
     private onMultiTabDemoted;
+    /** Close and reopen the live transport so the next connect binds the
+     *  current token. Leader-only (followers hold no transport). */
+    private cycleTransport;
     /** Broadcast a payload to other tabs in this origin. Delegates to
      *  the orchestrator; no-op when the orchestrator isn't running
      *  (SSR-only consumers that never reach `start()`). */

package/dist/test-harness/server.d.ts

@@ -167,6 +167,30 @@ export declare class TestServer {
     delete(entity: string, id: string): void;
     /** Raw seq bump for tests that want to inject events directly. */
     nextSeqValue(): number;
+    /** The most recently issued seq (0 before any change). */
+    currentSeq(): number;
+    /**
+     * Apply one op from `/api/sync/push` the way the real server does:
+     * write the row, append a change-log entry at the next seq, and fan
+     * it out to subscribers. Returns the per-op result the server puts in
+     * `results[]`. An update/delete of a row that does not exist is
+     * rejected, not silently applied.
+     */
+    applyPushedChange(change: {
+        entity: string;
+        row_id: string;
+        kind: "insert" | "update" | "delete";
+        data?: Row;
+        op_id?: string;
+    }): {
+        op_id?: string;
+        status: "applied" | "error";
+        seq?: number;
+        error?: {
+            code: string;
+            message: string;
+        };
+    };
     /** /api/entities/<entity>/cursor — policy-filtered list.
      *  Async so the `beforeListEntityRows` hook can await state changes
      *  (e.g., land a session refresh mid-fetch). Auth is re-read AFTER

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.7.0",
+  "version": "0.8.1",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./dist/index.d.ts",

package/src/conformance.test.ts

@@ -0,0 +1,111 @@
+/**
+ * Shared sync-engine conformance scenarios.
+ *
+ * Every JSON file under `packages/sync/conformance/` runs here against
+ * the TS engine and, from the same files, against the Swift engine
+ * (`packages/swift/Tests/PylonSyncTests/SyncConformanceTests.swift`).
+ * A behavior fixed in one engine gets a scenario here so the other
+ * engine cannot drift. See `conformance/README.md` for the step schema.
+ */
+import { afterEach, describe, expect, test } from "bun:test";
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { createTestEnv, type TestEnv } from "./test-harness";
+import type { Row } from "./types";
+
+type Step =
+  | { op: "seed"; entity: string; row_id: string; kind: "insert" | "update" | "delete"; data?: Row }
+  | { op: "pull" }
+  | { op: "frame"; frame: Record<string, unknown> }
+  | { op: "update"; entity: string; id: string; data: Row }
+  | { op: "delete"; entity: string; id: string }
+  | { op: "expectRow"; entity: string; id: string; present: boolean; fields?: Row }
+  | { op: "expectCount"; entity: string; count: number }
+  | { op: "expectCursor"; last_seq: number };
+
+interface Scenario {
+  name: string;
+  steps: Step[];
+}
+
+const USER = "u1";
+const dir = join(import.meta.dir, "..", "conformance");
+const files = readdirSync(dir)
+  .filter((f) => f.endsWith(".json"))
+  .sort();
+
+describe("sync conformance", () => {
+  let env: TestEnv | null = null;
+
+  afterEach(async () => {
+    await env?.dispose();
+    env = null;
+  });
+
+  for (const file of files) {
+    const scenario = JSON.parse(readFileSync(join(dir, file), "utf8")) as Scenario;
+    test(`${file}: ${scenario.name}`, async () => {
+      env = createTestEnv({ reconnectDelay: 1 });
+      env.signIn({ userId: USER });
+      await env.start();
+      await env.flush(30);
+
+      for (const [index, step] of scenario.steps.entries()) {
+        const where = `${file} step ${index + 1} (${step.op})`;
+        switch (step.op) {
+          case "seed": {
+            if (step.kind === "insert") {
+              env.server.insert(step.entity, { ...(step.data ?? {}), id: step.row_id } as Row);
+            } else if (step.kind === "update") {
+              env.server.update(step.entity, step.row_id, step.data ?? {});
+            } else {
+              env.server.delete(step.entity, step.row_id);
+            }
+            // The harness fans server writes out over the mock WS; a
+            // scenario asserts through `pull`, so drain that delivery
+            // first to keep the two runners on the same path.
+            await env.flush(30);
+            break;
+          }
+          case "pull":
+            await env.engine.pull();
+            await env.flush(30);
+            break;
+          case "frame":
+            env.server.pushToUser(USER, step.frame);
+            await env.flush(30);
+            break;
+          case "update":
+            await env.engine.update(step.entity, step.id, step.data);
+            await env.flush(30);
+            break;
+          case "delete":
+            await env.engine.delete(step.entity, step.id);
+            await env.flush(30);
+            break;
+          case "expectRow": {
+            const row = env.engine.store.get(step.entity, step.id) as Row | null;
+            if (!step.present) {
+              expect(row, where).toBeNull();
+              break;
+            }
+            expect(row, where).not.toBeNull();
+            for (const [key, value] of Object.entries(step.fields ?? {})) {
+              expect((row as Row)[key], `${where} field ${key}`).toEqual(value);
+            }
+            break;
+          }
+          case "expectCount":
+            expect(env.engine.store.list(step.entity).length, where).toBe(step.count);
+            break;
+          case "expectCursor":
+            expect(
+              (env.engine as unknown as { cursor: { last_seq: number } }).cursor.last_seq,
+              where,
+            ).toBe(step.last_seq);
+            break;
+        }
+      }
+    });
+  }
+});

package/src/index.ts

@@ -1298,6 +1298,14 @@ export class SyncEngine {
     }
   }
 
+  /** Close and reopen the live transport so the next connect binds the
+   *  current token. Leader-only (followers hold no transport). */
+  private cycleTransport(): void {
+    if (!this.transport || !this.isMultiTabLeader || !this.running) return;
+    this.transport.stop();
+    this.transport.start();
+  }
+
   /** Broadcast a payload to other tabs in this origin. Delegates to
    *  the orchestrator; no-op when the orchestrator isn't running
    *  (SSR-only consumers that never reach `start()`). */
@@ -1754,6 +1762,13 @@ export class SyncEngine {
       // Token flipped → the cached tenant is for the previous user. Pull
       // the fresh session in parallel with the cursor catch-up below.
       void this.refreshResolvedSession();
+      // The live socket was opened with the OLD token (the bearer rides
+      // the WS subprotocol at connect time), so the server keeps
+      // fanning out the previous identity's events to it. Cycle the
+      // transport: stop() closes the socket, start() reconnects and
+      // reads the token fresh. The new socket's onConnected pull sees
+      // the token as already observed, so this does not recurse.
+      this.cycleTransport();
     }
 
     // Capture whether this pull started from cursor=0 BEFORE the

package/src/scenarios.test.ts

@@ -815,6 +815,47 @@ describe("sync scenarios", () => {
     expect((env.engine.mutations as unknown as { queue: unknown[] }).queue).toHaveLength(0);
   });
 
+  // TRANSPORT CYCLE ON IDENTITY FLIP. The WS binds the bearer token at
+  // connect time (subprotocol), so a socket opened as user A keeps
+  // receiving A's fan-out after the tab signs in as B. The token-flip
+  // path in pull() must close that socket and reconnect as B.
+  test("an identity flip reconnects the WebSocket as the new identity", async () => {
+    env = createTestEnv({ reconnectDelay: 1 });
+    env.signIn({ userId: "u1" });
+    await env.start();
+    await env.flush(50);
+    const before = env.transport.wsConnectCount();
+    expect(before).toBeGreaterThan(0);
+
+    // Sign in as a different user in the same tab and let the engine
+    // notice on its next pull (what a real sign-in triggers).
+    env.signIn({ userId: "u2" });
+    await env.engine.pull();
+    await env.flush(50);
+    expect(env.transport.wsConnectCount()).toBeGreaterThan(before);
+
+    // The live socket is now u2's: u2's fan-out lands, u1's does not.
+    env.server.pushToUser("u2", {
+      seq: env.server.nextSeqValue(),
+      entity: "Note",
+      row_id: "n-u2",
+      kind: "insert",
+      data: { id: "n-u2", title: "for u2" },
+      timestamp: "",
+    });
+    env.server.pushToUser("u1", {
+      seq: env.server.nextSeqValue(),
+      entity: "Note",
+      row_id: "n-u1",
+      kind: "insert",
+      data: { id: "n-u1", title: "for u1" },
+      timestamp: "",
+    });
+    await env.flush(50);
+    expect(env.engine.store.get("Note", "n-u2")).not.toBeNull();
+    expect(env.engine.store.get("Note", "n-u1")).toBeNull();
+  });
+
   test("a same-user 410 resync PRESERVES pending offline writes", async () => {
     env = createTestEnv({ transport: "poll" });
     env.signIn({ userId: "u1" });

package/src/test-harness/server.ts

@@ -355,6 +355,46 @@ export class TestServer {
     return this.bumpSeq();
   }
 
+  /** The most recently issued seq (0 before any change). */
+  currentSeq(): number {
+    return this.nextSeq;
+  }
+
+  /**
+   * Apply one op from `/api/sync/push` the way the real server does:
+   * write the row, append a change-log entry at the next seq, and fan
+   * it out to subscribers. Returns the per-op result the server puts in
+   * `results[]`. An update/delete of a row that does not exist is
+   * rejected, not silently applied.
+   */
+  applyPushedChange(change: {
+    entity: string;
+    row_id: string;
+    kind: "insert" | "update" | "delete";
+    data?: Row;
+    op_id?: string;
+  }): { op_id?: string; status: "applied" | "error"; seq?: number; error?: { code: string; message: string } } {
+    const { entity, row_id, kind, op_id } = change;
+    const exists = this.rows.get(entity)?.has(row_id) ?? false;
+    if (kind === "insert") {
+      this.insert(entity, { ...(change.data ?? {}), id: row_id } as Row);
+      return { op_id, status: "applied", seq: this.nextSeq };
+    }
+    if (!exists) {
+      return {
+        op_id,
+        status: "error",
+        error: { code: "NOT_FOUND", message: `${entity}/${row_id} does not exist` },
+      };
+    }
+    if (kind === "update") {
+      this.update(entity, row_id, change.data ?? {});
+    } else {
+      this.delete(entity, row_id);
+    }
+    return { op_id, status: "applied", seq: this.nextSeq };
+  }
+
   // ---- Read paths the engine calls ----------------------------------------
 
   /** /api/entities/<entity>/cursor — policy-filtered list.

package/src/test-harness/transport.ts

@@ -341,7 +341,36 @@ async function handle(
         body: { error: { code: "PUSH_REJECTED" } },
       };
     }
-    return { status: 200, body: { ops: [] } };
+    // Apply the ops like the real server: rows + change log + fan-out,
+    // and answer with the per-op `results[]` shape the engine maps by
+    // op_id. A stub that applied nothing left every pushed mutation
+    // pending and the server's own echo of the write never existed.
+    let changes: Array<{
+      entity: string;
+      row_id: string;
+      kind: "insert" | "update" | "delete";
+      data?: Record<string, unknown>;
+      op_id?: string;
+    }> = [];
+    try {
+      const body = typeof _init?.body === "string" ? JSON.parse(_init.body) : null;
+      changes = Array.isArray(body?.changes) ? body.changes : [];
+    } catch {
+      changes = [];
+    }
+    const results = changes.map((c) => server.applyPushedChange(c));
+    const applied = results.filter((r) => r.status === "applied").length;
+    const maxApplied = results.reduce((m, r) => Math.max(m, r.seq ?? 0), 0);
+    return {
+      status: 200,
+      body: {
+        applied,
+        errors: results.filter((r) => r.status === "error").map((r) => r.error?.message ?? "rejected"),
+        results,
+        cursor: { last_seq: server.currentSeq() },
+        max_applied_seq: maxApplied > 0 ? maxApplied : undefined,
+      },
+    };
   }
 
   // Anything else: 404 with a clear error so test failures point