or3-provider-sqlite 0.0.10 → 0.0.11

package/README.md

@@ -32,7 +32,7 @@ runtime.
 | Runtime | `OR3_SQLITE_DRIVER` | Required configuration | Extra install |
 |---|---|---|---|
 | Local Node (default) | `better-sqlite3` | `OR3_SQLITE_DB_PATH` | `better-sqlite3` |
-| Bun | `bun` | `OR3_SQLITE_DB_PATH` | None; uses built-in `bun:sqlite` |
+| Bun | `bun` | `OR3_SQLITE_DB_PATH` | None for sync; uses built-in `bun:sqlite` |
 | Turso/libSQL | `turso` | `OR3_SQLITE_TURSO_URL`, `OR3_SQLITE_TURSO_AUTH_TOKEN` | `libsql` |
 | Cloudflare D1 | `d1` | `OR3_SQLITE_D1_BINDING` (defaults to `DB`) | None; uses the Worker binding |
 
@@ -51,6 +51,16 @@ OR3_SQLITE_DRIVER=bun
 OR3_SQLITE_DB_PATH=/data/or3-sync.db
 ```
 
+OR3 Chat's source launcher (`bun run dev:ssr`) selects Bun when this provider
+uses the Bun driver, including when only the auth workspace store is active.
+Use the Bun version pinned in the host's `package.json`. The launcher checks
+the built-in driver and required native bindings before Nuxt starts. Run a
+built Bun-configured server with `bun .output/server/index.mjs`.
+
+Basic Auth still uses a separate `better-sqlite3` database; its native binding
+must also be compatible with Bun. The managed Cloud image uses Node and the
+default `better-sqlite3` sync driver.
+
 ### Turso/libSQL
 
 ```bash
@@ -131,6 +141,12 @@ On server startup, the Nitro plugin:
 Registration is skipped when `auth.enabled` is `false`, or when neither SQLite
 sync, SQLite Connect, nor SQLite background jobs are selected (local-only mode).
 
+SQLite background jobs also persist mixed-runtime tool handoffs. Browser-only
+calls are atomically claimed and settled in `execution_json`; parked calls are
+excluded from worker claims until their browser result makes the job runnable.
+Parked handoffs have a separate global and per-user admission cap, so they do
+not consume active worker slots or grow without bound.
+
 ### Schema
 
 Ordered migrations create and evolve all tables:
@@ -164,7 +180,7 @@ All tables use snake_case aligned with the sync wire format.
 - **Retention safety**: tombstone and `change_log` GC is enabled only under the explicit `snapshot-v1` capability and deletes old revisions acknowledged by every registered device
 - **Notifications**: push forces `payload.user_id` to the session user; foreign notification writes are rejected; pull/snapshot omit other users' rows
 
-LWW conflict resolution: incoming wins when `clock` is higher, then when clocks are equal and `hlc` is lexicographically greater, then when `op_id` is greater. Tombstones use the same `(clock, hlc, op_id)` tuple. LWW losers return `applied: false` with the winning payload.
+LWW conflict resolution: incoming wins when `clock` is higher, then when clocks are equal and `hlc` is lexicographically greater, then when `op_id` is greater. Tombstones use the same `(clock, hlc, op_id)` tuple. LWW losers return `applied: false` with the current winner as either `{ kind: 'put', payload, revision }` or `{ kind: 'delete', revision, serverDeletedAt? }`. Idempotent `op_id` retries return `replayed: true` and, if superseded, the current winner. A replay does not allocate another server version.
 
 Local, Bun, and Turso runtimes use `BEGIN IMMEDIATE` transactions. D1 uses its
 native atomic batch API for grouped writes.
@@ -235,3 +251,17 @@ bun run build       # build for distribution
   `OR3_CONNECT_ENABLED=false` or switch to better-sqlite3, Bun, or Turso.
 - **`OR3_SQLITE_DRIVER=bun requires Bun`** — the Bun driver only runs under
   the Bun runtime with its built-in `bun:sqlite`.
