silosdk 0.0.0 → 0.0.1

package/dist/local/provider.mjs

@@ -0,0 +1,203 @@
+import { applyRemoteOps } from "./sync.mjs";
+import { CloudflareSyncAdapter } from "./adapters/cloudflare.mjs";
+import { authEvents, clearStoredSessionToken, fetchCurrentUser, getStoredSessionToken, requestOtp, setAuthProdUrl, signOutFromServer, verifyOtpWithServer } from "./auth.mjs";
+import { Context } from "./config.mjs";
+import { getQueryStoreInstance } from "./view.mjs";
+import { AuthContext } from "./auth-context.mjs";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { SQLiteProvider, useSQLiteContext } from "expo-sqlite";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/local/provider.tsx
+function Provider(props) {
+	const { config } = props;
+	const subscribers = useRef(/* @__PURE__ */ new Map()).current;
+	const url = config?.url;
+	const prodUrl = config?.prodUrl;
+	const [user, setUser] = useState(null);
+	const [isLoading, setIsLoading] = useState(true);
+	const [authReady, setAuthReady] = useState(false);
+	const tokenRef = useRef(null);
+	const authReadyPromiseRef = useRef(null);
+	const authReadyResolveRef = useRef(null);
+	if (!authReadyPromiseRef.current) authReadyPromiseRef.current = new Promise((resolve) => {
+		authReadyResolveRef.current = resolve;
+	});
+	const resolvedGetToken = config?.getToken ? config.getToken : config?.url ? () => getStoredSessionToken(config?.url) : void 0;
+	const dbName = `${config?.name ?? "app"}.db`;
+	useEffect(() => {
+		setAuthProdUrl(prodUrl ?? null);
+	}, [prodUrl]);
+	useEffect(() => {
+		if (!url) {
+			setIsLoading(false);
+			setAuthReady(true);
+			return;
+		}
+		(async () => {
+			try {
+				const token = await getStoredSessionToken(url);
+				if (token) {
+					tokenRef.current = token;
+					const current = await fetchCurrentUser(url, token);
+					if (current.user) setUser(current.user);
+					else {
+						await clearStoredSessionToken(url);
+						tokenRef.current = null;
+					}
+				}
+			} catch (err) {
+				console.error("[silosdk] Auth init failed:", err);
+			} finally {
+				setIsLoading(false);
+				setAuthReady(true);
+			}
+		})();
+	}, [url]);
+	useEffect(() => {
+		if (authReady) authReadyResolveRef.current?.();
+	}, [authReady]);
+	const signIn = useCallback(async (opts) => {
+		if (!url) throw new Error("No URL configured");
+		await requestOtp(url, opts.email);
+	}, [url]);
+	const verifyOtp = useCallback(async (opts) => {
+		if (!url) throw new Error("No URL configured");
+		const result = await verifyOtpWithServer(url, opts);
+		tokenRef.current = result.token;
+		setUser(result.user);
+		authEvents.emit("token-changed");
+	}, [url]);
+	const signOut = useCallback(async () => {
+		if (!url) return;
+		const token = tokenRef.current;
+		if (token) await signOutFromServer(url, token);
+		await clearStoredSessionToken(url);
+		tokenRef.current = null;
+		setUser(null);
+		authEvents.emit("token-changed");
+	}, [url]);
+	useEffect(() => {
+		if (!url) return;
+		const handleUnauthorized = () => {
+			tokenRef.current = null;
+			setUser(null);
+		};
+		authEvents.on("unauthorized", handleUnauthorized);
+		return () => authEvents.off("unauthorized", handleUnauthorized);
+	}, [url]);
+	const authState = {
+		user,
+		isLoading,
+		signIn,
+		verifyOtp,
+		signOut
+	};
+	return /* @__PURE__ */ jsx(Context.Provider, {
+		value: {
+			subscribers,
+			url: config?.url,
+			getToken: resolvedGetToken,
+			authReady,
+			authReadyPromise: authReadyPromiseRef.current ?? Promise.resolve()
+		},
+		children: /* @__PURE__ */ jsx(AuthContext.Provider, {
+			value: authState,
+			children: /* @__PURE__ */ jsxs(SQLiteProvider, {
+				databaseName: dbName,
+				onInit: async (db) => {
+					await db.execAsync(`
+              PRAGMA journal_mode = WAL;
+              CREATE TABLE IF NOT EXISTS views (
+                id TEXT PRIMARY KEY,
+                view TEXT,
+                data BLOB,
+                createdAt TEXT,
+                updatedAt TEXT,
+                version INTEGER DEFAULT 0
+              );
+              CREATE TABLE IF NOT EXISTS relations (
+                parent TEXT,
+                pid TEXT,
+                child TEXT,
+                cid TEXT
+              );
+            `);
+				},
+				options: { enableChangeListener: true },
+				children: [/* @__PURE__ */ jsx(SyncManagerWithConfig, {
+					config,
+					subscribers
+				}), props.children]
+			})
+		})
+	});
+}
+function SyncManagerWithConfig({ config, subscribers }) {
+	const db = useSQLiteContext();
+	const adapterRef = useRef(void 0);
+	const [isAuthenticated, setIsAuthenticated] = useState(null);
+	const checkAuth = useCallback(async () => {
+		if (!config?.url) {
+			setIsAuthenticated(false);
+			return;
+		}
+		const token = await (config.getToken ? config.getToken : () => getStoredSessionToken(config.url))();
+		if (!token) {
+			setIsAuthenticated(false);
+			return;
+		}
+		try {
+			const res = await fetch(`${config.url}/auth/me`, { headers: { Authorization: `Bearer ${token}` } });
+			if (res.ok) setIsAuthenticated(!(await res.json()).isAnonymous);
+			else setIsAuthenticated(false);
+		} catch {
+			setIsAuthenticated(false);
+		}
+	}, [config?.url, config?.getToken]);
+	useEffect(() => {
+		checkAuth();
+	}, [checkAuth]);
+	useEffect(() => {
+		const handleTokenChanged = () => {
+			getQueryStoreInstance().clear();
+			checkAuth();
+			adapterRef.current?.resetConnection();
+		};
+		authEvents.on("token-changed", handleTokenChanged);
+		return () => {
+			authEvents.off("token-changed", handleTokenChanged);
+		};
+	}, [checkAuth]);
+	useEffect(() => {
+		if (!config?.url || isAuthenticated !== true) return;
+		const resolvedGetToken = config.getToken ? config.getToken : () => getStoredSessionToken(config.url);
+		const adapter = new CloudflareSyncAdapter({
+			url: config.url,
+			getToken: resolvedGetToken,
+			db,
+			subscribers
+		});
+		adapterRef.current = adapter;
+		let mounted = true;
+		adapter.onReceive(async (payload) => {
+			if (mounted) await applyRemoteOps(db, payload.ops, subscribers, adapter.merge);
+		});
+		adapter.connect();
+		return () => {
+			mounted = false;
+			adapter.disconnect();
+			adapterRef.current = void 0;
+		};
+	}, [
+		config?.url,
+		config?.getToken,
+		db,
+		subscribers,
+		isAuthenticated
+	]);
+	return null;
+}
+
+//#endregion
+export { Provider };

