@aigne/afs-did-space 1.12.0-beta.5

package/dist/local-changelog.mjs

@@ -0,0 +1,240 @@
+import { SYNC_STATE_INDEX_SQL, SYNC_STATE_TABLE_SQL } from "./changelog-schema.mjs";
+
+//#region src/local-changelog.ts
+/**
+* LocalChangelog — Phase 3 Task 3.4 (G6)
+*
+* Read-side + GC companion to the `changelog` writes produced by
+* MetadataDB / D1TreeIndex / SQLiteTreeIndex. Used exclusively by the
+* local SyncEngine (desktop + mobile); has NO counterpart inside the
+* CloudflareDIDSpace Worker — the server IS the cloud changelog, it has
+* no notion of "unpushed local rows".
+*
+* Responsibilities:
+*
+*  1. `getUnpushed(sinceSeq, limit?)`
+*     Return changelog rows written by THIS device (`device_id == self`)
+*     whose `seq > sinceSeq`, ordered by seq ascending. SyncEngine pages
+*     through these on the push leg of each sync round.
+*
+*  2. `markPushed(upToSeq)`
+*     Advance `sync_state['{scope}:local_seq']` to record that all self-
+*     written rows up to `upToSeq` have been accepted by the server. Does
+*     NOT delete anything — row retention is owned by `gc()`. The watermark
+*     is strictly monotonic (setting a lower value is a no-op).
+*
+*  3. `gc()`
+*     Single atomic DELETE that removes:
+*       (a) rows from THIS device with seq ≤ local_seq (pushed, no longer
+*           needed for resume) AND
+*       (b) rows from OTHER devices with seq ≤ cloud_seq (pulled + applied,
+*           no longer needed for replay).
+*     Called by SyncEngine AFTER a successful sync round. The gc contract
+*     is called-by-engine — gc() itself makes no assumption about timing.
+*
+*  4. `getLocalSeq` / `getCloudSeq` / `setCloudSeq`
+*     Helpers for SyncEngine and tests. Task 3.5 introduces a richer
+*     `SyncStateStore` that owns these KV lookups with Keychain/Keystore
+*     backing; for Task 3.4 we keep the reads/writes inside LocalChangelog
+*     so the module is self-contained and pre-3.5 integration tests work.
+*
+* The `sync_state` KV table is created by `ensureTable()` — idempotent —
+* and must be present before any of the methods above are called. The DDL
+* lives in `changelog-schema.ts` and is byte-identical across TypeScript,
+* Swift, and Kotlin (Task 3.5 will add a parity check once the schema
+* extends with Keychain-backed keys).
+*
+* Scope isolation: every SQL statement inside LocalChangelog includes a
+* `scope = ?` bind. Cross-scope leaks would regress Task 2.1's scope-
+* scoped changelog design, so both gc() and getUnpushed() carry the scope
+* through explicitly.
+*/
+/** Default `limit` applied by `getUnpushed` when none is specified. */
+const LOCAL_CHANGELOG_DEFAULT_LIMIT = 1e3;
+/** Maximum `limit` accepted by `getUnpushed`; larger values are clamped. */
+const LOCAL_CHANGELOG_MAX_LIMIT = 1e4;
+function toChangelogEntry(row) {
+	const r = row;
+	return {
+		seq: Number(r.seq),
+		scope: r.scope,
+		path: r.path,
+		op: r.op,
+		cid: r.cid ?? null,
+		old_cid: r.old_cid ?? null,
+		size: r.size === null || r.size === void 0 ? null : Number(r.size),
+		mtime: Number(r.mtime),
+		device_id: r.device_id
+	};
+}
+var LocalChangelog = class {
+	client;
+	scope;
+	deviceId;
+	constructor(opts) {
+		if (typeof opts.scope !== "string" || opts.scope.length === 0) throw new Error("LocalChangelog: scope must be a non-empty string");
+		if (typeof opts.deviceId !== "string" || opts.deviceId.length === 0) throw new Error("LocalChangelog: deviceId must be a non-empty string");
+		this.client = opts.client;
+		this.scope = opts.scope;
+		this.deviceId = opts.deviceId;
+	}
+	/**
+	* Idempotently create the `sync_state` table (and any future indices).
+	*
+	* MetadataDB.open() calls this on desktop; mobile runtimes run the DDL
+	* inline from their own migrate(). Safe to call from tests that
+	* construct LocalChangelog directly on a raw libsql client.
+	*/
+	static async ensureTable(client) {
+		await client.execute(SYNC_STATE_TABLE_SQL);
+		for (const sql of SYNC_STATE_INDEX_SQL) await client.execute(sql);
+	}
+	/**
+	* Read the `local_seq` watermark — highest changelog.seq that the current
+	* device has acknowledged as pushed. Returns 0 when the key is missing
+	* (nothing pushed yet).
+	*/
+	async getLocalSeq() {
+		return this.readSeqKey(`${this.scope}:local_seq`);
+	}
+	/**
+	* Read the `cloud_seq` watermark — highest changelog.seq from OTHER
+	* devices that the current device has applied locally. Task 3.4 does
+	* not write this key itself; Task 3.5's SyncEngine will advance it as
+	* part of the pull leg. Returns 0 as the "nothing pulled yet" sentinel.
+	*/
+	async getCloudSeq() {
+		return this.readSeqKey(`${this.scope}:cloud_seq`);
+	}
+	/**
+	* Test / SyncEngine helper to advance the cloud_seq watermark.
+	*
+	* Monotonic: a caller passing a lower value than the stored watermark
+	* is a no-op. This matches Task 3.5's eventual API contract and keeps
+	* LocalChangelog's GC branch for "other devices" safe under retries.
+	*/
+	async setCloudSeq(seq) {
+		await this.writeSeqKeyMonotonic(`${this.scope}:cloud_seq`, seq);
+	}
+	/**
+	* Low-level SELECT for a `sync_state` integer key. Returns 0 when the
+	* key is missing. Throws on non-numeric values (corrupt state).
+	*/
+	async readSeqKey(key) {
+		const result = await this.client.execute({
+			sql: "SELECT value FROM ds_sync_state WHERE key = ?",
+			args: [key]
+		});
+		if (result.rows.length === 0) return 0;
+		const raw = result.rows[0][0];
+		if (raw === null || raw === void 0) return 0;
+		const value = typeof raw === "string" ? raw : String(raw);
+		const parsed = Number(value);
+		if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) throw new Error(`LocalChangelog: corrupt sync_state value for key=${key}: ${value}`);
+		return parsed;
+	}
+	/**
+	* Monotonic INSERT-OR-REPLACE for a `sync_state` integer key. The CASE
+	* expression keeps the prior value when the incoming one is lower.
+	*
+	* Negative inputs are clamped to 0 so misbehaving callers cannot rewind
+	* the watermark below the "nothing synced yet" sentinel.
+	*/
+	async writeSeqKeyMonotonic(key, seq) {
+		const safe = Math.max(0, Math.floor(Number.isFinite(seq) ? seq : 0));
+		await this.client.execute({
+			sql: `INSERT INTO ds_sync_state (key, value) VALUES (?, ?)
+            ON CONFLICT(key) DO UPDATE SET
+              value = CASE
+                WHEN CAST(excluded.value AS INTEGER) > CAST(ds_sync_state.value AS INTEGER)
+                THEN excluded.value
+                ELSE ds_sync_state.value
+              END`,
+			args: [key, String(safe)]
+		});
+	}
+	/**
+	* Return self-written changelog rows with seq > sinceSeq, ordered by seq
+	* ascending. Rows from other devices are excluded at the SQL layer
+	* (device_id filter) so this function is cheap even on multi-device
+	* spaces with heavy pull traffic.
+	*
+	* Clamping rules (matches G5.a Worker endpoint for consistency):
+	*   - sinceSeq < 0 → clamped to 0 (not rejected; caller is internal)
+	*   - limit undefined → LOCAL_CHANGELOG_DEFAULT_LIMIT (1000)
+	*   - limit === 0 → returns [] without hitting SQLite
+	*   - limit > LOCAL_CHANGELOG_MAX_LIMIT → clamped to 10000
+	*/
+	async getUnpushed(sinceSeq, limit) {
+		const safeSince = Math.max(0, Math.floor(Number.isFinite(sinceSeq) ? sinceSeq : 0));
+		const requested = limit ?? LOCAL_CHANGELOG_DEFAULT_LIMIT;
+		if (requested === 0) return [];
+		const safeLimit = Math.min(LOCAL_CHANGELOG_MAX_LIMIT, Math.max(0, Math.floor(Number.isFinite(requested) ? requested : 0)));
+		if (safeLimit === 0) return [];
+		return (await this.client.execute({
+			sql: `SELECT seq, scope, path, op, cid, old_cid, size, mtime, device_id
+            FROM ds_changelog
+            WHERE scope = ? AND device_id = ? AND seq > ?
+            ORDER BY seq ASC
+            LIMIT ?`,
+			args: [
+				this.scope,
+				this.deviceId,
+				safeSince,
+				safeLimit
+			]
+		})).rows.map(toChangelogEntry);
+	}
+	/**
+	* Advance the `local_seq` watermark to `upToSeq`. Does NOT delete rows;
+	* `gc()` is the only path that removes data.
+	*
+	* Monotonic: calls with `upToSeq` less than or equal to the stored
+	* watermark become no-ops. This keeps the invariant that SyncEngine can
+	* safely retry pushes without rewinding progress.
+	*/
+	async markPushed(upToSeq) {
+		await this.writeSeqKeyMonotonic(`${this.scope}:local_seq`, upToSeq);
+	}
+	/**
+	* Atomically delete self-pushed rows (seq ≤ local_seq) AND other-device
+	* rows that have been applied locally (seq ≤ cloud_seq).
+	*
+	* Rows that do NOT match either branch — e.g. other-device rows above
+	* cloud_seq, or self rows above local_seq — remain untouched. This is
+	* the non-negotiable safety rule: GC must never remove a row whose
+	* application is still pending.
+	*
+	* Implementation note: we read local_seq + cloud_seq BEFORE issuing the
+	* DELETE and bake them into the WHERE clause. This keeps the DELETE a
+	* single statement (the spec mandates a single-shot DELETE, not a
+	* row-by-row loop) and makes the semantics easy to reason about under
+	* concurrent gc() invocations — each call operates on a point-in-time
+	* snapshot of the watermarks.
+	*/
+	async gc() {
+		const localSeq = await this.getLocalSeq();
+		const cloudSeq = await this.getCloudSeq();
+		const result = await this.client.execute({
+			sql: `DELETE FROM ds_changelog
+            WHERE scope = ?
+              AND (
+                (device_id = ?  AND seq <= ?)
+                OR
+                (device_id != ? AND seq <= ?)
+              )`,
+			args: [
+				this.scope,
+				this.deviceId,
+				localSeq,
+				this.deviceId,
+				cloudSeq
+			]
+		});
+		return { deleted: Number(result.rowsAffected ?? 0) };
+	}
+};
+
+//#endregion
+export { LOCAL_CHANGELOG_DEFAULT_LIMIT, LOCAL_CHANGELOG_MAX_LIMIT, LocalChangelog };
+//# sourceMappingURL=local-changelog.mjs.map