+
+### Atomic workspace settings
+
+The workspace settings store implements `compareAndSet(workspaceId, key, expectedValue, nextValue)` atomically. A `null` expected value means the key must be absent; a conflict returns `false` without overwriting it. The host uses this for concurrent plugin setup saves and persistent AI spend reservations.
+
+
+### Testing local changes in OR3 Chat
+
+With this repository beside `or3-chat`, run `bun install` here once, then
+`bun run dev:ssr` from Chat. Chat's dev wrapper rebuilds the local provider and
+prints its selected path; restart it after provider edits. Missing repositories
+or failed builds fall back to installed packages with a warning.
+`OR3_LOCAL_PROVIDERS=false` disables local selection. Production builds use the
+installed package, so local development does not publish these changes.

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "or3-provider-sqlite",
   "configKey": "or3-provider-sqlite",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/runtime/server/admin/stores/sqlite-store.js

@@ -323,6 +323,22 @@ class SqliteWorkspaceSettingsStore {
       })
     ).execute();
   }
+  /** Atomically write only when the stored value still equals the expected value. */
+  async compareAndSet(workspaceId, key, expectedValue, nextValue) {
+    const now = nowEpoch();
+    if (expectedValue === null) {
+      const result2 = await this.db.insertInto("admin_workspace_settings").values({
+        id: globalThis.crypto.randomUUID(),
+        workspace_id: workspaceId,
+        key,
+        value: nextValue,
+        updated_at: now
+      }).onConflict((oc) => oc.columns(["workspace_id", "key"]).doNothing()).executeTakeFirst();
+      return Number(result2.numInsertedOrUpdatedRows ?? 0) === 1;
+    }
+    const result = await this.db.updateTable("admin_workspace_settings").set({ value: nextValue, updated_at: now }).where("workspace_id", "=", workspaceId).where("key", "=", key).where("value", "=", expectedValue).executeTakeFirst();
+    return Number(result.numUpdatedRows ?? 0) === 1;
+  }
 }
 class SqliteAdminUserStore {
   get db() {

package/dist/runtime/server/background-jobs/sqlite-provider.d.ts

@@ -16,6 +16,8 @@ export declare class SqliteBackgroundJobProvider implements BackgroundJobProvide
     claimNextJob(leaseOwner: string, now: number, leaseExpiresAt: number): Promise<BackgroundJob | null>;
     renewJobLease(jobId: string, leaseOwner: string, _now: number, leaseExpiresAt: number): Promise<boolean>;
     updateJobExecution(jobId: string, execution: BackgroundJobExecution, leaseOwner: string): Promise<boolean>;
+    claimClientToolCall(jobId: string, userId: string, callId: string, claimToken: string, claimExpiresAt: number): Promise<BackgroundJob | null>;
+    settleClientToolCall(jobId: string, userId: string, callId: string, claimToken: string, execution: BackgroundJobExecution, toolCalls: BackgroundJob['tool_calls']): Promise<boolean>;
     saveTerminalSnapshot(jobId: string, snapshot: TerminalGenerationSnapshot, leaseOwner?: string): Promise<boolean>;
     setHistoryPhase(jobId: string, phase: GenerationHistoryPhase, options?: {
         from?: GenerationHistoryPhase[];

package/dist/runtime/server/background-jobs/sqlite-provider.js

@@ -109,8 +109,14 @@ const INSERT_JOB_IF_CAPACITY = `INSERT INTO background_jobs (
     chunks_received, started_at, last_activity_at, tool_calls_json,
     workflow_state_json, execution_json, idempotency_key, attempts
 ) SELECT ?, ?, ?, ?, ?, ?, 'streaming', ?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, 0
-  WHERE (SELECT COUNT(*) FROM background_jobs WHERE status = 'streaming') < ?
-    AND (SELECT COUNT(*) FROM background_jobs WHERE status = 'streaming' AND user_id = ?) < ?
+  WHERE (SELECT COUNT(*) FROM background_jobs WHERE status = 'streaming'
+           AND json_extract(execution_json, '$.clientToolCall') IS NULL) < ?
+    AND (SELECT COUNT(*) FROM background_jobs WHERE status = 'streaming' AND user_id = ?
+           AND json_extract(execution_json, '$.clientToolCall') IS NULL) < ?
+    AND (SELECT COUNT(*) FROM background_jobs WHERE status = 'streaming'
+           AND json_extract(execution_json, '$.clientToolCall') IS NOT NULL) < ?
+    AND (SELECT COUNT(*) FROM background_jobs WHERE status = 'streaming' AND user_id = ?
+           AND json_extract(execution_json, '$.clientToolCall') IS NOT NULL) < ?
     AND NOT EXISTS (
         SELECT 1 FROM background_admission_cancels
         WHERE user_id = ? AND admission_id = ? AND expires_at > ?
@@ -144,6 +150,9 @@ export class SqliteBackgroundJobProvider {
         config.maxConcurrentJobs,
         params.userId,
         config.maxConcurrentJobsPerUser,
+        config.maxConcurrentJobs,
+        params.userId,
+        config.maxConcurrentJobsPerUser,
         params.userId,
         params.idempotencyKey ?? "",
         now
@@ -186,11 +195,14 @@ export class SqliteBackgroundJobProvider {
         }
       }
       const active = raw.prepare(
-        `SELECT COUNT(*) AS total,
-                    SUM(CASE WHEN user_id = ? THEN 1 ELSE 0 END) AS user_total
+        `SELECT
+                    SUM(CASE WHEN json_extract(execution_json, '$.clientToolCall') IS NULL THEN 1 ELSE 0 END) AS total,
+                    SUM(CASE WHEN user_id = ? AND json_extract(execution_json, '$.clientToolCall') IS NULL THEN 1 ELSE 0 END) AS user_total,
+                    SUM(CASE WHEN json_extract(execution_json, '$.clientToolCall') IS NOT NULL THEN 1 ELSE 0 END) AS waiting_total,
+                    SUM(CASE WHEN user_id = ? AND json_extract(execution_json, '$.clientToolCall') IS NOT NULL THEN 1 ELSE 0 END) AS waiting_user_total
                  FROM background_jobs WHERE status = 'streaming'`
-      ).get(params.userId);
-      if (active.total >= config.maxConcurrentJobs || (active.user_total ?? 0) >= config.maxConcurrentJobsPerUser) {
+      ).get(params.userId, params.userId);
+      if ((active.total ?? 0) >= config.maxConcurrentJobs || (active.user_total ?? 0) >= config.maxConcurrentJobsPerUser || (active.waiting_total ?? 0) >= config.maxConcurrentJobs || (active.waiting_user_total ?? 0) >= config.maxConcurrentJobsPerUser) {
         throw new Error(
           "Maximum concurrent background jobs reached"
         );
@@ -394,6 +406,7 @@ export class SqliteBackgroundJobProvider {
                 chunks_received = CASE WHEN attempts > 0 THEN 0 ELSE chunks_received END,
                 attempts = attempts + 1
              WHERE id = ? AND status = 'streaming' AND execution_json IS NOT NULL
+               AND json_extract(execution_json, '$.clientToolCall') IS NULL
                AND COALESCE(history_phase, 'ready') = 'ready'
                AND (lease_owner IS NULL OR lease_expires_at <= ?)
              RETURNING *`,
@@ -422,6 +435,7 @@ export class SqliteBackgroundJobProvider {
              WHERE id = (
                 SELECT id FROM background_jobs
                 WHERE status = 'streaming' AND execution_json IS NOT NULL
+                  AND json_extract(execution_json, '$.clientToolCall') IS NULL
                   AND COALESCE(history_phase, 'ready') = 'ready'
                   AND (lease_owner IS NULL OR lease_expires_at <= ?)
                 ORDER BY started_at ASC LIMIT 1
@@ -455,6 +469,52 @@ export class SqliteBackgroundJobProvider {
       leaseOwner
     ) > 0;
   }
+  async claimClientToolCall(jobId, userId, callId, claimToken, claimExpiresAt) {
+    const now = Date.now();
+    const row = await one(
+      `UPDATE background_jobs SET
+                execution_json = json_set(
+                    execution_json,
+                    '$.clientToolCall.claimToken', ?,
+                    '$.clientToolCall.claimExpiresAt', ?
+                ),
+                last_activity_at = ?
+             WHERE id = ? AND user_id = ? AND status = 'streaming'
+               AND json_extract(execution_json, '$.clientToolCall.callId') = ?
+               AND (
+                    json_extract(execution_json, '$.clientToolCall.claimToken') IS NULL
+                    OR COALESCE(json_extract(execution_json, '$.clientToolCall.claimExpiresAt'), 0) <= ?
+               )
+             RETURNING *`,
+      claimToken,
+      claimExpiresAt,
+      now,
+      jobId,
+      userId,
+      callId,
+      now
+    );
+    return row ? toJob(row) : null;
+  }
+  async settleClientToolCall(jobId, userId, callId, claimToken, execution, toolCalls) {
+    const now = Date.now();
+    return await run(
+      `UPDATE background_jobs SET execution_json = ?, tool_calls_json = ?,
+                    lease_owner = NULL, lease_expires_at = NULL, last_activity_at = ?
+                 WHERE id = ? AND user_id = ? AND status = 'streaming'
+                   AND json_extract(execution_json, '$.clientToolCall.callId') = ?
+                   AND json_extract(execution_json, '$.clientToolCall.claimToken') = ?
+                   AND COALESCE(json_extract(execution_json, '$.clientToolCall.claimExpiresAt'), 0) > ?`,
+      json(execution),
+      json(toolCalls),
+      now,
+      jobId,
+      userId,
+      callId,
+      claimToken,
+      now
+    ) > 0;
+  }
   async saveTerminalSnapshot(jobId, snapshot, leaseOwner) {
     const values = [
       snapshot.status,
@@ -528,7 +588,8 @@ export class SqliteBackgroundJobProvider {
   }
   async getActiveJobCount() {
     const row = await one(
-      "SELECT COUNT(*) AS total FROM background_jobs WHERE status = 'streaming'"
+      `SELECT COUNT(*) AS total FROM background_jobs WHERE status = 'streaming'
+             AND json_extract(execution_json, '$.clientToolCall') IS NULL`
     );
     return row?.total ?? 0;
   }

package/dist/runtime/server/plugin-connections/sqlite-connection-store.d.ts

@@ -0,0 +1,7 @@
+import type { PluginConnectionStore } from '~~/server/utils/plugins/connections/store/registry';
+import { type SqliteRawDatabase } from '../db/kysely.js';
+type SqliteDatabase = SqliteRawDatabase;
+export declare function createSqlitePluginConnectionStore(options?: {
+    database?: SqliteDatabase;
+}): PluginConnectionStore;
+export {};

package/dist/runtime/server/plugin-connections/sqlite-connection-store.js

@@ -0,0 +1,209 @@
+import {
+  getRawDb,
+  getSqliteDriver
+} from "../db/kysely.js";
+function parseStringArray(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((value) => typeof value === "string");
+  } catch {
+    return [];
+  }
+}
+function toConnection(row) {
+  return {
+    id: row.id,
+    ownerUserId: row.owner_user_id,
+    workspaceId: row.workspace_id,
+    pluginId: row.plugin_id,
+    providerId: row.provider_id,
+    ...row.slot_id === null ? {} : { slotId: row.slot_id },
+    label: row.label,
+    scopes: parseStringArray(row.scopes),
+    revision: row.revision,
+    secretCiphertext: row.secret_ciphertext,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function toEvidence(row) {
+  return {
+    connectionId: row.connection_id,
+    revision: row.revision,
+    operationId: row.operation_id,
+    ok: row.ok === 1,
+    ...row.code === null ? {} : { code: row.code },
+    checkedAt: row.checked_at,
+    ...row.detail === null ? {} : { detail: row.detail }
+  };
+}
+class SqlitePluginConnectionStore {
+  constructor(db) {
+    this.db = db;
+    this.#initialize();
+  }
+  #initialize() {
+    if (getSqliteDriver() !== "turso") {
+      this.db.pragma?.("journal_mode = WAL");
+      this.db.pragma?.("synchronous = NORMAL");
+      this.db.pragma?.("foreign_keys = ON");
+    }
+    this.db.exec?.(`
+            CREATE TABLE IF NOT EXISTS plugin_connections (
+                id TEXT PRIMARY KEY,
+                owner_user_id TEXT NOT NULL,
+                workspace_id TEXT NOT NULL,
+                plugin_id TEXT NOT NULL,
+                provider_id TEXT NOT NULL,
+                slot_id TEXT,
+                label TEXT NOT NULL DEFAULT '',
+                scopes TEXT NOT NULL DEFAULT '[]',
+                revision INTEGER NOT NULL DEFAULT 1,
+                secret_ciphertext TEXT NOT NULL,
+                created_at INTEGER NOT NULL,
+                updated_at INTEGER NOT NULL
+            );
+
+            CREATE TABLE IF NOT EXISTS plugin_connection_tests (
+                connection_id TEXT PRIMARY KEY,
+                revision INTEGER NOT NULL,
+                operation_id TEXT NOT NULL,
+                ok INTEGER NOT NULL,
+                code TEXT,
+                checked_at INTEGER NOT NULL,
+                detail TEXT,
+                FOREIGN KEY (connection_id) REFERENCES plugin_connections(id) ON DELETE CASCADE
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_plugin_connections_workspace_plugin
+                ON plugin_connections (workspace_id, plugin_id);
+            CREATE INDEX IF NOT EXISTS idx_plugin_connections_owner
+                ON plugin_connections (owner_user_id);
+        `);
+    try {
+      this.db.prepare(`ALTER TABLE plugin_connections ADD COLUMN slot_id TEXT`).run();
+    } catch {
+    }
+  }
+  /**
+   * Owner-scoped listing. Ownership is part of the SQL predicate so a workspace
+   * peer cannot discover another user's connections or their references.
+   */
+  async list(input) {
+    const rows = input.pluginId === void 0 ? this.db.prepare(
+      `SELECT * FROM plugin_connections WHERE owner_user_id = ? AND workspace_id = ? ORDER BY created_at ASC`
+    ).all(input.ownerUserId, input.workspaceId) : this.db.prepare(
+      `SELECT * FROM plugin_connections WHERE owner_user_id = ? AND workspace_id = ? AND plugin_id = ? ORDER BY created_at ASC`
+    ).all(input.ownerUserId, input.workspaceId, input.pluginId);
+    return rows.map(toConnection);
+  }
+  async get(id) {
+    const row = this.db.prepare(`SELECT * FROM plugin_connections WHERE id = ?`).get(id);
+    return row ? toConnection(row) : null;
+  }
+  /**
+   * Insert-only creation. `DO NOTHING` is deliberate: an upsert here could
+   * reassign an existing record's owner, workspace, plugin or provider when two
+   * processes happen to generate the same id.
+   */
+  async insert(connection) {
+    const result = this.db.prepare(
+      `INSERT INTO plugin_connections (
+                    id, owner_user_id, workspace_id, plugin_id, provider_id, slot_id,
+                    label, scopes, revision, secret_ciphertext, created_at, updated_at
+                 ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                 ON CONFLICT(id) DO NOTHING`
+    ).run(
+      connection.id,
+      connection.ownerUserId,
+      connection.workspaceId,
+      connection.pluginId,
+      connection.providerId,
+      connection.slotId ?? null,
+      connection.label,
+      JSON.stringify(connection.scopes),
+      connection.revision,
+      connection.secretCiphertext,
+      connection.createdAt,
+      connection.updatedAt
+    );
+    return result.changes > 0;
+  }
+  /**
+   * Compare-and-swap update. Identity columns are not in the SET list, so a
+   * retry cannot move the record; the revision predicate is the whole
+   * concurrency control.
+   */
+  async update(update) {
+    const result = this.db.prepare(
+      `UPDATE plugin_connections
+                    SET revision = ?,
+                        secret_ciphertext = ?,
+                        updated_at = ?,
+                        scopes = COALESCE(?, scopes),
+                        label = COALESCE(?, label)
+                  WHERE id = ? AND revision = ?`
+    ).run(
+      update.revision,
+      update.secretCiphertext,
+      update.updatedAt,
+      update.scopes === void 0 ? null : JSON.stringify(update.scopes),
+      update.label ?? null,
+      update.id,
+      update.expectedRevision
+    );
+    return result.changes > 0;
+  }
+  async delete(id) {
+    this.db.prepare(`DELETE FROM plugin_connections WHERE id = ?`).run(id);
+    this.db.prepare(`DELETE FROM plugin_connection_tests WHERE connection_id = ?`).run(id);
+  }
+  async getTestEvidence(connectionId) {
+    const row = this.db.prepare(`SELECT * FROM plugin_connection_tests WHERE connection_id = ?`).get(connectionId);
+    return row ? toEvidence(row) : null;
+  }
+  /**
+   * Stores evidence only when it belongs to the connection's current revision
+   * and is not older than what is already stored. A slow test that finishes
+   * after a credential rotation therefore cannot reinstate itself as current
+   * evidence, and an older completion cannot replace a newer result.
+   */
+  async setTestEvidence(evidence) {
+    const result = this.db.prepare(
+      `INSERT INTO plugin_connection_tests (
+                    connection_id, revision, operation_id, ok, code, checked_at, detail
+                 )
+                 SELECT ?, ?, ?, ?, ?, ?, ?
+                  WHERE EXISTS (
+                        SELECT 1 FROM plugin_connections
+                         WHERE id = ? AND revision = ?
+                  )
+                 ON CONFLICT(connection_id) DO UPDATE SET
+                    revision = excluded.revision,
+                    operation_id = excluded.operation_id,
+                    ok = excluded.ok,
+                    code = excluded.code,
+                    checked_at = excluded.checked_at,
+                    detail = excluded.detail
+                  WHERE excluded.revision > plugin_connection_tests.revision
+                     OR (excluded.revision = plugin_connection_tests.revision
+                         AND excluded.checked_at >= plugin_connection_tests.checked_at)`
+    ).run(
+      evidence.connectionId,
+      evidence.revision,
+      evidence.operationId,
+      evidence.ok ? 1 : 0,
+      evidence.code ?? null,
+      evidence.checkedAt,
+      evidence.detail ?? null,
+      evidence.connectionId,
+      evidence.revision
+    );
+    return result.changes > 0;
+  }
+}
+export function createSqlitePluginConnectionStore(options = {}) {
+  const db = options.database ?? getRawDb();
+  return new SqlitePluginConnectionStore(db);
+}

package/dist/runtime/server/plugins/register.js

@@ -5,6 +5,7 @@ import { registerAdminStoreProvider } from "~~/server/admin/stores/registry";
 import { registerSyncGatewayAdapter } from "~~/server/sync/gateway/registry";
 import { registerWebhookStore } from "~~/server/utils/webhooks/store/registry";
 import { registerConnectStore } from "~~/server/connect/store/registry";
+import { registerPluginConnectionStore } from "~~/server/utils/plugins/connections/store/registry";
 import { registerRateLimitProvider } from "~~/server/utils/rate-limit/registry";
 import { registerBackgroundJobProvider } from "~~/server/utils/background-jobs/registry";
 import { createSqliteAuthWorkspaceStore } from "../auth/sqlite-auth-workspace-store.js";
@@ -17,6 +18,7 @@ import {
 } from "../admin/stores/sqlite-store.js";
 import { sqliteSyncAdminAdapter } from "../admin/adapters/sync-sqlite.js";
 import { createSqliteConnectStore } from "../connect/sqlite-connect-store.js";
+import { createSqlitePluginConnectionStore } from "../plugin-connections/sqlite-connection-store.js";
 import { getSqliteDriver, initializeSqliteDb } from "../db/kysely.js";
 import { runMigrations } from "../db/migrate.js";
 import { sqliteRateLimitProvider } from "../rate-limit/sqlite-provider.js";
@@ -72,6 +74,17 @@ export default defineNitroPlugin(async (nitroApp) => {
       "[or3-sqlite] Webhook persistence is unavailable with Cloudflare D1."
     );
   }
+  if (driver !== "d1") {
+    registerPluginConnectionStore({
+      id: SQLITE_PROVIDER_ID,
+      order: 100,
+      create: createSqlitePluginConnectionStore
+    });
+  } else {
+    console.warn(
+      "[or3-sqlite] Plugin connection persistence is unavailable with Cloudflare D1."
+    );
+  }
   registerAdminStoreProvider({
     id: SQLITE_PROVIDER_ID,
     createWorkspaceAccessStore: createSqliteWorkspaceAccessStore,

package/dist/runtime/server/sync/sqlite-sync-gateway-adapter.js

@@ -369,6 +369,56 @@ function incomingWinsRevision(incoming, existing) {
     opId: existing.opId || existing.op_id || ""
   });
 }
+function materializedWinner(row, tombstone) {
+  if (tombstone && (!row || incomingWinsRevision(
+    { clock: tombstone.clock, hlc: tombstone.hlc, opId: tombstone.op_id },
+    row
+  ))) {
+    return {
+      kind: "delete",
+      revision: { clock: tombstone.clock, hlc: tombstone.hlc, opId: tombstone.op_id },
+      serverDeletedAt: tombstone.deleted_at
+    };
+  }
+  if (!row) return void 0;
+  const revision = { clock: row.clock, hlc: row.hlc, opId: row.op_id };
+  return row.deleted ? {
+    kind: "delete",
+    revision,
+    serverDeletedAt: tombstone?.op_id === row.op_id ? tombstone.deleted_at : row.updated_at
+  } : { kind: "put", payload: JSON.parse(row.data_json), revision };
+}
+function currentWinnerNative(raw, workspaceId, tableName, pk) {
+  const materializedTable = SYNCED_TABLE_MAP[tableName];
+  if (!materializedTable) return void 0;
+  const row = raw.prepare(
+    `SELECT data_json, deleted, clock, hlc, op_id, updated_at
+         FROM ${materializedTable} WHERE id = ? AND workspace_id = ?`
+  ).get(pk, workspaceId);
+  const tombstone = raw.prepare(
+    `SELECT clock, hlc, op_id, deleted_at FROM tombstones
+         WHERE workspace_id = ? AND table_name = ? AND pk = ?`
+  ).get(workspaceId, tableName, pk);
+  return materializedWinner(row, tombstone);
+}
+async function currentWinnerD1(workspaceId, tableName, pk) {
+  const materializedTable = SYNCED_TABLE_MAP[tableName];
+  if (!materializedTable) return void 0;
+  const [row] = await d1All(
+    `SELECT data_json, deleted, clock, hlc, op_id, updated_at
+         FROM "${materializedTable}" WHERE id = ? AND workspace_id = ?`,
+    pk,
+    workspaceId
+  );
+  const [tombstone] = await d1All(
+    `SELECT clock, hlc, op_id, deleted_at FROM tombstones
+         WHERE workspace_id = ? AND table_name = ? AND pk = ?`,
+    workspaceId,
+    tableName,
+    pk
+  );
+  return materializedWinner(row, tombstone);
+}
 export class SqliteSyncGatewayAdapter {
   id = "sqlite";
   get capabilities() {
@@ -1105,14 +1155,14 @@ export class SqliteSyncGatewayAdapter {
             });
             continue;
           }
-          const materialized = SYNCED_TABLE_MAP[op.tableName] ? raw.prepare(
-            `SELECT op_id FROM ${SYNCED_TABLE_MAP[op.tableName]} WHERE id = ? AND workspace_id = ?`
-          ).get(op.pk, workspaceId) : void 0;
+          const winner = currentWinnerNative(raw, workspaceId, op.tableName, op.pk);
           uniqueResults.push({
             opId,
             success: true,
             serverVersion: existingLog.server_version,
-            applied: materialized?.op_id === opId
+            replayed: true,
+            applied: winner?.revision.opId === opId,
+            ...winner?.revision.opId === opId ? {} : { winner }
           });
           continue;
         }
@@ -1240,7 +1290,10 @@ export class SqliteSyncGatewayAdapter {
             success: true,
             serverVersion,
             applied,
-            ...applied ? {} : { payload: winnerPayload }
+            ...applied ? {} : {
+              payload: winnerPayload,
+              winner: currentWinnerNative(raw, workspaceId, op.tableName, pkValue)
+            }
           });
         } else if (op.operation === "delete") {
           const existing = raw.prepare(
@@ -1316,7 +1369,10 @@ export class SqliteSyncGatewayAdapter {
             success: true,
             serverVersion,
             applied,
-            ...applied || !existing ? {} : { payload: JSON.parse(existing.data_json) }
+            ...applied || !existing ? {} : { payload: JSON.parse(existing.data_json) },
+            ...applied ? {} : {
+              winner: currentWinnerNative(raw, workspaceId, op.tableName, pkValue)
+            }
           });
         }
       }
@@ -2431,21 +2487,15 @@ export class SqliteSyncGatewayAdapter {
       if (rejected.has(op.stamp.opId)) continue;
       const existing = existingOps.get(op.stamp.opId);
       if (existing) {
-        const materializedTable = SYNCED_TABLE_MAP[op.tableName];
-        let applied2 = true;
-        if (materializedTable) {
-          const [row] = await d1All(
-            `SELECT op_id FROM "${materializedTable}" WHERE id = ? AND workspace_id = ?`,
-            op.pk,
-            workspaceId
-          );
-          applied2 = row?.op_id === op.stamp.opId;
-        }
+        const winner = await currentWinnerD1(workspaceId, op.tableName, op.pk);
+        const applied2 = winner?.revision.opId === op.stamp.opId;
         const result2 = {
           opId: op.stamp.opId,
           success: true,
           serverVersion: existing.server_version,
-          applied: applied2
+          replayed: true,
+          applied: applied2,
+          ...applied2 ? {} : { winner }
         };
         for (const index of indicesByOpId.get(op.stamp.opId) ?? []) {
           resultSlots[index] = result2;
@@ -2478,7 +2528,10 @@ export class SqliteSyncGatewayAdapter {
         success: true,
         serverVersion,
         applied,
-        ...applied ? {} : { payload: winnerPayload }
+        ...applied ? {} : { payload: winnerPayload },
+        ...applied ? {} : {
+          winner: await currentWinnerD1(workspaceId, op.tableName, op.pk)
+        }
       };
       for (const index of indicesByOpId.get(op.stamp.opId) ?? []) {
         resultSlots[index] = result;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "or3-provider-sqlite",
-    "version": "0.0.10",
+    "version": "0.0.11",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/Saluana/or3-provider-sqlite.git"