@party-stack/ontology 0.20.0 → 0.21.0

package/lib/tanstack/subset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subset.js","names":[],"sources":["../../src/tanstack/subset.ts"],"sourcesContent":["import * as q from \"@party-stack/ontology-spec/query\";\nimport { IR } from \"@tanstack/db\";\nimport type { Expression, Subset, QueryOrder, OntologyIR } from \"@party-stack/ontology-spec\";\nimport type { ObjectSubset } from \"@party-stack/ontology-spec/query\";\nimport type { Field } from \"@party-stack/ontology-storage\";\nimport type {\n    Query,\n    Scalar,\n    Predicate as StoragePredicate,\n    Operand as StorageOperand,\n} from \"@party-stack/ontology-storage\";\nconst field = (...path: string[]): Expression => q.field(\"row\", ...path);\nconst isField = (value: Expression) => value.kind === \"getAt\";\nimport type { LoadSubsetOptions } from \"@tanstack/db\";\n\ntype Definition = OntologyIR[\"types\"][number][\"type\"];\ntype Family = \"string\" | \"number\" | \"boolean\" | \"date\" | \"timestamp\";\ninterface Value {\n    operand: Expression;\n    family?: Family;\n    elementFamily?: Family;\n    optional: boolean;\n}\ntype Condition = Expression | boolean;\ninterface Truth {\n    yes: Condition;\n    no: Condition;\n    exact: boolean;\n}\nconst unknown: Truth = { yes: true, no: true, exact: false };\nconst combine = (op: \"and\" | \"or\", values: readonly Condition[]): Condition => {\n    const terminal = op === \"or\";\n    if (values.includes(terminal)) return terminal;\n    const predicates = values.filter((value): value is Expression => typeof value !== \"boolean\");\n    return predicates.length === 0\n        ? !terminal\n        : predicates.length === 1\n          ? predicates[0]!\n          : q[op](...predicates);\n};\nconst predicate = (value: Condition): Expression | undefined =>\n    value === true ? undefined : value === false ? q.or() : value;\nconst negate = (value: Condition): Condition => (typeof value === \"boolean\" ? !value : q.not(value));\n\n/** Translate TanStack semantics into the shared ontology expression IR. Unsupported expressions\n * widen demand; TanStack still evaluates the original query on the returned rows.\n * In particular, a residual filter or locale comparator must run before LIMIT.\n */\nexport function analyzeOntologySubset(subset: LoadSubsetOptions, ir?: OntologyIR, objectType?: string) {\n    const objects = new Map(ir?.objectTypes.map((type) => [type.name, type]));\n    const named = new Map(ir?.types.map((type) => [type.name, type.type]));\n    const resolve = (\n        type: Definition | undefined,\n        path: readonly string[],\n        optional = false,\n        seen = new Set<Definition>()\n    ): Omit<Value, \"operand\"> | undefined => {\n        if (!type || seen.has(type)) return undefined;\n        const next = new Set([...seen, type]);\n        if (type.kind === \"optional\") return resolve(type.value.type, path, true, next);\n        if (type.kind === \"ref\") return resolve(named.get(type.value.name), path, optional, next);\n        if (type.kind === \"objectReference\") {\n            const object = objects.get(type.value.objectType);\n            return resolve(\n                object?.properties.find((prop) => prop.name === object.primaryKey)?.type,\n                path,\n                optional,\n                next\n            );\n        }\n        if (path.length)\n            return type.kind === \"struct\"\n                ? resolve(\n                      type.value.fields.find((prop) => prop.name === path[0])?.type,\n                      path.slice(1),\n                      optional,\n                      next\n                  )\n                : undefined;\n        if (type.kind === \"list\")\n            return { elementFamily: resolve(type.value.elementType, [], false, next)?.family, optional };\n        switch (type.kind) {\n            case \"string\":\n            case \"boolean\":\n            case \"date\":\n            case \"timestamp\":\n                return { family: type.kind, optional };\n            case \"integer\":\n            case \"float\":\n            case \"double\":\n                return { family: \"number\", optional };\n            default:\n                return undefined;\n        }\n    };\n    const value = (expression: IR.BasicExpression): Value | undefined => {\n        if (expression.type === \"ref\") {\n            const path = IR.getPropRefPropertyPath(expression);\n            if (!path.length) return undefined;\n            const type = objects\n                .get(objectType ?? \"\")\n                ?.properties.find((prop) => prop.name === path[0])?.type;\n            const resolved = resolve(type, path.slice(1));\n            return resolved && { operand: field(...path), ...resolved };\n        }\n        if (expression.type !== \"val\") return undefined;\n        const literal: unknown = expression.value;\n        if (literal == null) return { operand: q.literal(literal), optional: true };\n        if (typeof literal === \"string\" || typeof literal === \"boolean\")\n            return {\n                operand: q.literal(literal),\n                family: typeof literal as \"string\" | \"boolean\",\n                optional: false,\n            };\n        if (typeof literal === \"number\" && Number.isFinite(literal))\n            return { operand: q.literal(literal), family: \"number\", optional: false };\n        if (typeof literal === \"object\") {\n            const tag = Reflect.get(literal, Symbol.toStringTag) as unknown;\n            if (tag === \"Temporal.Instant\" || tag === \"Temporal.PlainDate\")\n                return {\n                    operand: q.literal(literal),\n                    family: tag === \"Temporal.Instant\" ? \"timestamp\" : \"date\",\n                    optional: false,\n                };\n        }\n        return undefined;\n    };\n    const present = (v: Value): Condition =>\n        !v.optional\n            ? true\n            : isField(v.operand)\n              ? // Ontology object decoding normalizes optional nulls to undefined.\n                q.ne(v.operand, q.literal(undefined))\n              : false;\n    const truth = (expression: IR.BasicExpression): Truth => {\n        if (expression.type === \"val\" && (typeof expression.value === \"boolean\" || expression.value == null))\n            return {\n                yes: expression.value === true,\n                no: expression.value === false,\n                exact: true,\n            };\n        if (expression.type === \"ref\") {\n            const v = value(expression);\n            return v?.family === \"boolean\"\n                ? {\n                      yes: q.eq(v.operand, q.literal(true)),\n                      no: q.eq(v.operand, q.literal(false)),\n                      exact: true,\n                  }\n                : unknown;\n        }\n        if (expression.type !== \"func\") return unknown;\n        const { name, args } = expression;\n        if (name === \"and\" || name === \"or\") {\n            const children = args.map(truth);\n            return {\n                yes: combine(\n                    name,\n                    children.map((c) => c.yes)\n                ),\n                no: combine(\n                    name === \"and\" ? \"or\" : \"and\",\n                    children.map((c) => c.no)\n                ),\n                exact: children.every((c) => c.exact),\n            };\n        }\n        if (name === \"not\" && args.length === 1) {\n            const child = truth(args[0]!);\n            return { yes: child.no, no: child.yes, exact: child.exact };\n        }\n        const left = args[0] && value(args[0]);\n        if (!left) return unknown;\n        if ((name === \"isNull\" || name === \"isUndefined\") && args.length === 1) {\n            const yes = q.eq(left.operand, q.literal(name === \"isNull\" ? null : undefined));\n            return { yes, no: negate(yes), exact: true };\n        }\n        // Physical PlainDate equality follows ISO day ordering, while TanStack\n        // equality also distinguishes calendars. Neither an equality/membership\n        // predicate nor its negation is exact at that boundary. Broaden both\n        // branches and let TanStack filter before applying its window.\n        if (left.family === \"date\" && (name === \"eq\" || name === \"in\")) return unknown;\n        if (name === \"in\" && args[1]?.type === \"ref\") {\n            const array = value(args[1]);\n            if (!array?.elementFamily || !isField(array.operand)) return unknown;\n            if (!left.family) return { yes: false, no: false, exact: true };\n            if (left.family !== array.elementFamily) return unknown;\n            const yes = q.contains(array.operand, left.operand);\n            return {\n                yes: combine(\"and\", [present(left), yes]),\n                no: combine(\"and\", [present(left), negate(yes)]),\n                exact: true,\n            };\n        }\n        if (name === \"in\" && args[1]?.type === \"val\" && Array.isArray(args[1].value)) {\n            const items = (args[1].value as unknown[])\n                .filter((item) => item != null)\n                .map((item) => value(new IR.Value(item)));\n            if (items.some((item) => !item || item.family !== left.family)) return unknown;\n            const yes = q.inArray(\n                left.operand,\n                q.literal(\n                    items.map(\n                        (item) => (item!.operand as Extract<Expression, { kind: \"literal\" }>).value.value\n                    )\n                )\n            );\n            return {\n                yes: combine(\"and\", [present(left), yes]),\n                no: combine(\"and\", [present(left), negate(yes)]),\n                exact: true,\n            };\n        }\n        if (![\"eq\", \"gt\", \"gte\", \"lt\", \"lte\", \"like\", \"ilike\"].includes(name)) return unknown;\n        const right = args[1] && value(args[1]);\n        if (!right || args.length !== 2) return unknown;\n        if (!left.family || !right.family) return { yes: false, no: false, exact: true };\n        if (left.family !== right.family) return unknown;\n        const guard = combine(\"and\", [present(left), present(right)]);\n        let yes: Expression;\n        if (name === \"eq\" || name === \"gt\" || name === \"gte\" || name === \"lt\" || name === \"lte\")\n            yes = q[name](left.operand, right.operand);\n        else if ((name === \"like\" || name === \"ilike\") && left.family === \"string\")\n            yes = q[name](left.operand, right.operand);\n        else return unknown;\n        // Equality against a defined operand already rejects missing values. Two\n        // optional operands can both be missing and still compare equal in storage.\n        // Negation always needs the guard: TanStack treats missing as UNKNOWN,\n        // whereas storage's NOT turns an ordinary false comparison into true.\n        return {\n            yes: name === \"eq\" && (!left.optional || !right.optional) ? yes : combine(\"and\", [guard, yes]),\n            no: combine(\"and\", [guard, negate(yes)]),\n            exact: true,\n        };\n    };\n    const filter = subset.where ? truth(subset.where) : { yes: true, exact: true };\n    // Load the entire leading-value tie on cursor requests. A local lastKey\n    // does not prove remote coverage for a composite ordering boundary.\n    const cursor = subset.cursor\n        ? truth(new IR.Func(\"or\", [subset.cursor.whereFrom, subset.cursor.whereCurrent]))\n        : undefined;\n    const orderBy: QueryOrder[] = [];\n    let ordered = true;\n    let homogeneousOrder = true;\n    for (const order of subset.orderBy ?? []) {\n        const v = value(order.expression);\n        const compare = order.compareOptions;\n        homogeneousOrder &&= !!v?.family && (compare.nulls === \"first\" || compare.nulls === \"last\");\n        if (\n            order.expression.type !== \"ref\" ||\n            !v ||\n            compare.stringSort === \"custom\" ||\n            (v.family === \"string\" && compare.stringSort !== \"lexical\")\n        ) {\n            ordered = false;\n            break;\n        }\n        orderBy.push({\n            expression: v.operand,\n            direction: compare.direction,\n            nulls: compare.nulls,\n        });\n    }\n    const bounded = filter.exact && ordered && !cursor;\n    const limit = bounded && subset.limit !== undefined ? subset.limit + (subset.offset ?? 0) : undefined;\n    const finalOrder = subset.orderBy?.at(-1)?.expression;\n    const finalPath = finalOrder?.type === \"ref\" ? IR.getPropRefPropertyPath(finalOrder) : [];\n    const finalValue = finalOrder && value(finalOrder);\n    // A finite prefix is independently complete only when the full comparison\n    // has known domains and a unique final key. This is schema evidence, never\n    // an inference from whichever rows happen to be cached.\n    const orderedWindowExact =\n        bounded &&\n        homogeneousOrder &&\n        subset.limit !== undefined &&\n        Number.isSafeInteger(subset.limit) &&\n        subset.limit >= 0 &&\n        limit !== undefined &&\n        Number.isSafeInteger(limit) &&\n        limit >= 0 &&\n        Number.isSafeInteger(subset.offset ?? 0) &&\n        (subset.offset ?? 0) >= 0 &&\n        finalPath.length === 1 &&\n        finalPath[0] === objects.get(objectType ?? \"\")?.primaryKey &&\n        !!finalValue &&\n        !finalValue.optional &&\n        (finalValue.family === \"string\" || finalValue.family === \"number\");\n    const subsetIR: Subset = {\n        where: predicate(combine(\"and\", [filter.yes, cursor?.yes ?? true])),\n        ...(ordered && orderBy.length ? { orderBy } : {}),\n        ...(limit !== undefined && Number.isSafeInteger(limit) ? { page: { limit } } : {}),\n    };\n    return {\n        subset: subsetIR,\n        exact: filter.exact && ordered && !cursor,\n        filterExact: filter.exact,\n        orderExact: ordered,\n        orderedWindowExact,\n    };\n}\n\n/** Raw Tables/transaction adapter. Only serializes nodes constructed by the analyzer above. */\nfunction storageScan(subset: Subset): Query {\n    const operand = (e: Expression): StorageOperand =>\n        e.kind === \"getAt\"\n            ? { _tag: \"Field\", path: e.value.path }\n            : ((e as Extract<Expression, { kind: \"literal\" }>).value.value as Scalar);\n    const predicate = (e: Expression): StoragePredicate => {\n        if (e.kind === \"and\" || e.kind === \"or\")\n            return { op: e.kind, predicates: e.value.expressions.map(predicate) };\n        if (e.kind === \"not\") return { op: \"not\", predicate: predicate(e.value.expression) };\n        if (e.kind === \"in\")\n            return {\n                op: \"in\",\n                left: operand(e.value.left),\n                values: (e.value.right as Extract<Expression, { kind: \"literal\" }>).value.value as Scalar[],\n            };\n        const binary = e as Extract<\n            Expression,\n            { kind: \"eq\" | \"ne\" | \"gt\" | \"gte\" | \"lt\" | \"lte\" | \"like\" | \"ilike\" | \"contains\" }\n        >;\n        return {\n            op: binary.kind,\n            left: operand(binary.value.left),\n            right: operand(binary.value.right),\n        } as StoragePredicate;\n    };\n    return {\n        where: subset.where ? predicate(subset.where) : undefined,\n        ...(subset.orderBy\n            ? {\n                  orderBy: subset.orderBy.map((o) => ({\n                      field: operand(o.expression) as Field,\n                      direction: o.direction,\n                      nulls: o.nulls,\n                  })),\n              }\n            : {}),\n        ...(subset.page?.limit !== undefined ? { limit: subset.page.limit } : {}),\n    };\n}\nexport function analyzeStorageSubset(subset: LoadSubsetOptions, ir?: OntologyIR, objectType?: string) {\n    const analysis = analyzeOntologySubset(subset, ir, objectType);\n    return { ...analysis, query: storageScan(analysis.subset) };\n}\nexport function storageSubset(subset: LoadSubsetOptions, ir?: OntologyIR, objectType?: string): Query {\n    return analyzeStorageSubset(subset, ir, objectType).query;\n}\nexport function ontologySubset(subset: LoadSubsetOptions, ir: OntologyIR, objectType: string): ObjectSubset {\n    return {\n        from: { source: { objectType }, binding: \"row\" },\n        ...analyzeOntologySubset(subset, ir, objectType).subset,\n    };\n}\n"],"mappings":"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"}

