silosdk 0.0.8 → 0.0.10

package/README.md

@@ -6,7 +6,7 @@ TanStack hooks.
 
 Silo owns:
 
-- SQLite persistence
+- local platform persistence
 - flat primitive document constraints
 - defaults-first source shape
 - settings storage
@@ -25,10 +25,16 @@ TanStack owns:
 yarn add silosdk @tanstack/react-db @tanstack/react-query expo-crypto expo-sqlite expo-file-system
 ```
 
+Native apps use Expo SQLite, Expo FileSystem, and Expo SQLite KV storage. Web
+builds use IndexedDB for stores, settings, and media blobs through browser export
+entrypoints, so the web bundle does not need to load the native SQLite or
+filesystem storage modules.
+
 ## Stores
 
-Stores define SQLite-backed document collections and a link collection for
-relationships between them. They produce options for TanStack DB collections.
+Stores define locally persisted document collections and a link collection for
+relationships between them. Native storage uses SQLite; web storage uses
+IndexedDB. Stores produce options for TanStack DB collections.
 
 ```ts
 import { createCollection } from '@tanstack/react-db'
@@ -154,8 +160,9 @@ only need one collection definition.
 
 ## Settings
 
-Settings are small persisted primitive values backed by `expo-sqlite/kv-store`.
-They produce TanStack Query options.
+Settings are small persisted primitive values. Native storage uses
+`expo-sqlite/kv-store`; web storage uses IndexedDB. Settings produce TanStack
+Query options.
 
 ```ts
 import { setting } from 'silosdk/settings'
@@ -186,6 +193,10 @@ type SettingValue = string | number | boolean | null
 Media is singleton infrastructure for app-owned files. Domain documents store
 stable media refs as plain strings, keeping source rows flat.
 
+Native media imports copy files into Silo-owned document storage and persist the
+mapping in SQLite. Web media imports store metadata and blobs in IndexedDB and
+resolve refs to cached `blob:` URLs.
+
 ```ts
 import { media, type MediaRef } from 'silosdk/media'
 ```
@@ -223,6 +234,18 @@ const { data: uri } = useQuery(media.queryOptions(post.coverImage))
 `media.queryOptions()` returns `string | null`. It returns `null` when the ref is
 empty, invalid, unknown, or missing on disk.
 
+Delete a media ref when your app no longer stores it:
+
+```tsx
+const deleteMedia = useMutation(media.deleteMutationOptions({ queryClient }))
+
+await deleteMedia.mutateAsync(coverImage)
+```
+
+Deletion removes Silo's copied file and media mapping only. Remove the ref from
+your own source rows or settings separately. Invalid or unknown refs are safe and
+return `false`.
+
 ## API Shape
 
 Silo exposes definition objects and option factories:
@@ -234,6 +257,7 @@ useQuery(theme.queryOptions())
 useMutation(theme.mutationOptions({ queryClient }))
 useQuery(media.queryOptions(ref))
 useMutation(media.mutationOptions({ queryClient }))
+useMutation(media.deleteMutationOptions({ queryClient }))
 ```
 
 There is no Silo provider and no Silo hook wrapper API.

package/dist/internal/indexed-db.cjs

@@ -0,0 +1,44 @@
+
+//#region src/internal/indexed-db.ts
+function createIndexedDbOpener(name, version, upgrade) {
+	let promise;
+	return () => {
+		if (promise) return promise;
+		promise = new Promise((resolve, reject) => {
+			const request = indexedDB.open(name, version);
+			request.onupgradeneeded = () => upgrade(request.result);
+			request.onsuccess = () => {
+				const database = request.result;
+				database.onversionchange = () => database.close();
+				resolve(database);
+			};
+			request.onerror = () => {
+				promise = void 0;
+				reject(request.error);
+			};
+			request.onblocked = () => {
+				promise = void 0;
+				reject(/* @__PURE__ */ new Error(`IndexedDB database "${name}" upgrade was blocked.`));
+			};
+		});
+		return promise;
+	};
+}
+function requestResult(request) {
+	return new Promise((resolve, reject) => {
+		request.onsuccess = () => resolve(request.result);
+		request.onerror = () => reject(request.error);
+	});
+}
+function transactionDone(transaction) {
+	return new Promise((resolve, reject) => {
+		transaction.oncomplete = () => resolve();
+		transaction.onerror = () => reject(transaction.error);
+		transaction.onabort = () => reject(transaction.error);
+	});
+}
+
+//#endregion
+exports.createIndexedDbOpener = createIndexedDbOpener;
+exports.requestResult = requestResult;
+exports.transactionDone = transactionDone;

