or3-provider-sqlite 0.0.1

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

@@ -0,0 +1,366 @@
+import { createError } from "h3";
+import { randomUUID } from "node:crypto";
+import { getSqliteDb, getRawDb } from "../db/kysely.js";
+import { SYNCED_TABLE_MAP, ALLOWED_SYNC_TABLES } from "../db/schema.js";
+const DEFAULT_PULL_LIMIT = 100;
+const MAX_PULL_LIMIT = 1e3;
+const SESSION_CONTEXT_KEY_PREFIX = "__or3_session_context_";
+function uid() {
+  return randomUUID();
+}
+function nowEpoch() {
+  return Math.floor(Date.now() / 1e3);
+}
+function resolvePullLimit(limit) {
+  if (typeof limit !== "number" || !Number.isFinite(limit)) return DEFAULT_PULL_LIMIT;
+  return Math.max(1, Math.min(Math.floor(limit), MAX_PULL_LIMIT));
+}
+async function assertWorkspaceScopeAuthorized(event, workspaceId) {
+  if (!workspaceId.trim()) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "workspaceId is required"
+    });
+  }
+  const context = event.context;
+  let activeWorkspaceId = null;
+  if (context && typeof context === "object") {
+    for (const [key, value] of Object.entries(context)) {
+      if (!key.startsWith(SESSION_CONTEXT_KEY_PREFIX)) continue;
+      const workspaceIdCandidate = value.workspace?.id;
+      if (typeof workspaceIdCandidate === "string" && workspaceIdCandidate.trim().length > 0) {
+        activeWorkspaceId = workspaceIdCandidate;
+        break;
+      }
+    }
+  }
+  if (activeWorkspaceId && activeWorkspaceId !== workspaceId) {
+    throw createError({
+      statusCode: 403,
+      statusMessage: "Forbidden"
+    });
+  }
+}
+function incomingWinsLww(inClock, inHlc, existingClock, existingHlc) {
+  if (inClock > existingClock) return true;
+  if (inClock === existingClock && inHlc > existingHlc) return true;
+  return false;
+}
+export class SqliteSyncGatewayAdapter {
+  id = "sqlite";
+  get db() {
+    return getSqliteDb();
+  }
+  async push(event, input) {
+    const { scope, ops } = input;
+    const workspaceId = scope.workspaceId;
+    await assertWorkspaceScopeAuthorized(event, workspaceId);
+    if (!ops.length) {
+      return { results: [], serverVersion: 0 };
+    }
+    for (const op of ops) {
+      if (!ALLOWED_SYNC_TABLES.includes(op.tableName)) {
+        return {
+          results: ops.map((o) => ({
+            opId: o.stamp.opId,
+            success: false,
+            error: `Invalid table: ${o.tableName}`,
+            errorCode: "VALIDATION_ERROR"
+          })),
+          serverVersion: 0
+        };
+      }
+    }
+    const raw = getRawDb();
+    const now = nowEpoch();
+    const results = [];
+    let finalServerVersion = 0;
+    const runTx = raw.transaction(() => {
+      const opIds = ops.map((o) => o.stamp.opId);
+      const existingOps = /* @__PURE__ */ new Map();
+      const chunkSize = 500;
+      for (let i = 0; i < opIds.length; i += chunkSize) {
+        const chunk = opIds.slice(i, i + chunkSize);
+        const placeholders = chunk.map(() => "?").join(",");
+        const rows = raw.prepare(
+          `SELECT op_id, server_version FROM change_log WHERE op_id IN (${placeholders})`
+        ).all(...chunk);
+        for (const row of rows) {
+          existingOps.set(row.op_id, row.server_version);
+        }
+      }
+      const uniqueNewOpIds = /* @__PURE__ */ new Set();
+      for (const op of ops) {
+        if (existingOps.has(op.stamp.opId)) continue;
+        uniqueNewOpIds.add(op.stamp.opId);
+      }
+      let baseVersion;
+      const counterRow = raw.prepare("SELECT value FROM server_version_counter WHERE workspace_id = ?").get(workspaceId);
+      if (counterRow) {
+        baseVersion = counterRow.value;
+        raw.prepare(
+          "UPDATE server_version_counter SET value = ? WHERE workspace_id = ?"
+        ).run(baseVersion + uniqueNewOpIds.size, workspaceId);
+      } else {
+        baseVersion = 0;
+        raw.prepare(
+          "INSERT INTO server_version_counter (workspace_id, value) VALUES (?, ?)"
+        ).run(workspaceId, uniqueNewOpIds.size);
+      }
+      finalServerVersion = baseVersion + uniqueNewOpIds.size;
+      const insertChangeLog = raw.prepare(`
+                INSERT INTO change_log (id, workspace_id, server_version, table_name, pk, op, payload_json, clock, hlc, device_id, op_id, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            `);
+      const assignedVersions = /* @__PURE__ */ new Map();
+      let versionOffset = 0;
+      for (const op of ops) {
+        if (existingOps.has(op.stamp.opId)) continue;
+        if (assignedVersions.has(op.stamp.opId)) continue;
+        versionOffset++;
+        assignedVersions.set(op.stamp.opId, baseVersion + versionOffset);
+      }
+      const processedNew = /* @__PURE__ */ new Set();
+      for (const op of ops) {
+        const opId = op.stamp.opId;
+        const existingSv = existingOps.get(opId);
+        if (existingSv !== void 0) {
+          results.push({
+            opId,
+            success: true,
+            serverVersion: existingSv
+          });
+          continue;
+        }
+        const serverVersion = assignedVersions.get(opId);
+        if (serverVersion === void 0) {
+          throw new Error(`Missing server version allocation for op_id ${opId}`);
+        }
+        if (processedNew.has(opId)) {
+          results.push({
+            opId,
+            success: true,
+            serverVersion
+          });
+          continue;
+        }
+        processedNew.add(opId);
+        const materializedTable = SYNCED_TABLE_MAP[op.tableName];
+        if (!materializedTable) {
+          results.push({
+            opId,
+            success: false,
+            error: `Unknown table: ${op.tableName}`,
+            errorCode: "VALIDATION_ERROR"
+          });
+          continue;
+        }
+        const pkValue = op.pk;
+        const payloadJson = op.payload != null ? JSON.stringify(op.payload) : null;
+        insertChangeLog.run(
+          uid(),
+          workspaceId,
+          serverVersion,
+          op.tableName,
+          pkValue,
+          op.operation,
+          payloadJson,
+          op.stamp.clock,
+          op.stamp.hlc,
+          op.stamp.deviceId,
+          opId,
+          now
+        );
+        if (op.operation === "put") {
+          const existing = raw.prepare(
+            `SELECT clock, hlc FROM ${materializedTable} WHERE id = ? AND workspace_id = ?`
+          ).get(pkValue, workspaceId);
+          if (!existing) {
+            raw.prepare(
+              `INSERT INTO ${materializedTable} (id, workspace_id, data_json, clock, hlc, device_id, deleted, created_at, updated_at)
+                             VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?)`
+            ).run(
+              pkValue,
+              workspaceId,
+              payloadJson ?? "{}",
+              op.stamp.clock,
+              op.stamp.hlc,
+              op.stamp.deviceId,
+              now,
+              now
+            );
+          } else if (incomingWinsLww(
+            op.stamp.clock,
+            op.stamp.hlc,
+            existing.clock,
+            existing.hlc
+          )) {
+            raw.prepare(
+              `UPDATE ${materializedTable}
+                             SET data_json = ?, clock = ?, hlc = ?, device_id = ?, deleted = 0, updated_at = ?
+                             WHERE id = ? AND workspace_id = ?`
+            ).run(
+              payloadJson ?? "{}",
+              op.stamp.clock,
+              op.stamp.hlc,
+              op.stamp.deviceId,
+              now,
+              pkValue,
+              workspaceId
+            );
+          }
+        } else if (op.operation === "delete") {
+          const existing = raw.prepare(
+            `SELECT clock, hlc FROM ${materializedTable} WHERE id = ? AND workspace_id = ?`
+          ).get(pkValue, workspaceId);
+          if (!existing) {
+            raw.prepare(
+              `INSERT INTO ${materializedTable} (id, workspace_id, data_json, clock, hlc, device_id, deleted, created_at, updated_at)
+                             VALUES (?, ?, '{}', ?, ?, ?, 1, ?, ?)`
+            ).run(
+              pkValue,
+              workspaceId,
+              op.stamp.clock,
+              op.stamp.hlc,
+              op.stamp.deviceId,
+              now,
+              now
+            );
+          } else if (incomingWinsLww(
+            op.stamp.clock,
+            op.stamp.hlc,
+            existing.clock,
+            existing.hlc
+          )) {
+            raw.prepare(
+              `UPDATE ${materializedTable}
+                             SET deleted = 1, clock = ?, hlc = ?, device_id = ?, updated_at = ?
+                             WHERE id = ? AND workspace_id = ?`
+            ).run(
+              op.stamp.clock,
+              op.stamp.hlc,
+              op.stamp.deviceId,
+              now,
+              pkValue,
+              workspaceId
+            );
+          }
+          raw.prepare(
+            `INSERT INTO tombstones (id, workspace_id, table_name, pk, deleted_at, clock, server_version, created_at)
+                         VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                         ON CONFLICT(workspace_id, table_name, pk) DO UPDATE SET
+                           deleted_at = excluded.deleted_at,
+                           clock = excluded.clock,
+                           server_version = excluded.server_version
+                         WHERE excluded.clock > tombstones.clock
+                            OR (
+                                excluded.clock = tombstones.clock
+                                AND excluded.server_version > tombstones.server_version
+                            )`
+          ).run(
+            uid(),
+            workspaceId,
+            op.tableName,
+            pkValue,
+            now,
+            op.stamp.clock,
+            serverVersion,
+            now
+          );
+        }
+        results.push({
+          opId,
+          success: true,
+          serverVersion
+        });
+      }
+    });
+    runTx.immediate();
+    return { results, serverVersion: finalServerVersion };
+  }
+  async pull(event, input) {
+    const db = this.db;
+    const { scope, cursor, limit, tables } = input;
+    await assertWorkspaceScopeAuthorized(event, scope.workspaceId);
+    const fetchLimit = resolvePullLimit(limit);
+    let query = db.selectFrom("change_log").selectAll().where("workspace_id", "=", scope.workspaceId).where("server_version", ">", cursor).orderBy("server_version", "asc").limit(fetchLimit + 1);
+    if (tables?.length) {
+      query = query.where("table_name", "in", tables);
+    }
+    const rows = await query.execute();
+    const hasMore = rows.length > fetchLimit;
+    const resultRows = hasMore ? rows.slice(0, fetchLimit) : rows;
+    const changes = resultRows.map((row) => ({
+      serverVersion: row.server_version,
+      tableName: row.table_name,
+      pk: row.pk,
+      op: row.op,
+      payload: row.payload_json ? JSON.parse(row.payload_json) : void 0,
+      stamp: {
+        clock: row.clock,
+        hlc: row.hlc,
+        deviceId: row.device_id,
+        opId: row.op_id
+      }
+    }));
+    const lastRow = resultRows[resultRows.length - 1];
+    const nextCursor = lastRow ? lastRow.server_version : cursor;
+    return { changes, nextCursor, hasMore };
+  }
+  async updateCursor(event, input) {
+    await assertWorkspaceScopeAuthorized(event, input.scope.workspaceId);
+    const raw = getRawDb();
+    const now = nowEpoch();
+    raw.prepare(
+      `INSERT INTO device_cursors (id, workspace_id, device_id, last_seen_version, updated_at)
+             VALUES (?, ?, ?, ?, ?)
+             ON CONFLICT(workspace_id, device_id) DO UPDATE SET
+               last_seen_version = MAX(device_cursors.last_seen_version, excluded.last_seen_version),
+               updated_at = excluded.updated_at`
+    ).run(uid(), input.scope.workspaceId, input.deviceId, input.version, now);
+  }
+  async gcTombstones(event, input) {
+    await assertWorkspaceScopeAuthorized(event, input.scope.workspaceId);
+    const raw = getRawDb();
+    const workspaceId = input.scope.workspaceId;
+    const minCursorRow = raw.prepare(
+      "SELECT MIN(last_seen_version) as min_version FROM device_cursors WHERE workspace_id = ?"
+    ).get(workspaceId);
+    const minCursor = minCursorRow?.min_version ?? 0;
+    const cutoff = nowEpoch() - input.retentionSeconds;
+    raw.prepare(
+      `DELETE FROM tombstones
+             WHERE workspace_id = ?
+               AND server_version < ?
+               AND created_at < ?`
+    ).run(workspaceId, minCursor, cutoff);
+  }
+  async gcChangeLog(event, input) {
+    await assertWorkspaceScopeAuthorized(event, input.scope.workspaceId);
+    const raw = getRawDb();
+    const workspaceId = input.scope.workspaceId;
+    const minCursorRow = raw.prepare(
+      "SELECT MIN(last_seen_version) as min_version FROM device_cursors WHERE workspace_id = ?"
+    ).get(workspaceId);
+    const minCursor = minCursorRow?.min_version ?? 0;
+    const cutoff = nowEpoch() - input.retentionSeconds;
+    const BATCH_SIZE = 1e3;
+    let deleted;
+    do {
+      const result = raw.prepare(
+        `DELETE FROM change_log
+                     WHERE rowid IN (
+                       SELECT rowid FROM change_log
+                       WHERE workspace_id = ?
+                         AND server_version < ?
+                         AND created_at < ?
+                       LIMIT ?
+                     )`
+      ).run(workspaceId, minCursor, cutoff, BATCH_SIZE);
+      deleted = result.changes;
+    } while (deleted >= BATCH_SIZE);
+  }
+}
+export function createSqliteSyncGatewayAdapter() {
+  return new SqliteSyncGatewayAdapter();
+}

