silosdk 0.0.0 → 0.0.1

package/dist/local/query-store.mjs

@@ -0,0 +1,274 @@
+//#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
+export { QueryStore, createCacheKey };

package/dist/local/storage.cjs

@@ -0,0 +1,71 @@
+const require_config = require('./config.cjs');
+
+//#region src/local/storage.ts
+function isPendingAsset(value) {
+	return typeof value === "object" && value !== null && typeof value.uri === "string" && value.uri.length > 0;
+}
+function isResolvedAsset(value) {
+	return typeof value === "object" && value !== null && typeof value.key === "string" && value.key.length > 0;
+}
+function isAssetValue(value) {
+	return isPendingAsset(value) || isResolvedAsset(value);
+}
+function assetUrl(baseUrl, asset) {
+	if (!asset) return null;
+	if (isPendingAsset(asset)) return asset.uri;
+	if (isResolvedAsset(asset)) return `${baseUrl}/storage/${encodeURIComponent(asset.key)}`;
+	return null;
+}
+function useAssetUrl(asset) {
+	const { url } = require_config.useConfig();
+	if (!url) return isPendingAsset(asset) ? asset.uri : null;
+	return assetUrl(url, asset);
+}
+async function uploadPendingAsset(input) {
+	const { pending, scope, url, getToken } = input;
+	const sourceRes = await fetch(pending.uri);
+	const blob = await sourceRes.blob();
+	if (!blob) throw new Error(`Failed to read asset from uri: ${pending.uri}`);
+	const contentType = pending.contentType || blob.type || sourceRes.headers.get("Content-Type") || "application/octet-stream";
+	const size = pending.size ?? blob.size;
+	const headers = {
+		"Content-Type": contentType,
+		"X-Asset-Scope": scope
+	};
+	if (pending.name) headers["X-File-Name"] = pending.name;
+	if (typeof size === "number") headers["Content-Length"] = String(size);
+	if (getToken) {
+		const token = await getToken();
+		if (token) headers.Authorization = `Bearer ${token}`;
+	}
+	const uploadRes = await fetch(`${url}/storage/upload`, {
+		method: "POST",
+		headers,
+		body: blob
+	});
+	if (!uploadRes.ok) throw new Error(`Asset upload failed: ${uploadRes.status}`);
+	const ref = await uploadRes.json();
+	if (!isResolvedAsset(ref)) throw new Error("Asset upload returned invalid payload");
+	return {
+		key: ref.key,
+		name: ref.name ?? pending.name,
+		contentType: ref.contentType ?? contentType,
+		size: ref.size ?? size
+	};
+}
+async function resolvePendingAsset(value, scope, url, getToken) {
+	if (!isPendingAsset(value)) return value;
+	if (!url) return value;
+	return uploadPendingAsset({
+		pending: value,
+		scope,
+		url,
+		getToken
+	});
+}
+
+//#endregion
+exports.isAssetValue = isAssetValue;
+exports.isResolvedAsset = isResolvedAsset;
+exports.resolvePendingAsset = resolvePendingAsset;
+exports.useAssetUrl = useAssetUrl;

package/dist/local/storage.d.cts

@@ -0,0 +1,7 @@
+import { AssetValue } from "../schema/index.cjs";
+
+//#region src/local/storage.d.ts
+
+declare function useAssetUrl(asset: AssetValue | null | undefined): string | null;
+//#endregion
+export { useAssetUrl };

package/dist/local/storage.d.mts

@@ -0,0 +1,7 @@
+import { AssetValue } from "../schema/index.mjs";
+
+//#region src/local/storage.d.ts
+
+declare function useAssetUrl(asset: AssetValue | null | undefined): string | null;
+//#endregion
+export { useAssetUrl };

package/dist/local/storage.mjs

