silosdk 0.0.0 → 0.0.1

package/dist/local/adapters/cloudflare.d.cts

@@ -0,0 +1,50 @@
+import { MergeFn, SyncAdapter, SyncPayload } from "../sync.cjs";
+import { SQLiteDatabase } from "expo-sqlite";
+
+//#region src/local/adapters/cloudflare.d.ts
+type CloudflareAdapterOptions = {
+  url: string;
+  getToken?: () => Promise<string | null>;
+  db: SQLiteDatabase;
+  subscribers: Map<string, {
+    update: () => void;
+  }>;
+  merge?: MergeFn;
+};
+declare class CloudflareSyncAdapter extends SyncAdapter {
+  private url;
+  private getToken?;
+  private db;
+  private subscribers;
+  private ws;
+  private receiveHandler?;
+  private reconnectTimer;
+  private backoff;
+  private alive;
+  private registeredViews;
+  private failureCount;
+  private firstFailureAt;
+  private blocked;
+  private warned;
+  private ignoreClose;
+  private pendingCommits;
+  constructor(options: CloudflareAdapterOptions);
+  /** Register the view names this adapter should subscribe to on connect. */
+  registerViews(names: string[]): void;
+  connect(): Promise<void>;
+  private handleMessage;
+  private scheduleReconnect;
+  private recordFailure;
+  resetConnection(): void;
+  send(payload: SyncPayload): Promise<void>;
+  onReceive(handler: (payload: SyncPayload) => Promise<void>): void;
+  fetchInitialState(): Promise<SyncPayload | null>;
+  disconnect(): void;
+  /**
+   * Reset backoff and force an immediate reconnect.
+   * Used after token changes (e.g. elevation from anonymous to authenticated).
+   */
+  forceReconnect(): void;
+}
+//#endregion
+export { CloudflareSyncAdapter };

package/dist/local/adapters/cloudflare.d.mts

@@ -0,0 +1,50 @@
+import { MergeFn, SyncAdapter, SyncPayload } from "../sync.mjs";
+import { SQLiteDatabase } from "expo-sqlite";
+
+//#region src/local/adapters/cloudflare.d.ts
+type CloudflareAdapterOptions = {
+  url: string;
+  getToken?: () => Promise<string | null>;
+  db: SQLiteDatabase;
+  subscribers: Map<string, {
+    update: () => void;
+  }>;
+  merge?: MergeFn;
+};
+declare class CloudflareSyncAdapter extends SyncAdapter {
+  private url;
+  private getToken?;
+  private db;
+  private subscribers;
+  private ws;
+  private receiveHandler?;
+  private reconnectTimer;
+  private backoff;
+  private alive;
+  private registeredViews;
+  private failureCount;
+  private firstFailureAt;
+  private blocked;
+  private warned;
+  private ignoreClose;
+  private pendingCommits;
+  constructor(options: CloudflareAdapterOptions);
+  /** Register the view names this adapter should subscribe to on connect. */
+  registerViews(names: string[]): void;
+  connect(): Promise<void>;
+  private handleMessage;
+  private scheduleReconnect;
+  private recordFailure;
+  resetConnection(): void;
+  send(payload: SyncPayload): Promise<void>;
+  onReceive(handler: (payload: SyncPayload) => Promise<void>): void;
+  fetchInitialState(): Promise<SyncPayload | null>;
+  disconnect(): void;
+  /**
+   * Reset backoff and force an immediate reconnect.
+   * Used after token changes (e.g. elevation from anonymous to authenticated).
+   */
+  forceReconnect(): void;
+}
+//#endregion
+export { CloudflareSyncAdapter };

package/dist/local/adapters/cloudflare.mjs

