silosdk 0.0.6 → 0.0.8

package/dist/store.mjs

@@ -0,0 +1,429 @@
+import { randomUUID } from "expo-crypto";
+import { openDatabaseSync } from "expo-sqlite";
+
+//#region src/store/index.ts
+const sourceNames = /* @__PURE__ */ new Set();
+const sourceNamePattern = /^[A-Za-z][A-Za-z0-9_-]*$/;
+const reservedDocumentFields = new Set([
+	"id",
+	"data",
+	"set"
+]);
+const deletedDocs = /* @__PURE__ */ new WeakSet();
+function createID() {
+	return randomUUID();
+}
+function createStore(defaults) {
+	const names = Object.keys(defaults);
+	const nameSet = new Set(names);
+	for (const name of names) {
+		assertSourceName(name);
+		assertFlatDefaults(name, defaults[name]);
+	}
+	if (new Set(names).size !== names.length) throw new Error("Store collection names must be unique.");
+	return {
+		names,
+		collectionOptions(name, options = {}) {
+			assertStoreCollectionName(nameSet, name);
+			return createSourceCollectionOptions(name, defaults[name], options);
+		},
+		linkCollectionOptions(options = {}) {
+			return createLinkCollectionOptions(names, nameSet, options);
+		}
+	};
+}
+function source(name, defaults) {
+	assertSourceName(name);
+	assertFlatDefaults(name, defaults);
+	if (sourceNames.has(name)) throw new Error(`Source "${name}" is already registered. Define each source once and import the existing source instead.`);
+	sourceNames.add(name);
+	return {
+		name,
+		defaults,
+		schema: createSourceSchema(name, defaults),
+		collectionOptions(options = {}) {
+			return createSourceCollectionOptions(name, defaults, options);
+		}
+	};
+}
+function createSourceCollectionOptions(name, defaults, options = {}) {
+	return {
+		id: name,
+		getKey: (item) => item.id,
+		schema: createSourceSchema(name, defaults),
+		startSync: options.startSync,
+		sync: { sync({ begin, write, commit, markReady, truncate }) {
+			const rows = loadRows(name);
+			begin();
+			truncate();
+			for (const row of rows) write({
+				type: "insert",
+				value: row
+			});
+			commit();
+			markReady();
+		} },
+		onInsert: async ({ transaction }) => {
+			await insertRows(name, transaction.mutations.map((mutation) => mutation.modified));
+		},
+		onUpdate: async ({ transaction }) => {
+			await updateRows(name, transaction.mutations);
+		},
+		onDelete: async ({ transaction }) => {
+			await deleteRows(name, transaction.mutations);
+		}
+	};
+}
+function createLinkCollectionOptions(names, nameSet, options = {}) {
+	const schema = createLinkSchema();
+	let syncBegin;
+	let syncWrite;
+	let syncCommit;
+	const writeSyncedLink = (type, row) => {
+		if (!syncBegin || !syncWrite || !syncCommit) return;
+		syncBegin();
+		syncWrite({
+			type,
+			value: row
+		});
+		syncCommit();
+	};
+	return {
+		id: "silo-links",
+		getKey: (item) => item.id,
+		schema,
+		startSync: options.startSync,
+		sync: { sync({ begin, write, commit, markReady, truncate }) {
+			syncBegin = begin;
+			syncWrite = write;
+			syncCommit = commit;
+			const rows = loadLinkRows().map((row) => createLinkRow(names, row));
+			begin();
+			truncate();
+			for (const row of rows) write({
+				type: "insert",
+				value: row
+			});
+			commit();
+			markReady();
+		} },
+		onInsert: async ({ transaction }) => {
+			for (const mutation of transaction.mutations) insertLinkRow(extractStoredLinkRow(mutation.modified));
+		},
+		onDelete: async ({ transaction }) => {
+			for (const mutation of transaction.mutations) deleteLinkRow(String(mutation.key));
+		},
+		utils: {
+			async link(collectionA, idA, collectionB, idB) {
+				const row = createStoredLinkRow(nameSet, collectionA, idA, collectionB, idB);
+				const exists = hasLinkRow(row.id);
+				insertLinkRow(row);
+				if (!exists) writeSyncedLink("insert", createLinkRow(names, row));
+			},
+			async unlink(collectionA, idA, collectionB, idB) {
+				const row = createStoredLinkRow(nameSet, collectionA, idA, collectionB, idB);
+				const exists = hasLinkRow(row.id);
+				deleteLinkRow(row.id);
+				if (exists) writeSyncedLink("delete", createLinkRow(names, row));
+			},
+			has(collectionA, idA, collectionB, idB) {
+				return hasLinkRow(createStoredLinkRow(nameSet, collectionA, idA, collectionB, idB).id);
+			}
+		}
+	};
+}
+function assertSourceName(name) {
+	if (!sourceNamePattern.test(name)) throw new Error(`Source names must start with a letter and contain only letters, numbers, underscores, or hyphens. Received "${name}".`);
+}
+function assertStoreCollectionName(nameSet, name) {
+	if (!nameSet.has(name)) throw new Error(`Store collection "${name}" is not registered.`);
+}
+function assertLinkCollectionName(nameSet, name) {
+	if (!nameSet.has(name)) throw new Error(`Cannot link unknown collection "${name}".`);
+}
+function createStoredLinkRow(nameSet, collectionA, idA, collectionB, idB) {
+	assertLinkCollectionName(nameSet, collectionA);
+	assertLinkCollectionName(nameSet, collectionB);
+	if (collectionA === collectionB) throw new Error(`Links between the same collection are not supported. Received "${collectionA}".`);
+	const [firstCollection, firstId, secondCollection, secondId] = collectionA < collectionB ? [
+		collectionA,
+		idA,
+		collectionB,
+		idB
+	] : [
+		collectionB,
+		idB,
+		collectionA,
+		idA
+	];
+	const collections = encodePair(firstCollection, secondCollection);
+	const ids = encodePair(firstId, secondId);
+	return {
+		id: encodePair(collections, ids),
+		collections,
+		ids,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+function createLinkRow(names, row) {
+	const [firstCollection, secondCollection] = decodePair(row.collections);
+	const [firstId, secondId] = decodePair(row.ids);
+	const result = {
+		id: row.id,
+		collections: row.collections,
+		ids: row.ids,
+		createdAt: row.createdAt
+	};
+	for (const other of names) {
+		const byCurrent = {};
+		for (const current of names) {
+			let id = null;
+			if (other !== current) {
+				if (current === firstCollection && other === secondCollection) id = firstId;
+				else if (current === secondCollection && other === firstCollection) id = secondId;
+			}
+			byCurrent[current] = { id };
+		}
+		result[other] = byCurrent;
+	}
+	return result;
+}
+function extractStoredLinkRow(row) {
+	if (!isRecord(row)) throw new Error("Expected a link row object.");
+	if (typeof row.id !== "string" || typeof row.collections !== "string" || typeof row.ids !== "string" || typeof row.createdAt !== "string") throw new Error("Link rows must include string id, collections, ids, and createdAt fields.");
+	return {
+		id: row.id,
+		collections: row.collections,
+		ids: row.ids,
+		createdAt: row.createdAt
+	};
+}
+function encodePair(first, second) {
+	return `${encodePart(first)}:${encodePart(second)}`;
+}
+function decodePair(value) {
+	const parts = value.split(":");
+	if (parts.length !== 2) throw new Error(`Invalid encoded link pair "${value}".`);
+	return [decodePart(parts[0]), decodePart(parts[1])];
+}
+function encodePart(value) {
+	return encodeURIComponent(value);
+}
+function decodePart(value) {
+	return decodeURIComponent(value);
+}
+function assertFlatDefaults(sourceName, defaults) {
+	for (const [field, defaultValue] of Object.entries(defaults)) {
+		if (reservedDocumentFields.has(field)) throw new Error(`Source "${sourceName}" field "${field}" is reserved by Silo documents.`);
+		if (!isFieldValue(resolveDefault(defaultValue))) throw new Error(`Source "${sourceName}" field "${field}" must default to a string, number, boolean, null, or a function returning one of those values.`);
+	}
+}
+function createSourceSchema(sourceName, defaults) {
+	return { "~standard": {
+		version: 1,
+		vendor: "silo",
+		validate(value) {
+			if (!isRecord(value)) return failure("Expected a flat source row object.");
+			if (typeof value.id !== "string") return failure("Expected source document field \"id\" to be a string.", ["id"]);
+			const inputData = isRecord(value.data) ? value.data : extractDocumentData(value);
+			const data = {};
+			for (const [field, fieldValue] of Object.entries(inputData)) {
+				if (reservedDocumentFields.has(field)) return failure(`Source "${sourceName}" field "${field}" is reserved by Silo documents.`, ["data", field]);
+				if (!isFieldValue(fieldValue)) return failure(`Source "${sourceName}" field "${field}" must be a string, number, boolean, or null.`, ["data", field]);
+				data[field] = fieldValue;
+			}
+			for (const [field, defaultValue] of Object.entries(defaults)) {
+				if (field in data) continue;
+				data[field] = resolveDefault(defaultValue);
+			}
+			return { value: createDoc(value.id, data) };
+		}
+	} };
+}
+function createLinkSchema() {
+	return { "~standard": {
+		version: 1,
+		vendor: "silo",
+		validate(value) {
+			try {
+				extractStoredLinkRow(value);
+				return { value };
+			} catch (error) {
+				return failure(error instanceof Error ? error.message : "Expected a link row.");
+			}
+		}
+	} };
+}
+function createDoc(id, data) {
+	const doc = {};
+	Object.defineProperty(doc, "id", {
+		value: id,
+		enumerable: true,
+		writable: false,
+		configurable: false
+	});
+	for (const [field, value] of Object.entries(data)) Object.defineProperty(doc, field, {
+		value,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	Object.defineProperty(doc, "data", {
+		value() {
+			return deletedDocs.has(this) ? null : extractDocumentData(this);
+		},
+		enumerable: true,
+		writable: false,
+		configurable: false
+	});
+	Object.defineProperty(doc, "set", {
+		get() {
+			return function setDocumentData(patch) {
+				Object.assign(this, patch);
+			};
+		},
+		enumerable: true,
+		configurable: false
+	});
+	return doc;
+}
+function extractDocumentData(value) {
+	if (!isRecord(value)) return {};
+	const data = {};
+	for (const [field, fieldValue] of Object.entries(value)) {
+		if (reservedDocumentFields.has(field) || field.startsWith("$") || typeof fieldValue === "function") continue;
+		if (isFieldValue(fieldValue)) data[field] = fieldValue;
+	}
+	return data;
+}
+function resolveDefault(value) {
+	const resolved = typeof value === "function" ? value() : value;
+	if (!isFieldValue(resolved)) throw new Error("Source defaults must resolve to a string, number, boolean, or null.");
+	return resolved;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFieldValue(value) {
+	return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null;
+}
+function failure(message, path) {
+	return { issues: [{
+		message,
+		path
+	}] };
+}
+let database;
+function getDatabase() {
+	if (!database) {
+		database = openDatabaseSync("silo.db");
+		database.execSync(`
+      PRAGMA journal_mode = WAL;
+
+      CREATE TABLE IF NOT EXISTS sources (
+        source TEXT NOT NULL,
+        id TEXT NOT NULL,
+        data TEXT NOT NULL,
+        createdAt TEXT NOT NULL,
+        updatedAt TEXT NOT NULL,
+        version INTEGER NOT NULL DEFAULT 1,
+        PRIMARY KEY (source, id)
+      );
+
+      CREATE TABLE IF NOT EXISTS links (
+        id TEXT PRIMARY KEY,
+        collections TEXT NOT NULL,
+        ids TEXT NOT NULL,
+        createdAt TEXT NOT NULL
+      );
+
+      CREATE UNIQUE INDEX IF NOT EXISTS links_collections_ids_idx
+      ON links(collections, ids);
+
+      CREATE INDEX IF NOT EXISTS links_collections_idx
+      ON links(collections);
+    `);
+	}
+	return database;
+}
+function loadRows(sourceName) {
+	return getDatabase().getAllSync(`SELECT id, data FROM sources WHERE source = ?`, [sourceName]).map((row) => createDoc(row.id, JSON.parse(row.data)));
+}
+function insertRows(sourceName, rows) {
+	const db = getDatabase();
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	db.withTransactionSync(() => {
+		for (const row of rows) {
+			const data = extractDocumentData(row);
+			db.runSync(`INSERT INTO sources (source, id, data, createdAt, updatedAt, version)
+         VALUES (?, ?, ?, ?, ?, 1)`, [
+				sourceName,
+				row.id,
+				JSON.stringify(data),
+				timestamp,
+				timestamp
+			]);
+		}
+	});
+	return Promise.resolve();
+}
+function updateRows(sourceName, mutations) {
+	const db = getDatabase();
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	db.withTransactionSync(() => {
+		for (const mutation of mutations) {
+			const data = extractDocumentData(mutation.modified);
+			mutation.modified = createDoc(String(mutation.key), data);
+			db.runSync(`UPDATE sources
+         SET data = ?, updatedAt = ?, version = version + 1
+         WHERE source = ? AND id = ?`, [
+				JSON.stringify(data),
+				timestamp,
+				sourceName,
+				String(mutation.key)
+			]);
+		}
+	});
+	return Promise.resolve();
+}
+function deleteRows(sourceName, mutations) {
+	const db = getDatabase();
+	db.withTransactionSync(() => {
+		for (const mutation of mutations) {
+			if (mutation.original) deletedDocs.add(mutation.original);
+			deletedDocs.add(mutation.modified);
+			db.runSync(`DELETE FROM sources WHERE source = ? AND id = ?`, [sourceName, String(mutation.key)]);
+			deleteLinksForSourceRow(sourceName, String(mutation.key));
+		}
+	});
+	return Promise.resolve();
+}
+function loadLinkRows() {
+	return getDatabase().getAllSync(`SELECT id, collections, ids, createdAt FROM links`);
+}
+function insertLinkRow(row) {
+	getDatabase().runSync(`INSERT OR IGNORE INTO links (id, collections, ids, createdAt)
+     VALUES (?, ?, ?, ?)`, [
+		row.id,
+		row.collections,
+		row.ids,
+		row.createdAt
+	]);
+}
+function deleteLinkRow(id) {
+	getDatabase().runSync(`DELETE FROM links WHERE id = ?`, [id]);
+}
+function hasLinkRow(id) {
+	return !!getDatabase().getFirstSync(`SELECT id FROM links WHERE id = ?`, [id]);
+}
+function deleteLinksForSourceRow(sourceName, id) {
+	const rows = loadLinkRows();
+	for (const row of rows) {
+		const [firstCollection, secondCollection] = decodePair(row.collections);
+		const [firstId, secondId] = decodePair(row.ids);
+		if (firstCollection === sourceName && firstId === id || secondCollection === sourceName && secondId === id) deleteLinkRow(row.id);
+	}
+}
+
+//#endregion
+export { createID, createStore, source };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "silosdk",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "type": "module",
   "scripts": {
     "build": "tsdown",
@@ -45,14 +45,14 @@
     "printWidth": 80,
     "tabWidth": 2
   },
-  "main": "./dist/source.cjs",
-  "module": "./dist/source.mjs",
-  "types": "./dist/source.d.cts",
+  "main": "./dist/store.cjs",
+  "module": "./dist/store.mjs",
+  "types": "./dist/store.d.cts",
   "exports": {
-    "./source": {
-      "types": "./dist/source.d.mts",
-      "import": "./dist/source.mjs",
-      "require": "./dist/source.cjs"
+    "./store": {
+      "types": "./dist/store.d.mts",
+      "import": "./dist/store.mjs",
+      "require": "./dist/store.cjs"
     },
     "./settings": {
       "types": "./dist/settings.d.mts",

package/dist/source.cjs

@@ -1,221 +0,0 @@
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
-let expo_crypto = require("expo-crypto");
-let expo_sqlite = require("expo-sqlite");
-
-//#region src/source/index.ts
-const sourceNames = /* @__PURE__ */ new Set();
-const sourceNamePattern = /^[A-Za-z][A-Za-z0-9_-]*$/;
-const reservedDocumentFields = new Set([
-	"id",
-	"data",
-	"set"
-]);
-const deletedDocs = /* @__PURE__ */ new WeakSet();
-function createID() {
-	return (0, expo_crypto.randomUUID)();
-}
-function source(name, defaults) {
-	assertSourceName(name);
-	assertFlatDefaults(name, defaults);
-	if (sourceNames.has(name)) throw new Error(`Source "${name}" is already registered. Define each source once and import the existing source instead.`);
-	sourceNames.add(name);
-	const schema = createSourceSchema(name, defaults);
-	return {
-		name,
-		defaults,
-		schema,
-		collectionOptions(options = {}) {
-			return {
-				id: name,
-				getKey: (item) => item.id,
-				schema,
-				startSync: options.startSync,
-				sync: { sync({ begin, write, commit, markReady, truncate }) {
-					const rows = loadRows(name);
-					begin();
-					truncate();
-					for (const row of rows) write({
-						type: "insert",
-						value: row
-					});
-					commit();
-					markReady();
-				} },
-				onInsert: async ({ transaction }) => {
-					await insertRows(name, transaction.mutations.map((mutation) => mutation.modified));
-				},
-				onUpdate: async ({ transaction }) => {
-					await updateRows(name, transaction.mutations);
-				},
-				onDelete: async ({ transaction }) => {
-					await deleteRows(name, transaction.mutations);
-				}
-			};
-		}
-	};
-}
-function assertSourceName(name) {
-	if (!sourceNamePattern.test(name)) throw new Error(`Source names must start with a letter and contain only letters, numbers, underscores, or hyphens. Received "${name}".`);
-}
-function assertFlatDefaults(sourceName, defaults) {
-	for (const [field, defaultValue] of Object.entries(defaults)) {
-		if (reservedDocumentFields.has(field)) throw new Error(`Source "${sourceName}" field "${field}" is reserved by Silo documents.`);
-		if (!isFieldValue(resolveDefault(defaultValue))) throw new Error(`Source "${sourceName}" field "${field}" must default to a string, number, boolean, null, or a function returning one of those values.`);
-	}
-}
-function createSourceSchema(sourceName, defaults) {
-	return { "~standard": {
-		version: 1,
-		vendor: "silo",
-		validate(value) {
-			if (!isRecord(value)) return failure("Expected a flat source row object.");
-			if (typeof value.id !== "string") return failure("Expected source document field \"id\" to be a string.", ["id"]);
-			const inputData = isRecord(value.data) ? value.data : extractDocumentData(value);
-			const data = {};
-			for (const [field, fieldValue] of Object.entries(inputData)) {
-				if (reservedDocumentFields.has(field)) return failure(`Source "${sourceName}" field "${field}" is reserved by Silo documents.`, ["data", field]);
-				if (!isFieldValue(fieldValue)) return failure(`Source "${sourceName}" field "${field}" must be a string, number, boolean, or null.`, ["data", field]);
-				data[field] = fieldValue;
-			}
-			for (const [field, defaultValue] of Object.entries(defaults)) {
-				if (field in data) continue;
-				data[field] = resolveDefault(defaultValue);
-			}
-			return { value: createDoc(value.id, data) };
-		}
-	} };
-}
-function createDoc(id, data) {
-	const doc = {};
-	Object.defineProperty(doc, "id", {
-		value: id,
-		enumerable: true,
-		writable: false,
-		configurable: false
-	});
-	for (const [field, value] of Object.entries(data)) Object.defineProperty(doc, field, {
-		value,
-		enumerable: true,
-		writable: true,
-		configurable: true
-	});
-	Object.defineProperty(doc, "data", {
-		value() {
-			return deletedDocs.has(this) ? null : extractDocumentData(this);
-		},
-		enumerable: true,
-		writable: false,
-		configurable: false
-	});
-	Object.defineProperty(doc, "set", {
-		get() {
-			return function setDocumentData(patch) {
-				Object.assign(this, patch);
-			};
-		},
-		enumerable: true,
-		configurable: false
-	});
-	return doc;
-}
-function extractDocumentData(value) {
-	if (!isRecord(value)) return {};
-	const data = {};
-	for (const [field, fieldValue] of Object.entries(value)) {
-		if (reservedDocumentFields.has(field) || field.startsWith("$") || typeof fieldValue === "function") continue;
-		if (isFieldValue(fieldValue)) data[field] = fieldValue;
-	}
-	return data;
-}
-function resolveDefault(value) {
-	const resolved = typeof value === "function" ? value() : value;
-	if (!isFieldValue(resolved)) throw new Error("Source defaults must resolve to a string, number, boolean, or null.");
-	return resolved;
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isFieldValue(value) {
-	return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null;
-}
-function failure(message, path) {
-	return { issues: [{
-		message,
-		path
-	}] };
-}
-let database;
-function getDatabase() {
-	if (!database) {
-		database = (0, expo_sqlite.openDatabaseSync)("silo.db");
-		database.execSync(`
-      PRAGMA journal_mode = WAL;
-
-      CREATE TABLE IF NOT EXISTS sources (
-        source TEXT NOT NULL,
-        id TEXT NOT NULL,
-        data TEXT NOT NULL,
-        createdAt TEXT NOT NULL,
-        updatedAt TEXT NOT NULL,
-        version INTEGER NOT NULL DEFAULT 1,
-        PRIMARY KEY (source, id)
-      );
-    `);
-	}
-	return database;
-}
-function loadRows(sourceName) {
-	return getDatabase().getAllSync(`SELECT id, data FROM sources WHERE source = ?`, [sourceName]).map((row) => createDoc(row.id, JSON.parse(row.data)));
-}
-function insertRows(sourceName, rows) {
-	const db = getDatabase();
-	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-	db.withTransactionSync(() => {
-		for (const row of rows) {
-			const data = extractDocumentData(row);
-			db.runSync(`INSERT INTO sources (source, id, data, createdAt, updatedAt, version)
-         VALUES (?, ?, ?, ?, ?, 1)`, [
-				sourceName,
-				row.id,
-				JSON.stringify(data),
-				timestamp,
-				timestamp
-			]);
-		}
-	});
-	return Promise.resolve();
-}
-function updateRows(sourceName, mutations) {
-	const db = getDatabase();
-	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-	db.withTransactionSync(() => {
-		for (const mutation of mutations) {
-			const data = extractDocumentData(mutation.modified);
-			mutation.modified = createDoc(String(mutation.key), data);
-			db.runSync(`UPDATE sources
-         SET data = ?, updatedAt = ?, version = version + 1
-         WHERE source = ? AND id = ?`, [
-				JSON.stringify(data),
-				timestamp,
-				sourceName,
-				String(mutation.key)
-			]);
-		}
-	});
-	return Promise.resolve();
-}
-function deleteRows(sourceName, mutations) {
-	const db = getDatabase();
-	db.withTransactionSync(() => {
-		for (const mutation of mutations) {
-			if (mutation.original) deletedDocs.add(mutation.original);
-			deletedDocs.add(mutation.modified);
-			db.runSync(`DELETE FROM sources WHERE source = ? AND id = ?`, [sourceName, String(mutation.key)]);
-		}
-	});
-	return Promise.resolve();
-}
-
-//#endregion
-exports.createID = createID;
-exports.source = source;