reflectdb 0.1.0

package/dist/cjs/client/storage/indexeddb.cjs

@@ -0,0 +1,253 @@
+var import_node_module = require("node:module");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/client/storage/indexeddb.ts
+var exports_indexeddb = {};
+__export(exports_indexeddb, {
+  createIndexedDBStorage: () => createIndexedDBStorage
+});
+module.exports = __toCommonJS(exports_indexeddb);
+function createIndexedDBStorage(config) {
+  let dbPromise = null;
+  let schemaChecked = false;
+  function openDB() {
+    if (dbPromise)
+      return dbPromise;
+    dbPromise = new Promise((resolve, reject) => {
+      const request = indexedDB.open(config.dbName, config.version ?? 1);
+      request.onupgradeneeded = (event) => {
+        const db = request.result;
+        const transaction = request.transaction;
+        if (!db.objectStoreNames.contains("rows")) {
+          const rowStore = db.createObjectStore("rows", { keyPath: ["table", "rowId"] });
+          rowStore.createIndex("table", "table", { unique: false });
+        }
+        if (!db.objectStoreNames.contains("pendingOps")) {
+          db.createObjectStore("pendingOps", { keyPath: "op.id" });
+        }
+        if (!db.objectStoreNames.contains("meta")) {
+          db.createObjectStore("meta", { keyPath: "key" });
+        }
+        if (config.migrate && transaction) {
+          config.migrate({
+            db,
+            transaction,
+            oldVersion: event.oldVersion,
+            newVersion: event.newVersion ?? (config.version ?? 1)
+          });
+        }
+      };
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+    return dbPromise;
+  }
+  function tx(storeNames, mode) {
+    return openDB().then((db) => {
+      const names = Array.isArray(storeNames) ? storeNames : [storeNames];
+      const transaction = db.transaction(names, mode);
+      const stores = {};
+      for (const name of names) {
+        stores[name] = transaction.objectStore(name);
+      }
+      return { tx: transaction, stores };
+    });
+  }
+  function reqToPromise(request) {
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  function txComplete(transaction) {
+    return new Promise((resolve, reject) => {
+      transaction.oncomplete = () => resolve();
+      transaction.onerror = () => reject(transaction.error);
+    });
+  }
+  async function readMetaRaw(key) {
+    const { stores } = await tx("meta", "readonly");
+    const result = await reqToPromise(stores.meta.get(key));
+    return result?.value ?? null;
+  }
+  async function writeMetaRaw(key, value) {
+    const { tx: transaction, stores } = await tx("meta", "readwrite");
+    stores.meta.put({ key, value });
+    await txComplete(transaction);
+  }
+  let schemaCheckPromise = null;
+  async function ensureSchemaChecked() {
+    if (schemaChecked)
+      return;
+    if (schemaCheckPromise)
+      return schemaCheckPromise;
+    schemaCheckPromise = (async () => {
+      if (config.appSchemaVersion === undefined) {
+        schemaChecked = true;
+        return;
+      }
+      const storedRaw = await readMetaRaw("__reflectdb_appSchemaVersion");
+      const stored = storedRaw == null ? null : Number.parseInt(storedRaw, 10);
+      if (stored === null) {
+        await writeMetaRaw("__reflectdb_appSchemaVersion", String(config.appSchemaVersion));
+        schemaChecked = true;
+        return;
+      }
+      if (stored !== config.appSchemaVersion) {
+        if (config.onSchemaChange) {
+          await config.onSchemaChange({ storedVersion: stored, configVersion: config.appSchemaVersion }, adapter);
+        } else {
+          console.warn(`[reflectdb] IndexedDB appSchemaVersion mismatch: stored=${stored} config=${config.appSchemaVersion}. ` + `Pass onSchemaChange to handle (e.g. await storage.clear()).`);
+        }
+        await writeMetaRaw("__reflectdb_appSchemaVersion", String(config.appSchemaVersion));
+      }
+      schemaChecked = true;
+    })().catch((err) => {
+      schemaCheckPromise = null;
+      throw err;
+    });
+    return schemaCheckPromise;
+  }
+  const adapter = {
+    async getRows(table) {
+      await ensureSchemaChecked();
+      const { stores } = await tx("rows", "readonly");
+      const index = stores.rows.index("table");
+      const results = await reqToPromise(index.getAll(table));
+      return results;
+    },
+    async getAllRows() {
+      const { stores } = await tx("rows", "readonly");
+      const results = await reqToPromise(stores.rows.getAll());
+      return results;
+    },
+    async putRow(table, rowId, row) {
+      const { tx: transaction, stores } = await tx("rows", "readwrite");
+      stores.rows.put(row);
+      await txComplete(transaction);
+    },
+    async deleteRow(table, rowId) {
+      const { tx: transaction, stores } = await tx("rows", "readwrite");
+      stores.rows.delete([table, rowId]);
+      await txComplete(transaction);
+    },
+    async clearTable(table) {
+      const { tx: transaction, stores } = await tx("rows", "readwrite");
+      const index = stores.rows.index("table");
+      const keys = await reqToPromise(index.getAllKeys(table));
+      const deletes = keys.map((key) => reqToPromise(stores.rows.delete(key)));
+      await Promise.all(deletes);
+      await txComplete(transaction);
+    },
+    async getPendingOps() {
+      const { stores } = await tx("pendingOps", "readonly");
+      const results = await reqToPromise(stores.pendingOps.getAll());
+      return results;
+    },
+    async putPendingOps(ops) {
+      const { tx: transaction, stores } = await tx("pendingOps", "readwrite");
+      stores.pendingOps.clear();
+      for (const op of ops) {
+        stores.pendingOps.put(op);
+      }
+      await txComplete(transaction);
+    },
+    async appendPendingOps(ops) {
+      const { tx: transaction, stores } = await tx("pendingOps", "readwrite");
+      for (const op of ops) {
+        stores.pendingOps.put(op);
+      }
+      await txComplete(transaction);
+    },
+    async updatePendingOps(ops) {
+      const { tx: transaction, stores } = await tx("pendingOps", "readwrite");
+      for (const op of ops) {
+        stores.pendingOps.put(op);
+      }
+      await txComplete(transaction);
+    },
+    async removePendingOps(opIds) {
+      const { tx: transaction, stores } = await tx("pendingOps", "readwrite");
+      for (const id of opIds) {
+        stores.pendingOps.delete(id);
+      }
+      await txComplete(transaction);
+    },
+    async clearPendingOps() {
+      const { tx: transaction, stores } = await tx("pendingOps", "readwrite");
+      stores.pendingOps.clear();
+      await txComplete(transaction);
+    },
+    async getMeta(key) {
+      const { stores } = await tx("meta", "readonly");
+      const result = await reqToPromise(stores.meta.get(key));
+      return result?.value ?? null;
+    },
+    async setMeta(key, value) {
+      const { tx: transaction, stores } = await tx("meta", "readwrite");
+      stores.meta.put({ key, value });
+      await txComplete(transaction);
+    },
+    async deleteMeta(key) {
+      const { tx: transaction, stores } = await tx("meta", "readwrite");
+      stores.meta.delete(key);
+      await txComplete(transaction);
+    },
+    async clear() {
+      const { tx: transaction, stores } = await tx(["rows", "pendingOps", "meta"], "readwrite");
+      stores.rows.clear();
+      stores.pendingOps.clear();
+      stores.meta.clear();
+      await txComplete(transaction);
+      dbPromise = null;
+    }
+  };
+  const _getAllRows = adapter.getAllRows;
+  adapter.getAllRows = async () => {
+    await ensureSchemaChecked();
+    return _getAllRows();
+  };
+  const _getPendingOps = adapter.getPendingOps;
+  adapter.getPendingOps = async () => {
+    await ensureSchemaChecked();
+    return _getPendingOps();
+  };
+  return adapter;
+}

package/dist/cjs/client/storage/indexeddb.d.cts

@@ -0,0 +1,85 @@
+type OpType = "insert" | "update" | "delete";
+type OpStatus = "pending" | "synced" | "rejected";
+type ErrorReason = "outside_shape" | "readonly_query" | "rate_limited" | "buffer_full" | "server_conflict" | "custom_conflict" | "merge_stale" | "clock_drift" | "replay" | "batch_too_large" | "schema_outdated" | "auth_revoked" | "compacted" | "mutation_rejected" | "server_error" | "unknown_query";
+interface ClientOp {
+	id: string;
+	table: string;
+	op: OpType;
+	rowId: string;
+	payload: Record<string, unknown> | null;
+	hlc: string;
+	batchId?: string;
+	batchSize?: number;
+	batchSeq?: number;
+}
+interface PendingOp {
+	op: ClientOp;
+	status: OpStatus;
+	rejectedReason: ErrorReason | null;
+	createdAt: number;
+	/**
+	* Row state captured just before the optimistic apply. Restored on reject
+	* so a rejected optimistic insert collapses back to no-row (instead of
+	* leaving a tombstone), and a rejected update reverts to the merged row
+	* the client had before touching it.
+	*/
+	preState?: {
+		data: Record<string, unknown> | null;
+		colClocks: Record<string, string>;
+		serverHlc: string | null;
+	} | null;
+}
+interface LocalRow {
+	table: string;
+	rowId: string;
+	data: Record<string, unknown> | null;
+	colClocks: Record<string, string>;
+	serverHlc: string | null;
+}
+interface ClientStorageAdapter {
+	getRows(table: string): Promise<LocalRow[]>;
+	getAllRows(): Promise<LocalRow[]>;
+	putRow(table: string, rowId: string, row: LocalRow): Promise<void>;
+	deleteRow(table: string, rowId: string): Promise<void>;
+	clearTable(table: string): Promise<void>;
+	getPendingOps(): Promise<PendingOp[]>;
+	putPendingOps(ops: PendingOp[]): Promise<void>;
+	appendPendingOps(ops: PendingOp[]): Promise<void>;
+	updatePendingOps(ops: PendingOp[]): Promise<void>;
+	removePendingOps(opIds: string[]): Promise<void>;
+	clearPendingOps(): Promise<void>;
+	getMeta(key: string): Promise<string | null>;
+	setMeta(key: string, value: string): Promise<void>;
+	deleteMeta(key: string): Promise<void>;
+	clear(): Promise<void>;
+}
+interface IndexedDBMigrationContext {
+	db: IDBDatabase;
+	transaction: IDBTransaction;
+	oldVersion: number;
+	newVersion: number;
+}
+declare function createIndexedDBStorage(config: {
+	dbName: string;
+	version?: number;
+	/**
+	* Called during onupgradeneeded after the built-in stores are ensured.
+	* Bump `version` and handle old→new schema changes here. Without this,
+	* raising `version` in app code with no migration wipes user data.
+	*/
+	migrate?: (ctx: IndexedDBMigrationContext) => void;
+	/**
+	* Application-level schema version (separate from IDB `version`).
+	* Persisted to meta on first open. On subsequent opens, mismatch fires
+	* `onSchemaChange` so the app can clear or migrate row data whose shape
+	* changed without an IDB version bump (e.g. new required field added to
+	* a Drizzle table).
+	*/
+	appSchemaVersion?: number;
+	/** Invoked when stored appSchemaVersion differs from config. Default: warn. */
+	onSchemaChange?: (ctx: {
+		storedVersion: number;
+		configVersion: number;
+	}, storage: ClientStorageAdapter) => void | Promise<void>;
+}): ClientStorageAdapter;
+export { createIndexedDBStorage, IndexedDBMigrationContext };

package/dist/cjs/core/index.cjs

@@ -0,0 +1,202 @@
+var import_node_module = require("node:module");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/core/types.ts
+var exports_types = {};
+__export(exports_types, {
+  reasonFromError: () => reasonFromError,
+  isErrorReason: () => isErrorReason,
+  TransportSendError: () => TransportSendError,
+  TOMBSTONE_RETENTION_MS: () => TOMBSTONE_RETENTION_MS,
+  SUPPORTED_PROTOCOL_VERSIONS: () => SUPPORTED_PROTOCOL_VERSIONS,
+  SERVER_TOMBSTONE_RETENTION_MS: () => SERVER_TOMBSTONE_RETENTION_MS,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  MutationError: () => MutationError,
+  MAX_CLOCK_DRIFT_MS: () => MAX_CLOCK_DRIFT_MS,
+  MAX_BATCH_SIZE: () => MAX_BATCH_SIZE
+});
+function isErrorReason(value) {
+  return typeof value === "string" && VALID_ERROR_REASONS.has(value);
+}
+function reasonFromError(err) {
+  if (err instanceof MutationError && isErrorReason(err.reason)) {
+    return err.reason;
+  }
+  return "server_error";
+}
+var TransportSendError, PROTOCOL_VERSION = 1, SUPPORTED_PROTOCOL_VERSIONS, MAX_CLOCK_DRIFT_MS, MAX_BATCH_SIZE = 100, TOMBSTONE_RETENTION_MS, SERVER_TOMBSTONE_RETENTION_MS, MutationError, VALID_ERROR_REASONS;
+var init_types = __esm(() => {
+  TransportSendError = class TransportSendError extends Error {
+    clientId;
+    cause;
+    constructor(clientId, message, cause) {
+      super(message);
+      this.clientId = clientId;
+      this.cause = cause;
+      this.name = "TransportSendError";
+    }
+  };
+  SUPPORTED_PROTOCOL_VERSIONS = [1];
+  MAX_CLOCK_DRIFT_MS = 5 * 60 * 1000;
+  TOMBSTONE_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+  SERVER_TOMBSTONE_RETENTION_MS = 90 * 24 * 60 * 60 * 1000;
+  MutationError = class MutationError extends Error {
+    reason;
+    constructor(reason, message) {
+      super(message ?? reason);
+      this.reason = reason;
+    }
+  };
+  VALID_ERROR_REASONS = new Set([
+    "outside_shape",
+    "readonly_query",
+    "rate_limited",
+    "buffer_full",
+    "server_conflict",
+    "custom_conflict",
+    "merge_stale",
+    "clock_drift",
+    "replay",
+    "batch_too_large",
+    "schema_outdated",
+    "auth_revoked",
+    "compacted",
+    "mutation_rejected",
+    "server_error",
+    "unknown_query"
+  ]);
+});
+
+// src/core/index.ts
+var exports_core = {};
+__export(exports_core, {
+  view: () => view,
+  unpackHlc: () => unpackHlc,
+  t: () => t,
+  sendHlc: () => sendHlc,
+  receiveHlc: () => receiveHlc,
+  reasonFromError: () => reasonFromError,
+  presence: () => presence,
+  packHlc: () => packHlc,
+  isErrorReason: () => isErrorReason,
+  defineSyncQueries: () => defineSyncQueries,
+  createHlc: () => createHlc,
+  compareHlc: () => compareHlc,
+  TransportSendError: () => TransportSendError,
+  TOMBSTONE_RETENTION_MS: () => TOMBSTONE_RETENTION_MS,
+  SUPPORTED_PROTOCOL_VERSIONS: () => SUPPORTED_PROTOCOL_VERSIONS,
+  SERVER_TOMBSTONE_RETENTION_MS: () => SERVER_TOMBSTONE_RETENTION_MS,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  MutationError: () => MutationError,
+  MAX_CLOCK_DRIFT_MS: () => MAX_CLOCK_DRIFT_MS,
+  MAX_BATCH_SIZE: () => MAX_BATCH_SIZE
+});
+module.exports = __toCommonJS(exports_core);
+
+// src/core/hlc.ts
+init_types();
+var MS_PAD = 19;
+var COUNTER_PAD = 4;
+var COUNTER_MAX = 9999;
+function createHlc(nodeId) {
+  return { ms: 0, counter: 0, nodeId };
+}
+function normalize(ms, counter, nodeId) {
+  if (counter > COUNTER_MAX) {
+    return { ms: ms + 1, counter: 0, nodeId };
+  }
+  return { ms, counter, nodeId };
+}
+function sendHlc(local) {
+  const wall = Date.now();
+  const ms = Math.max(wall, local.ms);
+  const counter = ms === local.ms ? local.counter + 1 : 0;
+  return normalize(ms, counter, local.nodeId);
+}
+function receiveHlc(local, remote) {
+  const wall = Date.now();
+  const clampedRemoteMs = Math.min(remote.ms, wall + MAX_CLOCK_DRIFT_MS);
+  const ms = Math.max(wall, local.ms, clampedRemoteMs);
+  const counter = ms === local.ms && ms === clampedRemoteMs ? Math.max(local.counter, remote.counter) + 1 : ms === local.ms ? local.counter + 1 : ms === clampedRemoteMs ? remote.counter + 1 : 0;
+  return normalize(ms, counter, local.nodeId);
+}
+function packHlc(hlc) {
+  const ms = String(hlc.ms).padStart(MS_PAD, "0");
+  const counter = String(hlc.counter).padStart(COUNTER_PAD, "0");
+  return `${ms}.${counter}.${hlc.nodeId}`;
+}
+function unpackHlc(packed) {
+  const firstDot = packed.indexOf(".");
+  const secondDot = firstDot < 0 ? -1 : packed.indexOf(".", firstDot + 1);
+  if (firstDot < 0 || secondDot < 0) {
+    throw new Error(`Malformed HLC: ${packed}`);
+  }
+  const ms = Number(packed.slice(0, firstDot));
+  const counter = Number(packed.slice(firstDot + 1, secondDot));
+  const nodeId = packed.slice(secondDot + 1);
+  if (!Number.isFinite(ms) || !Number.isFinite(counter) || nodeId.length === 0) {
+    throw new Error(`Malformed HLC: ${packed}`);
+  }
+  return { ms, counter, nodeId };
+}
+function compareHlc(a, b) {
+  if (a < b)
+    return -1;
+  if (a > b)
+    return 1;
+  return 0;
+}
+
+// src/core/index.ts
+init_types();
+
+// src/core/schema.ts
+function view(opts) {
+  return { __view: true, ...opts };
+}
+function presence(opts) {
+  return { __presence: true, ...opts };
+}
+function defineSyncQueries(queries) {
+  return queries;
+}
+function t() {
+  return;
+}