package/dist/internal/indexed-db.mjs

@@ -0,0 +1,41 @@
+//#region src/internal/indexed-db.ts
+function createIndexedDbOpener(name, version, upgrade) {
+	let promise;
+	return () => {
+		if (promise) return promise;
+		promise = new Promise((resolve, reject) => {
+			const request = indexedDB.open(name, version);
+			request.onupgradeneeded = () => upgrade(request.result);
+			request.onsuccess = () => {
+				const database = request.result;
+				database.onversionchange = () => database.close();
+				resolve(database);
+			};
+			request.onerror = () => {
+				promise = void 0;
+				reject(request.error);
+			};
+			request.onblocked = () => {
+				promise = void 0;
+				reject(/* @__PURE__ */ new Error(`IndexedDB database "${name}" upgrade was blocked.`));
+			};
+		});
+		return promise;
+	};
+}
+function requestResult(request) {
+	return new Promise((resolve, reject) => {
+		request.onsuccess = () => resolve(request.result);
+		request.onerror = () => reject(request.error);
+	});
+}
+function transactionDone(transaction) {
+	return new Promise((resolve, reject) => {
+		transaction.oncomplete = () => resolve();
+		transaction.onerror = () => reject(transaction.error);
+		transaction.onabort = () => reject(transaction.error);
+	});
+}
+
+//#endregion
+export { createIndexedDbOpener, requestResult, transactionDone };

package/dist/media/shared.cjs

@@ -0,0 +1,99 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let __tanstack_react_query = require("@tanstack/react-query");
+
+//#region src/media/shared.ts
+function createMediaApi(storage) {
+	return {
+		queryOptions(ref) {
+			return (0, __tanstack_react_query.queryOptions)({
+				queryKey: mediaQueryKey(ref),
+				queryFn: () => resolveMediaUri(storage, ref)
+			});
+		},
+		mutationOptions(options = {}) {
+			return (0, __tanstack_react_query.mutationOptions)({
+				mutationKey: [
+					"silo",
+					"media",
+					"import"
+				],
+				mutationFn: async (input) => {
+					assertMediaKind(input.kind);
+					const imported = await storage.importMedia(input);
+					options.queryClient?.setQueryData(mediaQueryKey(imported.ref), imported.uri);
+					return imported.ref;
+				}
+			});
+		},
+		delete(ref) {
+			return deleteMedia(storage, ref);
+		},
+		deleteMutationOptions(options = {}) {
+			return (0, __tanstack_react_query.mutationOptions)({
+				mutationKey: [
+					"silo",
+					"media",
+					"delete"
+				],
+				mutationFn: async (ref) => {
+					const deleted = await deleteMedia(storage, ref);
+					if (isMediaRef(ref)) options.queryClient?.setQueryData(mediaQueryKey(ref), null);
+					return deleted;
+				}
+			});
+		}
+	};
+}
+function isMediaRef(value) {
+	return typeof value === "string" && value.startsWith("media://");
+}
+function createMediaRef(kind, id) {
+	return `media://silo/${kindDirectoryName(kind)}/${id}`;
+}
+function kindDirectoryName(kind) {
+	switch (kind) {
+		case "image": return "images";
+		case "video": return "videos";
+		case "audio": return "audio";
+		case "file": return "files";
+	}
+}
+function extensionFor(name) {
+	return name.match(/\.[A-Za-z0-9]+$/)?.[0] ?? "";
+}
+function extensionForMimeType(mimeType) {
+	switch (mimeType) {
+		case "application/pdf": return ".pdf";
+		case "image/jpeg": return ".jpg";
+		case "image/png": return ".png";
+		case "image/webp": return ".webp";
+		case "image/gif": return ".gif";
+		default: return "";
+	}
+}
+function mediaQueryKey(ref) {
+	return [
+		"silo",
+		"media",
+		ref ?? null
+	];
+}
+async function resolveMediaUri(storage, ref) {
+	if (!isMediaRef(ref)) return null;
+	return storage.resolveMediaUri(ref);
+}
+async function deleteMedia(storage, ref) {
+	if (!isMediaRef(ref)) return false;
+	return storage.deleteMedia(ref);
+}
+function assertMediaKind(kind) {
+	if (kind !== "image" && kind !== "video" && kind !== "audio" && kind !== "file") throw new Error("Media kind must be one of \"image\", \"video\", \"audio\", or \"file\".");
+}
+
+//#endregion
+exports.createMediaApi = createMediaApi;
+exports.createMediaRef = createMediaRef;
+exports.extensionFor = extensionFor;
+exports.extensionForMimeType = extensionForMimeType;
+exports.isMediaRef = isMediaRef;
+exports.kindDirectoryName = kindDirectoryName;

