@earendil-works/chord 1.4.0 → 1.5.1

package/dist/store/expression.js

@@ -0,0 +1,268 @@
+// The table expression language (slice 6a §6, §7; rules 10, 13, 14, 16; decision "Nullable columns and the `set`
+// form"): the builders plugins write `where` and `set` with, and their compilation at staging into one data-only
+// vocabulary (what the outbox and archives carry; `evaluate.ts` runs it in JavaScript, `sql.ts` renders it).
+import { invalid } from "../data/internal.js";
+import { checkScalar, encodeCell } from "./rows.js";
+/** A value expression as a plugin builds it: `T` is its value, `K` its column type. Compiled when staged. */
+export class Expression {
+    op;
+    args;
+    constructor(op, args) {
+        this.op = op;
+        this.args = args;
+    }
+}
+/** A reference to a column of the row, as `(t) => …` callbacks get them. */
+export class ColumnRef extends Expression {
+    column;
+    constructor(column) {
+        super("col", [column]);
+        this.column = column;
+    }
+}
+/** A condition as a plugin builds it; compiled when staged or run. */
+export class Condition {
+    op;
+    args;
+    constructor(op, args) {
+        this.op = op;
+        this.args = args;
+    }
+}
+/** The column equals `value` (`NULL` never matches). */
+export function eq(column, value) {
+    return new Condition("eq", [column, value]);
+}
+/** The column differs from `value` (`NULL` never matches). */
+export function ne(column, value) {
+    return new Condition("ne", [column, value]);
+}
+/** The column is below `value`. */
+export function lt(column, value) {
+    return new Condition("lt", [column, value]);
+}
+/** The column is at most `value`. */
+export function lte(column, value) {
+    return new Condition("lte", [column, value]);
+}
+/** The column is above `value`. */
+export function gt(column, value) {
+    return new Condition("gt", [column, value]);
+}
+/** The column is at least `value`. */
+export function gte(column, value) {
+    return new Condition("gte", [column, value]);
+}
+/** The column equals one of `values` (`[]` matches nothing). */
+export function inArray(column, values) {
+    return new Condition("inArray", [column, values]);
+}
+/** The column is `NULL` (an `opt(...)` column without a value). */
+export function isNull(column) {
+    return new Condition("isNull", [column]);
+}
+/** The text column starts with `prefix`, compared by code point (`""` matches every value). */
+export function prefix(column, prefix) {
+    return new Condition("prefix", [column, prefix]);
+}
+/** Every condition holds (`and()` always does). */
+export function and(...conditions) {
+    return new Condition("and", conditions);
+}
+/** Some condition holds (`or()` never does). */
+export function or(...conditions) {
+    return new Condition("or", conditions);
+}
+/** The condition does not hold (`NULL` stays `NULL`: it never matches). */
+export function not(condition) {
+    return new Condition("not", [condition]);
+}
+/** `a + b` over integers; a result outside ±(2^53 - 1) fails (rule 10). */
+export function add(a, b) {
+    return new Expression("add", [a, b]);
+}
+/** `a - b` over integers; a result outside ±(2^53 - 1) fails (rule 10). */
+export function sub(a, b) {
+    return new Expression("sub", [a, b]);
+}
+/** The larger of `a` and b` (`int` or `num`). */
+export function max(a, b) {
+    return new Expression("max", [a, b]);
+}
+/** The smaller of `a` and `b` (`int` or `num`). */
+export function min(a, b) {
+    return new Expression("min", [a, b]);
+}
+/** `a` followed by `b`. */
+export function concat(a, b) {
+    return new Expression("concat", [a, b]);
+}
+/** `value` with its prefix `from` replaced by `to`; a value without the prefix stays as it is. */
+export function replacePrefix(value, from, to) {
+    return new Expression("replacePrefix", [value, from, to]);
+}
+/** `a` unless it is `NULL`, else `b`. */
+export function coalesce(a, b) {
+    return new Expression("coalesce", [a, b]);
+}
+/** `a` where `condition` holds for the row, else `b`. */
+export function when(condition, a, b) {
+    return new Expression("when", [condition, a, b]);
+}
+/** One `ColumnRef` per column of `definition`, for its `(t) => …` callbacks. */
+export function columnRefs(columns) {
+    return Object.fromEntries(columns.map(({ name }) => [name, new ColumnRef(name)]));
+}
+/**
+ * Compiles a plugin's condition over `table`'s columns (a trust boundary: plugin values): known scalar columns,
+ * operands of their type made storable (`invalid/args` otherwise, `undefined` included: ask with `isNull`, rule 16).
+ */
+export function compileWhere(table, condition, what) {
+    if (!(condition instanceof Condition))
+        throw invalid("args", `${table.name}: ${what}: expected a condition`);
+    const { op, args } = condition;
+    switch (op) {
+        case "and":
+        case "or": {
+            const nodes = args.map((each) => compileWhere(table, each, what));
+            return op === "and" ? { and: nodes } : { or: nodes };
+        }
+        case "not":
+            return { not: compileWhere(table, args[0], what) };
+        case "isNull":
+            return { isNull: scalarColumn(table, args[0], what).name };
+        case "prefix": {
+            const column = scalarColumn(table, args[0], what);
+            if (column.type !== "str")
+                throw invalid("args", `${table.name}: ${what}: prefix needs a str() column`);
+            return { prefix: [column.name, operand(column, args[1], what)] };
+        }
+        case "inArray": {
+            const column = scalarColumn(table, args[0], what);
+            const values = args[1];
+            if (!Array.isArray(values))
+                throw invalid("args", `${table.name}: ${what}: inArray needs an array`);
+            return { inArray: [column.name, values.map((value) => operand(column, value, what))] };
+        }
+        default: {
+            const column = scalarColumn(table, args[0], what);
+            // One of the six comparisons: the node's shape is `{ [op]: [column, value] }`.
+            return { [op]: [column.name, operand(column, args[1], what)] };
+        }
+    }
+}
+/**
+ * Compiles a plugin's `set` (plain values or a callback's result) for `table` (a trust boundary): known non-key
+ * columns (rule 13), at least one (rule 14), `undefined` clearing an `opt(...)` column as the explicit `null` (a
+ * `null` value is a `json(...)` cell's JSON `null`, refused for other columns), an
+ * expression whose result may be `NULL` only for an `opt(...)` column; integer arithmetic only on `int` columns.
+ */
+export function compileSet(table, set, what) {
+    if (typeof set !== "object" || set === null || Array.isArray(set)) {
+        throw invalid("args", `${table.name}: ${what}: expected an object of column values`);
+    }
+    const entries = Object.entries(set);
+    if (entries.length === 0)
+        throw invalid("args", `${table.name}: ${what}: the set is empty`);
+    const node = {};
+    for (const [name, value] of entries) {
+        const column = table.byName.get(name);
+        if (column === undefined)
+            throw invalid("args", `${table.name}: ${what}: no column "${name}"`);
+        if (table.key.includes(name)) {
+            throw invalid("args", `${table.name}: ${what}: key column "${name}" cannot change (delete and put)`);
+        }
+        const where = `${what}: column "${name}"`;
+        if (value === undefined) {
+            if (!column.optional)
+                throw invalid("args", `${table.name}: ${where} is not opt(...) and cannot be cleared`);
+            node[name] = null;
+        }
+        else if (value === null && column.type !== "json") {
+            // A row never holds an explicit `null` (decision "Nullable columns and the set form"); a JSON `null` is a value.
+            throw invalid("args", `${table.name}: ${where}: null is no ${column.type} value (undefined clears)`);
+        }
+        else if (value instanceof Expression) {
+            if (column.type === "json")
+                throw invalid("args", `${table.name}: ${where}: json(...) columns take plain values`);
+            const compiled = compileExpr(table, value, column.type, where);
+            if (compiled.nullable && !column.optional) {
+                throw invalid("args", `${table.name}: ${where}: the expression may be NULL; the column is not opt(...)`);
+            }
+            node[name] = compiled.node;
+        }
+        else if (column.type === "json") {
+            node[name] = { json: encodeCell(column, value, `${table.name}: ${where}`).stored };
+        }
+        else
+            node[name] = checkScalar(column.type, value, `${table.name}: ${where}`);
+    }
+    return node;
+}
+function compileExpr(table, value, type, what) {
+    if (!(value instanceof Expression)) {
+        if (value === undefined || value === null)
+            return { node: null, nullable: true };
+        return { node: checkScalar(type, value, `${table.name}: ${what}`), nullable: false };
+    }
+    const { op, args } = value;
+    const refuse = (message) => {
+        throw invalid("args", `${table.name}: ${what}: ${message}`);
+    };
+    switch (op) {
+        case "col": {
+            const column = table.byName.get(args[0]) ?? refuse(`no column "${String(args[0])}"`);
+            if (column.type !== type)
+                refuse(`column "${column.name}" is ${column.type}, not ${type}`);
+            return { node: { col: column.name }, nullable: column.optional };
+        }
+        case "add":
+        case "sub":
+        case "max":
+        case "min":
+        case "concat": {
+            const types = op === "concat" ? ["str"] : op === "add" || op === "sub" ? ["int"] : ["int", "num"];
+            if (!types.includes(type))
+                refuse(`${op} gives ${types.join(" or ")}, the column is ${type}`);
+            const [a, b] = [compileExpr(table, args[0], type, what), compileExpr(table, args[1], type, what)];
+            // The operation's shape is `{ [op]: [a, b] }`.
+            return { node: { [op]: [a.node, b.node] }, nullable: a.nullable || b.nullable };
+        }
+        case "coalesce": {
+            const [a, b] = [compileExpr(table, args[0], type, what), compileExpr(table, args[1], type, what)];
+            return { node: { coalesce: [a.node, b.node] }, nullable: a.nullable && b.nullable };
+        }
+        case "replacePrefix": {
+            if (type !== "str")
+                refuse(`replacePrefix gives str, the column is ${type}`);
+            const subject = compileExpr(table, args[0], type, what);
+            const [from, to] = [args[1], args[2]].map((each) => checkScalar("str", each, `${table.name}: ${what}`));
+            return { node: { replacePrefix: [subject.node, from, to] }, nullable: subject.nullable };
+        }
+        case "when": {
+            const condition = compileWhere(table, args[0], what);
+            const [a, b] = [compileExpr(table, args[1], type, what), compileExpr(table, args[2], type, what)];
+            return { node: { when: [condition, a.node, b.node] }, nullable: a.nullable || b.nullable };
+        }
+    }
+}
+/** The column a condition compares: a reference to a known scalar column. */
+function scalarColumn(table, ref, what) {
+    if (!(ref instanceof ColumnRef))
+        throw invalid("args", `${table.name}: ${what}: expected a column reference`);
+    const column = table.byName.get(ref.column);
+    if (column === undefined)
+        throw invalid("args", `${table.name}: ${what}: no column "${ref.column}"`);
+    if (column.type === "json")
+        throw invalid("args", `${table.name}: ${what}: json(...) column "${ref.column}" is not queryable`);
+    return column;
+}
+/** An operand compared with `column`, made storable; `undefined` and `null` are refused (rule 16). */
+function operand(column, value, what) {
+    if (value === undefined || value === null) {
+        throw invalid("args", `${what}: column "${column.name}" compared with ${String(value)}; ask with isNull`);
+    }
+    // `scalarColumn` refused json columns.
+    return checkScalar(column.type, value, `${what}: column "${column.name}"`);
+}
+//# sourceMappingURL=expression.js.map

