reflectdb 0.1.0

package/dist/client/index.js

@@ -0,0 +1,106 @@
+import {
+  ClientStore,
+  SyncClient,
+  createOpCreator,
+  pushSafely
+} from "../shared/esm-ytrd3hbq.js";
+import"../shared/esm-rw7jjtrv.js";
+import"../shared/esm-3tkwvysa.js";
+import"../shared/esm-b7xs9cde.js";
+// src/client/storage/memory.ts
+function createMemoryStorage() {
+  const rows = new Map;
+  let pendingOps = [];
+  const meta = new Map;
+  return {
+    async getRows(table) {
+      return Array.from(rows.get(table)?.values() ?? []);
+    },
+    async getAllRows() {
+      const all = [];
+      for (const tableRows of rows.values()) {
+        for (const row of tableRows.values()) {
+          all.push(row);
+        }
+      }
+      return all;
+    },
+    async putRow(table, rowId, row) {
+      let tableRows = rows.get(table);
+      if (!tableRows) {
+        tableRows = new Map;
+        rows.set(table, tableRows);
+      }
+      tableRows.set(rowId, row);
+    },
+    async deleteRow(table, rowId) {
+      rows.get(table)?.delete(rowId);
+    },
+    async clearTable(table) {
+      rows.delete(table);
+    },
+    async getPendingOps() {
+      return [...pendingOps];
+    },
+    async putPendingOps(ops) {
+      pendingOps = [...ops];
+    },
+    async appendPendingOps(ops) {
+      pendingOps.push(...ops);
+    },
+    async updatePendingOps(ops) {
+      const updateMap = new Map;
+      for (const op of ops) {
+        updateMap.set(op.op.id, op);
+      }
+      for (let i = 0;i < pendingOps.length; i++) {
+        const updated = updateMap.get(pendingOps[i].op.id);
+        if (updated) {
+          pendingOps[i] = updated;
+        }
+      }
+    },
+    async removePendingOps(opIds) {
+      const idSet = new Set(opIds);
+      pendingOps = pendingOps.filter((p) => !idSet.has(p.op.id));
+    },
+    async clearPendingOps() {
+      pendingOps = [];
+    },
+    async getMeta(key) {
+      return meta.get(key) ?? null;
+    },
+    async setMeta(key, value) {
+      meta.set(key, value);
+    },
+    async deleteMeta(key) {
+      meta.delete(key);
+    },
+    async clear() {
+      rows.clear();
+      pendingOps = [];
+      meta.clear();
+    }
+  };
+}
+// src/client/typed-client.ts
+function createSyncClient(config) {
+  const { queries, autoSync, ...clientConfig } = config;
+  const client = new SyncClient(clientConfig);
+  if (autoSync) {
+    const origConnect = client.connect.bind(client);
+    client.connect = async () => {
+      await origConnect();
+      await Promise.all(Object.keys(queries).filter((name) => !("params" in queries[name])).map((name) => client.sync(name)));
+    };
+  }
+  return client;
+}
+export {
+  pushSafely,
+  createSyncClient,
+  createOpCreator,
+  createMemoryStorage,
+  SyncClient,
+  ClientStore
+};

package/dist/client/storage/indexeddb.d.ts

@@ -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/client/storage/indexeddb.js

@@ -0,0 +1,213 @@
+import"../../shared/esm-b7xs9cde.js";
+
+// src/client/storage/indexeddb.ts
+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;
+}
+export {
+  createIndexedDBStorage
+};