@@ -0,0 +1,200 @@
+import { SyncAdapter, applyRemoteOps } from "../sync.mjs";
+
+//#region src/local/adapters/cloudflare.ts
+const INITIAL_BACKOFF = 1e3;
+const MAX_BACKOFF = 3e4;
+const SYNC_RETRY_WINDOW_MS = 3e4;
+const SYNC_MAX_RETRIES = 5;
+var CloudflareSyncAdapter = class extends SyncAdapter {
+	constructor(options) {
+		super({ merge: options.merge });
+		this.ws = null;
+		this.reconnectTimer = null;
+		this.backoff = INITIAL_BACKOFF;
+		this.alive = true;
+		this.registeredViews = [];
+		this.failureCount = 0;
+		this.firstFailureAt = 0;
+		this.blocked = false;
+		this.warned = false;
+		this.ignoreClose = false;
+		this.pendingCommits = /* @__PURE__ */ new Map();
+		this.url = options.url;
+		this.getToken = options.getToken;
+		this.db = options.db;
+		this.subscribers = options.subscribers;
+	}
+	/** Register the view names this adapter should subscribe to on connect. */
+	registerViews(names) {
+		this.registeredViews = names;
+	}
+	async connect() {
+		if (!this.alive) return;
+		if (this.blocked) return;
+		try {
+			const wsUrl = this.url.replace(/^https?/, (m) => m === "https" ? "wss" : "ws");
+			const token = this.getToken ? await this.getToken() : null;
+			if (this.getToken && !token) return;
+			const url = token ? `${wsUrl}/sync?token=${encodeURIComponent(token)}` : `${wsUrl}/sync`;
+			this.ws = new WebSocket(url);
+			this.ws.onopen = () => {
+				this.backoff = INITIAL_BACKOFF;
+				if (this.registeredViews.length > 0) this.ws.send(JSON.stringify({
+					type: "subscribe",
+					views: this.registeredViews
+				}));
+			};
+			this.ws.onmessage = async (event) => {
+				const msg = JSON.parse(event.data);
+				await this.handleMessage(msg);
+			};
+			this.ws.onclose = () => {
+				if (this.ignoreClose) {
+					this.ignoreClose = false;
+					return;
+				}
+				if (this.alive) this.scheduleReconnect();
+			};
+			this.ws.onerror = () => {
+				this.ws?.close();
+			};
+		} catch {
+			if (this.alive) this.scheduleReconnect();
+		}
+	}
+	async handleMessage(msg) {
+		switch (msg.type) {
+			case "hydrate": {
+				const ops = (msg.rows ?? []).map((row) => ({
+					kind: "add",
+					view: { name: msg.view },
+					id: row.id,
+					value: row.data,
+					version: row.version ?? 1,
+					timestamp: row.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+				}));
+				if (ops.length > 0) await applyRemoteOps(this.db, ops, this.subscribers, this.merge);
+				break;
+			}
+			case "push": {
+				const ops = msg.ops ?? [];
+				if (ops.length > 0) await applyRemoteOps(this.db, ops, this.subscribers, this.merge);
+				break;
+			}
+			case "committed": {
+				const pending = this.pendingCommits.get(msg.requestId);
+				if (pending) {
+					pending.resolve();
+					this.pendingCommits.delete(msg.requestId);
+				}
+				break;
+			}
+			case "rejected": {
+				const pending = this.pendingCommits.get(msg.requestId);
+				if (pending) {
+					pending.reject(msg.reason ?? "Rejected by server");
+					this.pendingCommits.delete(msg.requestId);
+				}
+				break;
+			}
+			case "error":
+				console.error("[CloudflareSyncAdapter] server error:", msg.message);
+				break;
+		}
+		if (msg.type === "push" && this.receiveHandler) await this.receiveHandler({ ops: msg.ops ?? [] });
+	}
+	scheduleReconnect() {
+		this.recordFailure();
+		if (this.blocked) return;
+		if (this.reconnectTimer) return;
+		this.reconnectTimer = setTimeout(() => {
+			this.reconnectTimer = null;
+			this.backoff = Math.min(this.backoff * 2, MAX_BACKOFF);
+			this.connect();
+		}, this.backoff);
+	}
+	recordFailure() {
+		const now = Date.now();
+		if (!this.firstFailureAt || now - this.firstFailureAt > SYNC_RETRY_WINDOW_MS) {
+			this.firstFailureAt = now;
+			this.failureCount = 0;
+		}
+		this.failureCount += 1;
+		if (this.failureCount > SYNC_MAX_RETRIES) {
+			this.blocked = true;
+			if (!this.warned) {
+				this.warned = true;
+				console.warn("[CloudflareSyncAdapter] Retry budget exceeded, blocking reconnects");
+			}
+		}
+	}
+	resetConnection() {
+		this.blocked = false;
+		this.warned = false;
+		this.failureCount = 0;
+		this.firstFailureAt = 0;
+		this.backoff = INITIAL_BACKOFF;
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+		if (this.ws) {
+			this.ignoreClose = true;
+			this.ws.close();
+			this.ws = null;
+		}
+		this.connect();
+	}
+	async send(payload) {
+		if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+		const requestId = Math.random().toString(36).slice(2);
+		return new Promise((resolve, reject) => {
+			this.pendingCommits.set(requestId, {
+				resolve,
+				reject
+			});
+			this.ws.send(JSON.stringify({
+				type: "commit",
+				ops: payload.ops,
+				requestId
+			}));
+			setTimeout(() => {
+				if (this.pendingCommits.has(requestId)) {
+					this.pendingCommits.delete(requestId);
+					resolve();
+				}
+			}, 1e4);
+		});
+	}
+	onReceive(handler) {
+		this.receiveHandler = handler;
+	}
+	async fetchInitialState() {
+		return null;
+	}
+	disconnect() {
+		this.alive = false;
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+		this.ws?.close();
+		this.ws = null;
+	}
+	/**
+	* Reset backoff and force an immediate reconnect.
+	* Used after token changes (e.g. elevation from anonymous to authenticated).
+	*/
+	forceReconnect() {
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+		this.backoff = INITIAL_BACKOFF;
+		if (this.ws) this.ws.close();
+		else this.connect();
+	}
+};
+
+//#endregion
+export { CloudflareSyncAdapter };