package/dist/store/expression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.js","sourceRoot":"","sources":["../../src/store/expression.ts"],"names":[],"mappings":"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","sourcesContent":["// The table expression language (slice 6a §6, §7; rules 10, 13, 14, 16; decision \"Nullable columns and the `set`\n// form\"): the builders plugins write `where` and `set` with, and their compilation at staging into one data-only\n// vocabulary (what the outbox and archives carry; `evaluate.ts` runs it in JavaScript, `sql.ts` renders it).\n\nimport type { Optional } from \"../contracts/index.ts\";\nimport { invalid } from \"../data/internal.ts\";\nimport type { JsonValue } from \"../json.ts\";\nimport type { Column, Columns, ColumnType, ColumnTypeOf, ValueOf } from \"./columns.ts\";\nimport { checkScalar, encodeCell, type Scalar } from \"./rows.ts\";\nimport type { TableDefinition } from \"./table.ts\";\n\n/** A compiled condition: column comparisons with checked operands, combined by `and`, `or`, `not`. */\nexport type WhereNode =\n\t| { readonly eq: readonly [string, Scalar] }\n\t| { readonly ne: readonly [string, Scalar] }\n\t| { readonly lt: readonly [string, Scalar] }\n\t| { readonly lte: readonly [string, Scalar] }\n\t| { readonly gt: readonly [string, Scalar] }\n\t| { readonly gte: readonly [string, Scalar] }\n\t| { readonly inArray: readonly [string, readonly Scalar[]] }\n\t| { readonly isNull: string }\n\t| { readonly prefix: readonly [string, string] }\n\t| { readonly and: readonly WhereNode[] }\n\t| { readonly or: readonly WhereNode[] }\n\t| { readonly not: WhereNode };\n\n/** A compiled value expression: a literal (`null` clears), a column, a `json(...)` cell, or an operation. */\nexport type ExprNode =\n\t| Scalar\n\t| null\n\t| { readonly col: string }\n\t| { readonly json: JsonValue }\n\t| { readonly add: readonly [ExprNode, ExprNode] }\n\t| { readonly sub: readonly [ExprNode, ExprNode] }\n\t| { readonly max: readonly [ExprNode, ExprNode] }\n\t| { readonly min: readonly [ExprNode, ExprNode] }\n\t| { readonly concat: readonly [ExprNode, ExprNode] }\n\t| { readonly coalesce: readonly [ExprNode, ExprNode] }\n\t| { readonly replacePrefix: readonly [ExprNode, string, string] }\n\t| { readonly when: readonly [WhereNode, ExprNode, ExprNode] };\n\n/** A compiled `set`: the new value of each changed column, every right side evaluated against the row before. */\nexport type SetNode = { readonly [column: string]: ExprNode };\n\n/** The comparison operators of a `WhereNode`. */\nexport type Comparison = \"eq\" | \"ne\" | \"lt\" | \"lte\" | \"gt\" | \"gte\";\n\n/** The operations of an `ExprNode`. */\nexport type Operation = \"add\" | \"sub\" | \"max\" | \"min\" | \"concat\" | \"coalesce\" | \"replacePrefix\" | \"when\";\n\n/** A value expression as a plugin builds it: `T` is its value, `K` its column type. Compiled when staged. */\nexport class Expression<T = unknown, K extends ColumnType = ColumnType> {\n\treadonly op: Operation | \"col\";\n\treadonly args: readonly unknown[];\n\t/** Type only. */\n\tdeclare readonly \"~value\"?: T;\n\tdeclare readonly \"~type\"?: K;\n\n\tconstructor(op: Operation | \"col\", args: readonly unknown[]) {\n\t\tthis.op = op;\n\t\tthis.args = args;\n\t}\n}\n\n/** A reference to a column of the row, as `(t) => …` callbacks get them. */\nexport class ColumnRef<T = unknown, K extends ColumnType = ColumnType> extends Expression<T, K> {\n\treadonly column: string;\n\n\tconstructor(column: string) {\n\t\tsuper(\"col\", [column]);\n\t\tthis.column = column;\n\t}\n}\n\n/** A condition as a plugin builds it; compiled when staged or run. */\nexport class Condition {\n\treadonly op: Comparison | \"inArray\" | \"isNull\" | \"prefix\" | \"and\" | \"or\" | \"not\";\n\treadonly args: readonly unknown[];\n\n\tconstructor(op: Condition[\"op\"], args: readonly unknown[]) {\n\t\tthis.op = op;\n\t\tthis.args = args;\n\t}\n}\n\n/**\n * A `set` of a table with columns `C` and key `K`: new values of non-key columns, each a value or an expression of\n * the column's type; `undefined` clears an `opt(...)` column.\n */\nexport type SetOf<C extends Columns, K extends readonly string[]> = {\n\treadonly [P in Exclude<keyof C & string, K[number]>]?: C[P] extends Optional\n\t\t? ValueOf<C[P]> | Expression<ValueOf<C[P]>, ColumnTypeOf<C[P]>> | undefined\n\t\t: ValueOf<C[P]> | Expression<ValueOf<C[P]>, ColumnTypeOf<C[P]>>;\n};\n\n/** A scalar column type. */\ntype ScalarType = Exclude<ColumnType, \"json\">;\n\n/** An operand of type `T` and column type `K`: an expression or a plain value. */\ntype Operand<T, K extends ColumnType> = Expression<T, K> | T;\n\n/** The column equals `value` (`NULL` never matches). */\nexport function eq<T extends Scalar>(column: ColumnRef<T, ScalarType>, value: T): Condition {\n\treturn new Condition(\"eq\", [column, value]);\n}\n\n/** The column differs from `value` (`NULL` never matches). */\nexport function ne<T extends Scalar>(column: ColumnRef<T, ScalarType>, value: T): Condition {\n\treturn new Condition(\"ne\", [column, value]);\n}\n\n/** The column is below `value`. */\nexport function lt<T extends Scalar>(column: ColumnRef<T, ScalarType>, value: T): Condition {\n\treturn new Condition(\"lt\", [column, value]);\n}\n\n/** The column is at most `value`. */\nexport function lte<T extends Scalar>(column: ColumnRef<T, ScalarType>, value: T): Condition {\n\treturn new Condition(\"lte\", [column, value]);\n}\n\n/** The column is above `value`. */\nexport function gt<T extends Scalar>(column: ColumnRef<T, ScalarType>, value: T): Condition {\n\treturn new Condition(\"gt\", [column, value]);\n}\n\n/** The column is at least `value`. */\nexport function gte<T extends Scalar>(column: ColumnRef<T, ScalarType>, value: T): Condition {\n\treturn new Condition(\"gte\", [column, value]);\n}\n\n/** The column equals one of `values` (`[]` matches nothing). */\nexport function inArray<T extends Scalar>(column: ColumnRef<T, ScalarType>, values: readonly T[]): Condition {\n\treturn new Condition(\"inArray\", [column, values]);\n}\n\n/** The column is `NULL` (an `opt(...)` column without a value). */\nexport function isNull(column: ColumnRef<unknown, ScalarType>): Condition {\n\treturn new Condition(\"isNull\", [column]);\n}\n\n/** The text column starts with `prefix`, compared by code point (`\"\"` matches every value). */\nexport function prefix(column: ColumnRef<string, \"str\">, prefix: string): Condition {\n\treturn new Condition(\"prefix\", [column, prefix]);\n}\n\n/** Every condition holds (`and()` always does). */\nexport function and(...conditions: Condition[]): Condition {\n\treturn new Condition(\"and\", conditions);\n}\n\n/** Some condition holds (`or()` never does). */\nexport function or(...conditions: Condition[]): Condition {\n\treturn new Condition(\"or\", conditions);\n}\n\n/** The condition does not hold (`NULL` stays `NULL`: it never matches). */\nexport function not(condition: Condition): Condition {\n\treturn new Condition(\"not\", [condition]);\n}\n\n/** `a + b` over integers; a result outside ±(2^53 - 1) fails (rule 10). */\nexport function add(a: Operand<number, \"int\">, b: Operand<number, \"int\">): Expression<number, \"int\"> {\n\treturn new Expression(\"add\", [a, b]);\n}\n\n/** `a - b` over integers; a result outside ±(2^53 - 1) fails (rule 10). */\nexport function sub(a: Operand<number, \"int\">, b: Operand<number, \"int\">): Expression<number, \"int\"> {\n\treturn new Expression(\"sub\", [a, b]);\n}\n\n/** The larger of `a` and b` (`int` or `num`). */\nexport function max<K extends \"int\" | \"num\">(a: Operand<number, K>, b: Operand<number, K>): Expression<number, K> {\n\treturn new Expression(\"max\", [a, b]);\n}\n\n/** The smaller of `a` and `b` (`int` or `num`). */\nexport function min<K extends \"int\" | \"num\">(a: Operand<number, K>, b: Operand<number, K>): Expression<number, K> {\n\treturn new Expression(\"min\", [a, b]);\n}\n\n/** `a` followed by `b`. */\nexport function concat(a: Operand<string, \"str\">, b: Operand<string, \"str\">): Expression<string, \"str\"> {\n\treturn new Expression(\"concat\", [a, b]);\n}\n\n/** `value` with its prefix `from` replaced by `to`; a value without the prefix stays as it is. */\nexport function replacePrefix(value: Operand<string, \"str\">, from: string, to: string): Expression<string, \"str\"> {\n\treturn new Expression(\"replacePrefix\", [value, from, to]);\n}\n\n/** `a` unless it is `NULL`, else `b`. */\nexport function coalesce<T, K extends ScalarType>(a: Expression<T, K>, b: Operand<T, K>): Expression<T, K> {\n\treturn new Expression(\"coalesce\", [a, b]);\n}\n\n/** `a` where `condition` holds for the row, else `b`. */\nexport function when<T, K extends ScalarType>(\n\tcondition: Condition,\n\ta: Operand<T, K>,\n\tb: Operand<T, K>,\n): Expression<T, K> {\n\treturn new Expression(\"when\", [condition, a, b]);\n}\n\n/** One `ColumnRef` per column of `definition`, for its `(t) => …` callbacks. */\nexport function columnRefs(columns: readonly Column[]): { readonly [column: string]: ColumnRef } {\n\treturn Object.fromEntries(columns.map(({ name }) => [name, new ColumnRef(name)]));\n}\n\n/**\n * Compiles a plugin's condition over `table`'s columns (a trust boundary: plugin values): known scalar columns,\n * operands of their type made storable (`invalid/args` otherwise, `undefined` included: ask with `isNull`, rule 16).\n */\nexport function compileWhere(table: TableDefinition, condition: unknown, what: string): WhereNode {\n\tif (!(condition instanceof Condition)) throw invalid(\"args\", `${table.name}: ${what}: expected a condition`);\n\tconst { op, args } = condition;\n\tswitch (op) {\n\t\tcase \"and\":\n\t\tcase \"or\": {\n\t\t\tconst nodes = args.map((each) => compileWhere(table, each, what));\n\t\t\treturn op === \"and\" ? { and: nodes } : { or: nodes };\n\t\t}\n\t\tcase \"not\":\n\t\t\treturn { not: compileWhere(table, args[0], what) };\n\t\tcase \"isNull\":\n\t\t\treturn { isNull: scalarColumn(table, args[0], what).name };\n\t\tcase \"prefix\": {\n\t\t\tconst column = scalarColumn(table, args[0], what);\n\t\t\tif (column.type !== \"str\") throw invalid(\"args\", `${table.name}: ${what}: prefix needs a str() column`);\n\t\t\treturn { prefix: [column.name, operand(column, args[1], what) as string] };\n\t\t}\n\t\tcase \"inArray\": {\n\t\t\tconst column = scalarColumn(table, args[0], what);\n\t\t\tconst values = args[1];\n\t\t\tif (!Array.isArray(values)) throw invalid(\"args\", `${table.name}: ${what}: inArray needs an array`);\n\t\t\treturn { inArray: [column.name, values.map((value) => operand(column, value, what))] };\n\t\t}\n\t\tdefault: {\n\t\t\tconst column = scalarColumn(table, args[0], what);\n\t\t\t// One of the six comparisons: the node's shape is `{ [op]: [column, value] }`.\n\t\t\treturn { [op]: [column.name, operand(column, args[1], what)] as const } as WhereNode;\n\t\t}\n\t}\n}\n\n/**\n * Compiles a plugin's `set` (plain values or a callback's result) for `table` (a trust boundary): known non-key\n * columns (rule 13), at least one (rule 14), `undefined` clearing an `opt(...)` column as the explicit `null` (a\n * `null` value is a `json(...)` cell's JSON `null`, refused for other columns), an\n * expression whose result may be `NULL` only for an `opt(...)` column; integer arithmetic only on `int` columns.\n */\nexport function compileSet(table: TableDefinition, set: unknown, what: string): SetNode {\n\tif (typeof set !== \"object\" || set === null || Array.isArray(set)) {\n\t\tthrow invalid(\"args\", `${table.name}: ${what}: expected an object of column values`);\n\t}\n\tconst entries = Object.entries(set);\n\tif (entries.length === 0) throw invalid(\"args\", `${table.name}: ${what}: the set is empty`);\n\tconst node: { [column: string]: ExprNode } = {};\n\tfor (const [name, value] of entries) {\n\t\tconst column = table.byName.get(name);\n\t\tif (column === undefined) throw invalid(\"args\", `${table.name}: ${what}: no column \"${name}\"`);\n\t\tif (table.key.includes(name)) {\n\t\t\tthrow invalid(\"args\", `${table.name}: ${what}: key column \"${name}\" cannot change (delete and put)`);\n\t\t}\n\t\tconst where = `${what}: column \"${name}\"`;\n\t\tif (value === undefined) {\n\t\t\tif (!column.optional) throw invalid(\"args\", `${table.name}: ${where} is not opt(...) and cannot be cleared`);\n\t\t\tnode[name] = null;\n\t\t} else if (value === null && column.type !== \"json\") {\n\t\t\t// A row never holds an explicit `null` (decision \"Nullable columns and the set form\"); a JSON `null` is a value.\n\t\t\tthrow invalid(\"args\", `${table.name}: ${where}: null is no ${column.type} value (undefined clears)`);\n\t\t} else if (value instanceof Expression) {\n\t\t\tif (column.type === \"json\")\n\t\t\t\tthrow invalid(\"args\", `${table.name}: ${where}: json(...) columns take plain values`);\n\t\t\tconst compiled = compileExpr(table, value, column.type, where);\n\t\t\tif (compiled.nullable && !column.optional) {\n\t\t\t\tthrow invalid(\"args\", `${table.name}: ${where}: the expression may be NULL; the column is not opt(...)`);\n\t\t\t}\n\t\t\tnode[name] = compiled.node;\n\t\t} else if (column.type === \"json\") {\n\t\t\tnode[name] = { json: encodeCell(column, value, `${table.name}: ${where}`).stored };\n\t\t} else node[name] = checkScalar(column.type, value, `${table.name}: ${where}`);\n\t}\n\treturn node;\n}\n\n/** A compiled expression and whether its result may be `NULL`. */\ntype Compiled = { readonly node: ExprNode; readonly nullable: boolean };\n\nfunction compileExpr(table: TableDefinition, value: unknown, type: ScalarType, what: string): Compiled {\n\tif (!(value instanceof Expression)) {\n\t\tif (value === undefined || value === null) return { node: null, nullable: true };\n\t\treturn { node: checkScalar(type, value, `${table.name}: ${what}`), nullable: false };\n\t}\n\tconst { op, args } = value;\n\tconst refuse = (message: string): never => {\n\t\tthrow invalid(\"args\", `${table.name}: ${what}: ${message}`);\n\t};\n\tswitch (op) {\n\t\tcase \"col\": {\n\t\t\tconst column = table.byName.get(args[0] as string) ?? refuse(`no column \"${String(args[0])}\"`);\n\t\t\tif (column.type !== type) refuse(`column \"${column.name}\" is ${column.type}, not ${type}`);\n\t\t\treturn { node: { col: column.name }, nullable: column.optional };\n\t\t}\n\t\tcase \"add\":\n\t\tcase \"sub\":\n\t\tcase \"max\":\n\t\tcase \"min\":\n\t\tcase \"concat\": {\n\t\t\tconst types: readonly ScalarType[] =\n\t\t\t\top === \"concat\" ? [\"str\"] : op === \"add\" || op === \"sub\" ? [\"int\"] : [\"int\", \"num\"];\n\t\t\tif (!types.includes(type)) refuse(`${op} gives ${types.join(\" or \")}, the column is ${type}`);\n\t\t\tconst [a, b] = [compileExpr(table, args[0], type, what), compileExpr(table, args[1], type, what)];\n\t\t\t// The operation's shape is `{ [op]: [a, b] }`.\n\t\t\treturn { node: { [op]: [a.node, b.node] } as ExprNode, nullable: a.nullable || b.nullable };\n\t\t}\n\t\tcase \"coalesce\": {\n\t\t\tconst [a, b] = [compileExpr(table, args[0], type, what), compileExpr(table, args[1], type, what)];\n\t\t\treturn { node: { coalesce: [a.node, b.node] }, nullable: a.nullable && b.nullable };\n\t\t}\n\t\tcase \"replacePrefix\": {\n\t\t\tif (type !== \"str\") refuse(`replacePrefix gives str, the column is ${type}`);\n\t\t\tconst subject = compileExpr(table, args[0], type, what);\n\t\t\tconst [from, to] = [args[1], args[2]].map(\n\t\t\t\t(each) => checkScalar(\"str\", each, `${table.name}: ${what}`) as string,\n\t\t\t);\n\t\t\treturn { node: { replacePrefix: [subject.node, from!, to!] }, nullable: subject.nullable };\n\t\t}\n\t\tcase \"when\": {\n\t\t\tconst condition = compileWhere(table, args[0], what);\n\t\t\tconst [a, b] = [compileExpr(table, args[1], type, what), compileExpr(table, args[2], type, what)];\n\t\t\treturn { node: { when: [condition, a.node, b.node] }, nullable: a.nullable || b.nullable };\n\t\t}\n\t}\n}\n\n/** The column a condition compares: a reference to a known scalar column. */\nfunction scalarColumn(table: TableDefinition, ref: unknown, what: string): Column {\n\tif (!(ref instanceof ColumnRef)) throw invalid(\"args\", `${table.name}: ${what}: expected a column reference`);\n\tconst column = table.byName.get(ref.column);\n\tif (column === undefined) throw invalid(\"args\", `${table.name}: ${what}: no column \"${ref.column}\"`);\n\tif (column.type === \"json\")\n\t\tthrow invalid(\"args\", `${table.name}: ${what}: json(...) column \"${ref.column}\" is not queryable`);\n\treturn column;\n}\n\n/** An operand compared with `column`, made storable; `undefined` and `null` are refused (rule 16). */\nfunction operand(column: Column, value: unknown, what: string): Scalar {\n\tif (value === undefined || value === null) {\n\t\tthrow invalid(\"args\", `${what}: column \"${column.name}\" compared with ${String(value)}; ask with isNull`);\n\t}\n\t// `scalarColumn` refused json columns.\n\treturn checkScalar(column.type as ScalarType, value, `${what}: column \"${column.name}\"`);\n}\n"]}