package/dist/media/shared.d.cts

@@ -0,0 +1,26 @@
+import { QueryClient, UseMutationOptions, UseQueryOptions } from "@tanstack/react-query";
+
+//#region src/media/shared.d.ts
+type MediaRef = `media://${string}`;
+type MediaKind = 'image' | 'video' | 'audio' | 'file';
+type MediaJson = string | number | boolean | null | MediaJson[] | {
+  [key: string]: MediaJson;
+};
+type MediaData = {
+  [key: string]: MediaJson;
+};
+type MediaImportInput = {
+  uri: string;
+  kind: MediaKind;
+  name?: string;
+  mimeType?: string | null;
+  data?: MediaData;
+};
+type MediaDeleteInput = MediaRef | string | null | undefined;
+type MediaQueryKey = readonly ['silo', 'media', MediaRef | string | null];
+type MediaMutationOptions = {
+  queryClient?: QueryClient;
+};
+declare function isMediaRef(value: unknown): value is MediaRef;
+//#endregion
+export { MediaData, MediaDeleteInput, MediaImportInput, MediaJson, MediaKind, MediaMutationOptions, MediaQueryKey, MediaRef, isMediaRef };

package/dist/media/shared.d.mts

@@ -0,0 +1,26 @@
+import { QueryClient, UseMutationOptions, UseQueryOptions } from "@tanstack/react-query";
+
+//#region src/media/shared.d.ts
+type MediaRef = `media://${string}`;
+type MediaKind = 'image' | 'video' | 'audio' | 'file';
+type MediaJson = string | number | boolean | null | MediaJson[] | {
+  [key: string]: MediaJson;
+};
+type MediaData = {
+  [key: string]: MediaJson;
+};
+type MediaImportInput = {
+  uri: string;
+  kind: MediaKind;
+  name?: string;
+  mimeType?: string | null;
+  data?: MediaData;
+};
+type MediaDeleteInput = MediaRef | string | null | undefined;
+type MediaQueryKey = readonly ['silo', 'media', MediaRef | string | null];
+type MediaMutationOptions = {
+  queryClient?: QueryClient;
+};
+declare function isMediaRef(value: unknown): value is MediaRef;
+//#endregion
+export { MediaData, MediaDeleteInput, MediaImportInput, MediaJson, MediaKind, MediaMutationOptions, MediaQueryKey, MediaRef, isMediaRef };

package/dist/media/shared.mjs