package/dist/local/auth-context.cjs

@@ -0,0 +1,14 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let react = require("react");
+
+//#region src/local/auth-context.ts
+const AuthContext = (0, react.createContext)(null);
+function useAuth() {
+	const ctx = (0, react.useContext)(AuthContext);
+	if (!ctx) throw new Error("silosdk: useAuth() must be used within <Provider>");
+	return ctx;
+}
+
+//#endregion
+exports.AuthContext = AuthContext;
+exports.useAuth = useAuth;

package/dist/local/auth-context.d.cts

@@ -0,0 +1,7 @@
+import { AuthState } from "./auth.cjs";
+import "react";
+
+//#region src/local/auth-context.d.ts
+declare function useAuth(): AuthState;
+//#endregion
+export { useAuth };

package/dist/local/auth-context.d.mts

@@ -0,0 +1,7 @@
+import { AuthState } from "./auth.mjs";
+import "react";
+
+//#region src/local/auth-context.d.ts
+declare function useAuth(): AuthState;
+//#endregion
+export { useAuth };

package/dist/local/auth-context.mjs

@@ -0,0 +1,12 @@
+import { createContext, useContext } from "react";
+
+//#region src/local/auth-context.ts
+const AuthContext = createContext(null);
+function useAuth() {
+	const ctx = useContext(AuthContext);
+	if (!ctx) throw new Error("silosdk: useAuth() must be used within <Provider>");
+	return ctx;
+}
+
+//#endregion
+export { AuthContext, useAuth };

package/dist/local/auth.cjs

