@atscript/db 0.1.146 → 0.1.148

package/dist/plugin.mjs

@@ -1,10 +1,11 @@
-import { i as SUPPORTED_AGGREGATE_FNS, r as NULL_WHEN_EMPTY_AGGREGATE_FNS } from "./aggregate-fns-CfsveE1w.mjs";
+import { i as NULL_WHEN_EMPTY_AGGREGATE_FNS, o as SUPPORTED_AGGREGATE_FNS, t as AGG_ANNOTATIONS } from "./aggregate-fns-CyaZyb9I.mjs";
 import { n as DERIVED_INCOMPATIBLE, r as JSON_LEAF_TYPES, t as DB_ENTITY_ANNOTATIONS } from "./derived-rules-0sKn4f5C.mjs";
+import { t as numericTypeProblem } from "./numeric-operand-B1jKH7x5.mjs";
 import "./consts-C_-5_pFq.mjs";
-import { S as validateSiblingStringField, _ as getParentTypeName, a as hasAnyViewAnnotation, b as validateExclusiveWith, d as viewJoins, f as viewScopeTypes, g as getParentStruct, h as getNavTargetTypeName, l as validateQueryScope, m as getDbTableOwner, n as findFKFieldsPointingTo, o as isAliasDecl, p as getAnnotationAlias, r as findViewCycle, s as isDbSourceDecl, t as earlierJoinTargets, u as validateRefArgument, v as primitiveBaseType, x as validateFieldBaseType, y as refActionAnnotation } from "./validation-utils-CMR4fe2M.mjs";
+import { S as validateSiblingStringField, _ as getParentTypeName, a as hasAnyViewAnnotation, b as validateExclusiveWith, d as viewJoins, f as viewScopeTypes, g as getParentStruct, h as getNavTargetTypeName, i as forEachFieldRef, l as validateQueryScope, m as getDbTableOwner, n as findFKFieldsPointingTo, o as isAliasDecl, p as getAnnotationAlias, r as findViewCycle, s as isDbSourceDecl, t as earlierJoinTargets, u as validateRefArgument, v as primitiveBaseType, x as validateFieldBaseType, y as refActionAnnotation } from "./validation-utils-Dq0uZ7ef.mjs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { AnnotationSpec, DEFAULT_FORMAT, isArray, isInterface, isPrimitive, isProp, isRef, isStructure } from "@atscript/core";
+import { AnnotationSpec, DEFAULT_FORMAT, getFieldsForType, isArray, isInterface, isPrimitive, isProp, isQueryComparison, isQueryLogical, isRef, isStructure } from "@atscript/core";
 //#region src/plugin/manifest.ts
 /**
 * Renders the model-manifest module: an inventory of every exported
@@ -138,6 +139,27 @@ function viewHavingScope(view) {
 		unqualifiedTarget: view.id
 	} : void 0;
 }
+/**
+* The ordering (4th argument) of a first-row `@db.view.joins`: the join
+* target only — an unqualified key is a field of the target.
+* @since 0.1.147
+*/
+function joinOrderScope(join) {
+	const target = join.args[0]?.text;
+	return target ? {
+		allowedTypes: [target],
+		unqualifiedTarget: target
+	} : void 0;
+}
+/**
+* The expression of a `@db.compute` on a view field: the view's own fields,
+* unqualified — the `@db.view.having` scope.
+* @since 0.1.147
+*/
+function computeScope(propToken) {
+	const view = getDbTableOwner(propToken);
+	return view ? viewHavingScope(view) : void 0;
+}
 /** The condition of a `@db.agg.*` on a view field: the scope of the view's `@db.view.filter`. */
 function aggConditionScope(propToken) {
 	const view = getDbTableOwner(propToken);
@@ -172,16 +194,25 @@ function relFilterScope(field) {
 		unqualifiedTarget: target
 	};
 }