@@ -0,0 +1,93 @@
+import { mutationOptions, queryOptions } from "@tanstack/react-query";
+
+//#region src/media/shared.ts
+function createMediaApi(storage) {
+	return {
+		queryOptions(ref) {
+			return queryOptions({
+				queryKey: mediaQueryKey(ref),
+				queryFn: () => resolveMediaUri(storage, ref)
+			});
+		},
+		mutationOptions(options = {}) {
+			return mutationOptions({
+				mutationKey: [
+					"silo",
+					"media",
+					"import"
+				],
+				mutationFn: async (input) => {
+					assertMediaKind(input.kind);
+					const imported = await storage.importMedia(input);
+					options.queryClient?.setQueryData(mediaQueryKey(imported.ref), imported.uri);
+					return imported.ref;
+				}
+			});
+		},
+		delete(ref) {
+			return deleteMedia(storage, ref);
+		},
+		deleteMutationOptions(options = {}) {
+			return mutationOptions({
+				mutationKey: [
+					"silo",
+					"media",
+					"delete"
+				],
+				mutationFn: async (ref) => {
+					const deleted = await deleteMedia(storage, ref);
+					if (isMediaRef(ref)) options.queryClient?.setQueryData(mediaQueryKey(ref), null);
+					return deleted;
+				}
+			});
+		}
+	};
+}
+function isMediaRef(value) {
+	return typeof value === "string" && value.startsWith("media://");
+}
+function createMediaRef(kind, id) {
+	return `media://silo/${kindDirectoryName(kind)}/${id}`;
+}
+function kindDirectoryName(kind) {
+	switch (kind) {
+		case "image": return "images";
+		case "video": return "videos";
+		case "audio": return "audio";
+		case "file": return "files";
+	}
+}
+function extensionFor(name) {
+	return name.match(/\.[A-Za-z0-9]+$/)?.[0] ?? "";
+}
+function extensionForMimeType(mimeType) {
+	switch (mimeType) {
+		case "application/pdf": return ".pdf";
+		case "image/jpeg": return ".jpg";
+		case "image/png": return ".png";
+		case "image/webp": return ".webp";
+		case "image/gif": return ".gif";
+		default: return "";
+	}
+}
+function mediaQueryKey(ref) {
+	return [
+		"silo",
+		"media",
+		ref ?? null
+	];
+}
+async function resolveMediaUri(storage, ref) {
+	if (!isMediaRef(ref)) return null;
+	return storage.resolveMediaUri(ref);
+}
+async function deleteMedia(storage, ref) {
+	if (!isMediaRef(ref)) return false;
+	return storage.deleteMedia(ref);
+}
+function assertMediaKind(kind) {
+	if (kind !== "image" && kind !== "video" && kind !== "audio" && kind !== "file") throw new Error("Media kind must be one of \"image\", \"video\", \"audio\", or \"file\".");
+}
+
+//#endregion
+export { createMediaApi, createMediaRef, extensionFor, extensionForMimeType, isMediaRef, kindDirectoryName };

package/dist/media/storage.native.cjs

