sorodb 0.0.0

package/src/schema.js

@@ -0,0 +1,247 @@
+// @ts-check
+import { type } from "arktype";
+import { SchemaError, ValidationError } from "./errors.js";
+import { encodeData, stable, validName } from "./encoding.js";
+import { indexMethod } from "./index-methods.js";
+
+/** @param {any} definition @returns {any} */
+function normalizeType(definition) {
+	if (definition === "date") {
+		return "Date";
+	}
+	if (typeof definition === "string" && definition.endsWith("?")) {
+		const base = definition.slice(0, -1);
+		if (base === "date") {
+			return { optional: true, value: "Date" };
+		}
+		return { optional: true, value: base };
+	}
+	return definition;
+}
+
+/** @param {any} definition */
+function serializableType(definition) {
+	if (typeof definition === "string") {
+		return definition;
+	}
+	if (definition && typeof definition.expression === "string") {
+		return definition.expression;
+	}
+	if (Array.isArray(definition) || (definition && typeof definition === "object")) {
+		return stable(definition);
+	}
+	throw new SchemaError("Column type must be an ArkType definition");
+}
+
+/** @param {import("./types.js").IndexDefinition} index @param {Record<string, import("./types.js").ColumnDefinition>} columns @returns {import("./types.js").Index} */
+function normalizeIndex(index, columns) {
+	if (!index || typeof index !== "object") {
+		throw new SchemaError("Index must be an object");
+	}
+	const name = validName(index.name, "index name");
+	const method = index.method ?? "btree";
+	indexMethod(method);
+	if (!Array.isArray(index.columns) || !index.columns.length) {
+		throw new SchemaError(`Index ${name} must declare columns`);
+	}
+	const fields = index.columns.map((entry) => {
+		let field;
+		/** @type {import("./types.js").Direction} */
+		let direction = "asc";
+		if (typeof entry === "string") {
+			field = entry;
+		} else {
+			field = entry?.field;
+			direction = entry?.direction ?? "asc";
+		}
+		if (typeof field !== "string" || !field || !columns[field.split(".")[0]]) {
+			throw new SchemaError(`Index ${name} references unknown column ${field}`);
+		}
+		if (!["asc", "desc"].includes(direction)) {
+			throw new SchemaError(`Index ${name} has an invalid direction`);
+		}
+		return { name: field, direction };
+	});
+	if (new Set(fields.map((field) => field.name)).size !== fields.length) {
+		throw new SchemaError(`Index ${name} repeats a column`);
+	}
+	return { name, method, fields, unique: index.unique === true };
+}
+
+/** @param {{ version: number }} config @param {import("./types.js").TableDefinition[]} definitions @returns {import("./types.js").CompiledSchema} */
+export function compileSchema(config, definitions) {
+	if (!config || !Number.isSafeInteger(config.version) || config.version < 1) {
+		throw new SchemaError("Schema version must be an integer of at least 1");
+	}
+	if (!Array.isArray(definitions) || !definitions.length) {
+		throw new SchemaError("Schema needs at least one table");
+	}
+	/** @type {Map<string, import("./types.js").Table>} */
+	const tables = new Map();
+	/** @type {Record<string, import("./types.js").StoredTable>} */
+	const storedTables = {};
+	for (const definition of definitions) {
+		if (!definition || typeof definition !== "object") {
+			throw new SchemaError("Table definition must be an object");
+		}
+		const name = validName(definition.table, "table name");
+		if (tables.has(name)) {
+			throw new SchemaError(`Duplicate table ${name}`);
+		}
+		const columns = definition.columns;
+		if (!columns || typeof columns !== "object" || Array.isArray(columns)) {
+			throw new SchemaError(`Table ${name} needs columns`);
+		}
+		if (
+			!columns.id ||
+			columns.id.primary !== true ||
+			Object.entries(columns).filter(([, col]) => col?.primary).length !== 1
+		) {
+			throw new SchemaError(`Table ${name} must have exactly one primary column named id`);
+		}
+		/** @type {Record<string, any>} */
+		const shape = { "+": "reject" };
+		/** @type {Record<string, import("./types.js").StoredColumn>} */
+		const storedColumns = {};
+		for (const [columnName, column] of Object.entries(columns)) {
+			validName(columnName, "column name");
+			if (!column || typeof column !== "object" || !Object.hasOwn(column, "type")) {
+				throw new SchemaError(`Column ${name}.${columnName} needs a type`);
+			}
+			const normalized = normalizeType(column.type);
+			const optional = normalized?.optional === true;
+			let value = normalized;
+			let shapeKey = columnName;
+			if (optional) {
+				value = normalized.value;
+				shapeKey = `${columnName}?`;
+			}
+			shape[shapeKey] = value;
+			/** @type {import("./types.js").StoredColumn["default"]} */
+			let storedDefault = null;
+			if (Object.hasOwn(column, "default")) {
+				if (typeof column.default === "function") {
+					storedDefault = { kind: "function" };
+				} else {
+					storedDefault = { kind: "value", value: encodeData(column.default).toString("base64") };
+				}
+			}
+			storedColumns[columnName] = {
+				type: serializableType(column.type),
+				primary: column.primary === true,
+				optional,
+				default: storedDefault,
+			};
+		}
+		if (storedColumns.id.optional || !/^(number|string)(\.|$)/.test(storedColumns.id.type)) {
+			throw new SchemaError(`Table ${name} id must be a required string or number`);
+		}
+		let validator;
+		try {
+			validator = type(shape).onDeepUndeclaredKey("reject");
+		} catch (error) {
+			throw new SchemaError(`Invalid ArkType schema for ${name}: ${error.message}`);
+		}
+		const indexes = (definition.indexes ?? []).map((index) => normalizeIndex(index, columns));
+		if (new Set(indexes.map((index) => index.name)).size !== indexes.length) {
+			throw new SchemaError(`Table ${name} repeats an index name`);
+		}
+		tables.set(name, { name, columns, indexes, validator });
+		storedTables[name] = { columns: storedColumns, indexes };
+	}
+	return {
+		version: config.version,
+		tables,
+		stored: { version: config.version, tables: storedTables },
+	};
+}
+
+/** @param {object} value @returns {value is import("./types.js").Document} */
+function hasValidId(value) {
+	if (!("id" in value)) {
+		return false;
+	}
+	return (
+		typeof value.id === "string" || (typeof value.id === "number" && Number.isFinite(value.id))
+	);
+}
+
+/** @param {import("./types.js").Table} table @param {unknown} document @param {boolean} [applyDefaults] @returns {import("./types.js").Document} */
+export function validateDocument(table, document, applyDefaults = true) {
+	if (!document || typeof document !== "object" || Array.isArray(document)) {
+		throw new ValidationError("Document must be an object");
+	}
+	/** @type {Record<string, unknown>} */
+	const candidate = { ...document };
+	if (applyDefaults) {
+		for (const [name, column] of Object.entries(table.columns)) {
+			if (candidate[name] === undefined && Object.hasOwn(column, "default")) {
+				if (typeof column.default === "function") {
+					candidate[name] = column.default();
+				} else {
+					candidate[name] = structuredClone(column.default);
+				}
+			}
+		}
+	}
+	const result = table.validator(candidate);
+	if (result instanceof type.errors) {
+		throw new ValidationError(
+			`Document failed ${table.name} schema validation: ${result.summary}`,
+			result.flatByPath,
+		);
+	}
+	if (!result || typeof result !== "object" || Array.isArray(result)) {
+		throw new ValidationError("Document schema must produce an object");
+	}
+	if (!hasValidId(result)) {
+		throw new ValidationError("id must be a string or finite number");
+	}
+	encodeData(result);
+	return result;
+}
+
+/** @param {import("./types.js").StoredSchema} previous @param {import("./types.js").StoredSchema} next @returns {import("./types.js").SchemaDiff} */
+export function schemaDiff(previous, next) {
+	if (next.version < previous.version) {
+		throw new SchemaError(
+			`Schema version ${next.version} is older than stored version ${previous.version}`,
+		);
+	}
+	if (next.version === previous.version) {
+		if (stable(previous.tables) !== stable(next.tables)) {
+			throw new SchemaError("Schema definition changed without increasing its version");
+		}
+		return { changed: false, additions: new Map() };
+	}
+	const additions = new Map();
+	for (const [name, oldTable] of Object.entries(previous.tables)) {
+		const newTable = next.tables[name];
+		if (!newTable) {
+			throw new SchemaError(`Removing table ${name} is not a safe migration`);
+		}
+		for (const [field, oldColumn] of Object.entries(oldTable.columns)) {
+			if (!newTable.columns[field] || stable(oldColumn) !== stable(newTable.columns[field])) {
+				throw new SchemaError(`Changing or removing ${name}.${field} is not a safe migration`);
+			}
+		}
+		for (const oldIndex of oldTable.indexes) {
+			const newIndex = newTable.indexes.find((index) => index.name === oldIndex.name);
+			if (!newIndex || stable(oldIndex) !== stable(newIndex)) {
+				throw new SchemaError(
+					`Changing or removing index ${name}.${oldIndex.name} is not a safe migration`,
+				);
+			}
+		}
+	}
+	for (const [name, newTable] of Object.entries(next.tables)) {
+		const oldTable = previous.tables[name];
+		additions.set(name, {
+			columns: Object.keys(newTable.columns).filter((field) => !oldTable?.columns[field]),
+			indexes: newTable.indexes.filter(
+				(index) => !oldTable?.indexes.some((old) => old.name === index.name),
+			),
+		});
+	}
+	return { changed: true, additions };
+}