package/dist/local/query-store.cjs

@@ -0,0 +1,276 @@
+
+//#region src/local/query-store.ts
+const RETRY_WINDOW_MS = 3e4;
+const MAX_RETRIES = 5;
+var QueryStore = class {
+	constructor() {
+		this.cache = /* @__PURE__ */ new Map();
+	}
+	classifyError(error) {
+		if (error instanceof Error) {
+			if (error.message.includes("Unauthorized")) return {
+				retryable: false,
+				reason: "unauthorized"
+			};
+			if (error.message.includes("Forbidden")) return {
+				retryable: false,
+				reason: "forbidden"
+			};
+		}
+		return {
+			retryable: true,
+			reason: "unknown"
+		};
+	}
+	getRetryState(entry) {
+		if (!entry.retry) entry.retry = {
+			count: 0,
+			firstFailureAt: 0,
+			blocked: false,
+			warned: false
+		};
+		return entry.retry;
+	}
+	resetRetry(entry) {
+		if (entry.retry) {
+			entry.retry.count = 0;
+			entry.retry.firstFailureAt = 0;
+			entry.retry.blocked = false;
+			entry.retry.warned = false;
+		}
+	}
+	shouldRetry(key, entry, error) {
+		const classification = this.classifyError(error);
+		if (!classification.retryable) {
+			const retry$1 = this.getRetryState(entry);
+			retry$1.blocked = true;
+			if (!retry$1.warned) {
+				retry$1.warned = true;
+				console.warn(`[QueryStore] Blocking retries for ${key}: ${classification.reason}`);
+			}
+			return false;
+		}
+		const retry = this.getRetryState(entry);
+		const now = Date.now();
+		if (retry.blocked) return false;
+		if (!retry.firstFailureAt || now - retry.firstFailureAt > RETRY_WINDOW_MS) {
+			retry.firstFailureAt = now;
+			retry.count = 0;
+		}
+		retry.count += 1;
+		if (retry.count > MAX_RETRIES) {
+			retry.blocked = true;
+			if (!retry.warned) {
+				retry.warned = true;
+				console.warn(`[QueryStore] Retry budget exceeded for ${key}`);
+			}
+			return false;
+		}
+		return true;
+	}
+	/**
+	* Ensure data is being fetched for a cache key.
+	* Safe to call multiple times - only triggers one fetch.
+	* Call this during render before useSyncExternalStore.
+	*/
+	ensureFetching(key, fetcher, getToken) {
+		let entry = this.cache.get(key);
+		if (entry?.promise || entry?.status === "resolved") return;
+		if (entry?.retry?.blocked) return;
+		if (!entry) {
+			entry = {
+				status: "pending",
+				listeners: /* @__PURE__ */ new Set()
+			};
+			this.cache.set(key, entry);
+		}
+		const promise = fetcher().then((data) => {
+			const current = this.cache.get(key);
+			if (current) {
+				current.status = "resolved";
+				current.data = data;
+				current.error = void 0;
+				current.promise = void 0;
+				this.resetRetry(current);
+				this.notify(key);
+			}
+			return data;
+		}).catch((error) => {
+			const current = this.cache.get(key);
+			if (current) if (this.shouldRetry(key, current, error)) {
+				current.status = "rejected";
+				current.error = error;
+				current.promise = void 0;
+				this.notify(key);
+			} else {
+				current.status = "rejected";
+				current.error = error;
+				current.promise = void 0;
+				this.notify(key);
+			}
+			throw error;
+		});
+		entry.status = "pending";
+		entry.promise = promise;
+	}
+	/**
+	* Subscribe to changes for a specific cache key.
+	* Returns an unsubscribe function.
+	*/
+	subscribe(key, callback) {
+		let entry = this.cache.get(key);
+		if (!entry) {
+			entry = {
+				status: "pending",
+				listeners: /* @__PURE__ */ new Set()
+			};
+			this.cache.set(key, entry);
+		}
+		entry.listeners.add(callback);
+		return () => {
+			entry.listeners.delete(callback);
+			if (entry.listeners.size === 0 && entry.status === "pending" && !entry.promise) this.cache.delete(key);
+		};
+	}
+	/**
+	* Get the current snapshot for a cache key.
+	* Throws a Promise if data is still loading (for Suspense).
+	* Throws the error if the fetch failed.
+	* This is a pure function - no side effects.
+	*/
+	getSnapshot(key) {
+		const entry = this.cache.get(key);
+		if (!entry) throw new Promise(() => {});
+		if (entry.status === "pending") {
+			if (entry.promise) throw entry.promise;
+			throw new Promise(() => {});
+		}
+		if (entry.status === "rejected") throw entry.error;
+		return entry.data;
+	}
+	/**
+	* Check if a key has resolved data (useful for avoiding Suspense in some cases)
+	*/
+	has(key) {
+		return this.cache.get(key)?.status === "resolved";
+	}
+	/**
+	* Get data if available, otherwise return undefined.
+	* Does not throw - useful for optional data or checking cache.
+	*/
+	peek(key) {
+		const entry = this.cache.get(key);
+		if (entry?.status === "resolved") return entry.data;
+	}
+	/**
+	* Refetch data for a cache key, even if it's already resolved.
+	* Keeps old data visible while reloading (no Suspense trigger).
+	*/
+	refetch(key, fetcher, getToken) {
+		const entry = this.cache.get(key);
+		if (entry?.promise) return entry.promise;
+		const promise = fetcher().then((data) => {
+			const current = this.cache.get(key);
+			if (current) {
+				current.status = "resolved";
+				current.data = data;
+				current.error = void 0;
+				current.promise = void 0;
+				this.resetRetry(current);
+				this.notify(key);
+			}
+			return data;
+		}).catch((error) => {
+			const current = this.cache.get(key);
+			if (current) if (this.shouldRetry(key, current, error)) {
+				current.status = "rejected";
+				current.error = error;
+				current.promise = void 0;
+				this.notify(key);
+			} else {
+				current.status = "rejected";
+				current.error = error;
+				current.promise = void 0;
+				this.notify(key);
+			}
+			throw error;
+		});
+		if (entry) {
+			this.resetRetry(entry);
+			entry.promise = promise;
+		} else {
+			const newEntry = {
+				status: "pending",
+				promise,
+				listeners: /* @__PURE__ */ new Set()
+			};
+			this.cache.set(key, newEntry);
+		}
+		return promise;
+	}
+	/**
+	* Invalidate cache entries that match any of the given view names.
+	* Keys are expected to be in format "viewName:serializedOptions"
+	* Marks entries as stale so next ensureFetching will refetch.
+	*/
+	invalidate(viewNames) {
+		for (const [key, entry] of this.cache.entries()) {
+			const viewName = key.split(":")[0];
+			if (viewNames.has(viewName)) {
+				if (entry.status === "resolved") {
+					entry.status = "pending";
+					entry.data = void 0;
+					entry.promise = void 0;
+					this.resetRetry(entry);
+					this.notify(key);
+				}
+			}
+		}
+	}
+	/**
+	* Invalidate a specific cache key
+	*/
+	invalidateKey(key) {
+		const entry = this.cache.get(key);
+		if (entry && entry.status === "resolved") {
+			entry.status = "pending";
+			entry.data = void 0;
+			entry.promise = void 0;
+			this.resetRetry(entry);
+			this.notify(key);
+		}
+	}
+	/**
+	* Clear all cache entries
+	*/
+	clear() {
+		for (const key of this.cache.keys()) this.notify(key);
+		this.cache.clear();
+	}
+	/**
+	* Notify all listeners for a cache key
+	*/
+	notify(key) {
+		const entry = this.cache.get(key);
+		if (entry) for (const listener of entry.listeners) listener();
+	}
+};
+/**
+* Create a stable cache key from view name and options
+*/
+function createCacheKey(viewName, options) {
+	return `${viewName}:${stableStringify(options)}`;
+}
+/**
+* Stable JSON stringify that sorts object keys
+*/
+function stableStringify(obj) {
+	if (obj === null || obj === void 0) return "";
+	if (typeof obj !== "object") return JSON.stringify(obj);
+	if (Array.isArray(obj)) return "[" + obj.map(stableStringify).join(",") + "]";
+	return "{" + Object.keys(obj).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(obj[key])}`).join(",") + "}";
+}
+
+//#endregion
+exports.QueryStore = QueryStore;
+exports.createCacheKey = createCacheKey;