@pylonsync/sync 0.22.47 → 0.22.58

package/src/test-harness/server.ts

@@ -221,6 +221,9 @@ export class TestServer {
    *  answers. Lets a test queue a write while a push is in flight. */
   pushGate: Promise<void> | null = null;
 
+  /** The file endpoints (`/api/files/init`, PUT, `/api/files/confirm`). */
+  readonly files = new TestFileServer(this);
+
   /** Entities whose pushed writes are rejected per op, like a write
    *  policy denial on the real server (HTTP 200 with a per-op error). */
   private deniedWrites = new Map<string, { code: string; message: string }>();
@@ -228,6 +231,22 @@ export class TestServer {
     this.deniedWrites.set(entity, { code, message });
   }
 
+  /** Reject a pushed insert/update of `entity` whose fields match
+   *  `predicate`, like a write policy that checks a field value. */
+  private conditionalDenials: Array<{
+    entity: string;
+    predicate: (data: Row) => boolean;
+    error: { code: string; message: string };
+  }> = [];
+  rejectWritesWhere(
+    entity: string,
+    predicate: (data: Row) => boolean,
+    code = "POLICY_DENIED",
+    message = "write denied by policy",
+  ): void {
+    this.conditionalDenials.push({ entity, predicate, error: { code, message } });
+  }
+
   private nextPushOutcome:
     | { kind: "network" }
     | { kind: "status"; status: number }
@@ -390,6 +409,11 @@ export class TestServer {
     if (denied) {
       return { op_id, status: "error", error: denied };
     }
+    if (kind !== "delete") {
+      const merged = { ...(this.rows.get(entity)?.get(row_id) ?? {}), ...(change.data ?? {}) } as Row;
+      const rule = this.conditionalDenials.find((d) => d.entity === entity && d.predicate(merged));
+      if (rule) return { op_id, status: "error", error: rule.error };
+    }
     const exists = this.rows.get(entity)?.has(row_id) ?? false;
     if (kind === "insert") {
       this.insert(entity, { ...(change.data ?? {}), id: row_id } as Row);
@@ -428,6 +452,60 @@ export class TestServer {
     return this.visible(entity, all, auth).map((r) => this.project(entity, r));
   }
 
+  /** When true, /api/sync/pull answers like the real server's snapshot
+   *  path: a pull from 0 (or a delta pull with `snapshot_ok=1` and a cursor
+   *  `farBehind` accepts) gets the current visible rows as insert events,
+   *  paged by `limit`, flagged `snapshot`, with `snapshot_entities` on the
+   *  last page. Off by default: older tests expect the log replay. */
+  snapshotMode = false;
+  /** In `snapshotMode`: delta cursors answered with a snapshot. */
+  farBehind: (since: number) => boolean = () => false;
+  /** In `snapshotMode`: leave `snapshot_entities` off the last page, like a
+   *  server from before it was added. */
+  omitSnapshotEntities = false;
+
+  /** One snapshot page for `snapshotMode`. `offset` is the continuation. */
+  snapshotPage(
+    token: string | undefined,
+    offset: number,
+    limit: number,
+  ): {
+    changes: ChangeEvent[];
+    cursor: SyncCursor;
+    has_more: boolean;
+    snapshot: true;
+    snapshot_after: string | null;
+    snapshot_entities?: string[];
+  } {
+    if (offset === 0) this.snapshotPullCount += 1;
+    const auth = this.authContextFor(token);
+    const entities = [...this.rows.keys()].sort();
+    const all: ChangeEvent[] = [];
+    for (const entity of entities) {
+      const rows = this.visible(entity, Array.from(this.rows.get(entity)?.values() ?? []), auth);
+      for (const row of rows) {
+        all.push({
+          seq: this.nextSeq,
+          entity,
+          row_id: (row as { id: string }).id,
+          kind: "insert",
+          data: this.project(entity, row),
+          timestamp: "",
+        } as ChangeEvent);
+      }
+    }
+    const page = all.slice(offset, offset + limit);
+    const done = offset + limit >= all.length;
+    return {
+      changes: page,
+      cursor: { last_seq: done ? this.nextSeq : 0 },
+      has_more: !done,
+      snapshot: true,
+      snapshot_after: done ? null : String(offset + limit),
+      ...(done && !this.omitSnapshotEntities ? { snapshot_entities: entities } : {}),
+    };
+  }
+
   /** /api/sync/pull — every visible change since `since`. */
   async pull(token: string | undefined, since: number): Promise<{
     changes: ChangeEvent[];
@@ -569,3 +647,70 @@ export class TestServer {
     }
   }
 }
+
+/**
+ * In-memory stand-in for the runtime's file routes. Records every request
+ * so a test can count uploads, and lets a test refuse a file (`rejectInit`)
+ * or drop the connection during the next PUT (`dropNextPut`).
+ */
+export class TestFileServer {
+  private nextId = 1;
+  private slots = new Map<string, { owner: string | null; filename: string; size: number; bytes?: number }>();
+  readonly stored = new Map<string, { filename: string; size: number; owner: string | null }>();
+  initCount = 0;
+  putCount = 0;
+  private rejection: { status: number; code: string; message: string } | null = null;
+  private dropPut = false;
+
+  constructor(private readonly server: TestServer) {}
+
+  /** Refuse every init with this status, like a type or size check. */
+  rejectInit(status: number, code: string, message: string): void {
+    this.rejection = { status, code, message };
+  }
+  clearRejection(): void {
+    this.rejection = null;
+  }
+  /** When set, every PUT waits for it before it answers. */
+  putGate: Promise<void> | null = null;
+  /** The next PUT fails like a dropped connection (no status). */
+  dropNextPut(): void {
+    this.dropPut = true;
+  }
+
+  init(token: string | undefined, body: { filename?: string; size?: number }) {
+    this.initCount += 1;
+    if (this.rejection) {
+      const r = this.rejection;
+      return { status: r.status, body: { error: { code: r.code, message: r.message } } };
+    }
+    const id = `f_${this.nextId++}`;
+    const owner = this.server.authContextFor(token).userId;
+    this.slots.set(id, { owner, filename: body.filename ?? "upload", size: body.size ?? 0 });
+    return { status: 200, body: { uploadUrl: `/api/files/local-put/${id}`, assetId: id } };
+  }
+
+  put(id: string, bytes: unknown) {
+    this.putCount += 1;
+    if (this.dropPut) {
+      this.dropPut = false;
+      throw new TypeError("simulated dropped connection during upload");
+    }
+    const slot = this.slots.get(id);
+    if (!slot) return { status: 404, body: { error: { code: "NOT_FOUND" } } };
+    slot.bytes = bytes instanceof ArrayBuffer ? bytes.byteLength : slot.size;
+    return { status: 200, body: null };
+  }
+
+  confirm(token: string | undefined, id: string) {
+    const slot = this.slots.get(id);
+    if (!slot || slot.bytes === undefined) {
+      return { status: 400, body: { error: { code: "NOT_UPLOADED" } } };
+    }
+    if (slot.owner !== this.server.authContextFor(token).userId) {
+      return { status: 403, body: { error: { code: "FORBIDDEN" } } };
+    }
+    this.stored.set(id, { filename: slot.filename, size: slot.bytes, owner: slot.owner });
+    return { status: 200, body: { id, url: `/api/files/${id}`, size: slot.bytes } };
+  }
+}

package/src/test-harness/transport.ts

@@ -251,6 +251,15 @@ async function handle(
     }
     server.pullUrls.push(url);
     const since = Number(new URL(url, "http://test").searchParams.get("since") ?? "0");
+    if (server.snapshotMode) {
+      const params = new URL(url, "http://test").searchParams;
+      const after = params.get("snapshot_after");
+      const limit = Number(params.get("limit") ?? "1000");
+      const snapshotOk = params.get("snapshot_ok") === "1";
+      if (since === 0 || after !== null || (snapshotOk && server.farBehind(since))) {
+        return { status: 200, body: server.snapshotPage(token, Number(after ?? "0"), limit) };
+      }
+    }
     // Cluster-divergence sim: a delta pull lands on an instance that
     // can't serve our cursor → 410. A snapshot (since=0) still succeeds.
     if (since > 0 && server.force410OnDelta) {
@@ -374,6 +383,23 @@ async function handle(
     };
   }
 
+  // File uploads: /api/files/init, the PUT to the returned URL, and
+  // /api/files/confirm (see TestServer.files).
+  if (url.endsWith("/api/files/init") && method === "POST") {
+    const body = typeof _init?.body === "string" ? JSON.parse(_init.body) : {};
+    return server.files.init(token, body);
+  }
+  const put = url.match(/\/api\/files\/local-put\/([^/?]+)$/);
+  if (put && method === "PUT") {
+    const bytes = _init?.body instanceof Blob ? await _init.body.arrayBuffer() : _init?.body;
+    if (server.files.putGate) await server.files.putGate;
+    return server.files.put(put[1]!, bytes);
+  }
+  if (url.endsWith("/api/files/confirm") && method === "POST") {
+    const body = typeof _init?.body === "string" ? JSON.parse(_init.body) : {};
+    return server.files.confirm(token, body.assetId);
+  }
+
   // Anything else: 404 with a clear error so test failures point
   // at the exact missing route rather than a generic JSON parse.
   return {

package/src/types.ts

@@ -20,6 +20,16 @@ export interface PullResponse {
   changes: ChangeEvent[];
   cursor: SyncCursor;
   has_more: boolean;
+  /** Set on every page of a snapshot (current rows, not the log): a pull
+   *  from 0, or a far-behind catch-up the client accepted with
+   *  `snapshot_ok=1`. */
+  snapshot?: boolean;
+  /** Continuation of a snapshot that spans pages. Opaque; send it back
+   *  verbatim. */
+  snapshot_after?: string | null;
+  /** On a snapshot's last page: the entities it holds every visible row
+   *  of. Rows of these entities that it did not send are gone. */
+  snapshot_entities?: string[];
 }
 
 /**