@@ -0,0 +1,109 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let expo_secure_store = require("expo-secure-store");
+expo_secure_store = require_rolldown_runtime.__toESM(expo_secure_store);
+
+//#region src/local/auth.ts
+const SESSION_KEY = "silosdk_session_token";
+let prodUrl = null;
+function setAuthProdUrl(url) {
+	prodUrl = url;
+}
+function getSessionKey(url) {
+	if (!url) return SESSION_KEY;
+	return url === prodUrl ? `${SESSION_KEY}_prod` : `${SESSION_KEY}_dev`;
+}
+var AuthEventBus = class {
+	constructor() {
+		this.listeners = /* @__PURE__ */ new Map();
+	}
+	on(event, listener) {
+		if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+		this.listeners.get(event).add(listener);
+	}
+	off(event, listener) {
+		this.listeners.get(event)?.delete(listener);
+	}
+	emit(event) {
+		this.listeners.get(event)?.forEach((l) => l());
+	}
+};
+const authEvents = new AuthEventBus();
+function createAuthUser(data) {
+	return {
+		id: data.id,
+		email: data.email,
+		role: data.role,
+		isAnonymous: data.isAnonymous
+	};
+}
+async function getStoredSessionToken(url) {
+	try {
+		return await expo_secure_store.getItemAsync(getSessionKey(url));
+	} catch {
+		return null;
+	}
+}
+async function clearStoredSessionToken(url) {
+	try {
+		await expo_secure_store.deleteItemAsync(getSessionKey(url));
+	} catch {}
+}
+async function requestOtp(url, email) {
+	const res = await fetch(`${url}/auth/request`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ email })
+	});
+	if (!res.ok) throw new Error(`OTP request failed: ${res.status}`);
+}
+async function verifyOtpWithServer(url, opts) {
+	const res = await fetch(`${url}/auth/verify`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(opts)
+	});
+	if (!res.ok) throw new Error(`OTP verification failed: ${res.status}`);
+	const { token, user: userData } = await res.json();
+	await expo_secure_store.setItemAsync(getSessionKey(url), token);
+	return {
+		token,
+		user: createAuthUser(userData)
+	};
+}
+async function signOutFromServer(url, token) {
+	if (token) await fetch(`${url}/auth/signout`, {
+		method: "POST",
+		headers: { Authorization: `Bearer ${token}` }
+	});
+	await clearStoredSessionToken(url);
+}
+async function fetchCurrentUser(url, token) {
+	const res = await fetch(`${url}/auth/me`, { headers: { Authorization: `Bearer ${token}` } });
+	if (res.status === 401) return {
+		user: null,
+		unauthorized: true
+	};
+	if (!res.ok) return {
+		user: null,
+		unauthorized: false
+	};
+	return {
+		user: createAuthUser(await res.json()),
+		unauthorized: false
+	};
+}
+async function handleUnauthorized(url) {
+	await clearStoredSessionToken(url);
+	authEvents.emit("unauthorized");
+}
+
+//#endregion
+exports.authEvents = authEvents;
+exports.clearStoredSessionToken = clearStoredSessionToken;
+exports.fetchCurrentUser = fetchCurrentUser;
+exports.getStoredSessionToken = getStoredSessionToken;
+exports.handleUnauthorized = handleUnauthorized;
+exports.requestOtp = requestOtp;
+exports.setAuthProdUrl = setAuthProdUrl;
+exports.signOutFromServer = signOutFromServer;
+exports.verifyOtpWithServer = verifyOtpWithServer;

package/dist/local/auth.d.cts

@@ -0,0 +1,26 @@
+//#region src/local/auth.d.ts
+type AuthUser = {
+  id: string;
+  email: string | null;
+  role: string;
+  isAnonymous: boolean;
+};
+type AuthState = {
+  /** Resolved user — null for public-only access or while loading. */
+  user: AuthUser | null;
+  /** True while restoring session on first mount. */
+  isLoading: boolean;
+  /** Request an OTP to be sent to the given email address. */
+  signIn: (opts: {
+    email: string;
+  }) => Promise<void>;
+  /** Verify the OTP code sent to the email and establish an authenticated session. */
+  verifyOtp: (opts: {
+    email: string;
+    otp: string;
+  }) => Promise<void>;
+  /** Sign out and clear session. */
+  signOut: () => Promise<void>;
+};
+//#endregion
+export { AuthState, AuthUser };

package/dist/local/auth.d.mts

