@rebasepro/server 0.10.0 → 0.10.1-canary.a54c057

package/dist/index.es.js

@@ -13,7 +13,7 @@ import path, { join } from "path";
 import { pathToFileURL } from "url";
 import { Hono } from "hono";
 import { promisify } from "util";
-import * as crypto from "crypto";
+import * as crypto$1 from "crypto";
 import { createCipheriv, createDecipheriv, createHash as createHash$1, createHmac, randomBytes as randomBytes$1, randomUUID as randomUUID$1, scrypt, timingSafeEqual } from "crypto";
 import { bodyLimit } from "hono/body-limit";
 import { csrf } from "hono/csrf";
@@ -17633,6 +17633,578 @@ var RebaseRealtimeChannel = class {
 	}
 };
 /**
+* In-memory store: the default outside the browser and the workhorse of the
+* test suite. Values are deep-copied on the way in and out so a caller
+* mutating a returned row cannot silently edit the "persisted" copy — the
+* IndexedDB implementation gets the same guarantee for free from structured
+* cloning, and the two must not differ in aliasing behaviour.
+*/
+var MemoryOfflineStore = class {
+	cache = /* @__PURE__ */ new Map();
+	queue = /* @__PURE__ */ new Map();
+	async getCache(key) {
+		const entry = this.cache.get(key);
+		return entry ? structuredClone(entry) : void 0;
+	}
+	async setCache(key, entry) {
+		this.cache.set(key, structuredClone(entry));
+	}
+	async deleteCache(keys) {
+		for (const key of keys) this.cache.delete(key);
+	}
+	async listCache(prefix) {
+		const out = [];
+		for (const [key, entry] of this.cache) if (key.startsWith(prefix)) out.push({
+			key,
+			cachedAt: entry.cachedAt
+		});
+		return out;
+	}
+	async enqueue(key, mutation) {
+		this.queue.set(key, structuredClone(mutation));
+	}
+	async dequeue(key) {
+		this.queue.delete(key);
+	}
+	async listQueue(prefix) {
+		return [...this.queue.entries()].filter(([key]) => key.startsWith(prefix)).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([, mutation]) => structuredClone(mutation));
+	}
+	async clear(prefix) {
+		for (const key of [...this.cache.keys()]) if (key.startsWith(prefix)) this.cache.delete(key);
+		for (const key of [...this.queue.keys()]) if (key.startsWith(prefix)) this.queue.delete(key);
+	}
+};
+var IDB_NAME = "rebase-offline";
+var IDB_VERSION = 1;
+var CACHE_STORE = "cache";
+var QUEUE_STORE = "queue";
+/** The exclusive upper bound of an IDBKeyRange covering every key under `prefix`. */
+function prefixRange(prefix) {
+	return IDBKeyRange.bound(prefix, prefix + "￿", false, false);
+}
+function requestToPromise(request) {
+	return new Promise((resolve, reject) => {
+		request.onsuccess = () => resolve(request.result);
+		request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("IndexedDB request failed"));
+	});
+}
+/**
+* IndexedDB-backed store — the browser default, so cached reads and queued
+* writes survive a reload or a browser restart. Everything lives in one
+* database with two object stores; keys are the manager's full prefixed
+* strings, so multiple users (scopes) share the database without ever
+* sharing entries.
+*/
+var IndexedDBOfflineStore = class {
+	dbPromise;
+	open() {
+		if (!this.dbPromise) this.dbPromise = new Promise((resolve, reject) => {
+			const request = indexedDB.open(IDB_NAME, IDB_VERSION);
+			request.onupgradeneeded = () => {
+				const db = request.result;
+				if (!db.objectStoreNames.contains(CACHE_STORE)) db.createObjectStore(CACHE_STORE);
+				if (!db.objectStoreNames.contains(QUEUE_STORE)) db.createObjectStore(QUEUE_STORE);
+			};
+			request.onsuccess = () => resolve(request.result);
+			request.onerror = () => {
+				this.dbPromise = void 0;
+				reject(request.error ?? /* @__PURE__ */ new Error("Failed to open IndexedDB"));
+			};
+		});
+		return this.dbPromise;
+	}
+	async store(name, mode) {
+		return (await this.open()).transaction(name, mode).objectStore(name);
+	}
+	async getCache(key) {
+		return await requestToPromise((await this.store(CACHE_STORE, "readonly")).get(key));
+	}
+	async setCache(key, entry) {
+		await requestToPromise((await this.store(CACHE_STORE, "readwrite")).put(entry, key));
+	}
+	async deleteCache(keys) {
+		if (keys.length === 0) return;
+		const store = await this.store(CACHE_STORE, "readwrite");
+		await Promise.all(keys.map((key) => requestToPromise(store.delete(key))));
+	}
+	async listCache(prefix) {
+		const store = await this.store(CACHE_STORE, "readonly");
+		const [keys, entries] = await Promise.all([requestToPromise(store.getAllKeys(prefixRange(prefix))), requestToPromise(store.getAll(prefixRange(prefix)))]);
+		return keys.map((key, i) => ({
+			key: String(key),
+			cachedAt: entries[i]?.cachedAt ?? 0
+		}));
+	}
+	async enqueue(key, mutation) {
+		await requestToPromise((await this.store(QUEUE_STORE, "readwrite")).put(mutation, key));
+	}
+	async dequeue(key) {
+		await requestToPromise((await this.store(QUEUE_STORE, "readwrite")).delete(key));
+	}
+	async listQueue(prefix) {
+		return await requestToPromise((await this.store(QUEUE_STORE, "readonly")).getAll(prefixRange(prefix)));
+	}
+	async clear(prefix) {
+		await requestToPromise((await this.store(CACHE_STORE, "readwrite")).delete(prefixRange(prefix)));
+		await requestToPromise((await this.store(QUEUE_STORE, "readwrite")).delete(prefixRange(prefix)));
+	}
+};
+/** True for "the request never reached the server", false for a server reply. */
+function isNetworkError(error) {
+	if (error instanceof RebaseApiError) return false;
+	return error instanceof TypeError;
+}
+function generateOfflineId() {
+	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+	return `off-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+/** A find is "appendable" when queued creates provably belong in its result set. */
+function isAppendable(params) {
+	return !params?.where && !params?.logical && !params?.searchString;
+}
+var OfflineManager = class {
+	store;
+	maxCachedQueries;
+	onSyncError;
+	syncIntervalMs;
+	createInner;
+	inners = /* @__PURE__ */ new Map();
+	scope = "anon";
+	/** In-memory mirror of the current scope's queue, kept in seq order. */
+	queue = [];
+	loadPromise;
+	nextSeq = 1;
+	/** Serializes enqueues so concurrent writes get distinct, ordered seqs. */
+	enqueueChain = Promise.resolve();
+	flushPromise;
+	queueListeners = /* @__PURE__ */ new Set();
+	syncTimer;
+	onOnline = () => {
+		this.sync().catch(() => void 0);
+	};
+	api;
+	constructor(config, createInner) {
+		this.store = config.store ?? (typeof indexedDB !== "undefined" ? new IndexedDBOfflineStore() : new MemoryOfflineStore());
+		this.maxCachedQueries = config.maxCachedQueriesPerCollection ?? 50;
+		this.syncIntervalMs = config.syncIntervalMs ?? 3e4;
+		this.onSyncError = config.onSyncError;
+		this.createInner = createInner;
+		if (typeof window !== "undefined" && typeof window.addEventListener === "function") window.addEventListener("online", this.onOnline);
+		this.api = {
+			sync: () => this.sync(),
+			pending: async () => {
+				await this.ensureLoaded();
+				return this.queue.map((m) => structuredClone(m));
+			},
+			clear: async () => {
+				await this.store.clear(`${this.scope}|`);
+				this.queue = [];
+				this.notifyQueue();
+			},
+			onQueueChange: (listener) => {
+				this.queueListeners.add(listener);
+				return () => this.queueListeners.delete(listener);
+			}
+		};
+	}
+	/**
+	* Cache and queue are partitioned per signed-in user: cached rows are
+	* RLS-filtered for the user who fetched them, and queued writes must
+	* replay under the credentials that made them — so neither may ever leak
+	* across a sign-out/sign-in on a shared browser.
+	*/
+	setScope(uid) {
+		const next = uid || "anon";
+		if (next === this.scope) return;
+		this.scope = next;
+		this.loadPromise = void 0;
+		this.queue = [];
+		this.sync().catch(() => void 0);
+	}
+	/** Release the online listener and retry timer (client.close()). */
+	dispose() {
+		if (typeof window !== "undefined" && typeof window.removeEventListener === "function") window.removeEventListener("online", this.onOnline);
+		this.stopTimer();
+	}
+	wrap(slug, inner) {
+		this.inners.set(slug, inner);
+		const wrapped = {
+			find: async (params) => {
+				try {
+					const res = await inner.find(params);
+					await this.cacheSet(this.findKey(slug, params), res);
+					return await this.overlayFind(slug, params, res);
+				} catch (error) {
+					if (!isNetworkError(error)) throw error;
+					const cached = await this.cacheGet(this.findKey(slug, params));
+					if (cached === void 0) throw error;
+					return this.overlayFind(slug, params, cached);
+				}
+			},
+			findById: async (id) => {
+				try {
+					const row = await inner.findById(id);
+					if (row !== void 0) await this.cacheSet(this.rowKey(slug, id), row);
+					return await this.overlayRow(slug, id, row);
+				} catch (error) {
+					if (!isNetworkError(error)) throw error;
+					const cached = await this.cacheGet(this.rowKey(slug, id));
+					const { touched, row } = await this.composeRowFromQueue(slug, id, cached);
+					if (!touched && cached === void 0) throw error;
+					return touched ? row : cached;
+				}
+			},
+			create: async (data, id) => {
+				try {
+					return await inner.create(data, id);
+				} catch (error) {
+					if (!isNetworkError(error)) throw error;
+					const providedId = id ?? data.id;
+					const rowId = providedId ?? generateOfflineId();
+					const row = {
+						...data,
+						id: rowId
+					};
+					await this.enqueue({
+						collection: slug,
+						type: "create",
+						id: rowId,
+						data: row,
+						generatedId: providedId === void 0
+					});
+					await this.cacheSet(this.rowKey(slug, rowId), row);
+					return row;
+				}
+			},
+			createMany: async (data, options) => {
+				try {
+					return await inner.createMany(data, options);
+				} catch (error) {
+					if (!isNetworkError(error)) throw error;
+					if (!Array.isArray(data) || data.length === 0) return [];
+					const rows = data.map((r) => ({
+						...r,
+						id: r.id ?? generateOfflineId()
+					}));
+					await this.enqueue({
+						collection: slug,
+						type: "createMany",
+						data: rows,
+						upsert: options?.upsert
+					});
+					for (const row of rows) await this.cacheSet(this.rowKey(slug, row.id), row);
+					return rows;
+				}
+			},
+			update: async (id, data) => {
+				try {
+					const row = await inner.update(id, data);
+					await this.cacheSet(this.rowKey(slug, id), row);
+					return row;
+				} catch (error) {
+					if (!isNetworkError(error)) throw error;
+					await this.enqueue({
+						collection: slug,
+						type: "update",
+						id,
+						data
+					});
+					const optimistic = {
+						...await this.cacheGet(this.rowKey(slug, id)) ?? {},
+						...data,
+						id
+					};
+					await this.cacheSet(this.rowKey(slug, id), optimistic);
+					return optimistic;
+				}
+			},
+			delete: async (id) => {
+				try {
+					await inner.delete(id);
+					await this.cacheDelete(this.rowKey(slug, id));
+				} catch (error) {
+					if (!isNetworkError(error)) throw error;
+					await this.enqueue({
+						collection: slug,
+						type: "delete",
+						id
+					});
+					await this.cacheDelete(this.rowKey(slug, id));
+				}
+			},
+			count: async (params) => {
+				try {
+					const n = await inner.count(params);
+					await this.cacheSet(this.countKey(slug, params), n);
+					return this.overlayCount(slug, params, n);
+				} catch (error) {
+					if (!isNetworkError(error)) throw error;
+					const cached = await this.cacheGet(this.countKey(slug, params));
+					if (cached === void 0) throw error;
+					return this.overlayCount(slug, params, cached);
+				}
+			},
+			where(columnOrCondition, operator, value) {
+				const builder = new SDKQueryBuilder(wrapped);
+				if (typeof columnOrCondition === "object") return builder.where(columnOrCondition);
+				return builder.where(columnOrCondition, operator, value);
+			},
+			orderBy: (column, direction) => new SDKQueryBuilder(wrapped).orderBy(column, direction),
+			limit: (count) => new SDKQueryBuilder(wrapped).limit(count),
+			offset: (count) => new SDKQueryBuilder(wrapped).offset(count),
+			search: (searchString) => new SDKQueryBuilder(wrapped).search(searchString),
+			include: (...relations) => new SDKQueryBuilder(wrapped).include(...relations)
+		};
+		if (inner.listen) wrapped.listen = inner.listen.bind(inner);
+		if (inner.listenById) wrapped.listenById = inner.listenById.bind(inner);
+		return wrapped;
+	}
+	async pendingFor(slug) {
+		await this.ensureLoaded();
+		return this.queue.filter((m) => m.collection === slug);
+	}
+	async overlayFind(slug, params, result) {
+		const ops = await this.pendingFor(slug);
+		if (ops.length === 0) return result;
+		const appendable = isAppendable(params);
+		let rows = result.data.map((r) => ({ ...r }));
+		let total = result.meta.total;
+		const applyCreate = (row) => {
+			if (!appendable) return;
+			if (rows.some((r) => r.id === row.id)) return;
+			rows.push({ ...row });
+			total++;
+		};
+		for (const op of ops) if (op.type === "create") applyCreate(op.data);
+		else if (op.type === "createMany") for (const row of op.data) applyCreate(row);
+		else if (op.type === "update") {
+			const idx = rows.findIndex((r) => r.id === op.id);
+			if (idx >= 0) rows[idx] = {
+				...rows[idx],
+				...op.data
+			};
+		} else if (op.type === "delete") {
+			const before = rows.length;
+			rows = rows.filter((r) => r.id !== op.id);
+			if (rows.length < before) total = Math.max(0, total - 1);
+		}
+		return {
+			data: rows,
+			meta: {
+				...result.meta,
+				total
+			}
+		};
+	}
+	async overlayCount(slug, params, count) {
+		const ops = await this.pendingFor(slug);
+		if (ops.length === 0 || !isAppendable(params)) return count;
+		let n = count;
+		for (const op of ops) if (op.type === "create") n++;
+		else if (op.type === "createMany") n += op.data.length;
+		else if (op.type === "delete") n = Math.max(0, n - 1);
+		return n;
+	}
+	/**
+	* Fold the queued ops for one row into a base value. `touched` separates
+	* "the queue says this row does not exist" (a pending delete → undefined)
+	* from "the queue has nothing to say" — the caller falls back differently.
+	*/
+	async composeRowFromQueue(slug, id, base) {
+		const ops = await this.pendingFor(slug);
+		let touched = false;
+		let row = base;
+		for (const op of ops) if (op.type === "create" && op.id === id) {
+			row = { ...op.data };
+			touched = true;
+		} else if (op.type === "createMany") {
+			const match = op.data.find((r) => r.id === id);
+			if (match) {
+				row = { ...match };
+				touched = true;
+			}
+		} else if (op.type === "update" && op.id === id) {
+			row = {
+				...row ?? {},
+				...op.data,
+				id
+			};
+			touched = true;
+		} else if (op.type === "delete" && op.id === id) {
+			row = void 0;
+			touched = true;
+		}
+		return {
+			touched,
+			row
+		};
+	}
+	async overlayRow(slug, id, base) {
+		const { touched, row } = await this.composeRowFromQueue(slug, id, base);
+		return touched ? row : base;
+	}
+	ensureLoaded() {
+		if (!this.loadPromise) {
+			const scope = this.scope;
+			this.loadPromise = this.store.listQueue(`${scope}|`).then((queue) => {
+				if (this.scope !== scope) return;
+				this.queue = queue;
+				this.nextSeq = queue.reduce((max, m) => Math.max(max, m.seq), 0) + 1;
+				if (queue.length > 0) this.startTimer();
+				this.notifyQueue();
+			});
+		}
+		return this.loadPromise;
+	}
+	enqueue(mutation) {
+		const result = this.enqueueChain.then(async () => {
+			await this.ensureLoaded();
+			if (mutation.type === "update") {
+				const tail = this.queue[this.queue.length - 1];
+				if (tail && tail.collection === mutation.collection && (tail.type === "create" || tail.type === "update") && tail.id === mutation.id) {
+					tail.data = {
+						...tail.data,
+						...mutation.data,
+						id: tail.id
+					};
+					await this.store.enqueue(this.queueKey(tail.seq), tail);
+					return;
+				}
+			}
+			if (mutation.type === "delete") {
+				if (this.queue.some((m) => m.collection === mutation.collection && m.type === "create" && m.id === mutation.id && m.generatedId === true)) {
+					const doomed = this.queue.filter((m) => m.collection === mutation.collection && m.id === mutation.id && (m.type === "create" || m.type === "update"));
+					for (const op of doomed) await this.store.dequeue(this.queueKey(op.seq));
+					this.queue = this.queue.filter((m) => !doomed.includes(m));
+					this.notifyQueue();
+					return;
+				}
+			}
+			const full = {
+				...mutation,
+				seq: this.nextSeq++,
+				queuedAt: Date.now()
+			};
+			await this.store.enqueue(this.queueKey(full.seq), full);
+			this.queue.push(full);
+			this.startTimer();
+			this.notifyQueue();
+		});
+		this.enqueueChain = result.catch(() => void 0);
+		return result;
+	}
+	sync() {
+		if (this.flushPromise) return this.flushPromise;
+		this.flushPromise = (async () => {
+			await this.ensureLoaded();
+			let flushed = 0;
+			while (this.queue.length > 0) {
+				const op = this.queue[0];
+				try {
+					await this.replay(op);
+				} catch (error) {
+					if (isNetworkError(error)) break;
+					await this.drop(op);
+					this.onSyncError?.(error, op);
+					continue;
+				}
+				await this.drop(op);
+				flushed++;
+			}
+			if (this.queue.length === 0) this.stopTimer();
+			return {
+				flushed,
+				remaining: this.queue.length
+			};
+		})().finally(() => {
+			this.flushPromise = void 0;
+		});
+		return this.flushPromise;
+	}
+	async replay(op) {
+		const inner = this.innerFor(op.collection);
+		if (op.type === "create") {
+			const row = await inner.create(op.data);
+			await this.cacheSet(this.rowKey(op.collection, row.id ?? op.id), row);
+		} else if (op.type === "createMany") await inner.createMany(op.data, op.upsert ? { upsert: true } : void 0);
+		else if (op.type === "update") {
+			const row = await inner.update(op.id, op.data);
+			await this.cacheSet(this.rowKey(op.collection, op.id), row);
+		} else if (op.type === "delete") await inner.delete(op.id);
+	}
+	async drop(op) {
+		await this.store.dequeue(this.queueKey(op.seq));
+		this.queue = this.queue.filter((m) => m.seq !== op.seq);
+		this.notifyQueue();
+	}
+	/** Replay uses unwrapped clients: a failure must never re-enqueue itself. */
+	innerFor(slug) {
+		let inner = this.inners.get(slug);
+		if (!inner) {
+			inner = this.createInner(slug);
+			this.inners.set(slug, inner);
+		}
+		return inner;
+	}
+	notifyQueue() {
+		for (const listener of this.queueListeners) listener(this.queue.length);
+	}
+	startTimer() {
+		if (this.syncTimer || this.syncIntervalMs <= 0) return;
+		this.syncTimer = setInterval(() => {
+			if (typeof navigator !== "undefined" && navigator.onLine === false) return;
+			this.sync().catch(() => void 0);
+		}, this.syncIntervalMs);
+		this.syncTimer.unref?.();
+	}
+	stopTimer() {
+		if (this.syncTimer) {
+			clearInterval(this.syncTimer);
+			this.syncTimer = void 0;
+		}
+	}
+	findKey(slug, params) {
+		return `${this.scope}|find|${slug}|${buildQueryString(params)}`;
+	}
+	countKey(slug, params) {
+		return `${this.scope}|count|${slug}|${buildQueryString(params)}`;
+	}
+	rowKey(slug, id) {
+		return `${this.scope}|row|${slug}|${String(id)}`;
+	}
+	queueKey(seq) {
+		return `${this.scope}|${String(seq).padStart(16, "0")}`;
+	}
+	async cacheGet(key) {
+		try {
+			return (await this.store.getCache(key))?.value;
+		} catch {
+			return;
+		}
+	}
+	async cacheSet(key, value) {
+		try {
+			await this.store.setCache(key, {
+				value,
+				cachedAt: Date.now()
+			});
+			if (key.startsWith(`${this.scope}|find|`)) {
+				const bucket = key.slice(0, key.lastIndexOf("|") + 1);
+				const entries = await this.store.listCache(bucket);
+				if (entries.length > this.maxCachedQueries) {
+					entries.sort((a, b) => a.cachedAt - b.cachedAt);
+					await this.store.deleteCache(entries.slice(0, entries.length - this.maxCachedQueries).map((e) => e.key));
+				}
+			}
+		} catch {}
+	}
+	async cacheDelete(key) {
+		try {
+			await this.store.deleteCache([key]);
+		} catch {}
+	}
+};
+/**
 * Derive a WebSocket URL from an HTTP base URL.
 * `http://` → `ws://`, `https://` → `wss://`.
 */
@@ -17755,10 +18327,20 @@ function createRebaseClient(options) {
 			if (diffs <= 1) return key;
 		}
 	}
