@isaijs/core 0.1.5 → 0.1.8

package/dist/{migrator-B25prc9n.js → migrator-DxTpns_-.js}

@@ -1,5 +1,5 @@
-import { G as ValidationError, M as id } from "./validation-Cppmd0RV.js";
-import { A as mapOperands, B as aroundDelete, F as unbound, H as aroundUpsert, I as fromBase64url$1, K as wrap, L as toBase64url, M as readsNow, N as readsOtherRows, O as storageOf, P as tableTotals, R as actionEntry, V as aroundUpdate, W as assertNotLog, _ as Expr, c as rowOf$1, h as Condition, i as columnNode, k as fieldsOf, l as IMPLICIT_FIELDS, n as assertNotEncrypted, o as fieldOf, r as columnName, v as Now, w as conditionNode, z as aroundCreate } from "./model-Dc3HunKb.js";
+import { P as id, q as ValidationError } from "./validation-C3MCRBQO.js";
+import { A as mapOperands, B as aroundDelete, F as unbound, H as aroundUpsert, I as fromBase64url$1, K as wrap, L as toBase64url, M as readsNow, N as readsOtherRows, O as storageOf, P as tableTotals, R as actionEntry, V as aroundUpdate, W as assertNotLog, _ as Expr, c as rowOf$1, h as Condition, i as columnNode, k as fieldsOf, l as IMPLICIT_FIELDS, n as assertNotEncrypted, o as fieldOf, r as columnName, v as Now, w as conditionNode, z as aroundCreate } from "./model-6pJBqqGd.js";
 import { r as ulid } from "./case-DpXlJCL9.js";
 import { t as NotImplementedError } from "./errors-mCNLlXg9.js";
 //#region src/db/errors.ts
@@ -814,13 +814,28 @@ function onConflict(model, conflict, writer) {
 	if ("fromInsert" in action) return `${target} DO UPDATE SET ${action.fromInsert.map((field) => `${column(model, field)} = excluded.${column(model, field)}`).join(", ")}`;
 	return `${target} DO UPDATE SET ${writer.set(action.set)}`;
 }
+/**
+* A select. With a limit, computed fields are worked out for the rows it returns only: an inner
+* query picks them (filtered, sorted, limited), and the outer one adds the computed values. SQLite
+* otherwise works out every select-list subquery for every matching row before it sorts (a page of
+* 24 products would price all 800 in their category), and each of those reads is billed. Not when
+* the order is by a computed value: the inner query couldn't sort by it.
+*/
 function select(model, query, context) {
 	return withinLimit(context, (mode) => {
 		const writer = new Writer(model, mode, context);
-		let text = `SELECT ${writer.selection()} FROM ${quote(model.table)}${writer.where(query.where)}`;
-		if (query.order.length > 0) text += ` ORDER BY ${query.order.map(({ field, direction }) => `${column(model, field)} ${direction.toUpperCase()}`).join(", ")}`;
-		if (query.limit !== void 0 || query.offset !== void 0) text += ` LIMIT ${writer.value(query.limit ?? -1)}`;
+		const table = quote(model.table);
+		const order = query.order.length > 0 ? ` ORDER BY ${query.order.map(({ field, direction }) => `${column(model, field)} ${direction.toUpperCase()}`).join(", ")}` : "";
+		const limited = query.limit !== void 0 || query.offset !== void 0;
+		const computed = Object.values(model.fields).some((spec) => spec.computed);
+		const sortsByComputed = query.order.some(({ field }) => model.fields[field]?.computed);
+		const selection = writer.selection();
+		const inner = limited && computed && !sortsByComputed;
+		let text = inner ? `SELECT * FROM ${table}` : `SELECT ${selection} FROM ${table}`;
+		text += writer.where(query.where) + order;
+		if (limited) text += ` LIMIT ${writer.value(query.limit ?? -1)}`;
 		if (query.offset !== void 0) text += ` OFFSET ${writer.value(query.offset)}`;
+		if (inner) text = `SELECT ${selection} FROM (${text}) AS ${table}${order}`;
 		return writer.sql(text);
 	});
 }
@@ -1037,7 +1052,23 @@ function columnDefinition(column) {
 	return definition;
 }
 function createTable(table) {
-	return `CREATE TABLE ${quote(table.name)} (${table.columns.map(columnDefinition).join(", ")})`;
+	const columns = table.columns.map(columnDefinition).join(", ");
+	return `CREATE TABLE ${quote(table.name)} (${columns})${table.withoutRowid ? " WITHOUT ROWID" : ""}`;
+}
+/** Where a rebuilt table's old rows wait while the new table is filled. */
+const aside = (table) => quote(`_isai_rebuild_${table}`);
+/** `operations.ts` → rebuild, in SQLite: one atomic step, its foreign keys checked at the end. */
+function rebuild(operation) {
+	const { tables, copy, triggers } = operation;
+	const columns = (table) => (copy[table] ?? []).map(quote).join(", ");
+	return [
+		"PRAGMA defer_foreign_keys = ON",
+		...triggers.map((name) => `DROP TRIGGER IF EXISTS ${quote(name)}`),
+		...tables.map((table) => `ALTER TABLE ${quote(table.name)} RENAME TO ${aside(table.name)}`),
+		...tables.map(createTable),
+		...tables.filter((table) => (copy[table.name] ?? []).length > 0).map((table) => `INSERT INTO ${quote(table.name)} (${columns(table.name)}) SELECT ${columns(table.name)} FROM ${aside(table.name)}`),
+		...[...tables].reverse().map((table) => `DROP TABLE ${aside(table.name)}`)
+	];
 }
 function createIndex(table, index) {
 	const columns = index.columns.map(quote).join(", ");
@@ -1229,6 +1260,7 @@ function render(operation) {
 		case "dropRule": return [`DROP ${operation.rule.kind.toUpperCase()} IF EXISTS ${quote(operation.rule.name)}`];
 		case "dropColumn": return [`ALTER TABLE ${quote(operation.table)} DROP COLUMN ${quote(operation.column.name)}`, ...dropCounter(operation.table, operation.column)];
 		case "dropTable": return [`DROP TABLE ${quote(operation.table.name)}`, ...operation.table.columns.flatMap((column) => dropCounter(operation.table.name, column))];
+		case "rebuild": return rebuild(operation);
 	}
 }
 //#endregion