package/lib/testing/sqlite.d.ts

@@ -0,0 +1,40 @@
+import { SQLiteDatabase } from "./sqliteBackend.js";
+import { OntologyIR } from "@party-stack/ontology";
+//#region src/testing/sqlite.d.ts
+declare const conformanceIR: OntologyIR;
+declare function runSchemaCreation(database: SQLiteDatabase): Promise<void>;
+declare function runActionsAndContext(database: SQLiteDatabase): Promise<void>;
+declare function runHandlers(database: SQLiteDatabase): Promise<void>;
+declare function runInlineAttachments(database: SQLiteDatabase): Promise<void>;
+declare function runTransactionRollback(database: SQLiteDatabase): void;
+declare function runExternalAttachments(database: SQLiteDatabase): Promise<void>;
+export declare const sqliteOntologyConformanceCases: readonly [{
+  readonly id: "schema";
+  readonly name: "creates schemas idempotently";
+  readonly run: typeof runSchemaCreation;
+}, {
+  readonly id: "actions-context";
+  readonly name: "persists declarative actions with context.user";
+  readonly run: typeof runActionsAndContext;
+}, {
+  readonly id: "handlers";
+  readonly name: "runs registered mutators and query functions";
+  readonly run: typeof runHandlers;
+}, {
+  readonly id: "inline-attachments";
+  readonly name: "persists inline SQLite attachment bytes";
+  readonly run: typeof runInlineAttachments;
+}, {
+  readonly id: "transaction-rollback";
+  readonly name: "rolls back synchronous transactions";
+  readonly run: typeof runTransactionRollback;
+}, {
+  readonly id: "external-attachments";
+  readonly name: "uses injectable external attachment bytes safely";
+  readonly run: typeof runExternalAttachments;
+}];
+export type SQLiteOntologyConformanceCaseId = (typeof sqliteOntologyConformanceCases)[number]["id"];
+export declare function runSQLiteOntologyConformanceCase(id: SQLiteOntologyConformanceCaseId, database: SQLiteDatabase): Promise<void>;
+//#endregion
+export { conformanceIR as sqliteOntologyConformanceIR };
+//# sourceMappingURL=sqlite.d.ts.map