package/dist/local-changelog.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-changelog.mjs","names":[],"sources":["../src/local-changelog.ts"],"sourcesContent":["/**\n * LocalChangelog — Phase 3 Task 3.4 (G6)\n *\n * Read-side + GC companion to the `changelog` writes produced by\n * MetadataDB / D1TreeIndex / SQLiteTreeIndex. Used exclusively by the\n * local SyncEngine (desktop + mobile); has NO counterpart inside the\n * CloudflareDIDSpace Worker — the server IS the cloud changelog, it has\n * no notion of \"unpushed local rows\".\n *\n * Responsibilities:\n *\n *  1. `getUnpushed(sinceSeq, limit?)`\n *     Return changelog rows written by THIS device (`device_id == self`)\n *     whose `seq > sinceSeq`, ordered by seq ascending. SyncEngine pages\n *     through these on the push leg of each sync round.\n *\n *  2. `markPushed(upToSeq)`\n *     Advance `sync_state['{scope}:local_seq']` to record that all self-\n *     written rows up to `upToSeq` have been accepted by the server. Does\n *     NOT delete anything — row retention is owned by `gc()`. The watermark\n *     is strictly monotonic (setting a lower value is a no-op).\n *\n *  3. `gc()`\n *     Single atomic DELETE that removes:\n *       (a) rows from THIS device with seq ≤ local_seq (pushed, no longer\n *           needed for resume) AND\n *       (b) rows from OTHER devices with seq ≤ cloud_seq (pulled + applied,\n *           no longer needed for replay).\n *     Called by SyncEngine AFTER a successful sync round. The gc contract\n *     is called-by-engine — gc() itself makes no assumption about timing.\n *\n *  4. `getLocalSeq` / `getCloudSeq` / `setCloudSeq`\n *     Helpers for SyncEngine and tests. Task 3.5 introduces a richer\n *     `SyncStateStore` that owns these KV lookups with Keychain/Keystore\n *     backing; for Task 3.4 we keep the reads/writes inside LocalChangelog\n *     so the module is self-contained and pre-3.5 integration tests work.\n *\n * The `sync_state` KV table is created by `ensureTable()` — idempotent —\n * and must be present before any of the methods above are called. The DDL\n * lives in `changelog-schema.ts` and is byte-identical across TypeScript,\n * Swift, and Kotlin (Task 3.5 will add a parity check once the schema\n * extends with Keychain-backed keys).\n *\n * Scope isolation: every SQL statement inside LocalChangelog includes a\n * `scope = ?` bind. Cross-scope leaks would regress Task 2.1's scope-\n * scoped changelog design, so both gc() and getUnpushed() carry the scope\n * through explicitly.\n */\n\nimport { SYNC_STATE_INDEX_SQL, SYNC_STATE_TABLE_SQL } from \"./changelog-schema.js\";\nimport type { ChangelogEntry } from \"./tree-index.js\";\n\n/** Default `limit` applied by `getUnpushed` when none is specified. */\nexport const LOCAL_CHANGELOG_DEFAULT_LIMIT = 1000;\n\n/** Maximum `limit` accepted by `getUnpushed`; larger values are clamped. */\nexport const LOCAL_CHANGELOG_MAX_LIMIT = 10000;\n\nexport interface LocalChangelogOptions {\n  /**\n   * Already-opened libsql client sharing the same DB file as the TreeIndex.\n   * LocalChangelog does NOT own the client lifecycle — callers (typically\n   * `DIDSpaceProvider` construction) remain responsible for close().\n   */\n  client: import(\"@libsql/client\").Client;\n\n  /** Scope string written into `changelog` and used to partition `sync_state` keys. */\n  scope: string;\n\n  /**\n   * Device identifier of the current process. Used BOTH as the `self` filter\n   * for `getUnpushed` AND as the branch discriminator in `gc()`.\n   *\n   * Task 3.4 takes this via constructor injection. Task 3.5 will wire the\n   * argument to a Keychain/Keystore-backed SyncStateStore without changing\n   * LocalChangelog's public surface.\n   */\n  deviceId: string;\n}\n\n/** Raw row shape returned by libsql SELECT against `changelog`. */\ninterface RawChangelogRow {\n  seq: unknown;\n  scope: unknown;\n  path: unknown;\n  op: unknown;\n  cid: unknown;\n  old_cid: unknown;\n  size: unknown;\n  mtime: unknown;\n  device_id: unknown;\n}\n\nfunction toChangelogEntry(row: object): ChangelogEntry {\n  const r = row as unknown as RawChangelogRow;\n  return {\n    seq: Number(r.seq),\n    scope: r.scope as string,\n    path: r.path as string,\n    op: r.op as \"put\" | \"delete\",\n    cid: (r.cid as string | null) ?? null,\n    old_cid: (r.old_cid as string | null) ?? null,\n    size: r.size === null || r.size === undefined ? null : Number(r.size),\n    mtime: Number(r.mtime),\n    device_id: r.device_id as string,\n  };\n}\n\nexport class LocalChangelog {\n  private readonly client: import(\"@libsql/client\").Client;\n  private readonly scope: string;\n  private readonly deviceId: string;\n\n  constructor(opts: LocalChangelogOptions) {\n    if (typeof opts.scope !== \"string\" || opts.scope.length === 0) {\n      throw new Error(\"LocalChangelog: scope must be a non-empty string\");\n    }\n    if (typeof opts.deviceId !== \"string\" || opts.deviceId.length === 0) {\n      throw new Error(\"LocalChangelog: deviceId must be a non-empty string\");\n    }\n    this.client = opts.client;\n    this.scope = opts.scope;\n    this.deviceId = opts.deviceId;\n  }\n\n  /**\n   * Idempotently create the `sync_state` table (and any future indices).\n   *\n   * MetadataDB.open() calls this on desktop; mobile runtimes run the DDL\n   * inline from their own migrate(). Safe to call from tests that\n   * construct LocalChangelog directly on a raw libsql client.\n   */\n  static async ensureTable(client: import(\"@libsql/client\").Client): Promise<void> {\n    await client.execute(SYNC_STATE_TABLE_SQL);\n    for (const sql of SYNC_STATE_INDEX_SQL) {\n      await client.execute(sql);\n    }\n  }\n\n  // ── sync_state KV helpers ──────────────────────────────────────\n\n  /**\n   * Read the `local_seq` watermark — highest changelog.seq that the current\n   * device has acknowledged as pushed. Returns 0 when the key is missing\n   * (nothing pushed yet).\n   */\n  async getLocalSeq(): Promise<number> {\n    return this.readSeqKey(`${this.scope}:local_seq`);\n  }\n\n  /**\n   * Read the `cloud_seq` watermark — highest changelog.seq from OTHER\n   * devices that the current device has applied locally. Task 3.4 does\n   * not write this key itself; Task 3.5's SyncEngine will advance it as\n   * part of the pull leg. Returns 0 as the \"nothing pulled yet\" sentinel.\n   */\n  async getCloudSeq(): Promise<number> {\n    return this.readSeqKey(`${this.scope}:cloud_seq`);\n  }\n\n  /**\n   * Test / SyncEngine helper to advance the cloud_seq watermark.\n   *\n   * Monotonic: a caller passing a lower value than the stored watermark\n   * is a no-op. This matches Task 3.5's eventual API contract and keeps\n   * LocalChangelog's GC branch for \"other devices\" safe under retries.\n   */\n  async setCloudSeq(seq: number): Promise<void> {\n    await this.writeSeqKeyMonotonic(`${this.scope}:cloud_seq`, seq);\n  }\n\n  /**\n   * Low-level SELECT for a `sync_state` integer key. Returns 0 when the\n   * key is missing. Throws on non-numeric values (corrupt state).\n   */\n  private async readSeqKey(key: string): Promise<number> {\n    const result = await this.client.execute({\n      sql: \"SELECT value FROM ds_sync_state WHERE key = ?\",\n      args: [key],\n    });\n    if (result.rows.length === 0) return 0;\n    const raw = result.rows[0]![0];\n    if (raw === null || raw === undefined) return 0;\n    const value = typeof raw === \"string\" ? raw : String(raw);\n    const parsed = Number(value);\n    if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) {\n      throw new Error(`LocalChangelog: corrupt sync_state value for key=${key}: ${value}`);\n    }\n    return parsed;\n  }\n\n  /**\n   * Monotonic INSERT-OR-REPLACE for a `sync_state` integer key. The CASE\n   * expression keeps the prior value when the incoming one is lower.\n   *\n   * Negative inputs are clamped to 0 so misbehaving callers cannot rewind\n   * the watermark below the \"nothing synced yet\" sentinel.\n   */\n  private async writeSeqKeyMonotonic(key: string, seq: number): Promise<void> {\n    const safe = Math.max(0, Math.floor(Number.isFinite(seq) ? seq : 0));\n    await this.client.execute({\n      sql: `INSERT INTO ds_sync_state (key, value) VALUES (?, ?)\n            ON CONFLICT(key) DO UPDATE SET\n              value = CASE\n                WHEN CAST(excluded.value AS INTEGER) > CAST(ds_sync_state.value AS INTEGER)\n                THEN excluded.value\n                ELSE ds_sync_state.value\n              END`,\n      args: [key, String(safe)],\n    });\n  }\n\n  // ── public API ─────────────────────────────────────────────────\n\n  /**\n   * Return self-written changelog rows with seq > sinceSeq, ordered by seq\n   * ascending. Rows from other devices are excluded at the SQL layer\n   * (device_id filter) so this function is cheap even on multi-device\n   * spaces with heavy pull traffic.\n   *\n   * Clamping rules (matches G5.a Worker endpoint for consistency):\n   *   - sinceSeq < 0 → clamped to 0 (not rejected; caller is internal)\n   *   - limit undefined → LOCAL_CHANGELOG_DEFAULT_LIMIT (1000)\n   *   - limit === 0 → returns [] without hitting SQLite\n   *   - limit > LOCAL_CHANGELOG_MAX_LIMIT → clamped to 10000\n   */\n  async getUnpushed(sinceSeq: number, limit?: number): Promise<ChangelogEntry[]> {\n    const safeSince = Math.max(0, Math.floor(Number.isFinite(sinceSeq) ? sinceSeq : 0));\n    const requested = limit ?? LOCAL_CHANGELOG_DEFAULT_LIMIT;\n    if (requested === 0) return [];\n    const safeLimit = Math.min(\n      LOCAL_CHANGELOG_MAX_LIMIT,\n      Math.max(0, Math.floor(Number.isFinite(requested) ? requested : 0)),\n    );\n    if (safeLimit === 0) return [];\n\n    const result = await this.client.execute({\n      sql: `SELECT seq, scope, path, op, cid, old_cid, size, mtime, device_id\n            FROM ds_changelog\n            WHERE scope = ? AND device_id = ? AND seq > ?\n            ORDER BY seq ASC\n            LIMIT ?`,\n      args: [this.scope, this.deviceId, safeSince, safeLimit],\n    });\n    return result.rows.map(toChangelogEntry);\n  }\n\n  /**\n   * Advance the `local_seq` watermark to `upToSeq`. Does NOT delete rows;\n   * `gc()` is the only path that removes data.\n   *\n   * Monotonic: calls with `upToSeq` less than or equal to the stored\n   * watermark become no-ops. This keeps the invariant that SyncEngine can\n   * safely retry pushes without rewinding progress.\n   */\n  async markPushed(upToSeq: number): Promise<void> {\n    await this.writeSeqKeyMonotonic(`${this.scope}:local_seq`, upToSeq);\n  }\n\n  /**\n   * Atomically delete self-pushed rows (seq ≤ local_seq) AND other-device\n   * rows that have been applied locally (seq ≤ cloud_seq).\n   *\n   * Rows that do NOT match either branch — e.g. other-device rows above\n   * cloud_seq, or self rows above local_seq — remain untouched. This is\n   * the non-negotiable safety rule: GC must never remove a row whose\n   * application is still pending.\n   *\n   * Implementation note: we read local_seq + cloud_seq BEFORE issuing the\n   * DELETE and bake them into the WHERE clause. This keeps the DELETE a\n   * single statement (the spec mandates a single-shot DELETE, not a\n   * row-by-row loop) and makes the semantics easy to reason about under\n   * concurrent gc() invocations — each call operates on a point-in-time\n   * snapshot of the watermarks.\n   */\n  async gc(): Promise<{ deleted: number }> {\n    const localSeq = await this.getLocalSeq();\n    const cloudSeq = await this.getCloudSeq();\n\n    const result = await this.client.execute({\n      sql: `DELETE FROM ds_changelog\n            WHERE scope = ?\n              AND (\n                (device_id = ?  AND seq <= ?)\n                OR\n                (device_id != ? AND seq <= ?)\n              )`,\n      args: [this.scope, this.deviceId, localSeq, this.deviceId, cloudSeq],\n    });\n    return { deleted: Number(result.rowsAffected ?? 0) };\n  }\n}\n"],"mappings":"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"}