package/src/storage.js

@@ -0,0 +1,334 @@
+// @ts-check
+import { DbBuilder, IsolationLevel, ObjectStore } from "@slatedb/uniffi";
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { SchemaError, CursorError } from "./errors.js";
+import { compileSchema, schemaDiff, validateDocument } from "./schema.js";
+import { addIndexes } from "./indexes.js";
+import {
+	decodeData,
+	docKey,
+	docPrefix,
+	encodeData,
+	indexPrefix,
+	range,
+	stable,
+} from "./encoding.js";
+import { Collection } from "./collection.js";
+
+const META_KEY = Buffer.from("M\0schema");
+const CURSOR_TTL = 5 * 60 * 1000;
+
+/** @param {import("./types.js").Reader} reader @param {Uint8Array} prefix @param {Uint8Array} [after] */
+export async function* scan(reader, prefix, after) {
+	const iterator = await reader.scan(range(prefix, after));
+	try {
+		while (true) {
+			const row = await iterator.next();
+			if (!row) {
+				return;
+			}
+			yield { key: Buffer.from(row.key), value: Buffer.from(row.value) };
+		}
+	} finally {
+		iterator.dispose();
+	}
+}
+
+export class Database {
+	/** @param {import("./types.js").DatabaseConfig} config */
+	constructor(config) {
+		if (
+			!config ||
+			typeof config.store !== "string" ||
+			typeof config.path !== "string" ||
+			!config.path
+		) {
+			throw new SchemaError("SoroDB needs { store: URL, path: nonempty string }");
+		}
+		this.config = config;
+		if (
+			config.cursorTtlMs !== undefined &&
+			(!Number.isSafeInteger(config.cursorTtlMs) || config.cursorTtlMs < 1)
+		) {
+			throw new SchemaError("cursorTtlMs must be a positive integer");
+		}
+		this.cursorTtlMs = config.cursorTtlMs ?? CURSOR_TTL;
+		this.definition = null;
+		this.native = null;
+		this.store = null;
+		this.opening = null;
+		this.closed = false;
+		/** @type {Map<string, import("./types.js").Session>} */
+		this.sessions = new Map();
+	}
+
+	/** @param {{ version: number }} config @param {import("./types.js").TableDefinition[]} definitions */
+	schema(config, definitions) {
+		if (this.opening || this.native || this.closed) {
+			throw new SchemaError("Register the schema before opening the database");
+		}
+		this.definition = compileSchema(config, definitions);
+		return this;
+	}
+
+	async _ready() {
+		if (this.closed) {
+			throw new SchemaError("Database is closed");
+		}
+		if (!this.definition) {
+			throw new SchemaError("Register a schema before using collections");
+		}
+		if (!this.opening) {
+			this.opening = this._open();
+		}
+		return this.opening;
+	}
+
+	async _open() {
+		const definition = this.definition;
+		if (!definition) {
+			throw new SchemaError("Register a schema before opening the database");
+		}
+		// SlateDB 0.16 accepts the filesystem location in DbBuilder's path, not
+		// in ObjectStore.resolve's URL. Keep the friendlier SoroDB config shape.
+		const local = this.config.store.startsWith("file:");
+		let storeUrl = this.config.store;
+		let databasePath = this.config.path;
+		if (local) {
+			storeUrl = "file:///";
+			databasePath = join(fileURLToPath(this.config.store), this.config.path);
+		}
+		this.store = ObjectStore.resolve(storeUrl);
+		const builder = new DbBuilder(databasePath, this.store);
+		try {
+			this.native = await builder.build();
+		} catch (error) {
+			this.store.dispose();
+			this.store = null;
+			throw error;
+		} finally {
+			builder.dispose();
+		}
+		try {
+			const bytes = await this.native.get(META_KEY);
+			if (!bytes) {
+				await this.native.put(META_KEY, encodeData(definition.stored));
+			} else {
+				const previous = decodeData(bytes);
+				const diff = schemaDiff(previous, definition.stored);
+				if (diff.changed) {
+					await this._migrate(diff);
+				}
+			}
+		} catch (error) {
+			await this.native.shutdown().catch(() => {});
+			this.native.dispose();
+			this.store.dispose();
+			this.native = null;
+			this.store = null;
+			throw error;
+		}
+	}
+
+	/** @param {import("./types.js").SchemaDiff} diff */
+	async _migrate(diff) {
+		const definition = this.definition;
+		const native = this.native;
+		if (!definition || !native) {
+			throw new SchemaError("Database is not open");
+		}
+		for (const [name, changes] of diff.additions) {
+			if (!changes.columns.length && !changes.indexes.length) {
+				continue;
+			}
+			const table = definition.tables.get(name);
+			if (!table) {
+				throw new SchemaError(`Collection ${name} is absent from the schema`);
+			}
+			// A prior attempt may have stopped after writing some entries. Rebuild only
+			// indexes newly introduced by this version before exposing the schema.
+			for (const index of changes.indexes) {
+				for await (const row of scan(native, indexPrefix(name, index.name))) {
+					await native.delete(row.key);
+				}
+			}
+			for await (const row of scan(native, docPrefix(name))) {
+				const before = decodeData(row.value);
+				const after = validateDocument(table, before);
+				const changed = stable(before) !== stable(after);
+				const tx = await native.begin(IsolationLevel.SerializableSnapshot);
+				try {
+					if (changed) {
+						await tx.put(docKey(name, after.id), encodeData(after));
+					}
+					if (changes.indexes.length) {
+						await addIndexes(tx, table, after, changes.indexes);
+					}
+					await tx.commit();
+				} catch (error) {
+					await tx.rollback().catch(() => {});
+					throw error;
+				} finally {
+					tx.dispose();
+				}
+			}
+		}
+		await native.put(META_KEY, encodeData(definition.stored));
+	}
+
+	/** @param {string} name */
+	async collection(name) {
+		await this._ready();
+		if (!this.definition) {
+			throw new SchemaError("Register a schema before using collections");
+		}
+		const table = this.definition.tables.get(name);
+		if (!table) {
+			throw new SchemaError(`Collection ${name} is absent from the schema`);
+		}
+		return new Collection(this, table);
+	}
+
+	/** @template T @param {(tx: import("@slatedb/uniffi").DbTransaction) => Promise<T>} fn @returns {Promise<T>} */
+	async _atomic(fn) {
+		await this._ready();
+		if (!this.native) {
+			throw new SchemaError("Database is not open");
+		}
+		const tx = await this.native.begin(IsolationLevel.SerializableSnapshot);
+		try {
+			const result = await fn(tx);
+			await tx.commit();
+			return result;
+		} catch (error) {
+			await tx.rollback().catch(() => {});
+			throw error;
+		} finally {
+			tx.dispose();
+		}
+	}
+
+	/** @template T @param {(tx: { collection: (name: string) => Promise<Collection> }) => Promise<T>} callback @returns {Promise<T>} */
+	async transaction(callback) {
+		if (typeof callback !== "function") {
+			throw new SchemaError("transaction requires a callback");
+		}
+		const definition = this.definition;
+		if (!definition) {
+			throw new SchemaError("Register a schema before using collections");
+		}
+		return this._atomic(async (native) => {
+			/** @type {{ collection: (name: string) => Promise<Collection> }} */
+			const tx = {
+				collection: async (name) => {
+					const table = definition.tables.get(name);
+					if (!table) {
+						throw new SchemaError(`Collection ${name} is absent from the schema`);
+					}
+					return new Collection(this, table, native);
+				},
+			};
+			return callback(tx);
+		});
+	}
+
+	_session() {
+		const now = Date.now();
+		for (const [id, session] of this.sessions) {
+			if (!session.active && session.lastUsed + this.cursorTtlMs < now) {
+				this._releaseSession(id);
+			}
+		}
+	}
+
+	/** @param {string} fingerprint */
+	async _newSession(fingerprint) {
+		await this._ready();
+		if (!this.native) {
+			throw new SchemaError("Database is not open");
+		}
+		this._session();
+		const id = randomUUID();
+		const snapshot = await this.native.snapshot();
+		const session = { snapshot, fingerprint, lastUsed: Date.now(), active: 0 };
+		this.sessions.set(id, session);
+		this._armSession(id, session);
+		return { id, session };
+	}
+
+	/** @param {string} id @param {import("./types.js").Session} session */
+	_armSession(id, session) {
+		clearTimeout(session.timer);
+		if (session.active) {
+			return;
+		}
+		session.timer = setTimeout(() => this._releaseSession(id), this.cursorTtlMs);
+		session.timer.unref?.();
+	}
+
+	/** @param {import("./types.js").Session} session */
+	_holdSession(session) {
+		session.active++;
+		clearTimeout(session.timer);
+	}
+
+	/** @param {string} id */
+	_idleSession(id) {
+		const session = this.sessions.get(id);
+		if (!session) {
+			return;
+		}
+		session.active--;
+		session.lastUsed = Date.now();
+		this._armSession(id, session);
+	}
+
+	/** @param {string} id @param {string} fingerprint */
+	_getSession(id, fingerprint) {
+		this._session();
+		const session = this.sessions.get(id);
+		if (!session || session.fingerprint !== fingerprint) {
+			throw new CursorError("Cursor is expired or belongs to a different query");
+		}
+		session.lastUsed = Date.now();
+		this._armSession(id, session);
+		return session;
+	}
+
+	/** @param {string} id */
+	_releaseSession(id) {
+		const session = this.sessions.get(id);
+		if (session) {
+			clearTimeout(session.timer);
+			session.snapshot.dispose();
+			this.sessions.delete(id);
+		}
+	}
+
+	async close() {
+		if (this.closed) {
+			return;
+		}
+		this.closed = true;
+		if (this.opening) {
+			await this.opening.catch(() => {});
+		}
+		for (const id of this.sessions.keys()) {
+			this._releaseSession(id);
+		}
+		if (this.native) {
+			try {
+				await this.native.shutdown();
+			} finally {
+				this.native.dispose();
+				this.native = null;
+			}
+		}
+		if (this.store) {
+			this.store.dispose();
+			this.store = null;
+		}
+	}
+}