@@ -0,0 +1,26 @@
+//#region src/local/auth.d.ts
+type AuthUser = {
+  id: string;
+  email: string | null;
+  role: string;
+  isAnonymous: boolean;
+};
+type AuthState = {
+  /** Resolved user — null for public-only access or while loading. */
+  user: AuthUser | null;
+  /** True while restoring session on first mount. */
+  isLoading: boolean;
+  /** Request an OTP to be sent to the given email address. */
+  signIn: (opts: {
+    email: string;
+  }) => Promise<void>;
+  /** Verify the OTP code sent to the email and establish an authenticated session. */
+  verifyOtp: (opts: {
+    email: string;
+    otp: string;
+  }) => Promise<void>;
+  /** Sign out and clear session. */
+  signOut: () => Promise<void>;
+};
+//#endregion
+export { AuthState, AuthUser };

package/dist/local/auth.mjs

@@ -0,0 +1,99 @@
+import * as SecureStore from "expo-secure-store";
+
+//#region src/local/auth.ts
+const SESSION_KEY = "silosdk_session_token";
+let prodUrl = null;
+function setAuthProdUrl(url) {
+	prodUrl = url;
+}
+function getSessionKey(url) {
+	if (!url) return SESSION_KEY;
+	return url === prodUrl ? `${SESSION_KEY}_prod` : `${SESSION_KEY}_dev`;
+}
+var AuthEventBus = class {
+	constructor() {
+		this.listeners = /* @__PURE__ */ new Map();
+	}
+	on(event, listener) {
+		if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+		this.listeners.get(event).add(listener);
+	}
+	off(event, listener) {
+		this.listeners.get(event)?.delete(listener);
+	}
+	emit(event) {
+		this.listeners.get(event)?.forEach((l) => l());
+	}
+};
+const authEvents = new AuthEventBus();
+function createAuthUser(data) {
+	return {
+		id: data.id,
+		email: data.email,
+		role: data.role,
+		isAnonymous: data.isAnonymous
+	};
+}
+async function getStoredSessionToken(url) {
+	try {
+		return await SecureStore.getItemAsync(getSessionKey(url));
+	} catch {
+		return null;
+	}
+}
+async function clearStoredSessionToken(url) {
+	try {
+		await SecureStore.deleteItemAsync(getSessionKey(url));
+	} catch {}
+}
+async function requestOtp(url, email) {
+	const res = await fetch(`${url}/auth/request`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ email })
+	});
+	if (!res.ok) throw new Error(`OTP request failed: ${res.status}`);
+}
+async function verifyOtpWithServer(url, opts) {
+	const res = await fetch(`${url}/auth/verify`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(opts)
+	});
+	if (!res.ok) throw new Error(`OTP verification failed: ${res.status}`);
+	const { token, user: userData } = await res.json();
+	await SecureStore.setItemAsync(getSessionKey(url), token);
+	return {
+		token,
+		user: createAuthUser(userData)
+	};
+}
+async function signOutFromServer(url, token) {
+	if (token) await fetch(`${url}/auth/signout`, {
+		method: "POST",
+		headers: { Authorization: `Bearer ${token}` }
+	});
+	await clearStoredSessionToken(url);
+}
+async function fetchCurrentUser(url, token) {
+	const res = await fetch(`${url}/auth/me`, { headers: { Authorization: `Bearer ${token}` } });
+	if (res.status === 401) return {
+		user: null,
+		unauthorized: true
+	};
+	if (!res.ok) return {
+		user: null,
+		unauthorized: false
+	};
+	return {
+		user: createAuthUser(await res.json()),
+		unauthorized: false
+	};
+}
+async function handleUnauthorized(url) {
+	await clearStoredSessionToken(url);
+	authEvents.emit("unauthorized");
+}
+
+//#endregion
+export { authEvents, clearStoredSessionToken, fetchCurrentUser, getStoredSessionToken, handleUnauthorized, requestOtp, setAuthProdUrl, signOutFromServer, verifyOtpWithServer };