@@ -0,0 +1,102 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_shared = require('./shared.cjs');
+let expo_crypto = require("expo-crypto");
+let expo_sqlite = require("expo-sqlite");
+let expo_file_system = require("expo-file-system");
+
+//#region src/media/storage.native.ts
+let database;
+const mediaStorage = {
+	importMedia,
+	resolveMediaUri,
+	deleteMedia
+};
+async function importMedia(input) {
+	const id = (0, expo_crypto.randomUUID)();
+	const ref = require_shared.createMediaRef(input.kind, id);
+	const source = new expo_file_system.File(input.uri);
+	const name = input.name ?? source.name ?? `${id}${source.extension}`;
+	const destinationDirectory = mediaDirectory(input.kind);
+	destinationDirectory.create({
+		idempotent: true,
+		intermediates: true
+	});
+	const destination = new expo_file_system.File(destinationDirectory, `${id}${require_shared.extensionFor(name)}`);
+	await source.copy(destination);
+	const info = destination.info();
+	const mimeType = input.mimeType ?? (destination.type || null);
+	const size = info.size ?? destination.size;
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	insertMediaFile({
+		ref,
+		uri: destination.uri,
+		kind: input.kind,
+		name,
+		mimeType,
+		size,
+		createdAt: timestamp,
+		data: input.data ?? {}
+	});
+	return {
+		ref,
+		uri: destination.uri
+	};
+}
+async function resolveMediaUri(ref) {
+	const row = getMediaFile(ref);
+	if (!row) return null;
+	return new expo_file_system.File(row.uri).exists ? row.uri : null;
+}
+async function deleteMedia(ref) {
+	const row = getMediaFile(ref);
+	if (!row) return false;
+	const file = new expo_file_system.File(row.uri);
+	if (file.exists) await file.delete();
+	deleteMediaFileRow(ref);
+	return true;
+}
+function mediaDirectory(kind) {
+	return new expo_file_system.Directory(expo_file_system.Paths.document, "silo", "media", require_shared.kindDirectoryName(kind));
+}
+function getMediaFile(ref) {
+	return getDatabase().getFirstSync(`SELECT ref, uri FROM media_files WHERE ref = ?`, [ref]);
+}
+function getDatabase() {
+	if (!database) {
+		database = (0, expo_sqlite.openDatabaseSync)("silo.db");
+		database.execSync(`
+      PRAGMA journal_mode = WAL;
+
+      CREATE TABLE IF NOT EXISTS media_files (
+        ref TEXT PRIMARY KEY,
+        uri TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        name TEXT NOT NULL,
+        mimeType TEXT,
+        size INTEGER NOT NULL,
+        createdAt TEXT NOT NULL,
+        data TEXT NOT NULL
+      );
+    `);
+	}
+	return database;
+}
+function insertMediaFile(file) {
+	getDatabase().runSync(`INSERT INTO media_files (ref, uri, kind, name, mimeType, size, createdAt, data)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+		file.ref,
+		file.uri,
+		file.kind,
+		file.name,
+		file.mimeType,
+		file.size,
+		file.createdAt,
+		JSON.stringify(file.data)
+	]);
+}
+function deleteMediaFileRow(ref) {
+	getDatabase().runSync(`DELETE FROM media_files WHERE ref = ?`, [ref]);
+}
+
+//#endregion
+exports.mediaStorage = mediaStorage;

package/dist/media/storage.native.mjs

@@ -0,0 +1,101 @@
+import { createMediaRef, extensionFor, kindDirectoryName } from "./shared.mjs";
+import { randomUUID } from "expo-crypto";
+import { openDatabaseSync } from "expo-sqlite";
+import { Directory, File, Paths } from "expo-file-system";
+
+//#region src/media/storage.native.ts
+let database;
+const mediaStorage = {
+	importMedia,
+	resolveMediaUri,
+	deleteMedia
+};
+async function importMedia(input) {
+	const id = randomUUID();
+	const ref = createMediaRef(input.kind, id);
+	const source = new File(input.uri);
+	const name = input.name ?? source.name ?? `${id}${source.extension}`;
+	const destinationDirectory = mediaDirectory(input.kind);
+	destinationDirectory.create({
+		idempotent: true,
+		intermediates: true
+	});
+	const destination = new File(destinationDirectory, `${id}${extensionFor(name)}`);
+	await source.copy(destination);
+	const info = destination.info();
+	const mimeType = input.mimeType ?? (destination.type || null);
+	const size = info.size ?? destination.size;
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	insertMediaFile({
+		ref,
+		uri: destination.uri,
+		kind: input.kind,
+		name,
+		mimeType,
+		size,
+		createdAt: timestamp,
+		data: input.data ?? {}
+	});
+	return {
+		ref,
+		uri: destination.uri
+	};
+}
+async function resolveMediaUri(ref) {
+	const row = getMediaFile(ref);
+	if (!row) return null;
+	return new File(row.uri).exists ? row.uri : null;
+}
+async function deleteMedia(ref) {
+	const row = getMediaFile(ref);
+	if (!row) return false;
+	const file = new File(row.uri);
+	if (file.exists) await file.delete();
+	deleteMediaFileRow(ref);
+	return true;
+}
+function mediaDirectory(kind) {
+	return new Directory(Paths.document, "silo", "media", kindDirectoryName(kind));
+}
+function getMediaFile(ref) {
+	return getDatabase().getFirstSync(`SELECT ref, uri FROM media_files WHERE ref = ?`, [ref]);
+}
+function getDatabase() {
+	if (!database) {
+		database = openDatabaseSync("silo.db");
+		database.execSync(`
+      PRAGMA journal_mode = WAL;
+
+      CREATE TABLE IF NOT EXISTS media_files (
+        ref TEXT PRIMARY KEY,
+        uri TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        name TEXT NOT NULL,
+        mimeType TEXT,
+        size INTEGER NOT NULL,
+        createdAt TEXT NOT NULL,
+        data TEXT NOT NULL
+      );
+    `);
+	}
+	return database;
+}
+function insertMediaFile(file) {
+	getDatabase().runSync(`INSERT INTO media_files (ref, uri, kind, name, mimeType, size, createdAt, data)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+		file.ref,
+		file.uri,
+		file.kind,
+		file.name,
+		file.mimeType,
+		file.size,
+		file.createdAt,
+		JSON.stringify(file.data)
+	]);
+}
+function deleteMediaFileRow(ref) {
+	getDatabase().runSync(`DELETE FROM media_files WHERE ref = ?`, [ref]);
+}
+
+//#endregion
+export { mediaStorage };