package/src/types.js

@@ -0,0 +1,29 @@
+// @ts-check
+
+/** @typedef {"asc" | "desc"} Direction */
+/** @typedef {Record<string, unknown> & { id: string | number }} Document */
+/** @typedef {{ store: string, path: string, cursorTtlMs?: number }} DatabaseConfig */
+/** @typedef {string | import("arktype").Type<unknown> | readonly ArkTypeValue[] | { [key: string]: ArkTypeValue }} ArkTypeDefinition */
+/** @typedef {ArkTypeDefinition | null | boolean | number | bigint | Date | Uint8Array} ArkTypeValue */
+/** @typedef {null | boolean | number | string | bigint | Date | Uint8Array | readonly DataValue[] | { [key: string]: DataValue }} DataValue */
+/** @typedef {{ type: ArkTypeDefinition, primary?: boolean, default?: DataValue | (() => DataValue) }} ColumnDefinition */
+/** @typedef {{ name: string, method?: "btree", columns: (string | { field: string, direction?: Direction })[], unique?: boolean }} IndexDefinition */
+/** @typedef {{ table: string, columns: Record<string, ColumnDefinition>, indexes?: IndexDefinition[] }} TableDefinition */
+/** @typedef {{ name: string, direction: Direction }} IndexField */
+/** @typedef {{ name: string, method: "btree", fields: IndexField[], unique: boolean }} Index */
+/** @typedef {{ name: string, columns: Record<string, ColumnDefinition>, indexes: Index[], validator: (document: unknown) => unknown }} Table */
+/** @typedef {{ type: string, primary: boolean, optional: boolean, default: null | { kind: string, value?: string } }} StoredColumn */
+/** @typedef {{ columns: Record<string, StoredColumn>, indexes: Index[] }} StoredTable */
+/** @typedef {{ version: number, tables: Record<string, StoredTable> }} StoredSchema */
+/** @typedef {{ version: number, tables: Map<string, Table>, stored: StoredSchema }} CompiledSchema */
+/** @typedef {{ changed: boolean, additions: Map<string, { columns: string[], indexes: Index[] }> }} SchemaDiff */
+/** @typedef {import("@slatedb/uniffi").Db | import("@slatedb/uniffi").DbSnapshot | import("@slatedb/uniffi").DbTransaction} Reader */
+/** @typedef {{ snapshot: import("@slatedb/uniffi").DbSnapshot, fingerprint: string, lastUsed: number, active: number, timer?: NodeJS.Timeout }} Session */
+/** @typedef {{ op: "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in" | "contains" | "startsWith" | "exists", path: string, value: unknown }} Predicate */
+/** @typedef {{ op: "and", conditions: WhereNode[] } | { op: "or", conditions: WhereNode[] } | { op: "not", condition: WhereNode } | Predicate} WhereNode */
+/** @typedef {{ eq: (path: string, value: unknown) => WhereNode, ne: (path: string, value: unknown) => WhereNode, gt: (path: string, value: unknown) => WhereNode, gte: (path: string, value: unknown) => WhereNode, lt: (path: string, value: unknown) => WhereNode, lte: (path: string, value: unknown) => WhereNode, in: (path: string, value: unknown[]) => WhereNode, contains: (path: string, value: unknown) => WhereNode, startsWith: (path: string, value: string) => WhereNode, exists: (path: string, value?: boolean) => WhereNode, and: (...conditions: WhereNode[]) => WhereNode, or: (...conditions: WhereNode[]) => WhereNode, not: (condition: WhereNode) => WhereNode }} WhereBuilder */
+/** @typedef {{ asc: (path: string) => OrderBuilder, desc: (path: string) => OrderBuilder }} OrderBuilder */
+/** @typedef {{ where?: (builder: WhereBuilder) => WhereNode, orderBy?: (builder: OrderBuilder) => unknown, select?: string[], limit?: number, cursor?: string }} QueryOptions */
+/** @typedef {{ id: string, last: Buffer, fingerprint: string }} Cursor */
+
+export {};