@@ -1500,10 +1532,15 @@ var Engine = class Engine {
 };
 //#endregion
 //#region src/db/orm/include.ts
+/** How the boundary gives a query its `IncludeRule`: internal, so the app's API never shows it. */
+const withIncludeRule = Symbol("isai.withIncludeRule");
 /** The rows of `model` whose `field` is one of `values`. */
-async function rowsWhereIn(engine, model, field, values) {
+async function rowsWhereIn(engine, model, field, values, rule) {
 	const spec = fieldOf(model, field);
 	if (!spec) throw new TypeError(`isai: ${model.name} has no field "${field}"`);
+	if (values.length === 0) return [];
+	const allowed = rule ? await rule(model) : void 0;
+	if (allowed === false) return [];
 	const chunk = engine.driver.capabilities.maxBoundParams;
 	const found = [];
 	for (let start = 0; start < values.length; start += chunk) {
@@ -1513,7 +1550,7 @@ async function rowsWhereIn(engine, model, field, values) {
 			values: values.slice(start, start + chunk)
 		};
 		found.push(...await engine.read(model, {
-			where: [where],
+			where: allowed ? [where, allowed] : [where],
 			order: [{
 				field: "id",
 				direction: "asc"
@@ -1535,27 +1572,27 @@ function byHead(paths) {
 	}
 	return groups;
 }
-async function loadIncludes(engine, model, registry, rows, paths) {
+async function loadIncludes(engine, model, registry, rows, paths, rule) {
 	if (rows.length === 0 || paths.length === 0) return;
 	for (const [head, tails] of byHead(paths)) {
 		const ref = fieldOf(model, head)?.ref;
 		if (ref) {
 			const target = registry.get(ref.model);
-			const found = await rowsWhereIn(engine, target, "id", [...new Set(rows.map((row) => row[head]).filter((id) => id !== null && id !== void 0))]);
-			await loadIncludes(engine, target, registry, found, tails);
+			const found = await rowsWhereIn(engine, target, "id", [...new Set(rows.map((row) => row[head]).filter((id) => id !== null && id !== void 0))], rule);
+			await loadIncludes(engine, target, registry, found, tails, rule);
 			const byId = new Map(found.map((row) => [row.id, row]));
 			for (const row of rows) row[head] = row[head] === null ? null : byId.get(row[head]) ?? null;
 			continue;
 		}
 		const relation = registry.relation(model.name, head);
 		if (!relation) throw new TypeError(`isai: ${model.name} has no ref or relation named "${head}"`);
-		const found = await rowsWhereIn(engine, relation.model, relation.field, rows.map((row) => row.id));
+		const found = await rowsWhereIn(engine, relation.model, relation.field, rows.map((row) => row.id), rule);
 		const groups = /* @__PURE__ */ new Map();
 		for (const row of found) {
 			const owner = row[relation.field];
 			groups.set(owner, [...groups.get(owner) ?? [], row]);
 		}
-		await loadIncludes(engine, relation.model, registry, found, tails);
+		await loadIncludes(engine, relation.model, registry, found, tails, rule);
 		for (const row of rows) row[head] = groups.get(row.id) ?? [];
 	}
 }
@@ -1707,15 +1744,21 @@ var Query = class Query {
 	target;
 	query;
 	paths;
+	rule;
 	constructor(engine, target, query = {
 		where: [],
 		order: [],
 		limit: void 0
-	}, paths = []) {
+	}, paths = [], rule) {
 		this.engine = engine;
 		this.target = target;
 		this.query = query;
 		this.paths = paths;
+		this.rule = rule;
+	}
+	/** The same query, its includes held to `rule` (the boundary's; `./include`). */
+	[withIncludeRule](rule) {
+		return new Query(this.engine, this.target, this.query, this.paths, rule);
 	}
 	/** Repeated calls are ANDed. */
 	where(build) {
@@ -1739,7 +1782,7 @@ var Query = class Query {
 	}
 	/** Loads related rows: refs in place of their ids, relations as lists (`"fest"`, `"registrations.members"`). */
 	include(...paths) {
-		return new Query(this.engine, this.target, this.query, [...this.paths, ...paths]);
+		return new Query(this.engine, this.target, this.query, [...this.paths, ...paths], this.rule);
 	}
 	async all() {
 		return this.fetch({
@@ -1843,7 +1886,7 @@ var Query = class Query {
 		return this.withIncludes(await this.engine.read(this.target.spec, query));
 	}
 	async withIncludes(rows) {
-		await loadIncludes(this.engine, this.target.spec, this.target.registry, rows, this.paths);
+		await loadIncludes(this.engine, this.target.spec, this.target.registry, rows, this.paths, this.rule);
 		return rows;
 	}
 	/** The first row (by the query's order), or `undefined`. */
@@ -1870,7 +1913,7 @@ var Query = class Query {
 		return new Query(this.engine, this.target, {
 			...this.query,
 			...change
-		}, this.paths);
+		}, this.paths, this.rule);
 	}
 };
 /** Kinds a group key may be: never free text. */
@@ -2885,7 +2928,6 @@ var UnsafeMigration = class extends Error {
 const COPY = "add a new field, copy the values in a data step, then remove the old one";
 const KEPT = "add a new field; the database fills it, then remove the old one";
 const PLAIN = "add a plain field, copy the values in a data step, then remove the old one";
-const REBUILD = "it needs a table rebuild, which isn't supported yet; add a new field instead";
 const CLEANUP = "pick another name, or drop the retired one first with `isai cleanup`";
 const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
 /** Why a column can't stay as it is when its field changes, and what to do instead; undefined when it can. */
@@ -2905,9 +2947,88 @@ function columnChange(before, after) {
 		change: `it's no longer kept by the database (${before.maintained})`,
 		advice: PLAIN
 	};
-	if (!same(before.references, after.references)) return {
-		change: before.references && after.references && before.references.table === after.references.table ? `its onDelete changed from ${before.references.onDelete} to ${after.references.onDelete}` : "its reference changed",
-		advice: REBUILD
+}
+/** Every table in the database under a schema: live ones with their retired columns, and retired tables. */
+function physicalTables(schema, alsoRetired = []) {
+	const retired = [...schema.retired, ...alsoRetired];
+	const tables = /* @__PURE__ */ new Map();
+	for (const table of Object.values(schema.tables)) {
+		const gone = retired.flatMap((r) => r.kind === "column" && r.table === table.name ? [r.column] : []);
+		tables.set(table.name, {
+			table,
+			columns: [...table.columns, ...gone]
+		});
+	}
+	for (const r of retired) if (r.kind === "table" && !tables.has(r.table.name)) tables.set(r.table.name, {
+		table: r.table,
+		columns: r.table.columns
+	});
+	return tables;
+}
+const referenced = (columns) => new Set(columns.flatMap((c) => c.references ? [c.references.table] : []));
+/**
+* The rebuild these schemas need, if any: the tables whose storage or a reference changed, with
+* every table that references one of them (live or retired, before or after), so no foreign key is
+* left pointing at a table that was dropped (`operations.ts` → rebuild).
+*/
+function rebuildOf(previous, next, retiredNow, unsafe) {
+	const before = physicalTables(previous);
+	const after = physicalTables({
+		...next,
+		retired: previous.retired
+	}, retiredNow);
+	const roots = Object.values(next.tables).filter((table) => {
+		const was = previous.tables[table.name];
+		if (!was) return false;
+		if (Boolean(was.withoutRowid) !== Boolean(table.withoutRowid)) return true;
+		const references = new Map(was.columns.map((c) => [c.name, c.references]));
+		return table.columns.some((c) => references.has(c.name) && !same(references.get(c.name), c.references));
+	});
+	if (roots.length === 0) return void 0;
+	const members = new Set(roots.map((table) => table.name));
+	for (let grew = true; grew;) {
+		grew = false;
+		for (const [name, table] of after) {
+			if (members.has(name) || !before.has(name)) continue;
+			if ([.../* @__PURE__ */ new Set([...referenced(table.columns), ...referenced(before.get(name)?.columns ?? [])])].some((ref) => members.has(ref))) {
+				members.add(name);
+				grew = true;
+			}
+		}
+	}
+	const ordered = [];
+	const pending = new Set(members);
+	while (pending.size > 0) {
+		const ready = [...pending].filter((name) => [...referenced(after.get(name)?.columns ?? [])].every((ref) => ref === name || !pending.has(ref)));
+		if (ready.length === 0) {
+			const tables = [...pending].sort();
+			unsafe.push({
+				model: after.get(tables[0] ?? "")?.table.model ?? "",
+				change: `its table is rebuilt, and ${tables.join(", ")} reference each other`,
+				advice: "break the cycle (make one of the refs a plain field) before the change that rebuilds them"
+			});
+			return;
+		}
+		for (const name of ready.sort()) {
+			ordered.push(name);
+			pending.delete(name);
+		}
+	}
+	const tables = ordered.map((name) => {
+		const { table, columns } = after.get(name);
+		return {
+			...table,
+			columns
+		};
+	});
+	return {
+		op: "rebuild",
+		tables,
+		copy: Object.fromEntries(tables.map((table) => {
+			const had = new Set(before.get(table.name)?.columns.map((c) => c.name));
+			return [table.name, table.columns.flatMap((c) => had.has(c.name) ? [c.name] : [])];
+		})),
+		triggers: []
 	};
 }
 /** A dropped column and an added one of the same kind, in one model: probably a rename. */
@@ -2998,12 +3119,18 @@ function diff(previous, next, since) {
 			index
 		});
 	}
+	const rebuild = rebuildOf(previous, next, retired, unsafe);
 	if (unsafe.length > 0) throw new UnsafeMigration(unsafe);
+	const rebuilt = new Set(rebuild?.tables.map((table) => table.name));
 	return {
-		operations: [...created.map((table) => ({
-			op: "createTable",
-			table
-		})), ...addColumns],
+		operations: [
+			...rebuild ? [rebuild] : [],
+			...created.map((table) => ({
+				op: "createTable",
+				table
+			})),
+			...addColumns.filter((operation) => operation.op !== "addColumn" || !rebuilt.has(operation.table))
+		],
 		retired,
 		renames
 	};
@@ -3154,7 +3281,15 @@ function tableOf(spec, registry, tables) {
 			unique: true
 		};
 	});
-	const refIndexes = columns.filter((c) => c.references && !uniques.some((u) => u.columns[0] === c.name)).map((c) => ({
+	const declared = spec.indexes.map((index) => {
+		const columns = index.fields.map(column);
+		return {
+			name: `${spec.table}_${columns.join("_")}_index`,
+			columns,
+			unique: false
+		};
+	});
+	const refIndexes = columns.filter((c) => c.references && ![...uniques, ...declared].some((index) => index.columns[0] === c.name)).map((c) => ({
 		name: `${spec.table}_${c.name}_index`,
 		columns: [c.name],
 		unique: false
@@ -3169,7 +3304,11 @@ function tableOf(spec, registry, tables) {
 		name: spec.table,
 		model: spec.name,
 		columns,
-		indexes: [...uniques, ...refIndexes],
+		indexes: [
+			...uniques,
+			...declared,
+			...refIndexes
+		],
 		guards: [...checks, ...limitGuards(spec)],
 		counts: countsOf(spec, registry),
 		copies: copiesOf(spec, registry),
@@ -3177,7 +3316,8 @@ function tableOf(spec, registry, tables) {
 			field,
 			column: columnName(field, fieldSpec),
 			transitions: fieldSpec.flow
-		}] : [])
+		}] : []),
+		withoutRowid: true
 	};
 }
 function snapshotOf(models) {
@@ -3209,7 +3349,11 @@ function generateMigration(options) {
 	const { previous, dialect, name, clock = systemClock } = options;
 	const live = snapshotOf(options.models);
 	const { operations, retired, renames } = diff(previous, live, dayOf(clock.now()));
-	const statements = operations.flatMap((operation) => dialect.render(operation));
+	const triggers = dialect.migrations.rules(previous).flatMap((rule) => rule.kind === "trigger" ? [rule.name] : []);
+	const statements = operations.map((operation) => operation.op === "rebuild" ? {
+		...operation,
+		triggers
+	} : operation).flatMap((operation) => dialect.render(operation));
 	const last = statements.length > 0 ? name : previous.last;
 	const stillRetired = previous.retired.filter((r) => r.kind !== "index" || !live.tables[r.table]?.indexes.some((index) => index.name === r.index.name));
 	const snapshot = {
@@ -3605,4 +3749,4 @@ async function migrateFresh(driver, models, options = {}) {
 	await sync(driver, manifest, options);
 }
 //#endregion
-export { planUpdate as A, NeedsDatabase as B, database as C, recordAction as D, forUpkeep as E, dialectFor as F, newSecretKey as G, fixedClock as H, sqlite as I, NotFound as J, CheckFailed as K, PLATFORM as L, Query as M, conditionOf as N, withTableTotals as O, modelOfRow as P, TENANT as R, clockOf as S, driverOf as T, systemClock as U, evaluate as V, utc as W, UniqueFailed as X, ReferenceFailed as Y, TODO as _, currentRelease as a, Database as b, rollback as c, applyRules as d, dayOf as f, UnsafeMigration as g, snapshotOf as h, acquireLock as i, keyCondition as j, planInsert as k, setReleaseStatus as l, emptySnapshot as m, migrateFresh as n, holdOf as o, generateMigration as p, DatabaseError as q, sync as r, releaseLock as s, migrate as t, startRelease as u, dataStep as v, decodeStored as w, Transaction as x, MigrationError as y, checkTenancy as z };
+export { planUpdate as A, checkTenancy as B, database as C, recordAction as D, forUpkeep as E, modelOfRow as F, utc as G, evaluate as H, dialectFor as I, DatabaseError as J, newSecretKey as K, sqlite as L, Query as M, conditionOf as N, withTableTotals as O, withIncludeRule as P, PLATFORM as R, clockOf as S, driverOf as T, fixedClock as U, NeedsDatabase as V, systemClock as W, ReferenceFailed as X, NotFound as Y, UniqueFailed as Z, TODO as _, currentRelease as a, Database as b, rollback as c, applyRules as d, dayOf as f, UnsafeMigration as g, snapshotOf as h, acquireLock as i, keyCondition as j, planInsert as k, setReleaseStatus as l, emptySnapshot as m, migrateFresh as n, holdOf as o, generateMigration as p, CheckFailed as q, sync as r, releaseLock as s, migrate as t, startRelease as u, dataStep as v, decodeStored as w, Transaction as x, MigrationError as y, TENANT as z };

package/dist/{model-Dc3HunKb.js → model-6pJBqqGd.js}

@@ -1,4 +1,4 @@
-import { A as fakeUlid, C as text, D as choice, E as url, F as quantity, I as sequence, M as id, N as int, O as date, P as money, R as list, S as subdomain, T as token, W as kind, _ as newToken, a as file, b as slug, c as image, d as json, f as urls, g as markdown, h as line, j as flag, k as datetime, l as images, n as phoneKind, p as email, s as files, u as define, v as personName, w as textKind, x as slugify, y as secret } from "./validation-Cppmd0RV.js";
+import { A as date, B as list, C as slugify, D as token, E as textKind, F as int, I as money, K as kind, L as quantity, M as fakeUlid, N as flag, O as url, P as id, R as sequence, S as slug, T as text, _ as line, a as document, b as personName, d as images, f as define, h as email, j as datetime, k as choice, l as files, m as urls, n as phoneKind, o as documents, p as json, s as file, u as image, v as markdown, w as subdomain, x as secret, y as newToken } from "./validation-C3MCRBQO.js";
 import { n as snakeCase, r as ulid } from "./case-DpXlJCL9.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/internal/scope.ts
@@ -920,6 +920,10 @@ function fieldKinds(defaults) {
 		image: (options = {}) => field(image(options), "json"),
 		files: (options = {}) => field(files(options), "json"),
 		images: (options = {}) => field(images(options), "json"),
+		/** A PDF or image to print or read whole (never resized), up to 100 MB; `{ storage }` as for `file`. */
+		document: (options = {}) => field(document(options), "json"),
+		/** Up to 100 documents: an order's files. */
+		documents: (options = {}) => field(documents(options), "json"),
 		/** A row of another model, by its id. Restricts deletes of that row unless `.cascade()` / `.setNull()`. */
 		ref: (model, options = {}) => new Field(fieldSpec(id(`a ${model} id`), "text", { ref: {
 			model,
@@ -1091,6 +1095,31 @@ var Model = class Model {
 		});
 	}
 	/**
+	* An index on these fields, in this order, for the lists the app runs: a list sorted by a field
+	* (`.index("createdAt")`), or filtered by one field then sorted by another
+	* (`.index("status", "createdAt")`). Refs index themselves, and traits bring the indexes their
+	* behaviour needs (`publishable`: `publishedAt`; `ordered`: its group, then `position`), so most
+	* models never call it. `isai check` warns when a resource sorts by a field no index leads with.
+	* Each index costs a row written on every insert, and on each update of its fields.
+	*/
+	index(...fields) {
+		const name = this.spec.name;
+		if (fields.length === 0) throw new TypeError(`isai: ${name}.index() takes one or more fields`);
+		if (new Set(fields).size !== fields.length) throw new TypeError(`isai: ${name}.index() lists a field twice`);
+		for (const field of fields) {
+			const spec = this.spec.fields[field];
+			if (!spec || spec.computed) throw new TypeError(`isai: ${name}.index() lists "${field}", which isn't one of ${name}'s stored fields`);
+			assertNotEncrypted(this.spec, field, "indexed");
+		}
+		const key = fields.join(",");
+		if (this.spec.indexes.some((index) => index.fields.join(",") === key)) throw new TypeError(`isai: ${name} already has an index on ${fields.join(", ")}`);
+		if (this.spec.uniques.some((unique) => unique.fields.join(",") === key)) throw new TypeError(`isai: ${name} already has a unique on ${fields.join(", ")}, which is an index too`);
+		return this.derive({
+			...this.spec,
+			indexes: [...this.spec.indexes, { fields }]
+		});
+	}
+	/**
 	* The table it's stored in, when that isn't its name in snake_case: after the model was renamed,
 	* so the data stays where it is (`model("Squad", {…}).table("team")`). Physical renames never happen.
 	*/
@@ -1302,6 +1331,7 @@ function defineModel(registry, name, declared, traits = [], origin = {}) {
 		table: snakeCase(name),
 		fields: withCopyPaths(name, specs, registry, () => spec),
 		uniques,
+		indexes: traits.flatMap((trait) => (trait.spec.indexes ?? []).map((fields) => ({ fields }))),
 		checks: [],
 		traits: names,
 		...origin.database === void 0 ? {} : { database: origin.database },

package/dist/{policies-KsqmlX67.js → policies-C_oiSgmY.js}

@@ -1,4 +1,4 @@
-import { G as isRecorded, _ as Expr, c as rowOf, h as Condition, j as nodesOf, r as columnName, w as conditionNode } from "./model-Dc3HunKb.js";
+import { G as isRecorded, _ as Expr, c as rowOf, h as Condition, j as nodesOf, r as columnName, w as conditionNode } from "./model-6pJBqqGd.js";
 //#region src/auth/enforce.ts
 /**
 * Checking a policy: its action's condition, with the

package/dist/{resource-BQK7bkPQ.js → resource-BIMAiOre.js}

@@ -1,7 +1,7 @@
-import { G as ValidationError, H as validate, V as toKind, z as object } from "./validation-Cppmd0RV.js";
-import { J as NotFound, K as CheckFailed, X as UniqueFailed, Y as ReferenceFailed } from "./migrator-B25prc9n.js";
-import { C as asCondition, _ as Expr, g as Embed, l as IMPLICIT_FIELDS, r as columnName, s as computedFieldOf } from "./model-Dc3HunKb.js";
-import { r as actionsOf } from "./policies-KsqmlX67.js";
+import { U as toKind, V as object, W as validate, q as ValidationError } from "./validation-C3MCRBQO.js";
+import { X as ReferenceFailed, Y as NotFound, Z as UniqueFailed, q as CheckFailed } from "./migrator-DxTpns_-.js";
+import { C as asCondition, _ as Expr, g as Embed, l as IMPLICIT_FIELDS, r as columnName, s as computedFieldOf } from "./model-6pJBqqGd.js";
+import { r as actionsOf } from "./policies-C_oiSgmY.js";
 import { n as RESERVED, t as LOOKUPS } from "./syntax-CrUZFrS7.js";
 //#region src/api/fail.ts
 /**
@@ -199,13 +199,15 @@ var Route = class {
 	anonymous;
 	handler;
 	platform;
-	constructor(method, path, input, anonymous, handler, platform = false) {
+	upload;
+	constructor(method, path, input, anonymous, handler, platform = false, upload) {
 		this.method = method;
 		this.path = path;
 		this.input = input;
 		this.anonymous = anonymous;
 		this.handler = handler;
 		this.platform = platform;
+		this.upload = upload;
 	}
 };
 function declare(method) {
@@ -214,7 +216,7 @@ function declare(method) {
 		const handler = typeof second === "function" ? second : third;
 		if (!handler) throw new TypeError(`isai: ${method} ${path} has no handler`);
 		if (!path.startsWith("/")) throw new TypeError(`isai: a route's path starts with "/" (${method} ${path})`);
-		return new Route(method, path, options.input ?? {}, options.anonymous ?? false, handler, options.platform ?? false);
+		return new Route(method, path, options.input ?? {}, options.anonymous ?? false, handler, options.platform ?? false, options.upload);
 	}
 	return define;
 }

package/dist/{tables-DgSwge7s.js → tables-DjW96Ubl.js}

@@ -1,4 +1,4 @@
-import { a as defineModel, t as Model } from "./model-Dc3HunKb.js";
+import { a as defineModel, t as Model } from "./model-6pJBqqGd.js";
 //#region src/db/schema/builtins.ts
 /**
 * Built-in tables: sets of models a part of isai owns, switched on

package/dist/testing/index.d.ts

@@ -1,5 +1,5 @@
 import { a as DatabaseDriver, g as Storage } from "../index-Ce5p2-EB.js";
-import { I as Clock, L as FixedClock, R as fixedClock, V as AnyModel, i as Row, l as Overrides, p as Database, s as Makers, u as Seed } from "../types-BgOkJy5d.js";
+import { I as Clock, L as FixedClock, R as fixedClock, V as AnyModel, i as Row, l as Overrides, p as Database, s as Makers, u as Seed } from "../types-D5SIVeej.js";
 //#region src/testing/conformance/database.d.ts
 /**
  * Makes the driver under test. Every call must return a driver on an **empty** database:

package/dist/testing/index.js

@@ -1,8 +1,8 @@
 import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.js";
-import { F as dialectFor, H as fixedClock, L as PLATFORM, R as TENANT, W as utc, a as currentRelease, b as Database, c as rollback, i as acquireLock, j as keyCondition, l as setReleaseStatus, m as emptySnapshot, n as migrateFresh, o as holdOf, p as generateMigration, r as sync, s as releaseLock, t as migrate, u as startRelease, v as dataStep, y as MigrationError } from "../migrator-B25prc9n.js";
-import { L as toBase64url, t as Model } from "../model-Dc3HunKb.js";
-import { t as createDataLayer } from "../data-layer-C5oJZ8V1.js";
-import { d as forgetGoogleKeys, r as authOf, s as GOOGLE, t as makers, y as seedAs } from "../makers-P9kg68C8.js";
+import { G as utc, I as dialectFor, R as PLATFORM, U as fixedClock, a as currentRelease, b as Database, c as rollback, i as acquireLock, j as keyCondition, l as setReleaseStatus, m as emptySnapshot, n as migrateFresh, o as holdOf, p as generateMigration, r as sync, s as releaseLock, t as migrate, u as startRelease, v as dataStep, y as MigrationError, z as TENANT } from "../migrator-DxTpns_-.js";
+import { L as toBase64url, t as Model } from "../model-6pJBqqGd.js";
+import { t as createDataLayer } from "../data-layer-CVCFjPyv.js";
+import { d as forgetGoogleKeys, r as authOf, s as GOOGLE, t as makers, y as seedAs } from "../makers-A0Pj6Tda.js";
 import { describe, expect, it } from "vitest";
 //#region src/testing/conformance/database.ts
 /**

package/dist/{types-BgOkJy5d.d.ts → types-D5SIVeej.d.ts}

@@ -1,5 +1,5 @@
 import { a as DatabaseDriver, f as Row$1, h as Sql, o as DialectName } from "./index-Ce5p2-EB.js";
-import { E as list, G as FileType, M as IdInput, T as Shape, Y as StoredFile, ct as Sensitivity, ft as StandardProps, g as KindDefinition, h as Definable, nt as AnyKind, ot as KindTypes, q as ImageType, st as Measure, w as Output, x as Input$2 } from "./index-CYcklQ1l.js";
+import { E as list, G as FileType, M as IdInput, T as Shape, Y as StoredFile, ct as KindTypes, g as KindDefinition, h as Definable, it as AnyKind, lt as Measure, mt as StandardProps, q as ImageType, ut as Sensitivity, w as Output, x as Input$2 } from "./index-CaR3hb0i.js";
 //#region src/db/fields/slot.d.ts
 interface SlotSpec {
   /** Namespaced by module: `auth.owner`. */
@@ -296,6 +296,14 @@ declare function fieldKinds(defaults: () => SchemaDefaults): {
     readonly types?: readonly ImageType[];
     readonly storage?: string;
   }) => Field<StoredFile[], StoredFile[], false, false, {}>;
+  /** A PDF or image to print or read whole (never resized), up to 100 MB; `{ storage }` as for `file`. */
+  document: (options?: {
+    readonly storage?: string;
+  }) => Field<StoredFile, StoredFile, false, false, {}>;
+  /** Up to 100 documents: an order's files. */
+  documents: (options?: {
+    readonly storage?: string;
+  }) => Field<StoredFile[], StoredFile[], false, false, {}>;
   /** A row of another model, by its id. Restricts deletes of that row unless `.cascade()` / `.setNull()`. */
   ref: <const Model extends string, const Related extends string | undefined = undefined>(model: Model, options?: {
     readonly related?: Related;
@@ -673,6 +681,10 @@ declare class ModelRegistry {
 interface UniqueSpec {
   readonly fields: readonly string[];
 }
+/** An index the model asks for (`.index(...)`, or a trait's), by field names, in order. */
+interface IndexSpec {
+  readonly fields: readonly string[];
+}
 interface CheckSpec {
   readonly name: string;
   readonly condition: ConditionNode;
@@ -685,6 +697,8 @@ interface ModelSpec {
   /** Every field, implicit ones first, in declaration order. */
   readonly fields: Readonly<Record<string, FieldSpec>>;
   readonly uniques: readonly UniqueSpec[];
+  /** Its plain indexes: its traits' first, then `.index(...)`. Refs' indexes are added by the schema. */
+  readonly indexes: readonly IndexSpec[];
   readonly checks: readonly CheckSpec[];
   /** The traits it took (`ordered`, `singleton`…), by name. */
   readonly traits: readonly string[];
@@ -773,6 +787,15 @@ declare class Model<Name extends string = string, F extends Fields = Fields, Uni
   get name(): Name;
   /** A unique combination of two or more fields (one field: `.unique()` on the field). */
   unique<const K extends readonly [keyof F & string, keyof F & string, ...(keyof F & string)[]]>(...fields: K): Model<Name, F, Uniques | K>;
+  /**
+   * An index on these fields, in this order, for the lists the app runs: a list sorted by a field
+   * (`.index("createdAt")`), or filtered by one field then sorted by another
+   * (`.index("status", "createdAt")`). Refs index themselves, and traits bring the indexes their
+   * behaviour needs (`publishable`: `publishedAt`; `ordered`: its group, then `position`), so most
+   * models never call it. `isai check` warns when a resource sorts by a field no index leads with.
+   * Each index costs a row written on every insert, and on each update of its fields.
+   */
+  index<const K extends readonly [keyof (ImplicitFields & F) & string, ...(keyof (ImplicitFields & F) & string)[]]>(...fields: K): Model<Name, F, Uniques>;
   /**
    * The table it's stored in, when that isn't its name in snake_case: after the model was renamed,
    * so the data stays where it is (`model("Squad", {…}).table("team")`). Physical renames never happen.
@@ -941,6 +964,12 @@ interface TableSnapshot {
   readonly counts: readonly CountSnapshot[];
   readonly copies: readonly CopySnapshot[];
   readonly flows: readonly FlowSnapshot[];
+  /**
+   * Its rows live in its primary key's index (`WITHOUT ROWID`): every model's table, since the id is
+   * text, so a plain table would also keep a hidden rowid and a second index on the id, one more row
+   * written per insert and read per lookup. Absent in snapshots from before, whose tables are rebuilt.
+   */
+  readonly withoutRowid?: true;
 }
 /**
  * Something the models no longer have, kept in the database until `isai cleanup` so that an
@@ -1013,6 +1042,25 @@ type Operation = {
 {
   readonly op: "dropTable";
   readonly table: TableSnapshot;
+} |
+/**
+ * Tables made again (a new storage, a reference's `onDelete`), with every table that references
+ * one of them, so no foreign key ever points at a dropped table. Cloudflare's SQLite can't turn
+ * foreign keys off (`PRAGMA foreign_keys = OFF` is ignored), and dropping a referenced table
+ * deletes its rows first, which would cascade into the rows that reference them. So: the old
+ * tables are renamed aside, the new ones created and filled, and the old ones dropped children
+ * first, when nothing references them any more. Rules (indexes, triggers) are dropped with them,
+ * every trigger first (one naming a renamed table would stop the rename), and come back from the
+ * schema after the step.
+ */
+{
+  readonly op: "rebuild";
+  /** The tables as they become, retired columns included, in dependency order (parents first). */
+  readonly tables: readonly TableSnapshot[];
+  /** Each table's columns that hold data now, copied across. */
+  readonly copy: Readonly<Record<string, readonly string[]>>;
+  /** Every trigger the database has now, by name. */
+  readonly triggers: readonly string[];
 };
 //#endregion
 //#region src/db/dialects/dialect.d.ts
@@ -1227,6 +1275,12 @@ declare class Engine {
   private secrets;
 }
 //#endregion
+//#region src/db/orm/include.d.ts
+/** The condition a model's related rows must meet, or `false` when none may be read. */
+type IncludeRule = (model: ModelSpec) => Promise<ConditionNode | false>;
+/** How the boundary gives a query its `IncludeRule`: internal, so the app's API never shows it. */
+declare const withIncludeRule: unique symbol;
+//#endregion
 //#region src/db/orm/page.d.ts
 interface PageOptions {
   /** Rows per page. */
@@ -1312,7 +1366,10 @@ declare class Query<M extends AnyModel, R> implements PromiseLike<R[]> {
   private readonly target;
   private readonly query;
   private readonly paths;
-  constructor(engine: Engine, target: M, query?: SelectQuery, paths?: readonly string[]);
+  private readonly rule?;
+  constructor(engine: Engine, target: M, query?: SelectQuery, paths?: readonly string[], rule?: IncludeRule | undefined);
+  /** The same query, its includes held to `rule` (the boundary's; `./include`). */
+  [withIncludeRule](rule: IncludeRule): Query<M, R>;
   /** Repeated calls are ANDed. */
   where(build: (row: RowOf<M>) => Condition): Query<M, R>;
   order(...keys: readonly OrderKey<M>[]): Query<M, R>;

package/dist/validation/index.d.ts

@@ -1,3 +1,3 @@
 import { a as ValidationError, i as Result, n as IssueCode, r as Path, t as Issue } from "../issues-CKto95IW.js";
-import { $ as images, A as validate, B as money, C as ObjectShape, D as object, E as list, F as datetime, G as FileType, H as sequence, I as fakeUlid, J as SIZES_MAX, K as ImageSize, L as flag, M as IdInput, N as choice, O as serialize, P as date, Q as image, R as id, S as LIST_MAX, T as Shape, U as phone, V as quantity, W as phoneKind, X as file, Y as StoredFile, Z as files, _ as define, a as newToken, at as KindSpec, b as CarriesKind, c as slug, ct as Sensitivity, d as text, dt as StandardIssue, et as Fake, f as textKind, ft as StandardProps, g as KindDefinition, h as Definable, i as markdown, it as Kind, j as CalendarDate, k as toKind, l as slugify, lt as TypeText, m as url, mt as StandardSchemaV1, n as host, nt as AnyKind, o as personName, ot as KindTypes, p as token, pt as StandardResult, q as ImageType, r as line, rt as FileSpec, s as secret, st as Measure, t as email, tt as FakeContext, u as subdomain, ut as kind, v as json, w as Output, x as Input, y as urls, z as int } from "../index-CYcklQ1l.js";
-export { type AnyKind, type CalendarDate, type CarriesKind, type Definable, Fake, type FakeContext, type FileSpec, type FileType, type IdInput, type ImageSize, type ImageType, type Input, type Issue, type IssueCode, Kind, type KindDefinition, type KindSpec, type KindTypes, LIST_MAX, type Measure, type ObjectShape, type Output, type Path, type Result, SIZES_MAX, type Sensitivity, type Shape, type StandardIssue, type StandardProps, type StandardResult, type StandardSchemaV1, type StoredFile, type TypeText, ValidationError, choice, date, datetime, define, email, fakeUlid, file, files, flag, host, id, image, images, int, json, kind, line, list, markdown, money, newToken, object, personName, phone, phoneKind, quantity, secret, sequence, serialize, slug, slugify, subdomain, text, textKind, toKind, token, url, urls, validate };
+import { $ as files, A as validate, B as money, C as ObjectShape, D as object, E as list, F as datetime, G as FileType, H as sequence, I as fakeUlid, J as SIZES_MAX, K as ImageSize, L as flag, M as IdInput, N as choice, O as serialize, P as date, Q as file, R as id, S as LIST_MAX, T as Shape, U as phone, V as quantity, W as phoneKind, X as document, Y as StoredFile, Z as documents, _ as define, a as newToken, at as FileSpec, b as CarriesKind, c as slug, ct as KindTypes, d as text, dt as TypeText, et as image, f as textKind, ft as kind, g as KindDefinition, gt as StandardSchemaV1, h as Definable, ht as StandardResult, i as markdown, it as AnyKind, j as CalendarDate, k as toKind, l as slugify, lt as Measure, m as url, mt as StandardProps, n as host, nt as Fake, o as personName, ot as Kind, p as token, pt as StandardIssue, q as ImageType, r as line, rt as FakeContext, s as secret, st as KindSpec, t as email, tt as images, u as subdomain, ut as Sensitivity, v as json, w as Output, x as Input, y as urls, z as int } from "../index-CaR3hb0i.js";
+export { type AnyKind, type CalendarDate, type CarriesKind, type Definable, Fake, type FakeContext, type FileSpec, type FileType, type IdInput, type ImageSize, type ImageType, type Input, type Issue, type IssueCode, Kind, type KindDefinition, type KindSpec, type KindTypes, LIST_MAX, type Measure, type ObjectShape, type Output, type Path, type Result, SIZES_MAX, type Sensitivity, type Shape, type StandardIssue, type StandardProps, type StandardResult, type StandardSchemaV1, type StoredFile, type TypeText, ValidationError, choice, date, datetime, define, document, documents, email, fakeUlid, file, files, flag, host, id, image, images, int, json, kind, line, list, markdown, money, newToken, object, personName, phone, phoneKind, quantity, secret, sequence, serialize, slug, slugify, subdomain, text, textKind, toKind, token, url, urls, validate };

package/dist/validation/index.js

@@ -1 +1 @@
-export { K as Fake, U as Kind, L as LIST_MAX, i as SIZES_MAX, G as ValidationError, D as choice, O as date, k as datetime, u as define, p as email, A as fakeUlid, a as file, s as files, j as flag, m as host, M as id, c as image, l as images, N as int, d as json, W as kind, h as line, R as list, g as markdown, P as money, _ as newToken, z as object, v as personName, t as phone, n as phoneKind, F as quantity, y as secret, I as sequence, B as serialize, b as slug, x as slugify, S as subdomain, C as text, w as textKind, V as toKind, T as token, E as url, f as urls, H as validate } from "../validation-Cppmd0RV.js";
+export { J as Fake, G as Kind, z as LIST_MAX, i as SIZES_MAX, q as ValidationError, k as choice, A as date, j as datetime, f as define, a as document, o as documents, h as email, M as fakeUlid, s as file, l as files, N as flag, g as host, P as id, u as image, d as images, F as int, p as json, K as kind, _ as line, B as list, v as markdown, I as money, y as newToken, V as object, b as personName, t as phone, n as phoneKind, L as quantity, x as secret, R as sequence, H as serialize, S as slug, C as slugify, w as subdomain, T as text, E as textKind, U as toKind, D as token, O as url, m as urls, W as validate } from "../validation-C3MCRBQO.js";