+	const offlineManager = options.offline ? new OfflineManager(typeof options.offline === "object" ? options.offline : {}, (slug) => createCollectionClient(transport, slug)) : void 0;
+	if (offlineManager) {
+		offlineManager.setScope(auth.getSession()?.user?.uid);
+		auth.onAuthStateChange((event, session) => {
+			offlineManager.setScope(event === "SIGNED_OUT" ? void 0 : session?.user?.uid);
+		});
+	}
 	const collectionClients = /* @__PURE__ */ new Map();
 	let untypedWarned = false;
 	function collection(slug) {
-		if (!collectionClients.has(slug)) collectionClients.set(slug, createCollectionClient(transport, slug, ws));
+		if (!collectionClients.has(slug)) {
+			const inner = createCollectionClient(transport, slug, ws);
+			collectionClients.set(slug, offlineManager ? offlineManager.wrap(slug, inner) : inner);
+		}
 		return collectionClients.get(slug);
 	}
 	const dataProxy = new Proxy({ collection }, { get(_target, prop) {
@@ -17822,6 +18404,7 @@ channel: (name, options) => {
 			for (const channel of realtimeChannels.values()) channel.leave();
 			realtimeChannels.clear();
 			ws?.disconnect(true);
+			offlineManager?.dispose();
 		},
 		setToken: transport.setToken,
 		setAuthTokenGetter: transport.setAuthTokenGetter,
@@ -17837,7 +18420,8 @@ channel: (name, options) => {
 			});
 			return res.data ?? res;
 		},
-		data: dataProxy
+		data: dataProxy,
+		...offlineManager ? { offline: offlineManager.api } : {}
 	};
 }
 //#endregion
@@ -19779,7 +20363,7 @@ var authJwt = () => {
 * avoids the need for hardcoded dev secrets.
 */
 function generateSecret(bytes = 48) {
-	return crypto.randomBytes(bytes).toString("hex");
+	return crypto$1.randomBytes(bytes).toString("hex");
 }
 /**
 * Zod coercion helper: transforms `"true"` → `true`, everything else → `false`.