package/types/collection.d.ts

@@ -0,0 +1,20 @@
+import { Query } from "./query.js";
+export declare class Collection {
+    db: import("./storage.js").Database;
+    table: import("./types.js").Table;
+    transaction: import("@slatedb/uniffi").DbTransaction | null;
+    /** @param {import("./storage.js").Database} db @param {import("./types.js").Table} table @param {import("@slatedb/uniffi").DbTransaction | null} [transaction] */
+    constructor(db: import("./storage.js").Database, table: import("./types.js").Table, transaction?: import("@slatedb/uniffi").DbTransaction | null);
+    /** @template T @param {(tx: import("@slatedb/uniffi").DbTransaction) => Promise<T>} callback @returns {Promise<T>} */
+    _write<T>(callback: (tx: import("@slatedb/uniffi").DbTransaction) => Promise<T>): Promise<T>;
+    /** @param {import("./types.js").Document} document */
+    create(document: import("./types.js").Document): Promise<import("./types.js").Document>;
+    /** @param {string | number} id */
+    get(id: string | number): Promise<any>;
+    /** @param {string | number} id @param {import("./types.js").Document} document */
+    replace(id: string | number, document: import("./types.js").Document): Promise<import("./types.js").Document>;
+    /** @param {string | number} id */
+    delete(id: string | number): Promise<boolean>;
+    /** @param {import("./types.js").QueryOptions} [options] */
+    filter(options?: import("./types.js").QueryOptions): Query;
+}