package/dist/store/import.d.ts

@@ -0,0 +1,10 @@
+import { type Context } from "../context/index.ts";
+import type { Backend } from "./backend.ts";
+import { type Store, type StoreOptions } from "./store.ts";
+/**
+ * A store holding the archive `parts` on `backend`, which must not hold a store yet: at the manifest's `lastSeq`, its
+ * outbox (when `options.outbox`) starting after it. A refused archive, a stalled input cancelled by `context` or a
+ * backend error rejects; the backend is closed then (rule 12).
+ */
+export declare function importStore(backend: Backend, parts: AsyncIterable<unknown> | Iterable<unknown>, context: Context, options?: StoreOptions): Promise<Store>;
+//# sourceMappingURL=import.d.ts.map

package/dist/store/import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../src/store/import.ts"],"names":[],"mappings":"AAOA,OAAO,EAAoB,KAAK,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAOrE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAK5C,OAAO,EAAc,KAAK,KAAK,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAGvE;;;;GAIG;AACH,wBAAsB,WAAW,CAChC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,EACjD,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE,YAAiB,GACxB,OAAO,CAAC,KAAK,CAAC,CAqBhB"}

package/dist/store/import.js

@@ -0,0 +1,276 @@
+// `importStore(backend, parts, ctx, { outbox? })` (slice 6a §13, rules 12, 24, 25): a store made from an archive, a
+// trust boundary. Every part is checked against the archive schema, its place in the archive's order and its content
+// (names, rows against their table's recorded columns, ids and seqs, lifetimes at one address never overlapping,
+// revisions in seq order from a base, versions, duplicates, the `end` count, the manifest); everything is applied in
+// one backend transaction with the applier, so a refused import leaves the backend as it was. An input that stalls is
+// cancelled by `ctx`.
+import { awaitWithContext } from "../context/index.js";
+import { ChordError } from "../data/index.js";
+import { invalid } from "../data/internal.js";
+import { IdAllocator } from "./allocator.js";
+import { applyWrite } from "./applier.js";
+import { ARCHIVE_FORMAT, checkPart } from "./archive.js";
+import { readCatalog, writeCatalog } from "./catalog.js";
+import { applyStoreSchema, STORE_SCHEMA, TABLES } from "./schema.js";
+import { Step } from "./step.js";
+import { ChordStore } from "./store.js";
+import { storedText } from "./text.js";
+/**
+ * A store holding the archive `parts` on `backend`, which must not hold a store yet: at the manifest's `lastSeq`, its
+ * outbox (when `options.outbox`) starting after it. A refused archive, a stalled input cancelled by `context` or a
+ * backend error rejects; the backend is closed then (rule 12).
+ */
+export async function importStore(backend, parts, context, options = {}) {
+    const { db } = backend;
+    try {
+        context.abortSignal?.throwIfAborted();
+        const existing = await db.get(`SELECT name FROM sqlite_master WHERE name = ?`, TABLES.meta);
+        if (existing !== undefined)
+            throw invalid("args", "import: the backend holds a store already");
+        const meta = await db.transaction(async (executor) => {
+            const meta = await applyStoreSchema(inTransaction(executor));
+            const archive = new ArchiveImport(executor, context);
+            await each(parts, context, (part) => archive.take(part));
+            return archive.finish(meta, options.outbox === true);
+        });
+        return new ChordStore(db, meta, await readCatalog(db));
+    }
+    catch (error) {
+        try {
+            await db.close();
+        }
+        catch {
+            // The import's own failure is the one to report.
+        }
+        throw error;
+    }
+}
+/** The store's schema migrations run inside the import's backend transaction (they open none of their own). */
+function inTransaction(executor) {
+    return {
+        exec: (sql) => executor.exec(sql),
+        run: (sql, ...params) => executor.run(sql, ...params),
+        runCounted: (sql, ...params) => executor.runCounted(sql, ...params),
+        get: (sql, ...params) => executor.get(sql, ...params),
+        all: (sql, ...params) => executor.all(sql, ...params),
+        transaction: (callback) => callback(executor),
+        close: () => Promise.reject(new Error("import: the backend closes after the import")),
+    };
+}
+/**
+ * One archive being imported: the place reached in its order (the manifest, then table groups of a `table` write, its
+ * `put`s and its `index` writes, then the documents, then `end`), what was seen (tables, ids, live addresses, the
+ * write count) and the step its writes are applied in.
+ */
+class ArchiveImport {
+    #executor;
+    #context;
+    #position = 0;
+    #manifest;
+    #step;
+    /** Where the next part may go. */
+    #place = "manifest";
+    /** The table whose group is open. */
+    #table;
+    #tables = new Set();
+    #ids = new Set();
+    /** The lifetimes seen at each address, `[createdAt, retiredAt)` (`Infinity` while live). */
+    #lifetimes = new Map();
+    /** The record whose revisions may follow, with the last revision's seq and its base's version. */
+    #document;
+    #writes = 0;
+    constructor(executor, context) {
+        this.#executor = executor;
+        this.#context = context;
+    }
+    /** Checks the next part and applies it. */
+    async take(value) {
+        const position = this.#position++;
+        const part = checkPart(value, position, this.#context);
+        const what = `import: part ${position} (${part.kind})`;
+        if (this.#place === "ended")
+            throw invalid("args", `${what}: after the end`);
+        if (part.kind === "manifest" || this.#step === undefined) {
+            this.#start(part, what);
+            return;
+        }
+        if (part.kind === "end") {
+            if (part.writes !== this.#writes) {
+                throw invalid("args", `${what}: counts ${part.writes} writes, the archive has ${this.#writes}`);
+            }
+            this.#endDocument(what);
+            this.#place = "ended";
+            return;
+        }
+        this.#place = this.#placeOf(part, what);
+        this.#writes++;
+        await applyWrite(this.#step, part, what);
+    }
+    /** The stored metadata once the archive ended: its `lastSeq`, the allocator's next id and the outbox setting. */
+    async finish(meta, outbox) {
+        if (this.#place !== "ended" || this.#step === undefined || this.#manifest === undefined) {
+            throw invalid("args", "import: the archive has no end part");
+        }
+        const { lastSeq, nextId } = this.#manifest;
+        await writeCatalog(this.#step);
+        await this.#executor.run(`UPDATE ${TABLES.meta} SET last_seq = ?, next_id = ?, outbox = ?, outbox_floor = ? WHERE singleton = 1`, lastSeq, nextId, outbox ? 1 : 0, lastSeq);
+        return {
+            ...meta,
+            last_seq: lastSeq,
+            next_id: nextId,
+            outbox: outbox ? 1 : 0,
+            outbox_floor: lastSeq,
+        };
+    }
+    /** The manifest, first: a format and schema this code reads. */
+    #start(part, what) {
+        if (part.kind !== "manifest" || this.#step !== undefined)
+            throw invalid("args", `${what}: the manifest comes first, once`);
+        if (part.format !== ARCHIVE_FORMAT)
+            throw invalid("args", `${what}: format ${part.format} is not ${ARCHIVE_FORMAT}`);
+        if (part.schema > STORE_SCHEMA)
+            throw invalid("args", `${what}: schema ${part.schema} is newer than ${STORE_SCHEMA}`);
+        this.#manifest = part;
+        this.#step = new Step(this.#executor, part.lastSeq, new IdAllocator(part.nextId), new Map());
+    }
+    /** Where `part` puts the archive, refused when out of order, a duplicate, or outside the manifest's ranges. */
+    #placeOf(part, what) {
+        const place = this.#place;
+        switch (part.kind) {
+            case "table":
+                if (place === "documents")
+                    throw invalid("args", `${what}: tables come before the documents`);
+                if (this.#tables.has(part.table))
+                    throw invalid("args", `${what}: table ${part.table} occurs twice`);
+                this.#tables.add(part.table);
+                this.#table = part.table;
+                return "puts";
+            case "put":
+                if (place !== "puts" || part.table !== this.#table) {
+                    throw invalid("args", `${what}: a put follows its table's table write, before its indexes`);
+                }
+                return "puts";
+            case "index":
+                if ((place !== "puts" && place !== "indexes") || part.table !== this.#table) {
+                    throw invalid("args", `${what}: an index follows its table's table write and puts`);
+                }
+                return "indexes";
+            case "document.create":
+                this.#checkDocument(part, what);
+                return "documents";
+            case "document.revision":
+                this.#checkRevision(part, what);
+                return "documents";
+        }
+    }
+    /**
+     * A record within the manifest's ids and seqs (an id equal to a saturated `nextId` too), unique, its lifetime
+     * overlapping no other at its address; its address and meta well-formed text without NUL (SQLite would cut a NUL off,
+     * slice 6a §8). The record before it must have ended well (`#endDocument`).
+     */
+    #checkDocument(part, what) {
+        this.#endDocument(what);
+        const { record } = part;
+        const { lastSeq, nextId } = this.#manifest;
+        const saturated = nextId === Number.MAX_SAFE_INTEGER && record.id === nextId;
+        if (record.id >= nextId && !saturated)
+            throw invalid("args", `${what}: id ${record.id} is not below ${nextId}`);
+        if (this.#ids.has(record.id))
+            throw invalid("args", `${what}: id ${record.id} occurs twice`);
+        const { createdAt, retiredAt } = record;
+        if (createdAt > lastSeq || (retiredAt !== undefined && (retiredAt < createdAt || retiredAt > lastSeq))) {
+            throw invalid("args", `${what}: a lifetime outside the manifest's lastSeq`);
+        }
+        const { namespace, owner, kind, meta } = record;
+        // A singleton's record has no key; its column keeps `""`.
+        const key = record.key ?? "";
+        for (const text of [namespace, owner, kind, key]) {
+            if (storedText(text, what) !== text)
+                throw invalid("args", `${what}: an address is not well-formed text`);
+        }
+        if (meta !== undefined && storedText(meta, what) !== meta) {
+            throw invalid("args", `${what}: the meta is not well-formed text`);
+        }
+        const address = JSON.stringify([owner, namespace, kind, key]);
+        const lifetime = [createdAt, retiredAt ?? Number.POSITIVE_INFINITY];
+        const lifetimes = this.#lifetimes.get(address) ?? [];
+        // Two live records are two infinite lifetimes, which overlap; an empty one (`createdAt = retiredAt`) overlaps none.
+        if (lifetime[0] < lifetime[1] && lifetimes.some(([from, to]) => from < lifetime[1] && lifetime[0] < to)) {
+            throw invalid("args", `${what}: a second record at one address for an overlapping lifetime`);
+        }
+        lifetimes.push(lifetime);
+        this.#lifetimes.set(address, lifetimes);
+        this.#ids.add(record.id);
+        this.#document = { record, seq: 0, base: undefined };
+    }
+    /**
+     * A revision of the record before it, in seq order within its lifetime, from a base, each delta at its base's
+     * version.
+     */
+    #checkRevision(part, what) {
+        const document = this.#document;
+        if (document === undefined || document.record.id !== part.id) {
+            throw invalid("args", `${what}: a revision follows its record's create`);
+        }
+        const { record } = document;
+        if (record.retiredAt !== undefined && record.history !== "rewindable") {
+            throw invalid("args", `${what}: a retired ${record.history} record keeps no revisions`);
+        }
+        if (part.seq <= document.seq ||
+            part.seq < record.createdAt ||
+            part.seq > (record.retiredAt ?? this.#manifest.lastSeq)) {
+            throw invalid("args", `${what}: a revision out of seq order or outside its lifetime`);
+        }
+        const { content } = part;
+        if (content.kind === "base")
+            document.base = content.version;
+        else if (document.base !== content.version) {
+            throw invalid("args", `${what}: a delta without a base at its version`);
+        }
+        document.seq = part.seq;
+    }
+    /**
+     * The record before ends well: its last base is at the record's version; only a retired `latest` record has none
+     * (its content was dropped at retirement; a retired `rewindable` one keeps its history).
+     */
+    #endDocument(what) {
+        const document = this.#document;
+        this.#document = undefined;
+        if (document === undefined)
+            return;
+        const { record, base } = document;
+        const contentless = record.retiredAt !== undefined && record.history === "latest";
+        if (base === undefined ? !contentless : base !== record.version) {
+            throw invalid("args", `${what}: record ${record.id} has no base at its version`);
+        }
+    }
+}
+/** Runs `take` on each part in turn; a wait for the next part ends when `context` aborts (the input is closed). */
+async function each(parts, context, take) {
+    const iterator = Symbol.asyncIterator in parts ? parts[Symbol.asyncIterator]() : parts[Symbol.iterator]();
+    let done = false;
+    try {
+        for (;;) {
+            let result;
+            try {
+                result = await awaitWithContext(Promise.resolve(iterator.next()), context);
+            }
+            catch (error) {
+                if (!context.abortSignal?.aborted)
+                    throw error;
+                throw new ChordError({ code: "aborted", message: "import: aborted" }, { cause: context.abortSignal.reason });
+            }
+            if (result.done) {
+                done = true;
+                return;
+            }
+            await take(result.value);
+        }
+    }
+    finally {
+        // A stalled input is not awaited: the backend transaction ends now.
+        if (!done)
+            void Promise.resolve(iterator.return?.()).catch(() => { });
+    }
+}
+//# sourceMappingURL=import.js.map