+/** The `@db.view.joins` annotation one of whose arguments is `arg`. */
+function joinOfArg(joins, arg) {
+	return joins.find((a) => a.args.includes(arg));
+}
 /** The `fieldScope` hooks (argument token → scope) the annotation specs declare. */
 const fieldScopes = {
 	viewFilter: (arg) => arg.parentNode ? viewFilterScope(arg.parentNode) : void 0,
 	viewJoin: (arg) => {
 		const view = arg.parentNode;
 		const joins = view ? viewJoins(view) : [];
-		const join = joins.find((a) => a.args.includes(arg));
+		const join = joinOfArg(joins, arg);
 		return view && join ? viewJoinScope(view, join, earlierJoinTargets(joins, join)) : void 0;
 	},
+	joinOrder: (arg) => {
+		const join = arg.parentNode ? joinOfArg(viewJoins(arg.parentNode), arg) : void 0;
+		return join ? joinOrderScope(join) : void 0;
+	},
 	viewHaving: (arg) => arg.parentNode ? viewHavingScope(arg.parentNode) : void 0,
+	compute: computeScope,
 	aggCondition: aggConditionScope,
 	aggField: aggFieldScope,
 	relFilter: (arg) => arg.parentNode ? relFilterScope(arg.parentNode) : void 0
@@ -832,6 +863,123 @@ function columnCapability(capability, verb) {
 	});
 }
 //#endregion