package/dist/media/storage.web.cjs

@@ -0,0 +1,79 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_indexed_db = require('../internal/indexed-db.cjs');
+const require_shared = require('./shared.cjs');
+let expo_crypto = require("expo-crypto");
+
+//#region src/media/storage.web.ts
+const objectUrls = /* @__PURE__ */ new Map();
+const mediaStorage = {
+	importMedia,
+	resolveMediaUri,
+	deleteMedia
+};
+const openSiloMediaIndexedDb = require_indexed_db.createIndexedDbOpener("silo-media", 1, (db) => {
+	if (!db.objectStoreNames.contains("media_files")) db.createObjectStore("media_files", { keyPath: "ref" });
+	if (!db.objectStoreNames.contains("media_blobs")) db.createObjectStore("media_blobs", { keyPath: "ref" });
+});
+async function importMedia(input) {
+	const id = (0, expo_crypto.randomUUID)();
+	const ref = require_shared.createMediaRef(input.kind, id);
+	const blob = await (await fetch(input.uri)).blob();
+	const name = input.name ?? `${id}${require_shared.extensionForMimeType(input.mimeType ?? blob.type)}`;
+	const mimeType = input.mimeType ?? (blob.type || null);
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	const transaction = (await openSiloMediaIndexedDb()).transaction(["media_files", "media_blobs"], "readwrite");
+	transaction.objectStore("media_files").put({
+		ref,
+		uri: ref,
+		kind: input.kind,
+		name,
+		mimeType,
+		size: blob.size,
+		createdAt: timestamp,
+		data: JSON.stringify(input.data ?? {})
+	});
+	transaction.objectStore("media_blobs").put({
+		ref,
+		blob
+	});
+	await require_indexed_db.transactionDone(transaction);
+	const uri = URL.createObjectURL(blob);
+	objectUrls.set(ref, uri);
+	return {
+		ref,
+		uri
+	};
+}
+async function resolveMediaUri(ref) {
+	const existingUrl = objectUrls.get(ref);
+	if (existingUrl) return existingUrl;
+	const transaction = (await openSiloMediaIndexedDb()).transaction("media_blobs", "readonly");
+	const done = require_indexed_db.transactionDone(transaction);
+	const row = await require_indexed_db.requestResult(transaction.objectStore("media_blobs").get(ref));
+	await done;
+	if (!row) return null;
+	const uri = URL.createObjectURL(row.blob);
+	objectUrls.set(ref, uri);
+	return uri;
+}
+async function deleteMedia(ref) {
+	const db = await openSiloMediaIndexedDb();
+	const readTransaction = db.transaction("media_files", "readonly");
+	const readDone = require_indexed_db.transactionDone(readTransaction);
+	const existing = await require_indexed_db.requestResult(readTransaction.objectStore("media_files").get(ref));
+	await readDone;
+	if (!existing) return false;
+	const transaction = db.transaction(["media_files", "media_blobs"], "readwrite");
+	transaction.objectStore("media_files").delete(ref);
+	transaction.objectStore("media_blobs").delete(ref);
+	await require_indexed_db.transactionDone(transaction);
+	const objectUrl = objectUrls.get(ref);
+	if (objectUrl) {
+		URL.revokeObjectURL(objectUrl);
+		objectUrls.delete(ref);
+	}
+	return true;
+}
+
+//#endregion
+exports.mediaStorage = mediaStorage;