package/types/encoding.d.ts

@@ -0,0 +1,32 @@
+/** @param {Uint8Array} bytes */
+export declare function part(bytes: Uint8Array): Buffer<ArrayBuffer>;
+/** @param {number} value */
+declare function sortableNumber(value: number): Buffer<ArrayBuffer>;
+export { sortableNumber };
+/** @param {unknown} name @param {string} [label] */
+export declare function validName(name: unknown, label?: string): string;
+/** @param {unknown} id */
+export declare function idBytes(id: unknown): Buffer<ArrayBuffer>;
+/** @param {string} table */
+export declare function docPrefix(table: string): Buffer<ArrayBuffer>;
+/** @param {string} table @param {string | number} id */
+export declare function docKey(table: string, id: string | number): Buffer<ArrayBuffer>;
+/** @param {string} table @param {string} name */
+export declare function indexPrefix(table: string, name: string): Buffer<ArrayBuffer>;
+/** @param {unknown} object @param {string} path @returns {unknown} */
+export declare function getPath(object: unknown, path: string): unknown;
+/** @param {Uint8Array} prefix */
+export declare function prefixEnd(prefix: Uint8Array): Buffer<ArrayBuffer> | undefined;
+/** @param {Uint8Array} prefix @param {Uint8Array} [after] */
+export declare function range(prefix: Uint8Array, after?: Uint8Array): {
+    start: Uint8Array<ArrayBufferLike>;
+    start_inclusive: boolean;
+    end: Buffer<ArrayBuffer> | undefined;
+    end_inclusive: boolean;
+};
+/** @param {unknown} value */
+export declare function encodeData(value: unknown): Buffer<ArrayBuffer>;
+/** @param {Uint8Array} bytes @returns {any} */
+export declare function decodeData(bytes: Uint8Array): any;
+/** @param {unknown} value */
+export declare function stable(value: unknown): string;

package/types/errors.d.ts

@@ -0,0 +1,26 @@
+export declare class SoroError extends Error {
+    code: string;
+    details: unknown;
+    /** @param {string} message @param {string} code @param {unknown} [details] */
+    constructor(message: string, code: string, details?: unknown);
+}
+export declare class ValidationError extends SoroError {
+    /** @param {string} message @param {unknown} [details] */
+    constructor(message: string, details?: unknown);
+}
+export declare class SchemaError extends SoroError {
+    /** @param {string} message @param {unknown} [details] */
+    constructor(message: string, details?: unknown);
+}
+export declare class ConflictError extends SoroError {
+    /** @param {string} message @param {unknown} [details] */
+    constructor(message: string, details?: unknown);
+}
+export declare class QueryError extends SoroError {
+    /** @param {string} message @param {unknown} [details] */
+    constructor(message: string, details?: unknown);
+}
+export declare class CursorError extends SoroError {
+    /** @param {string} message @param {unknown} [details] */
+    constructor(message: string, details?: unknown);
+}