package/dist/types.d.mts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.mjs'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module.mjs'

package/package.json

@@ -0,0 +1,54 @@
+{
+    "name": "or3-provider-sqlite",
+    "version": "0.0.1",
+    "description": "SQLite sync and workspace store provider for OR3 Chat — lightweight self-hosted backend via Kysely.",
+    "license": "MIT",
+    "type": "module",
+    "sideEffects": false,
+    "exports": {
+        ".": {
+            "types": "./dist/types.d.mts",
+            "import": "./dist/module.mjs"
+        },
+        "./nuxt": {
+            "types": "./dist/types.d.mts",
+            "import": "./dist/module.mjs"
+        }
+    },
+    "main": "./dist/module.mjs",
+    "types": "./dist/types.d.mts",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "prepack": "bun run build",
+        "build": "nuxt-module-build build",
+        "lint": "eslint src --max-warnings 0",
+        "type-check": "tsc --noEmit",
+        "test": "vitest run"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "dependencies": {
+        "better-sqlite3": "^12.6.2",
+        "kysely": "^0.28.11"
+    },
+    "peerDependencies": {
+        "@nuxt/kit": "^3.0.0 || ^4.0.0",
+        "nuxt": "^3.0.0 || ^4.0.0"
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.34.0",
+        "@nuxt/module-builder": "^1.0.2",
+        "@types/better-sqlite3": "^7.6.13",
+        "@types/node": "^25.2.2",
+        "@typescript-eslint/eslint-plugin": "^8.41.0",
+        "@typescript-eslint/parser": "^8.41.0",
+        "eslint": "^9.34.0",
+        "h3": "^1.15.4",
+        "pathe": "^2.0.3",
+        "typescript": "^5.9.3",
+        "vitest": "^4.0.18"
+    }
+}