package/lib/testing/sqlite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite.d.ts","names":[],"sources":["../../src/testing/sqlite.ts"],"mappings":";;;cAiBM,eAAe;iBA0MN,kBAAkB,UAAU,iBAAiB;iBAe7C,qBAAqB,UAAU,iBAAiB;iBA+BhD,YAAY,UAAU,iBAAiB;iBAqCvC,qBAAqB,UAAU,iBAAiB;iBA+BtD,uBAAuB,UAAU;iBAsE3B,uBAAuB,UAAU,iBAAiB;qBAuFpD;WACP;WAAc;WAAsC,YAAG;;WAErD;WACA;WACA,YAAG;;WAGH;WACA;WACA,YAAG;;WAGH;WACA;WACA,YAAG;;WAGH;WACA;WACA,YAAG;;WAGH;WACA;WACA,YAAG;;YAIC,0CAA0C;wBAEhC,iCAClB,IAAI,iCACJ,UAAU,iBACX"}

package/lib/testing/sqlite.js

@@ -0,0 +1,409 @@
+import { makeSQLiteTestBackend } from "./sqliteBackend.js";
+import { Effect } from "effect";
+import { eq, queryOnce } from "@tanstack/db";
+import { collectByteBlob } from "@party-stack/ontology-storage/blobs";
+import { createLiveOntology, o } from "@party-stack/ontology";
+//#region src/testing/sqlite.ts
+const conformanceIR = {
+	types: [],
+	objectTypes: [{
+		name: "Note",
+		displayName: "Note",
+		pluralDisplayName: "Notes",
+		primaryKey: "id",
+		properties: [
+			{
+				name: "id",
+				displayName: "ID",
+				type: o.string({})
+			},
+			{
+				name: "title",
+				displayName: "Title",
+				type: o.string({})
+			},
+			{
+				name: "owner",
+				displayName: "Owner",
+				type: o.string({})
+			}
+		]
+	}, {
+		name: "Asset",
+		displayName: "Asset",
+		pluralDisplayName: "Assets",
+		primaryKey: "id",
+		properties: [{
+			name: "id",
+			displayName: "ID",
+			type: o.string({})
+		}, {
+			name: "attachment",
+			displayName: "Attachment",
+			type: o.attachment({})
+		}]
+	}],
+	linkTypes: [],
+	actionTypes: [
+		{
+			name: "createNote",
+			displayName: "Create note",
+			parameters: [
+				{
+					name: "id",
+					displayName: "ID",
+					type: o.string({})
+				},
+				{
+					name: "title",
+					displayName: "Title",
+					type: o.string({})
+				},
+				{
+					name: "owner",
+					displayName: "Owner",
+					type: o.string({}),
+					defaultValue: o.Expression.contextReference({ name: "user" })
+				}
+			],
+			logic: [o.ActionLogicStep.createObject({
+				objectType: "Note",
+				values: [
+					{
+						property: ["id"],
+						value: o.Expression.inputReference({ name: "id" })
+					},
+					{
+						property: ["title"],
+						value: o.Expression.inputReference({ name: "title" })
+					},
+					{
+						property: ["owner"],
+						value: o.Expression.inputReference({ name: "owner" })
+					}
+				]
+			})]
+		},
+		{
+			name: "renameNote",
+			displayName: "Rename note",
+			parameters: [{
+				name: "note",
+				displayName: "Note",
+				type: o.objectReference({ objectType: "Note" })
+			}, {
+				name: "title",
+				displayName: "Title",
+				type: o.string({})
+			}],
+			logic: []
+		},
+		{
+			name: "createAsset",
+			displayName: "Create asset",
+			parameters: [{
+				name: "id",
+				displayName: "ID",
+				type: o.string({})
+			}, {
+				name: "attachment",
+				displayName: "Attachment",
+				type: o.attachment({})
+			}],
+			logic: [o.ActionLogicStep.createObject({
+				objectType: "Asset",
+				values: [{
+					property: ["id"],
+					value: o.Expression.inputReference({ name: "id" })
+				}, {
+					property: ["attachment"],
+					value: o.Expression.inputReference({ name: "attachment" })
+				}]
+			})]
+		}
+	],
+	queryFunctionTypes: [{
+		name: "noteTitle",
+		displayName: "Note title",
+		parameters: [{
+			name: "note",
+			displayName: "Note",
+			type: o.objectReference({ objectType: "Note" })
+		}],
+		returnType: o.string({})
+	}, {
+		name: "currentUser",
+		displayName: "Current user",
+		parameters: [],
+		returnType: o.string({})
+	}]
+};
+function assert(condition, message) {
+	if (!condition) throw new Error(message);
+}
+function assertEqual(actual, expected, message) {
+	if (JSON.stringify(actual) !== JSON.stringify(expected)) throw new Error(`${message} Expected ${JSON.stringify(expected)}, received ${JSON.stringify(actual)}.`);
+}
+async function readObject(collection, id) {
+	return (await queryOnce((query) => query.from({ object: collection }).where(({ object }) => eq(object.id, id)).select(({ object }) => object)))[0];
+}
+const mutators = { renameNote: async ({ tx, args }) => {
+	await tx.mutate.Note.update(args.note, { title: args.title });
+} };
+const queryFunctions = {
+	noteTitle: async ({ tx, args }) => {
+		return (await tx.query((query, objects) => query.from({ note: objects.Note }).where(({ note }) => eq(note.id, args.note)).select(({ note }) => ({ title: note.title })).findOne()))?.title;
+	},
+	currentUser: ({ context }) => context.user
+};
+async function runSchemaCreation(database) {
+	const open = (name) => Effect.runPromise(Effect.scoped(makeSQLiteTestBackend({
+		ir: conformanceIR,
+		database,
+		name,
+		context: {}
+	})));
+	await open("sqlite");
+	await open("sqlite");
+	assert(database.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get("party_tables_rows"), "Native Tables rows were not created.");
+}
+async function runActionsAndContext(database) {
+	const ontology = await createLiveOntology({
+		ir: conformanceIR,
+		backend: makeSQLiteTestBackend({
+			ir: conformanceIR,
+			database,
+			name: "sqlite",
+			context: { user: "alice" }
+		}),
+		context: { user: "alice" }
+	});
+	try {
+		await ontology.actions.createNote({
+			id: "note-1",
+			title: "Hello"
+		});
+		const note = await readObject(ontology.objects.Note, "note-1");
+		assertEqual(note && {
+			id: note.id,
+			title: note.title,
+			owner: note.owner
+		}, {
+			id: "note-1",
+			title: "Hello",
+			owner: "alice"
+		}, "Declarative action or context.user failed.");
+	} finally {
+		await ontology.cleanup();
+	}
+}
+async function runHandlers(database) {
+	const ontology = await createLiveOntology({
+		ir: conformanceIR,
+		backend: makeSQLiteTestBackend({
+			ir: conformanceIR,
+			database,
+			name: "sqlite",
+			mutators,
+			queryFunctions,
+			context: { user: "alice" }
+		}),
+		context: { user: "alice" }
+	});
+	try {
+		await ontology.actions.createNote({
+			id: "note-1",
+			title: "Before"
+		});
+		await ontology.actions.renameNote({
+			note: "note-1",
+			title: "After"
+		});
+		assertEqual(await ontology.queryFunctions.noteTitle({ note: "note-1" }), "After", "Registered mutator or query function failed.");
+		assertEqual(await ontology.queryFunctions.currentUser({}), "alice", "Query function did not receive context.user.");
+	} finally {
+		await ontology.cleanup();
+	}
+}
+async function runInlineAttachments(database) {
+	const ontology = await createLiveOntology({
+		ir: conformanceIR,
+		backend: makeSQLiteTestBackend({
+			ir: conformanceIR,
+			database,
+			name: "sqlite"
+		})
+	});
+	try {
+		const created = await ontology.attachments.create(new Blob(["inline"], { type: "text/plain" }), { target: {
+			kind: "objectProperty",
+			objectType: "Asset",
+			property: "attachment"
+		} });
+		await ontology.actions.createAsset({
+			id: "asset-1",
+			attachment: created.attachment
+		});
+		assertEqual(await (await ontology.attachments.blob(created.attachment)).text(), "inline", "Inline attachment bytes were not persisted.");
+	} finally {
+		await ontology.cleanup();
+	}
+}
+function runTransactionRollback(database) {
+	database.exec(`CREATE TABLE rollback_test (id TEXT PRIMARY KEY)`);
+	try {
+		database.transaction(() => {
+			database.prepare(`INSERT INTO rollback_test (id) VALUES (?)`).run("rolled-back");
+			throw new Error("intentional rollback");
+		})();
+	} catch {}
+	assertEqual(database.prepare(`SELECT id FROM rollback_test`).all(), [], "Synchronous transaction did not roll back.");
+}
+var MemoryAttachmentBytesStore = class {
+	blobs = /* @__PURE__ */ new Map();
+	async write(id, input) {
+		this.blobs.set(id, await Effect.runPromise(collectByteBlob(input)));
+	}
+	read(id) {
+		const blob = this.blobs.get(id);
+		return blob ? Promise.resolve(blob) : Promise.reject(/* @__PURE__ */ new Error(`Missing external bytes "${id}".`));
+	}
+	delete(id) {
+		this.blobs.delete(id);
+		return Promise.resolve();
+	}
+};
+var DelayedAttachmentBytesStore = class extends MemoryAttachmentBytesStore {
+	releaseWrite;
+	writeGate;
+	markStarted;
+	writeStarted;
+	deleteCalls = 0;
+	constructor() {
+		super();
+		let started;
+		this.writeStarted = new Promise((resolve) => {
+			started = resolve;
+		});
+		this.writeGate = new Promise((resolve) => {
+			this.releaseWrite = resolve;
+		});
+		this.markStarted = started;
+	}
+	async write(id, blob) {
+		this.markStarted();
+		await this.writeGate;
+		await super.write(id, blob);
+	}
+	delete(id) {
+		this.deleteCalls++;
+		return super.delete(id);
+	}
+	release() {
+		this.releaseWrite();
+	}
+};
+async function runExternalAttachments(database) {
+	const storage = { external: { bytes: new MemoryAttachmentBytesStore() } };
+	const ontology = await createLiveOntology({
+		ir: conformanceIR,
+		backend: makeSQLiteTestBackend({
+			ir: conformanceIR,
+			database,
+			name: "sqlite",
+			attachmentStorage: storage
+		})
+	});
+	try {
+		const created = await ontology.attachments.create(new Blob(["external"], { type: "text/plain" }), { target: {
+			kind: "objectProperty",
+			objectType: "Asset",
+			property: "attachment"
+		} });
+		await ontology.actions.createAsset({
+			id: "external-asset",
+			attachment: created.attachment
+		});
+		assertEqual(await (await ontology.attachments.blob(created.attachment)).text(), "external", "External authoritative bytes were not readable.");
+	} finally {
+		await ontology.cleanup();
+	}
+	const delayedBytes = new DelayedAttachmentBytesStore();
+	const delayed = await createLiveOntology({
+		ir: conformanceIR,
+		backend: makeSQLiteTestBackend({
+			ir: conformanceIR,
+			database,
+			name: "sqlite",
+			attachmentStorage: { external: { bytes: delayedBytes } }
+		})
+	});
+	try {
+		const created = await delayed.attachments.create(new Blob(["delayed"], { type: "text/plain" }), { target: {
+			kind: "objectProperty",
+			objectType: "Asset",
+			property: "attachment"
+		} });
+		const action = delayed.actions.createAsset({
+			id: "delayed-asset",
+			attachment: created.attachment
+		});
+		action.catch(() => void 0);
+		await delayedBytes.writeStarted;
+		assertEqual(await Effect.runPromise(Effect.scoped(Effect.gen(function* () {
+			return yield* (yield* makeSQLiteTestBackend({
+				ir: conformanceIR,
+				database,
+				name: "sqlite",
+				attachmentStorage: { external: { bytes: delayedBytes } }
+			})).collectGarbage({ orphanGraceMs: 0 });
+		}))), 0, "Collector claimed an active upload.");
+		delayedBytes.release();
+		await action;
+		assertEqual(delayedBytes.deleteCalls, 0, "Collector deleted an active upload.");
+	} finally {
+		delayedBytes.release();
+		await delayed.cleanup();
+	}
+}
+const sqliteOntologyConformanceCases = [
+	{
+		id: "schema",
+		name: "creates schemas idempotently",
+		run: runSchemaCreation
+	},
+	{
+		id: "actions-context",
+		name: "persists declarative actions with context.user",
+		run: runActionsAndContext
+	},
+	{
+		id: "handlers",
+		name: "runs registered mutators and query functions",
+		run: runHandlers
+	},
+	{
+		id: "inline-attachments",
+		name: "persists inline SQLite attachment bytes",
+		run: runInlineAttachments
+	},
+	{
+		id: "transaction-rollback",
+		name: "rolls back synchronous transactions",
+		run: runTransactionRollback
+	},
+	{
+		id: "external-attachments",
+		name: "uses injectable external attachment bytes safely",
+		run: runExternalAttachments
+	}
+];
+async function runSQLiteOntologyConformanceCase(id, database) {
+	const test = sqliteOntologyConformanceCases.find((candidate) => candidate.id === id);
+	assert(test, `Unknown SQLite ontology conformance case "${id}".`);
+	await test.run(database);
+}
+//#endregion
+export { runSQLiteOntologyConformanceCase, sqliteOntologyConformanceCases, conformanceIR as sqliteOntologyConformanceIR };
+
+//# sourceMappingURL=sqlite.js.map