+//#region src/plugin/annotations/compute.ts
+/** What a `@db.compute` field cannot also carry (VC1). */
+const EXCLUSIVE_WITH = [
+	...AGG_ANNOTATIONS,
+	"db.json",
+	"db.ignore"
+].map((key) => ({ key }));
+/** The `@db.compute` expression token of a prop, if any. */
+function computeArg(prop) {
+	return prop?.annotations?.find((a) => a.name === "db.compute")?.args[0];
+}
+/**
+* Whether a prop is typed exactly `number` (a plain primitive ref — no chain
+* ref, no `number.*` extension).
+*/
+function isPlainNumber(prop, doc) {
+	const def = prop.getDefinition();
+	if (!def || !isRef(def) || def.hasChain || def.id !== "number") return false;
+	return isPrimitive(doc.unwindType("number")?.def);
+}
+/**
+* Why an operand prop cannot be computed with, or `undefined` when it can:
+* its resolved type must be a `number` primitive — not `decimal`, not a
+* timestamp — and it must have storage (no `@db.ignore`).
+*/
+function operandProblem(prop, doc) {
+	if (prop.countAnnotations("db.ignore") > 0) return "is @db.ignore'd";
+	if (computeArg(prop)) return void 0;
+	const def = prop.getDefinition();
+	const leaf = def && isRef(def) ? doc.unwindType(def.id, def.chain)?.def : def;
+	const base = primitiveBaseType(leaf);
+	if (base === void 0) return void 0;
+	return numericTypeProblem({
+		base,
+		tags: isPrimitive(leaf) ? leaf.tags : void 0
+	});
+}
+/** VC6 — whether an expression may be NULL (`/` by zero, an optional operand). */
+function exprNullable(node, props) {
+	if ("value" in node) return false;
+	if ("left" in node) return node.op === "/" || exprNullable(node.left, props) || exprNullable(node.right, props);
+	if ("operand" in node) return exprNullable(node.operand, props);
+	if ("args" in node) return node.args.every((a) => exprNullable(a, props));
+	return props.get(node.fieldRef.text)?.has("optional") ?? false;
+}
+/**
+* VC4 — the first `@db.compute` cycle through `start`, as field names
+* (`rank → priority → rank`), or `undefined`.
+*/
+function findComputeCycle(start, props) {
+	const path = [];
+	const done = /* @__PURE__ */ new Set();
+	const visit = (name) => {
+		const at = path.indexOf(name);
+		if (at !== -1) return name === start ? [...path.slice(at), name] : void 0;
+		if (done.has(name)) return void 0;
+		const refs = computeArg(props.get(name))?.exprNode?.fieldRefs() ?? [];
+		path.push(name);
+		for (const ref of refs) {
+			if (ref.typeRef) continue;
+			const cycle = visit(ref.fieldRef.text);
+			if (cycle) return cycle;
+		}
+		path.pop();
+		done.add(name);
+	};
+	return visit(start);
+}
+function validateCompute(token, args, doc) {
+	const errors = [];
+	const prop = token.parentNode;
+	const field = prop.id ?? "field";
+	const view = getDbTableOwner(token);
+	const error = (message, range = token.range) => errors.push({
+		message,
+		severity: 1,
+		range
+	});
+	if (!view || view.countAnnotations("db.view.for") === 0) {
+		error("@db.compute is only valid on a field of a @db.view.for view");
+		return errors;
+	}
+	errors.push(...validateExclusiveWith(token, "@db.compute", EXCLUSIVE_WITH));
+	if (!isPlainNumber(prop, doc)) error(`Field "${field}" has a @db.compute and must be typed \`number\``);
+	const expr = args[0]?.exprNode;
+	if (!expr) return errors;
+	const refs = expr.fieldRefs();
+	const props = viewProps(view) ?? /* @__PURE__ */ new Map();
+	if (refs.length === 0) error("@db.compute needs at least one view field — a constant column is not supported", args[0].range);
+	const scope = viewHavingScope(view);
+	if (scope) errors.push(...validateQueryScope(args[0], scope, doc, "@db.compute references the view's own fields — declare it on the view first (`field: Type.field`)"));
+	for (const ref of refs) {
+		if (ref.typeRef) continue;
+		const operand = props.get(ref.fieldRef.text);
+		const why = operand && operandProblem(operand, doc);
+		if (why) error(`@db.compute operand '${ref.fieldRef.text}' ${why} — operands must be number fields`, ref.fieldRef.range);
+	}
+	if (prop.id) {
+		const cycle = findComputeCycle(prop.id, props);
+		if (cycle) error(`@db.compute of "${field}" depends on itself: ${cycle.join(" → ")}`, args[0].range);
+	}
+	if (!prop.has("optional") && exprNullable(expr.expression, props)) error(`Field "${field}" has a @db.compute that may be NULL and must be optional (${field}?: …) — it is NULL when an operand is NULL or a divisor is 0`);
+	return errors;
+}
+const dbComputeAnnotations = { compute: new AnnotationSpec({
+	description: "Declares a **computed view column** (since 0.1.147): closed arithmetic over the view's own fields — dimensions, aggregates, first-row-join fields and other computed fields — evaluated by the database, so the column sorts, filters and pages like any other.\n\nGrammar: `+ - * /`, unary `-`, parentheses, numeric literals, `coalesce(a, b, …)`. Every value is a double (`7 / 2 = 3.5`); a NULL operand yields NULL; division by zero yields NULL — so an expression with `/` or an optional operand needs an optional field.\n\n**Example:**\n```atscript\n@db.agg.count 'id', `Issue.status = 'open'`\nopenCount: Issue.id\n\n@db.compute `openCount * 10 + coalesce(oldestSeverity, 0)`\nrank: number\n```\n",
+	nodeType: ["prop"],
+	passedWhenReferred: false,
+	argument: {
+		name: "expression",
+		type: "expr",
+		description: "Arithmetic over the view's own fields (unqualified): `+ - * /`, unary `-`, parentheses, numbers, `coalesce(a, b, …)`.",
+		fieldScope: fieldScopes.compute
+	},
+	validate: validateCompute
+}) };
+//#endregion
 //#region src/plugin/annotations/index-ann.ts
 const dbIndexAnnotations = { index: {
 	plain: new AnnotationSpec({
@@ -899,6 +1047,31 @@ const dbIndexAnnotations = { index: {
 } };
 //#endregion
 //#region src/plugin/annotations/rel.ts
+/**
+* X2b: on a `@db.table` a foreign key is a real constraint — one column of a
+* composite primary key is not unique on its own. Columns that together cover
+* the whole key (same alias, same target, each naming a top-level key column)
+* are a valid composite foreign key. Returns whether `token`'s FK is covered
+* (or the rule does not apply). Cheap checks run before the sibling scan.
+*/
+function checkCompositeFkCoverage(token, alias, refTypeName, targetStruct, targetProp) {
+	if (targetProp.countAnnotations("db.index.unique") > 0) return true;
+	const pk = [...targetStruct.props.entries()].filter(([, p]) => p.countAnnotations("meta.id") > 0).map(([name]) => name);
+	if (pk.length <= 1) return true;
+	const hostStruct = getParentStruct(token);
+	const owner = getDbTableOwner(token);
+	if (!hostStruct || owner === void 0 || !isDbTable(owner)) return true;
+	const covered = /* @__PURE__ */ new Set();
+	for (const [, sibling] of hostStruct.props) {
+		if (sibling.countAnnotations("db.rel.FK") === 0) continue;
+		if (getAnnotationAlias(sibling, "db.rel.FK") !== alias) continue;
+		const siblingDef = sibling.getDefinition();
+		if (siblingDef && isRef(siblingDef) && siblingDef.id === refTypeName) {
+			if (siblingDef.chain.length === 1) covered.add(siblingDef.chain[0].text);
+		}
+	}
+	return pk.every((name) => covered.has(name));
+}
 const dbRelAnnotations = { rel: {
 	FK: new AnnotationSpec({
 		description: "Declares a foreign key reference on this field. The field must use a chain reference type (e.g., `User.id`) whose target is a primary key (`@meta.id`) or unique (`@db.index.unique`) field.\n\n**Dual role:**\n- On a `@db.table` interface, `@db.rel.FK` additionally drives DB-relation semantics —   relation loading with `@db.rel.to` / `@db.rel.from`, junction pairing with `@db.rel.via`, etc.\n- On any other interface (value-help sources, WF forms, plain interfaces), `@db.rel.FK`   acts purely as the value-help indicator: the client-side picker resolver uses it to   decide which fields render a value-help picker. The target's `@db.http.path` (stamped   by its readable controller) supplies the picker URL.\n- In `/meta` (and `/meta/form/:name`) the marker is inherited through reference chains:   a field declared as `code: Issue.code` where `Issue.code: Dict.code` carries `@db.rel.FK`   is served with `ref` pointing at the terminal field (`Dict.code`) and `db.rel.FK: true`,   so view fields get the dictionary picker. Runtime metadata is untouched.\n\n**Example:**\n```atscript\n@db.rel.FK\nauthorId: User.id\n\n// With alias (required when multiple FKs point to the same type)\n@db.rel.FK \"author\"\nauthorId: User.id\n```\n",
@@ -944,6 +1117,11 @@ const dbRelAnnotations = { rel: {
 								severity: 1,
 								range: token.range
 							});
+							if (!checkCompositeFkCoverage(token, alias, refTypeName, struct, targetProp)) errors.push({
+								message: `@db.rel.FK target '${refTypeName}.${chainFields.join(".")}' is one column of a composite primary key — a foreign key must reference a unique column; for value help without a constraint use @ui.valueHelp`,
+								severity: 1,
+								range: token.range
+							});
 							const propDef = targetProp.getDefinition();
 							if (propDef && isRef(propDef)) {
 								const propUnwound = targetUnwound.doc.unwindType(propDef.id, propDef.chain);
@@ -1222,8 +1400,23 @@ const dbRelAnnotations = { rel: {
 			return errors;
 		}
 	}),
+	filterable: new AnnotationSpec({
+		description: "Lets HTTP clients filter the parent rows by this relation's related rows — `ticket=$some(status=open)` / `ticket=$none(...)` in a moost-db query (`{ ticket: { $some: { status: 'open' } } }`). Off by default: a client predicate filters the PARENT set and runs a correlated subquery. Server-side code (`transformFilter`, `actionRowScope`, direct table calls) never needs it. The related table's own field rules (visibility, encryption, write-only) apply inside the predicate.\n\n**Example:**\n```atscript\n@db.rel.to\n@db.rel.filterable\nticket?: Ticket\n```\n",
+		nodeType: ["prop"],
+		passedWhenReferred: false,
+		validate(token) {
+			const errors = [];
+			const field = token.parentNode;
+			if (!(field.countAnnotations("db.rel.to") > 0 || field.countAnnotations("db.rel.from") > 0 || field.countAnnotations("db.rel.via") > 0)) errors.push({
+				message: "@db.rel.filterable is only valid on navigational fields (@db.rel.to, @db.rel.from, or @db.rel.via)",
+				severity: 1,
+				range: token.range
+			});
+			return errors;
+		}
+	}),
 	filter: new AnnotationSpec({
-		description: "Applies a filter to a navigational property, restricting which related records are loaded.\n\n**Example:**\n```atscript\n@db.rel.from\n@db.rel.filter `Post.published = true`\npublishedPosts: Post[]\n```\n",
+		description: "Applies a filter to a navigational property, restricting which related records are loaded (`$with`) and which count in relational predicates (`$some` / `$none`).\n\n**Example:**\n```atscript\n@db.rel.from\n@db.rel.filter `Post.published = true`\npublishedPosts: Post[]\n```\n",
 		nodeType: ["prop"],
 		passedWhenReferred: false,
 		argument: {
@@ -1249,10 +1442,40 @@ const dbRelAnnotations = { rel: {
 			if (!args[0]?.queryNode) return errors;
 			const scope = relFilterScope(field);
 			if (scope) errors.push(...validateQueryScope(args[0], scope, doc));
+			const expression = args[0].queryNode.expression;
+			forEachComparison(expression, (cmp) => {
+				if (cmp.right && "fieldRef" in cmp.right) errors.push({
+					message: "@db.rel.filter compares two fields — only field-to-value conditions are supported",
+					severity: 1,
+					range: cmp.right.fieldRef.range
+				});
+			});
+			const junction = hasVia ? getAnnotationAlias(field, "db.rel.via") : void 0;
+			if (junction) {
+				const conjuncts = isQueryLogical(expression) && expression.operator === "and" ? expression.operands : [expression];
+				for (const conjunct of conjuncts) {
+					let junctionRef;
+					let targetRef = false;
+					forEachFieldRef(conjunct, (ref) => {
+						if (ref.typeRef?.text === junction) junctionRef ??= ref.typeRef.range;
+						else targetRef = true;
+					});
+					if (junctionRef && targetRef) errors.push({
+						message: `@db.rel.filter has a condition reading both the junction '${junction}' and the related type — split it into separate top-level "and" conditions`,
+						severity: 1,
+						range: junctionRef
+					});
+				}
+			}
 			return errors;
 		}
 	})
 } };
+/** Every comparison of a query expression (through and / or / not). */
+function forEachComparison(expr, fn) {
+	if (isQueryLogical(expr)) for (const operand of expr.operands) forEachComparison(operand, fn);
+	else if (isQueryComparison(expr)) fn(expr);
+}
 //#endregion
 //#region src/plugin/annotations/search.ts
 const dbSearchAnnotations = { search: {
@@ -1602,6 +1825,61 @@ const dbUnitAnnotations = { unit: {
 } };
 //#endregion
 //#region src/plugin/annotations/view.ts
+/**
+* VJ6–VJ8 — the ordering of a first-row join: every key is a scalar field of
+* the join target (no object, array, `@db.json`, `@db.encrypted`, `@db.writeOnly` or
+* navigation field), no key repeats, and the target (through `@db.alias`)
+* declares exactly one `@meta.id` field — the anchor of the join's
+* correlated subquery.
+*/
+function validateJoinOrder(orderToken, scope, doc) {
+	const target = scope.unqualifiedTarget;
+	const errors = validateQueryScope(orderToken, scope, doc, `a first-row join orders by fields of its target '${target}'`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const item of orderToken.orderNode.items) {
+		const { ref } = item;
+		if (ref.typeRef && ref.typeRef.text !== target) continue;
+		const path = ref.fieldRef.text;
+		if (seen.has(path)) {
+			errors.push({
+				message: `Order key '${path}' appears more than once`,
+				severity: 1,
+				range: ref.fieldRef.range
+			});
+			continue;
+		}
+		seen.add(path);
+		const why = orderKeyProblem(doc, target, path.split("."));
+		if (why) errors.push({
+			message: `Order key '${path}' ${why} — order by a scalar field of '${target}'`,
+			severity: 1,
+			range: ref.fieldRef.range
+		});
+	}
+	const ids = getFieldsForType(doc, target).filter((p) => p.countAnnotations("meta.id") > 0);
+	if (ids.length !== 1) errors.push({
+		message: `A first-row join needs a target with exactly one @meta.id field — '${target}' has ${ids.length === 0 ? "none" : `${ids.length} (a composite key)`}`,
+		severity: 1,
+		range: orderToken.range
+	});
+	return errors;
+}
+/** Why `path` of `target` cannot order a first-row join, or `undefined` when it can. */
+function orderKeyProblem(doc, target, path) {
+	for (let i = 1; i <= path.length; i++) {
+		const step = doc.unwindType(target, path.slice(0, i));
+		if (!step) return void 0;
+		const node = step.node;
+		if (node && isProp(node)) {
+			if (node.countAnnotations("db.json") > 0) return "reads a @db.json field";
+			if (node.countAnnotations("db.encrypted") > 0) return "is @db.encrypted";
+			if (node.countAnnotations("db.writeOnly") > 0) return "is @db.writeOnly";
+			if (node.countAnnotations("db.ignore") > 0) return "is @db.ignore'd";
+		}
+		if (isArray(step.def)) return "is an array";
+		if (i === path.length && !isPrimitive(step.def)) return "is not a scalar";
+	}
+}
 const dbViewAnnotations = { view: {
 	$self: new AnnotationSpec({
 		description: "Marks an interface as a **database view**. Optionally takes a view name argument.\n\n**Example:**\n```atscript\n@db.view \"active_premium_users\"\n@db.view.for User\nexport interface ActivePremiumUser { ... }\n```\n",
@@ -1653,7 +1931,7 @@ const dbViewAnnotations = { view: {
 		}
 	}),
 	joins: new AnnotationSpec({
-		description: "Declares an explicit join for a view. Joins are INNER by default — pass `'left'` as the third argument to keep entry rows without a match (fields read from a left-joined table must be optional). A join condition may reference the entry table and joins declared before it (chained joins). The target is a `@db.table`, a `@db.view` (since 0.1.141), or a `@db.alias` type — the way to join one table twice or to self-join the entry table: every scope name (entry + joins) must be unique.\n\n**Example:**\n```atscript\n@db.view.for Order\n@db.view.joins Customer, `Customer.id = Order.customerId`\n@db.view.joins Region, `Region.id = Customer.regionId`, 'left'\nexport interface OrderRegion { ... }\n```\n",
+		description: "Declares an explicit join for a view. Joins are INNER by default — pass `'left'` as the third argument to keep entry rows without a match (fields read from a left-joined table must be optional). A join condition may reference the entry table and joins declared before it (chained joins). The target is a `@db.table`, a `@db.view` (since 0.1.141), or a `@db.alias` type — the way to join one table twice or to self-join the entry table: every scope name (entry + joins) must be unique.\n\n**Example:**\n```atscript\n@db.view.for Order\n@db.view.joins Customer, `Customer.id = Order.customerId`\n@db.view.joins Region, `Region.id = Customer.regionId`, 'left'\nexport interface OrderRegion { ... }\n```\n\n**First-row join** (since 0.1.147): a 4th argument — an ordering of the target's fields (`` `raisedAt, id` ``, `` `severity desc` ``) — joins only the FIRST matching target row by that ordering (the target's primary key is appended as the final tie-break), so every field read through the join comes from that one row. NULL sorts first in `asc`.\n```atscript\n@db.view.joins OldestOpenIssue, `OldestOpenIssue.ticketId = Ticket.id and OldestOpenIssue.status = 'open'`, 'left', `raisedAt`\n```\n",
 		nodeType: ["interface"],
 		passedWhenReferred: false,
 		multiple: true,
@@ -1677,6 +1955,13 @@ const dbViewAnnotations = { view: {
 				optional: true,
 				description: "`\"inner\"` (default) drops entry rows without a match; `\"left\"` keeps them with NULLs.",
 				values: ["inner", "left"]
+			},
+			{
+				name: "order",
+				type: "order",
+				optional: true,
+				description: "Makes this a first-row join: of the target rows matching the condition only the first by this ordering joins (`` `raisedAt, id` ``, `` `severity desc` ``). Keys are scalar fields of the join target; its primary key is appended as the final tie-break. NULL is the smallest value (first in `asc`, last in `desc`).",
+				fieldScope: fieldScopes.joinOrder
 			}
 		],
 		validate(token, args, doc) {
@@ -1725,6 +2010,8 @@ const dbViewAnnotations = { view: {
 			}
 			const scope = join && viewJoinScope(owner, join, earlier);
 			if (args[1]?.queryNode && scope) errors.push(...validateQueryScope(args[1], scope, doc, "a join may reference the entry table and joins declared before it"));
+			const order = join && args[3]?.orderNode ? joinOrderScope(join) : void 0;
+			if (order) errors.push(...validateJoinOrder(args[3], order, doc));
 			return errors;
 		}
 	}),
@@ -1854,6 +2141,7 @@ const dbPlugin = (options) => ({
 				view: dbViewAnnotations.view,
 				alias: dbAliasAnnotations.alias,
 				agg: dbAggAnnotations.agg,
+				compute: dbComputeAnnotations.compute,
 				search: dbSearchAnnotations.search,
 				amount: dbAmountAnnotations.amount,
 				unit: dbUnitAnnotations.unit

package/dist/rel.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_nested_writer = require("./nested-writer-xfQwxplL.cjs");
-const require_relation_loader = require("./relation-loader-CBPY6kM7.cjs");
+const require_nested_writer = require("./nested-writer-BUQvk6QT.cjs");
+const require_relation_loader = require("./relation-loader-D8OrdH-r.cjs");
 exports.applyPatchNestedTo = require_nested_writer.applyPatchNestedTo;
 exports.batchInsertNestedFrom = require_nested_writer.batchInsertNestedFrom;
 exports.batchInsertNestedTo = require_nested_writer.batchInsertNestedTo;

package/dist/rel.d.cts

@@ -1,6 +1,6 @@
-import { Dt as TTableResolver, Lt as TableMetadata, Mt as TWriteTableResolver, V as TDbForeignKey, Vt as BaseDbAdapter, Y as TDbRelation, gn as TGenericLogger, m as AtscriptDbWritable, p as AtscriptDbTableLike } from "./buckets-DYFu0eZ8.cjs";
+import { Jt as BaseDbAdapter, Nt as TTableResolver, Rt as TWriteTableResolver, U as TDbForeignKey, Ut as TableMetadata, Vn as TGenericLogger, et as TDbRelation, h as AtscriptDbWritable, m as AtscriptDbTableLike } from "./buckets-DJiYlMXc.cjs";
 import { t as DbValidationContext } from "./db-validator-plugin-BWy60OvG.cjs";
-import { n as findRemoteFK, r as resolveRelationTargetTable, t as findFKForRelation } from "./relation-helpers-BOMm_HUI.cjs";
+import { n as findRemoteFK, r as resolveRelationTargetTable, t as findFKForRelation } from "./relation-helpers-kX7jjgME.cjs";
 import { FilterExpr, WithRelation } from "@uniqu/core";
 import { Validator } from "@atscript/typescript/utils";
 

package/dist/rel.d.mts

@@ -1,6 +1,6 @@
-import { Dt as TTableResolver, Lt as TableMetadata, Mt as TWriteTableResolver, V as TDbForeignKey, Vt as BaseDbAdapter, Y as TDbRelation, gn as TGenericLogger, m as AtscriptDbWritable, p as AtscriptDbTableLike } from "./buckets-DRycmhOW.mjs";
+import { Jt as BaseDbAdapter, Nt as TTableResolver, Rt as TWriteTableResolver, U as TDbForeignKey, Ut as TableMetadata, Vn as TGenericLogger, et as TDbRelation, h as AtscriptDbWritable, m as AtscriptDbTableLike } from "./buckets-CNdTOnei.mjs";
 import { t as DbValidationContext } from "./db-validator-plugin-BWy60OvG.mjs";
-import { n as findRemoteFK, r as resolveRelationTargetTable, t as findFKForRelation } from "./relation-helpers-B-0NRKat.mjs";
+import { n as findRemoteFK, r as resolveRelationTargetTable, t as findFKForRelation } from "./relation-helpers-Ba0v49sn.mjs";
 import { Validator } from "@atscript/typescript/utils";
 import { FilterExpr, WithRelation } from "@uniqu/core";
 

package/dist/rel.mjs

@@ -1,3 +1,3 @@
-import { t as loadRelationsImpl } from "./relation-loader-D9XuXaMv.mjs";
-import { C as findRemoteFK, S as findFKForRelation, a as batchPatchNestedFrom, c as batchReplaceNestedFrom, d as checkDepthOverflow, f as planNestedFromVia, h as validateBatch, i as batchInsertNestedVia, l as batchReplaceNestedTo, m as preValidateNestedFrom, n as batchInsertNestedFrom, o as batchPatchNestedTo, p as planPatchNestedTo, r as batchInsertNestedTo, s as batchPatchNestedVia, t as applyPatchNestedTo, u as batchReplaceNestedVia, w as resolveRelationTargetTable } from "./nested-writer-CnOOAehr.mjs";
+import { t as loadRelationsImpl } from "./relation-loader-ByY1Byrl.mjs";
+import { L as findFKForRelation, R as findRemoteFK, a as batchPatchNestedFrom, c as batchReplaceNestedFrom, d as checkDepthOverflow, f as planNestedFromVia, h as validateBatch, i as batchInsertNestedVia, l as batchReplaceNestedTo, m as preValidateNestedFrom, n as batchInsertNestedFrom, o as batchPatchNestedTo, p as planPatchNestedTo, r as batchInsertNestedTo, s as batchPatchNestedVia, t as applyPatchNestedTo, u as batchReplaceNestedVia, z as resolveRelationTargetTable } from "./nested-writer-CUBoq1ZO.mjs";
 export { applyPatchNestedTo, batchInsertNestedFrom, batchInsertNestedTo, batchInsertNestedVia, batchPatchNestedFrom, batchPatchNestedTo, batchPatchNestedVia, batchReplaceNestedFrom, batchReplaceNestedTo, batchReplaceNestedVia, checkDepthOverflow, findFKForRelation, findRemoteFK, loadRelationsImpl, planNestedFromVia, planPatchNestedTo, preValidateNestedFrom, resolveRelationTargetTable, validateBatch };

package/dist/{relation-helpers-B-0NRKat.d.mts → relation-helpers-Ba0v49sn.d.mts}

@@ -1,4 +1,4 @@
-import { V as TDbForeignKey, Y as TDbRelation } from "./buckets-DRycmhOW.mjs";
+import { U as TDbForeignKey, et as TDbRelation } from "./buckets-CNdTOnei.mjs";
 import { TAtscriptAnnotatedType } from "@atscript/typescript/utils";
 
 //#region src/rel/relation-helpers.d.ts

package/dist/{relation-helpers-BOMm_HUI.d.cts → relation-helpers-kX7jjgME.d.cts}

@@ -1,4 +1,4 @@
-import { V as TDbForeignKey, Y as TDbRelation } from "./buckets-DYFu0eZ8.cjs";
+import { U as TDbForeignKey, et as TDbRelation } from "./buckets-DJiYlMXc.cjs";
 import { TAtscriptAnnotatedType } from "@atscript/typescript/utils";
 
 //#region src/rel/relation-helpers.d.ts