@@ -0,0 +1,68 @@
+import { useConfig } from "./config.mjs";
+
+//#region src/local/storage.ts
+function isPendingAsset(value) {
+	return typeof value === "object" && value !== null && typeof value.uri === "string" && value.uri.length > 0;
+}
+function isResolvedAsset(value) {
+	return typeof value === "object" && value !== null && typeof value.key === "string" && value.key.length > 0;
+}
+function isAssetValue(value) {
+	return isPendingAsset(value) || isResolvedAsset(value);
+}
+function assetUrl(baseUrl, asset) {
+	if (!asset) return null;
+	if (isPendingAsset(asset)) return asset.uri;
+	if (isResolvedAsset(asset)) return `${baseUrl}/storage/${encodeURIComponent(asset.key)}`;
+	return null;
+}
+function useAssetUrl(asset) {
+	const { url } = useConfig();
+	if (!url) return isPendingAsset(asset) ? asset.uri : null;
+	return assetUrl(url, asset);
+}
+async function uploadPendingAsset(input) {
+	const { pending, scope, url, getToken } = input;
+	const sourceRes = await fetch(pending.uri);
+	const blob = await sourceRes.blob();
+	if (!blob) throw new Error(`Failed to read asset from uri: ${pending.uri}`);
+	const contentType = pending.contentType || blob.type || sourceRes.headers.get("Content-Type") || "application/octet-stream";
+	const size = pending.size ?? blob.size;
+	const headers = {
+		"Content-Type": contentType,
+		"X-Asset-Scope": scope
+	};
+	if (pending.name) headers["X-File-Name"] = pending.name;
+	if (typeof size === "number") headers["Content-Length"] = String(size);
+	if (getToken) {
+		const token = await getToken();
+		if (token) headers.Authorization = `Bearer ${token}`;
+	}
+	const uploadRes = await fetch(`${url}/storage/upload`, {
+		method: "POST",
+		headers,
+		body: blob
+	});
+	if (!uploadRes.ok) throw new Error(`Asset upload failed: ${uploadRes.status}`);
+	const ref = await uploadRes.json();
+	if (!isResolvedAsset(ref)) throw new Error("Asset upload returned invalid payload");
+	return {
+		key: ref.key,
+		name: ref.name ?? pending.name,
+		contentType: ref.contentType ?? contentType,
+		size: ref.size ?? size
+	};
+}
+async function resolvePendingAsset(value, scope, url, getToken) {
+	if (!isPendingAsset(value)) return value;
+	if (!url) return value;
+	return uploadPendingAsset({
+		pending: value,
+		scope,
+		url,
+		getToken
+	});
+}
+
+//#endregion
+export { isAssetValue, isResolvedAsset, resolvePendingAsset, useAssetUrl };

package/dist/local/sync.cjs

@@ -0,0 +1,124 @@
+
+//#region src/local/sync.ts
+/**
+* Abstract sync adapter base class.
+*/
+var SyncAdapter = class {
+	constructor(options) {
+		this.merge = options?.merge;
+	}
+};
+/**
+* Apply remote ops to local SQLite with LWW conflict resolution.
+*/
+async function applyRemoteOps(db, ops, subscribers, merge) {
+	const touchedViews = /* @__PURE__ */ new Set();
+	await db.withTransactionAsync(async () => {
+		for (const op of ops) if (op.kind === "add") {
+			await handleRemoteAdd(db, op, merge);
+			touchedViews.add(op.view.name);
+		} else if (op.kind === "update") {
+			await handleRemoteUpdate(db, op, merge);
+			touchedViews.add(op.view.name);
+		} else if (op.kind === "remove") {
+			await handleRemoteRemove(db, op);
+			touchedViews.add(op.view.name);
+		} else if (op.kind === "link" || op.kind === "unlink") {
+			await handleRemoteLink(db, op);
+			touchedViews.add(op.parent.view.name);
+			touchedViews.add(op.child.view.name);
+		}
+	});
+	for (const [key, sub] of subscribers) for (const viewName of touchedViews) if (key.includes(viewName)) {
+		sub.update();
+		break;
+	}
+}
+async function handleRemoteAdd(db, op, merge) {
+	const existing = await db.getFirstAsync(`SELECT version, data FROM views WHERE id = ? AND view = ?`, [op.id, op.view.name]);
+	if (!existing) await db.runAsync(`INSERT INTO views (id, view, data, createdAt, updatedAt, version)
+       VALUES (?, ?, ?, ?, ?, ?)`, [
+		op.id,
+		op.view.name,
+		JSON.stringify(op.value),
+		op.timestamp,
+		op.timestamp,
+		op.version
+	]);
+	else if (op.version > existing.version) {
+		const finalData = merge ? merge({
+			data: JSON.parse(existing.data),
+			version: existing.version
+		}, {
+			data: op.value,
+			version: op.version
+		}, op.view.name) : op.value;
+		await db.runAsync(`UPDATE views SET data = ?, updatedAt = ?, version = ? WHERE id = ? AND view = ?`, [
+			JSON.stringify(finalData),
+			op.timestamp,
+			op.version,
+			op.id,
+			op.view.name
+		]);
+	}
+}
+async function handleRemoteUpdate(db, op, merge) {
+	const existing = await db.getFirstAsync(`SELECT version, data FROM views WHERE id = ? AND view = ?`, [op.id, op.view.name]);
+	if (!existing) return;
+	if (op.version > existing.version) {
+		const localData = JSON.parse(existing.data);
+		const mergedData = merge ? merge({
+			data: localData,
+			version: existing.version
+		}, {
+			data: {
+				...localData,
+				...op.value
+			},
+			version: op.version
+		}, op.view.name) : {
+			...localData,
+			...op.value
+		};
+		await db.runAsync(`UPDATE views SET data = ?, updatedAt = ?, version = ? WHERE id = ? AND view = ?`, [
+			JSON.stringify(mergedData),
+			op.timestamp,
+			op.version,
+			op.id,
+			op.view.name
+		]);
+	}
+}
+async function handleRemoteRemove(db, op) {
+	await db.runAsync(`DELETE FROM views WHERE id = ? AND view = ?`, [op.id, op.view.name]);
+	await db.runAsync(`DELETE FROM relations WHERE (parent = ? AND pid = ?) OR (child = ? AND cid = ?)`, [
+		op.view.name,
+		op.id,
+		op.view.name,
+		op.id
+	]);
+}
+async function handleRemoteLink(db, op) {
+	if (op.kind === "link") {
+		if (!await db.getFirstAsync(`SELECT 1 FROM relations WHERE parent = ? AND pid = ? AND child = ? AND cid = ?`, [
+			op.parent.view.name,
+			op.parent.id,
+			op.child.view.name,
+			op.child.id
+		])) await db.runAsync(`INSERT INTO relations (parent, pid, child, cid) VALUES (?, ?, ?, ?)`, [
+			op.parent.view.name,
+			op.parent.id,
+			op.child.view.name,
+			op.child.id
+		]);
+	} else await db.runAsync(`DELETE FROM relations WHERE parent = ? AND pid = ? AND child = ? AND cid = ?`, [
+		op.parent.view.name,
+		op.parent.id,
+		op.child.view.name,
+		op.child.id
+	]);
+}
+
+//#endregion
+exports.SyncAdapter = SyncAdapter;
+exports.applyRemoteOps = applyRemoteOps;