package/lib/testing/sqlite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite.js","names":[],"sources":["../../src/testing/sqlite.ts"],"sourcesContent":["import {\n    createLiveOntology,\n    o,\n    type OntologyIR,\n    type OntologyMutatorRegistry,\n    type OntologyQueryFunctionRegistry,\n} from \"@party-stack/ontology\";\nimport { collectByteBlob, type ByteInput } from \"@party-stack/ontology-storage/blobs\";\nimport { eq, queryOnce, type Collection } from \"@tanstack/db\";\nimport { Effect } from \"effect\";\nimport {\n    makeSQLiteTestBackend,\n    type SQLiteAttachmentBytesStore,\n    type SQLiteAttachmentStorageOptions,\n    type SQLiteDatabase,\n} from \"./sqliteBackend.js\";\n\nconst conformanceIR: OntologyIR = {\n    types: [],\n    objectTypes: [\n        {\n            name: \"Note\",\n            displayName: \"Note\",\n            pluralDisplayName: \"Notes\",\n            primaryKey: \"id\",\n            properties: [\n                { name: \"id\", displayName: \"ID\", type: o.string({}) },\n                {\n                    name: \"title\",\n                    displayName: \"Title\",\n                    type: o.string({}),\n                },\n                {\n                    name: \"owner\",\n                    displayName: \"Owner\",\n                    type: o.string({}),\n                },\n            ],\n        },\n        {\n            name: \"Asset\",\n            displayName: \"Asset\",\n            pluralDisplayName: \"Assets\",\n            primaryKey: \"id\",\n            properties: [\n                { name: \"id\", displayName: \"ID\", type: o.string({}) },\n                {\n                    name: \"attachment\",\n                    displayName: \"Attachment\",\n                    type: o.attachment({}),\n                },\n            ],\n        },\n    ],\n    linkTypes: [],\n    actionTypes: [\n        {\n            name: \"createNote\",\n            displayName: \"Create note\",\n            parameters: [\n                { name: \"id\", displayName: \"ID\", type: o.string({}) },\n                {\n                    name: \"title\",\n                    displayName: \"Title\",\n                    type: o.string({}),\n                },\n                {\n                    name: \"owner\",\n                    displayName: \"Owner\",\n                    type: o.string({}),\n                    defaultValue: o.Expression.contextReference({\n                        name: \"user\",\n                    }),\n                },\n            ],\n            logic: [\n                o.ActionLogicStep.createObject({\n                    objectType: \"Note\",\n                    values: [\n                        {\n                            property: [\"id\"],\n                            value: o.Expression.inputReference({\n                                name: \"id\",\n                            }),\n                        },\n                        {\n                            property: [\"title\"],\n                            value: o.Expression.inputReference({\n                                name: \"title\",\n                            }),\n                        },\n                        {\n                            property: [\"owner\"],\n                            value: o.Expression.inputReference({\n                                name: \"owner\",\n                            }),\n                        },\n                    ],\n                }),\n            ],\n        },\n        {\n            name: \"renameNote\",\n            displayName: \"Rename note\",\n            parameters: [\n                {\n                    name: \"note\",\n                    displayName: \"Note\",\n                    type: o.objectReference({ objectType: \"Note\" }),\n                },\n                {\n                    name: \"title\",\n                    displayName: \"Title\",\n                    type: o.string({}),\n                },\n            ],\n            logic: [],\n        },\n        {\n            name: \"createAsset\",\n            displayName: \"Create asset\",\n            parameters: [\n                { name: \"id\", displayName: \"ID\", type: o.string({}) },\n                {\n                    name: \"attachment\",\n                    displayName: \"Attachment\",\n                    type: o.attachment({}),\n                },\n            ],\n            logic: [\n                o.ActionLogicStep.createObject({\n                    objectType: \"Asset\",\n                    values: [\n                        {\n                            property: [\"id\"],\n                            value: o.Expression.inputReference({\n                                name: \"id\",\n                            }),\n                        },\n                        {\n                            property: [\"attachment\"],\n                            value: o.Expression.inputReference({\n                                name: \"attachment\",\n                            }),\n                        },\n                    ],\n                }),\n            ],\n        },\n    ],\n    queryFunctionTypes: [\n        {\n            name: \"noteTitle\",\n            displayName: \"Note title\",\n            parameters: [\n                {\n                    name: \"note\",\n                    displayName: \"Note\",\n                    type: o.objectReference({ objectType: \"Note\" }),\n                },\n            ],\n            returnType: o.string({}),\n        },\n        {\n            name: \"currentUser\",\n            displayName: \"Current user\",\n            parameters: [],\n            returnType: o.string({}),\n        },\n    ],\n};\n\nfunction assert(condition: unknown, message: string): asserts condition {\n    if (!condition) throw new Error(message);\n}\n\nfunction assertEqual(actual: unknown, expected: unknown, message: string): void {\n    if (JSON.stringify(actual) !== JSON.stringify(expected)) {\n        throw new Error(\n            `${message} Expected ${JSON.stringify(expected)}, received ${JSON.stringify(actual)}.`\n        );\n    }\n}\n\nasync function readObject(\n    collection: Collection<Record<string, unknown>>,\n    id: string\n): Promise<Record<string, unknown> | undefined> {\n    const rows = await queryOnce((query) =>\n        query\n            .from({ object: collection })\n            .where(({ object }) => eq(object.id, id))\n            .select(({ object }) => object)\n    );\n    return rows[0];\n}\n\nconst mutators = {\n    renameNote: async ({ tx, args }) => {\n        await tx.mutate.Note!.update(args.note as string, {\n            title: args.title,\n        });\n    },\n} satisfies OntologyMutatorRegistry;\n\nconst queryFunctions = {\n    noteTitle: async ({ tx, args }) => {\n        const note = await tx.query<{ title: unknown } | undefined>((query, objects) =>\n            query\n                .from({ note: objects.Note! })\n                .where(({ note }) => eq(note.id, args.note))\n                .select(({ note }) => ({ title: note.title }))\n                .findOne()\n        );\n        return note?.title;\n    },\n    currentUser: ({ context }) => context.user,\n} satisfies OntologyQueryFunctionRegistry;\n\nasync function runSchemaCreation(database: SQLiteDatabase): Promise<void> {\n    const open = (name: string) =>\n        Effect.runPromise(\n            Effect.scoped(makeSQLiteTestBackend({ ir: conformanceIR, database, name, context: {} }))\n        );\n    await open(\"sqlite\");\n    await open(\"sqlite\");\n    assert(\n        database\n            .prepare(\"SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?\")\n            .get(\"party_tables_rows\"),\n        \"Native Tables rows were not created.\"\n    );\n}\n\nasync function runActionsAndContext(database: SQLiteDatabase): Promise<void> {\n    const ontology = await createLiveOntology({\n        ir: conformanceIR,\n        backend: makeSQLiteTestBackend({\n            ir: conformanceIR,\n            database,\n            name: \"sqlite\",\n            context: { user: \"alice\" },\n        }),\n        context: { user: \"alice\" },\n    });\n    try {\n        await ontology.actions.createNote!({\n            id: \"note-1\",\n            title: \"Hello\",\n        });\n        const note = await readObject(ontology.objects.Note!, \"note-1\");\n        assertEqual(\n            note && {\n                id: note.id,\n                title: note.title,\n                owner: note.owner,\n            },\n            { id: \"note-1\", title: \"Hello\", owner: \"alice\" },\n            \"Declarative action or context.user failed.\"\n        );\n    } finally {\n        await ontology.cleanup();\n    }\n}\n\nasync function runHandlers(database: SQLiteDatabase): Promise<void> {\n    const ontology = await createLiveOntology({\n        ir: conformanceIR,\n        backend: makeSQLiteTestBackend({\n            ir: conformanceIR,\n            database,\n            name: \"sqlite\",\n            mutators,\n            queryFunctions,\n            context: { user: \"alice\" },\n        }),\n        context: { user: \"alice\" },\n    });\n    try {\n        await ontology.actions.createNote!({\n            id: \"note-1\",\n            title: \"Before\",\n        });\n        await ontology.actions.renameNote!({\n            note: \"note-1\",\n            title: \"After\",\n        });\n        assertEqual(\n            await ontology.queryFunctions.noteTitle!({ note: \"note-1\" }),\n            \"After\",\n            \"Registered mutator or query function failed.\"\n        );\n        assertEqual(\n            await ontology.queryFunctions.currentUser!({}),\n            \"alice\",\n            \"Query function did not receive context.user.\"\n        );\n    } finally {\n        await ontology.cleanup();\n    }\n}\n\nasync function runInlineAttachments(database: SQLiteDatabase): Promise<void> {\n    const ontology = await createLiveOntology({\n        ir: conformanceIR,\n        backend: makeSQLiteTestBackend({\n            ir: conformanceIR,\n            database,\n            name: \"sqlite\",\n        }),\n    });\n    try {\n        const created = await ontology.attachments.create(new Blob([\"inline\"], { type: \"text/plain\" }), {\n            target: {\n                kind: \"objectProperty\",\n                objectType: \"Asset\",\n                property: \"attachment\",\n            },\n        });\n        await ontology.actions.createAsset!({\n            id: \"asset-1\",\n            attachment: created.attachment,\n        });\n        assertEqual(\n            await (await ontology.attachments.blob(created.attachment)).text(),\n            \"inline\",\n            \"Inline attachment bytes were not persisted.\"\n        );\n    } finally {\n        await ontology.cleanup();\n    }\n}\n\nfunction runTransactionRollback(database: SQLiteDatabase): void {\n    database.exec(`CREATE TABLE rollback_test (id TEXT PRIMARY KEY)`);\n    try {\n        database.transaction(() => {\n            database.prepare(`INSERT INTO rollback_test (id) VALUES (?)`).run(\"rolled-back\");\n            throw new Error(\"intentional rollback\");\n        })();\n    } catch {\n        // Expected.\n    }\n    assertEqual(\n        database.prepare(`SELECT id FROM rollback_test`).all(),\n        [],\n        \"Synchronous transaction did not roll back.\"\n    );\n}\n\nclass MemoryAttachmentBytesStore implements SQLiteAttachmentBytesStore {\n    readonly blobs = new Map<string, Blob>();\n\n    async write(id: string, input: ByteInput): Promise<void> {\n        this.blobs.set(id, await Effect.runPromise(collectByteBlob(input)));\n    }\n\n    read(id: string): Promise<Blob> {\n        const blob = this.blobs.get(id);\n        return blob ? Promise.resolve(blob) : Promise.reject(new Error(`Missing external bytes \"${id}\".`));\n    }\n\n    delete(id: string): Promise<void> {\n        this.blobs.delete(id);\n        return Promise.resolve();\n    }\n}\n\nclass DelayedAttachmentBytesStore extends MemoryAttachmentBytesStore {\n    private releaseWrite!: () => void;\n    private readonly writeGate: Promise<void>;\n    private readonly markStarted: () => void;\n    readonly writeStarted: Promise<void>;\n    deleteCalls = 0;\n\n    constructor() {\n        super();\n        let started!: () => void;\n        this.writeStarted = new Promise<void>((resolve) => {\n            started = resolve;\n        });\n        this.writeGate = new Promise<void>((resolve) => {\n            this.releaseWrite = resolve;\n        });\n        this.markStarted = started;\n    }\n\n    override async write(id: string, blob: ByteInput): Promise<void> {\n        this.markStarted();\n        await this.writeGate;\n        await super.write(id, blob);\n    }\n\n    override delete(id: string): Promise<void> {\n        this.deleteCalls++;\n        return super.delete(id);\n    }\n\n    release(): void {\n        this.releaseWrite();\n    }\n}\n\nasync function runExternalAttachments(database: SQLiteDatabase): Promise<void> {\n    const bytes = new MemoryAttachmentBytesStore();\n    const storage = {\n        external: { bytes },\n    } satisfies SQLiteAttachmentStorageOptions;\n    const ontology = await createLiveOntology({\n        ir: conformanceIR,\n        backend: makeSQLiteTestBackend({\n            ir: conformanceIR,\n            database,\n            name: \"sqlite\",\n            attachmentStorage: storage,\n        }),\n    });\n    try {\n        const created = await ontology.attachments.create(new Blob([\"external\"], { type: \"text/plain\" }), {\n            target: {\n                kind: \"objectProperty\",\n                objectType: \"Asset\",\n                property: \"attachment\",\n            },\n        });\n        await ontology.actions.createAsset!({\n            id: \"external-asset\",\n            attachment: created.attachment,\n        });\n        assertEqual(\n            await (await ontology.attachments.blob(created.attachment)).text(),\n            \"external\",\n            \"External authoritative bytes were not readable.\"\n        );\n    } finally {\n        await ontology.cleanup();\n    }\n\n    const delayedBytes = new DelayedAttachmentBytesStore();\n    const delayed = await createLiveOntology({\n        ir: conformanceIR,\n        backend: makeSQLiteTestBackend({\n            ir: conformanceIR,\n            database,\n            name: \"sqlite\",\n            attachmentStorage: {\n                external: { bytes: delayedBytes },\n            },\n        }),\n    });\n    try {\n        const created = await delayed.attachments.create(new Blob([\"delayed\"], { type: \"text/plain\" }), {\n            target: {\n                kind: \"objectProperty\",\n                objectType: \"Asset\",\n                property: \"attachment\",\n            },\n        });\n        const action = delayed.actions.createAsset!({\n            id: \"delayed-asset\",\n            attachment: created.attachment,\n        });\n        void action.catch(() => undefined);\n        await delayedBytes.writeStarted;\n        assertEqual(\n            await Effect.runPromise(\n                Effect.scoped(\n                    Effect.gen(function* () {\n                        const backend = yield* makeSQLiteTestBackend({\n                            ir: conformanceIR,\n                            database,\n                            name: \"sqlite\",\n                            attachmentStorage: { external: { bytes: delayedBytes } },\n                        });\n                        return yield* backend.collectGarbage({ orphanGraceMs: 0 });\n                    })\n                )\n            ),\n            0,\n            \"Collector claimed an active upload.\"\n        );\n        delayedBytes.release();\n        await action;\n        assertEqual(delayedBytes.deleteCalls, 0, \"Collector deleted an active upload.\");\n    } finally {\n        delayedBytes.release();\n        await delayed.cleanup();\n    }\n}\n\nexport const sqliteOntologyConformanceCases = [\n    { id: \"schema\", name: \"creates schemas idempotently\", run: runSchemaCreation },\n    {\n        id: \"actions-context\",\n        name: \"persists declarative actions with context.user\",\n        run: runActionsAndContext,\n    },\n    {\n        id: \"handlers\",\n        name: \"runs registered mutators and query functions\",\n        run: runHandlers,\n    },\n    {\n        id: \"inline-attachments\",\n        name: \"persists inline SQLite attachment bytes\",\n        run: runInlineAttachments,\n    },\n    {\n        id: \"transaction-rollback\",\n        name: \"rolls back synchronous transactions\",\n        run: runTransactionRollback,\n    },\n    {\n        id: \"external-attachments\",\n        name: \"uses injectable external attachment bytes safely\",\n        run: runExternalAttachments,\n    },\n] as const;\n\nexport type SQLiteOntologyConformanceCaseId = (typeof sqliteOntologyConformanceCases)[number][\"id\"];\n\nexport async function runSQLiteOntologyConformanceCase(\n    id: SQLiteOntologyConformanceCaseId,\n    database: SQLiteDatabase\n): Promise<void> {\n    const test = sqliteOntologyConformanceCases.find((candidate) => candidate.id === id);\n    assert(test, `Unknown SQLite ontology conformance case \"${id}\".`);\n    await test.run(database);\n}\n\nexport { conformanceIR as sqliteOntologyConformanceIR };\n"],"mappings":"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"}

package/lib/testing/sqliteBackend.d.ts

@@ -0,0 +1,68 @@
+import { StorageOntologyBackendOptions } from "../live/storageBackend.js";
+import { BackendError } from "@party-stack/ontology-backend";
+import { Effect } from "effect";
+import { ByteInput } from "@party-stack/ontology-storage/blobs";
+import * as SQLite from "@party-stack/sql-ontology-storage/sqlite";
+//#region src/testing/sqliteBackend.d.ts
+export interface SQLiteDatabase extends SQLite.SQLiteDatabase {
+  prepare(sql: string): SQLite.SQLiteStatement & {
+    get(...parameters: unknown[]): unknown;
+  };
+  transaction(body: () => void): () => void;
+}
+export interface SQLiteAttachmentBytesStore {
+  write(id: string, blob: ByteInput, signal?: AbortSignal): Promise<void>;
+  read(id: string): Promise<ByteInput | undefined>;
+  delete(id: string): Promise<void>;
+}
+export interface SQLiteAttachmentStorageOptions {
+  external?: {
+    bytes: SQLiteAttachmentBytesStore;
+  };
+}
+type Options = Omit<StorageOntologyBackendOptions, "namespace" | "tables" | "blobs"> & {
+  database: SQLiteDatabase;
+  name?: string;
+  attachmentStorage?: SQLiteAttachmentStorageOptions;
+};
+export declare const makeSQLiteTestBackend: (options: Options) => Effect.Effect<{
+  name: string;
+  sourceId: string;
+  supportsIdempotency: boolean;
+  loadSubset: (subset: import("@party-stack/ontology-spec/query").ObjectSubset) => Effect.Effect<import("@party-stack/ontology-backend").BackendSnapshot, BackendError>;
+  subscribeSelection?: (selection: import("@party-stack/ontology-backend").ObjectSelection, policy?: import("@party-stack/ontology-backend/delivery").DeliveryPolicy, resume?: import("@party-stack/ontology-backend/delivery").DeliveryPosition) => Effect.Effect<import("@party-stack/ontology-backend/delivery").DeliverySubscription, BackendError, import("effect/Scope").Scope>;
+  acknowledgeDelivery?: (position: import("@party-stack/ontology-backend/delivery").DeliveryPosition) => Effect.Effect<void, BackendError>;
+  watchSubset?: (subset: import("@party-stack/ontology-spec/query").ObjectSubset) => Effect.Effect<import("effect/Stream").Stream<import("@party-stack/ontology-backend").SubsetWatchEvent, BackendError>, BackendError, import("effect/Scope").Scope> | undefined;
+  refresh?: (subset: import("@party-stack/ontology-spec/query").ObjectSubset) => {
+    readonly pollIntervalMs?: number | false;
+    readonly maxCoverageAgeMs?: number;
+  } | undefined;
+  validateAction?: (name: string, parameters: Record<string, unknown>, options?: {
+    readonly knownParameters?: readonly string[];
+  }) => Effect.Effect<import("@party-stack/ontology-backend").ValidationReport, BackendError>;
+  queryFunction: (name: string, parameters: Record<string, unknown>) => Effect.Effect<unknown, BackendError>;
+  changes?: {
+    readonly pull: (options: {
+      readonly cursor?: string;
+      readonly limit?: number;
+    }) => Effect.Effect<import("@party-stack/ontology-backend").BackendChangePage, BackendError>;
+    readonly watch?: Effect.Effect<import("effect/Stream").Stream<void, BackendError>, BackendError, import("effect/Scope").Scope>;
+  };
+  attachments?: import("@party-stack/ontology-backend").BackendAttachments;
+  encrypted?: import("@party-stack/ontology-backend").BackendEncryptedValues;
+  storage: import("@party-stack/ontology-backend/owned").OwnedStorageService;
+  maintenance: Effect.Effect<void, BackendError<"Conflict" | "Forbidden" | "HistoryExpired" | "Internal" | "InvalidConfiguration" | "InvalidRequest" | "InvalidResponse" | "NotFound" | "NotImplemented" | "RateLimited" | "ResultExpired" | "SchemaMismatch" | "SessionExpired" | "SessionReplaced" | "SourceMismatch" | "Unauthenticated" | "Unavailable" | "ValidationFailed" | "ViewReplaced">, never>;
+  query: (document: import("@party-stack/ontology-spec").QueryDocument, options?: {
+    readonly inputs?: Record<string, unknown>;
+  }) => Effect.Effect<Record<string, unknown>, BackendError>;
+  applyAction: (invocation: import("@party-stack/ontology-backend").ActionRequest) => Effect.Effect<import("@party-stack/ontology-backend").ActionReceipt, BackendError<"Conflict" | "Forbidden" | "HistoryExpired" | "Internal" | "InvalidConfiguration" | "InvalidRequest" | "InvalidResponse" | "NotFound" | "NotImplemented" | "RateLimited" | "ResultExpired" | "SchemaMismatch" | "SessionExpired" | "SessionReplaced" | "SourceMismatch" | "Unauthenticated" | "Unavailable" | "ValidationFailed" | "ViewReplaced">, never>;
+  blobs: import("@party-stack/ontology-storage/blobs").BlobStorageService;
+  resolveActionParameters: (name: string, parameters: Record<string, unknown>) => Effect.Effect<Record<string, unknown>, BackendError<any>, never>;
+  collectGarbage: (options?: {
+    readonly orphanGraceMs?: number;
+    readonly limit?: number;
+  }) => Effect.Effect<number, BackendError<"Conflict" | "Forbidden" | "HistoryExpired" | "Internal" | "InvalidConfiguration" | "InvalidRequest" | "InvalidResponse" | "NotFound" | "NotImplemented" | "RateLimited" | "ResultExpired" | "SchemaMismatch" | "SessionExpired" | "SessionReplaced" | "SourceMismatch" | "Unauthenticated" | "Unavailable" | "ValidationFailed" | "ViewReplaced">, never>;
+}, BackendError<"Conflict" | "Forbidden" | "HistoryExpired" | "Internal" | "InvalidConfiguration" | "InvalidRequest" | "InvalidResponse" | "NotFound" | "NotImplemented" | "RateLimited" | "ResultExpired" | "SchemaMismatch" | "SessionExpired" | "SessionReplaced" | "SourceMismatch" | "Unauthenticated" | "Unavailable" | "ValidationFailed" | "ViewReplaced">, import("effect/Scope").Scope>;
+//#endregion
+export {};
+//# sourceMappingURL=sqliteBackend.d.ts.map

package/lib/testing/sqliteBackend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqliteBackend.d.ts","names":[],"sources":["../../src/testing/sqliteBackend.ts"],"mappings":";;;;;;iBAKiB,uBAAuB,OAAO;EAC3C,QAAQ,cAAc,OAAO;IAAoB,OAAO;;EACxD,YAAY;;iBAEC;EACb,MAAM,YAAY,MAAM,WAAW,SAAS,cAAc;EAC1D,KAAK,aAAa,QAAQ;EAC1B,OAAO,aAAa;;iBAEP;EACb;IAAa,OAAO;;;KAEnB,UAAU,KAAK;EAChB,UAAU;EACV;EACA,oBAAoB;;qBAEX,wBAAqB,SAAA,YAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BjC,wXAAA"}