package/dist/local/sync.d.cts

@@ -0,0 +1,36 @@
+import { View } from "../schema/index.cjs";
+import "./view.cjs";
+import { AddOp, LinkOp, RemoveOp, UpdateOp } from "./commit.cjs";
+import { SQLiteDatabase } from "expo-sqlite";
+
+//#region src/local/sync.d.ts
+type Op = AddOp | UpdateOp | RemoveOp | LinkOp<View, View>;
+type SyncOp = Op & {
+  version: number;
+  timestamp: string;
+};
+type SyncPayload = {
+  ops: SyncOp[];
+};
+type MergeFn = (local: {
+  data: any;
+  version: number;
+}, remote: {
+  data: any;
+  version: number;
+}, viewName: string) => any;
+/**
+ * Abstract sync adapter base class.
+ */
+declare abstract class SyncAdapter {
+  merge?: MergeFn;
+  constructor(options?: {
+    merge?: MergeFn;
+  });
+  abstract send(payload: SyncPayload): Promise<void>;
+  abstract onReceive(handler: (payload: SyncPayload) => Promise<void>): void;
+  abstract fetchInitialState(): Promise<SyncPayload | null>;
+  abstract disconnect(): void;
+}
+//#endregion
+export { MergeFn, SyncAdapter, SyncOp, SyncPayload };

package/dist/local/sync.d.mts

@@ -0,0 +1,36 @@
+import { View } from "../schema/index.mjs";
+import "./view.mjs";
+import { AddOp, LinkOp, RemoveOp, UpdateOp } from "./commit.mjs";
+import { SQLiteDatabase } from "expo-sqlite";
+
+//#region src/local/sync.d.ts
+type Op = AddOp | UpdateOp | RemoveOp | LinkOp<View, View>;
+type SyncOp = Op & {
+  version: number;
+  timestamp: string;
+};
+type SyncPayload = {
+  ops: SyncOp[];
+};
+type MergeFn = (local: {
+  data: any;
+  version: number;
+}, remote: {
+  data: any;
+  version: number;
+}, viewName: string) => any;
+/**
+ * Abstract sync adapter base class.
+ */
+declare abstract class SyncAdapter {
+  merge?: MergeFn;
+  constructor(options?: {
+    merge?: MergeFn;
+  });
+  abstract send(payload: SyncPayload): Promise<void>;
+  abstract onReceive(handler: (payload: SyncPayload) => Promise<void>): void;
+  abstract fetchInitialState(): Promise<SyncPayload | null>;
+  abstract disconnect(): void;
+}
+//#endregion
+export { MergeFn, SyncAdapter, SyncOp, SyncPayload };