ultimabase 0.0.0-stage → 0.1.0

package/dist/functions.js

@@ -0,0 +1,99 @@
+import { called } from './define-function.js';
+import { functionDefinitions } from './definition.js';
+import { isObject } from './query-where.js';
+import { checkInstalled } from './plugin-use.js';
+import { Refused } from './errors.js';
+/** Checks the models and types an output reaches, each type once. */
+function checkOutput(name, output, resolved, types) {
+    if (output.kind === 'schema')
+        return;
+    if (output.kind === 'model') {
+        const info = resolved.byValue.get(output.value);
+        if (info === undefined) {
+            throw new Refused(`${name} returns ${output.name}, which is not in models.`);
+        }
+        if (info.owner === undefined)
+            return;
+        throw new Refused(`${name} returns ${output.name}, a model of ${info.owner}.`);
+    }
+    const { type } = output;
+    const known = types.get(type.name);
+    if (known === type)
+        return;
+    if (known !== undefined) {
+        throw new Refused(`Two types are named ${type.name}; name each once.`);
+    }
+    if (resolved.models.has(type.name)) {
+        throw new Refused(`The type ${type.name} is named like a model.`);
+    }
+    types.set(type.name, type);
+    for (const field of type.fields.values()) {
+        checkOutput(name, field, resolved, types);
+    }
+}
+const ownerOf = (plugin, name) => plugin === undefined
+    ? `the application's function ${name}`
+    : `${plugin}'s function ${name}`;
+/** The functions, each named once, or startup stops with a message. */
+export function resolveFunctions(sources, resolved, plugins) {
+    const definitions = new Map();
+    const owners = new Map();
+    const names = new Map();
+    const types = new Map();
+    for (const { plugin, values } of sources) {
+        const where = plugin === undefined ? 'functions' : `${plugin}.functions`;
+        for (const value of values) {
+            const definition = isObject(value)
+                ? functionDefinitions.get(value)
+                : undefined;
+            if (definition === undefined || !isObject(value)) {
+                throw new Refused(`${where} lists a value that defineFunction did not return.`);
+            }
+            const { name } = definition;
+            const owner = ownerOf(plugin, name);
+            const other = names.get(name);
+            if (other !== undefined) {
+                throw new Refused(other === owner
+                    ? `${where} lists two functions named ${name}.`
+                    : `${owner} and ${other} are both named ${name}.`);
+            }
+            names.set(name, owner);
+            for (const use of definition.uses) {
+                checkInstalled(name, use.code, plugins);
+            }
+            if (definition.output !== undefined) {
+                checkOutput(name, definition.output, resolved, types);
+            }
+            definitions.set(value, definition);
+            if (plugin !== undefined)
+                owners.set(value, plugin);
+        }
+    }
+    // A virtual's type is named once with the functions' (D-151).
+    for (const info of resolved.byValue.values()) {
+        for (const { name, output } of info.virtuals.values()) {
+            if (output.kind !== 'type')
+                continue;
+            checkOutput(`${info.name}.${name}`, output, resolved, types);
+        }
+    }
+    return { definitions, plugins: owners };
+}
+/** The functions as the plugin `name` reads them, with its `.with` key. */
+export function exposedFunctions(name, functions) {
+    return [...functions.definitions].map(([value, record]) => {
+        const { rules, input } = record;
+        const key = rules === undefined ? undefined : Reflect.get(rules, name);
+        return Object.freeze({
+            name: record.name,
+            description: record.description,
+            plugin: functions.plugins.get(value),
+            query: record.query,
+            used: record.uses.some((use) => use.code.name === name),
+            input,
+            output: record.output,
+            with: key,
+            run: async (given, options, client) => called(value, record, input === undefined ? [options] : [given, options], client),
+        });
+    });
+}

package/dist/group-by.d.ts

@@ -0,0 +1,10 @@
+import type { GroupKey } from './adapter.ts';
+import type { Context } from './query-context.ts';
+import type { Store } from './transaction.ts';
+/**
+ * The keys of a `findMany`'s `distinct`, which a cursor cannot page (D-147):
+ * `undefined` without one.
+ */
+export declare function distinctOf(context: Context, args: unknown): Promise<GroupKey[] | undefined>;
+export declare function groupBy(context: Context, store: Store, args: unknown): Promise<unknown>;
+//# sourceMappingURL=group-by.d.ts.map

package/dist/group-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-by.d.ts","sourceRoot":"","sources":["../src/group-by.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAiB,QAAQ,EAAE,MAAM,cAAc,CAAA;AAa3D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAKjD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AA8C7C;;;GAGG;AACH,wBAAsB,UAAU,CAC/B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,OAAO,GACX,OAAO,CAAC,QAAQ,EAAE,GAAG,SAAS,CAAC,CAOjC;AA+DD,wBAAsB,OAAO,CAC5B,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,OAAO,GACX,OAAO,CAAC,OAAO,CAAC,CAqClB"}

package/dist/group-by.js

@@ -0,0 +1,145 @@
+import { checked, keys, shaped, toAggregate, typeOf, wanted, } from './aggregate.js';
+import { InvalidQuery } from './errors.js';
+import { having } from './group-having.js';
+import { filtered, given } from './query-context.js';
+import { integer } from './query-args.js';
+import { direction, sortOf } from './query-order.js';
+import { entries, isObject } from './query-where.js';
+/**
+ * The fields of `by`, or of `distinct` (D-147), each checked; a `one`
+ * relation the row stores.
+ */
+function grouping({ model, scope }, value, name) {
+    const message = `${name} must be a non-empty list of fields.`;
+    const list = Array.isArray(value) ? value : [];
+    if (list.length === 0)
+        throw new InvalidQuery(name, message);
+    const [verb, done] = name === 'by'
+        ? ['aggregates', 'grouped']
+        : ['compares', 'compared'];
+    const fields = [];
+    for (const [index, field] of list.entries()) {
+        const path = `${name}.${index}`;
+        if (typeof field !== 'string')
+            throw new InvalidQuery(path, message);
+        if (fields.includes(field)) {
+            throw new InvalidQuery(path, `${path} repeats ${field}.`);
+        }
+        const known = model.fields.get(field);
+        if (known?.kind !== 'one' || !known.stored) {
+            typeOf(model, field, path, done);
+        }
+        scope.check(model, field, path, verb);
+        fields.push(field);
+    }
+    return fields;
+}
+/** Groups by a relation's target id, `null` when the caller cannot read it. */
+async function keyOf(context, field) {
+    const known = context.model.fields.get(field);
+    if (known?.kind !== 'one')
+        return { field };
+    const where = await context.scope.filter(known.target, false);
+    if (where === undefined)
+        return { field };
+    return { field: 'id', through: [{ relation: field, where }] };
+}
+/**
+ * The keys of a `findMany`'s `distinct`, which a cursor cannot page (D-147):
+ * `undefined` without one.
+ */
+export async function distinctOf(context, args) {
+    if (!isObject(args) || args['distinct'] === undefined)
+        return undefined;
+    if (args['cursor'] !== undefined) {
+        throw new InvalidQuery('distinct', 'distinct cannot be used with cursor.');
+    }
+    const fields = grouping(context, args['distinct'], 'distinct');
+    return Promise.all(fields.map(async (field) => keyOf(context, field)));
+}
+/**
+ * An aggregate's position in a group's values, after its keys; one the
+ * result does not ask for is added to `aggregates`.
+ */
+const positions = (by, aggregates) => (asked) => {
+    const index = aggregates.findIndex((each) => each.key === asked.key && each.field === asked.field);
+    if (index !== -1)
+        return by.length + index;
+    aggregates.push(asked);
+    return by.length + aggregates.length - 1;
+};
+/** The groups' sort: each key of `orderBy`, then the other fields of `by`. */
+function sorts(context, value, by, at) {
+    const parts = Array.isArray(value) ? value : [value];
+    const sorted = [];
+    for (const [index, part] of parts.entries()) {
+        const base = Array.isArray(value) ? `orderBy.${index}` : 'orderBy';
+        for (const [name, order] of entries(part, base)) {
+            const path = `${base}.${name}`;
+            if (by.includes(name)) {
+                const known = context.model.fields.get(name);
+                const optional = known?.kind !== 'many' && known?.optional === true;
+                sorted.push({ at: by.indexOf(name), ...sortOf(order, path, optional) });
+                continue;
+            }
+            const key = keys.find((each) => each === name);
+            if (key === undefined) {
+                throw new InvalidQuery(path, `${path} must be a field of by or an aggregate.`);
+            }
+            if (key === '_count' && !isObject(order)) {
+                const asked = { key, field: undefined };
+                sorted.push({ at: at(asked), direction: direction(order, path) });
+                continue;
+            }
+            for (const [field, each] of entries(order, path)) {
+                const asked = checked(context, key, field, `${path}.${field}`);
+                const sort = direction(each, `${path}.${field}`);
+                sorted.push({ at: at(asked), direction: sort });
+            }
+        }
+    }
+    for (const [index] of by.entries()) {
+        if (!sorted.some((sort) => sort.at === index)) {
+            sorted.push({ at: index, direction: 'asc' });
+        }
+    }
+    return sorted;
+}
+export async function groupBy(context, store, args) {
+    const { model } = context;
+    const allowed = ['by', 'where', 'having', 'orderBy', 'skip', 'take', ...keys];
+    const found = given(args, model.name, allowed, ['by']);
+    const by = grouping(context, found.get('by'), 'by');
+    const asked = wanted(context, found);
+    const aggregates = [...asked];
+    const position = positions(by, aggregates);
+    const orderBy = sorts(context, found.get('orderBy') ?? {}, by, position);
+    const filter = found.has('having')
+        ? having(context, found.get('having'), by, position)
+        : undefined;
+    const page = {};
+    if (found.has('skip'))
+        page.skip = integer(found.get('skip'), 'skip', 0);
+    if (found.has('take'))
+        page.take = integer(found.get('take'), 'take', 0);
+    const where = await filtered(context, found, 'read');
+    const groupKeys = await Promise.all(by.map(async (field) => keyOf(context, field)));
+    const groups = await store.aggregate({
+        model: model.name,
+        ...(where && { where }),
+        aggregates: aggregates.map(toAggregate),
+        by: groupKeys,
+        ...(filter && { having: filter }),
+        orderBy,
+        ...page,
+    });
+    return groups.map((values) => {
+        const row = {};
+        for (const [index, field] of by.entries()) {
+            const value = values[index] ?? null;
+            const relation = model.fields.get(field)?.kind === 'one';
+            row[field] = relation && value !== null ? { id: value } : value;
+        }
+        return { ...row, ...shaped(found, asked, values.slice(by.length)) };
+    });
+}

package/dist/group-having.d.ts

@@ -0,0 +1,8 @@
+import type { Filter } from './adapter.ts';
+import type { Asked } from './aggregate.ts';
+import type { Context } from './query-context.ts';
+/** An aggregate's position in the group's values, added if not asked. */
+export type Position = (asked: Asked) => number;
+/** The `having` of the groups by `by`, normalized; `path` names it in errors. */
+export declare function having(context: Context, value: unknown, by: readonly string[], position: Position, path?: string): Filter;
+//# sourceMappingURL=group-having.d.ts.map

package/dist/group-having.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-having.d.ts","sourceRoot":"","sources":["../src/group-having.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAa,MAAM,EAAE,MAAM,cAAc,CAAA;AACrD,OAAO,KAAK,EAAE,KAAK,EAAO,MAAM,gBAAgB,CAAA;AAIhD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAIjD,yEAAyE;AACzE,MAAM,MAAM,QAAQ,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,CAAA;AAkG/C,iFAAiF;AACjF,wBAAgB,MAAM,CACrB,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,OAAO,EACd,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,QAAQ,EAAE,QAAQ,EAClB,IAAI,SAAW,GACb,MAAM,CAuBR"}

package/dist/group-having.js

@@ -0,0 +1,97 @@
+import { checked, keys, typeOf } from './aggregate.js';
+import { decimalPattern, normalized } from './decimal.js';
+import { InvalidQuery } from './errors.js';
+import { entries, fieldCondition, isObject } from './query-where.js';
+const decimal = new RegExp(decimalPattern);
+const whole = {
+    type: 'number',
+    check: (item, at) => {
+        if (!Number.isSafeInteger(item)) {
+            throw new InvalidQuery(at, `${at} must be a whole number.`);
+        }
+        return item;
+    },
+};
+const finite = {
+    type: 'number',
+    check: (item, at) => {
+        if (typeof item !== 'number' || !Number.isFinite(item)) {
+            throw new InvalidQuery(at, `${at} must be a finite number.`);
+        }
+        return item;
+    },
+};
+/** A decimal's sum, exact at its field's scale, of any precision (D-145). */
+const sum = (scale) => ({
+    type: 'decimal',
+    check: (item, at) => {
+        if (typeof item !== 'string' || !decimal.test(item)) {
+            throw new InvalidQuery(at, `${at} must be a decimal string, such as '12.50'.`);
+        }
+        return normalized(item, scale);
+    },
+});
+/**
+ * The operands of aggregate `key` of a field: a count's a whole number, a
+ * sum's and an average's a number, a decimal's sum a decimal string, a
+ * minimum's and a maximum's the field's own.
+ */
+function operandOf(context, key, name) {
+    if (key === '_count')
+        return whole;
+    if (key === '_min' || key === '_max')
+        return undefined;
+    const field = context.model.fields.get(name);
+    return key === '_sum' && field?.kind === 'scalar' && field.type === 'decimal'
+        ? sum(field.scale ?? 0)
+        : finite;
+}
+/** The conditions of field `name`'s value and aggregates, by position. */
+function conditions(context, name, part, at, by, position) {
+    const { model, scope } = context;
+    typeOf(model, name, at, 'used in having');
+    const found = {};
+    const own = [];
+    const listed = isObject(part) ? entries(part, at) : [];
+    for (const [key, operand] of listed) {
+        const aggregate = keys.find((each) => each === key);
+        if (aggregate === undefined) {
+            own.push([key, operand]);
+            continue;
+        }
+        const where = `${at}.${key}`;
+        const asked = checked(context, aggregate, name, where);
+        const of = operandOf(context, aggregate, name);
+        const condition = fieldCondition(model, name, operand, where, of);
+        if (condition !== undefined)
+            found[String(position(asked))] = condition;
+    }
+    if (isObject(part) && own.length === 0)
+        return found;
+    if (!by.includes(name)) {
+        throw new InvalidQuery(at, `${at} is not a field of by: only its aggregates filter the groups.`);
+    }
+    scope.check(model, name, at, 'filters');
+    const value = isObject(part) ? Object.fromEntries(own) : part;
+    const condition = fieldCondition(model, name, value, at);
+    if (condition !== undefined)
+        found[String(by.indexOf(name))] = condition;
+    return found;
+}
+/** The `having` of the groups by `by`, normalized; `path` names it in errors. */
+export function having(context, value, by, position, path = 'having') {
+    const filter = {};
+    for (const [name, part] of entries(value, path)) {
+        const at = `${path}.${name}`;
+        if (name !== 'AND' && name !== 'OR' && name !== 'NOT') {
+            Object.assign(filter, conditions(context, name, part, at, by, position));
+            continue;
+        }
+        if (!Array.isArray(part) && name === 'OR') {
+            throw new InvalidQuery(at, `${at} must be a list.`);
+        }
+        const list = Array.isArray(part) ? part : [part];
+        filter[name] = list.map((item, index) => having(context, item, by, position, Array.isArray(part) ? `${at}.${index}` : at));
+    }
+    return filter;
+}

package/dist/hooks.d.ts

@@ -0,0 +1,41 @@
+import type { Filter, Row } from './adapter.ts';
+import type { hookNames } from './plugin-code.ts';
+import type { FindOperation } from './model.ts';
+import type { Caller } from './rules.ts';
+import type { Relations } from './relations.ts';
+import type { ModelInfo } from './schema.ts';
+import type { Models } from './query-where.ts';
+import type { Commit, Store } from './transaction.ts';
+type HookName = (typeof hookNames)[number];
+export declare function hasHook(model: ModelInfo, name: HookName): boolean;
+export declare function runHook(model: ModelInfo, name: 'beforeCreate' | 'beforeUpdate' | 'beforeDelete', facts: object): Promise<void>;
+/** The filters every `beforeFind` ANDs into each read of the model (D-71). */
+export declare function beforeFind(models: Models, model: ModelInfo, caller: Caller, operation: FindOperation, relations: Relations): Promise<Filter | undefined>;
+/**
+ * The plugin's `redirect.delete`, which replaces the write of a `delete`,
+ * given `where: { id }` of the row found (D-15, D-89).
+ */
+export declare function redirectOf(model: ModelInfo): ((caller: Caller, id: string) => Promise<unknown>) | undefined;
+/** A row a write changed, whose `after*` hooks run once it is written. */
+export type Event = {
+    readonly model: ModelInfo;
+    readonly operation: 'create';
+    readonly id: string;
+} | {
+    readonly model: ModelInfo;
+    readonly operation: 'update' | 'delete';
+    readonly id: string;
+    /** The stored row before the write. */
+    readonly before: Row;
+};
+/** Whether an `after*` hook may change the rows, so the result is read again. */
+export declare function rereads(events: readonly Event[]): boolean;
+/** Whether a hook follows the write, which then runs in a transaction. */
+export declare function settles(events: readonly Event[]): boolean;
+/**
+ * Runs each event's `after*` hook in the transaction, and queues its
+ * `*Commit` hook, with the same facts, for after the commit (D-15, D-71).
+ */
+export declare function settle(store: Store, caller: Caller, events: readonly Event[], commits: Commit[]): Promise<void>;
+export {};
+//# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAEjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAC/C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AACxC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAG/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAE9C,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAErD,KAAK,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAA;AA2D1C,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAEjE;AAED,wBAAsB,OAAO,CAC5B,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,cAAc,GAAG,cAAc,GAAG,cAAc,EACtD,KAAK,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAEf;AAED,8EAA8E;AAC9E,wBAAsB,UAAU,CAC/B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,aAAa,EACxB,SAAS,EAAE,SAAS,GAClB,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAqB7B;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACzB,KAAK,EAAE,SAAS,GACd,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,SAAS,CAShE;AAED,0EAA0E;AAC1E,MAAM,MAAM,KAAK,GACd;IACA,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IACzB,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAA;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAClB,GACD;IACA,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IACzB,QAAQ,CAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,CAAA;IACvC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,uCAAuC;IACvC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAA;CACnB,CAAA;AAQJ,iFAAiF;AACjF,wBAAgB,OAAO,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,OAAO,CAEzD;AAED,0EAA0E;AAC1E,wBAAgB,OAAO,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,OAAO,CAIzD;AAyBD;;;GAGG;AACH,wBAAsB,MAAM,CAC3B,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,SAAS,KAAK,EAAE,EACxB,OAAO,EAAE,MAAM,EAAE,GACf,OAAO,CAAC,IAAI,CAAC,CAcf"}

package/dist/hooks.js

@@ -0,0 +1,149 @@
+// The fixed hooks of D-15 at run time (D-71, D-88): the plugins', then the
+// model's `.with` (D-89), run with their facts; `after*` hooks in the
+// transaction, the `*Commit` hooks once it commits.
+import { and, recordOf } from './access.js';
+import { commandOf, outsideCommands } from './plugin-code.js';
+import { trusted } from './relations.js';
+import { filterOf, isReadFilter, readFilter } from './rules.js';
+import { isObject, normalizeWhere } from './query-where.js';
+/** Runs a hook's body; the queries it makes run outside any command. */
+async function called(hook, facts) {
+    return outsideCommands(async () => {
+        const result = await Reflect.apply(hook, undefined, [facts]);
+        return result;
+    });
+}
+/** The application's hook `name` of the model, from its `.with` (D-71). */
+function ownHook(model, name) {
+    const rules = model.definition.rules;
+    const hooks = rules !== undefined && isObject(rules) ? rules['hooks'] : undefined;
+    if (hooks === undefined)
+        return undefined;
+    if (!isObject(hooks)) {
+        throw new TypeError(`${model.name}: hooks is an object.`);
+    }
+    const hook = hooks[name];
+    if (hook === undefined)
+        return undefined;
+    if (typeof hook !== 'function') {
+        throw new TypeError(`${model.name}.hooks.${name} is a function.`);
+    }
+    const path = `${model.name}.hooks.${name}`;
+    return { path, run: async (facts) => called(hook, facts) };
+}
+/**
+ * The hooks `name` of the model: its plugins' first, in the order of
+ * `plugins`, then the application's (D-29). A plugin's facts add what its
+ * code gets of the model and the command running (D-89).
+ */
+function hooksOf(model, name) {
+    const hooks = [];
+    for (const use of model.plugins) {
+        const hook = use.code.hooks[name];
+        if (hook === undefined)
+            continue;
+        const plugin = use.code.name;
+        hooks.push({
+            path: `${plugin}.hooks.${name} on ${model.name}`,
+            run: async (facts) => called(hook, {
+                ...facts,
+                ...use.model,
+                command: commandOf(model.name, plugin),
+            }),
+        });
+    }
+    const own = ownHook(model, name);
+    return own === undefined ? hooks : [...hooks, own];
+}
+export function hasHook(model, name) {
+    return hooksOf(model, name).length > 0;
+}
+export async function runHook(model, name, facts) {
+    for (const hook of hooksOf(model, name))
+        await hook.run(facts);
+}
+/** The filters every `beforeFind` ANDs into each read of the model (D-71). */
+export async function beforeFind(models, model, caller, operation, relations) {
+    let filter;
+    for (const hook of hooksOf(model, 'beforeFind')) {
+        const result = await hook.run({ caller, operation, where: readFilter });
+        if (result === undefined)
+            continue;
+        if (!isReadFilter(result)) {
+            throw new TypeError(`${hook.path} returns where({ ... }) or nothing.`);
+        }
+        // Trusted server code, as a read rule's filter (D-86, D-88); the one
+        // filter of a plugin field (D-122).
+        const where = normalizeWhere(models, model, filterOf(result), hook.path, trusted(relations), true);
+        filter = and(where, filter);
+    }
+    return filter;
+}
+/**
+ * The plugin's `redirect.delete`, which replaces the write of a `delete`,
+ * given `where: { id }` of the row found (D-15, D-89).
+ */
+export function redirectOf(model) {
+    const use = model.plugins.find((each) => each.code.redirect !== undefined);
+    const redirect = use?.code.redirect;
+    if (use === undefined || redirect === undefined)
+        return undefined;
+    return async (caller, id) => {
+        const facts = { caller, where: { id }, ...use.model };
+        const result = await Reflect.apply(redirect, undefined, [facts]);
+        return result;
+    };
+}
+const names = {
+    create: ['afterCreate', 'afterCreateCommit'],
+    update: ['afterUpdate', 'afterUpdateCommit'],
+    delete: ['afterDelete', 'afterDeleteCommit'],
+};
+/** Whether an `after*` hook may change the rows, so the result is read again. */
+export function rereads(events) {
+    return events.some((event) => hasHook(event.model, names[event.operation][0]));
+}
+/** Whether a hook follows the write, which then runs in a transaction. */
+export function settles(events) {
+    return events.some((event) => names[event.operation].some((name) => hasHook(event.model, name)));
+}
+async function factsOf(store, caller, event) {
+    const { model, id } = event;
+    if (event.operation === 'delete') {
+        return { caller, record: recordOf(model, event.before) };
+    }
+    // As written, whatever `beforeFind` hides (D-88).
+    const [row] = await store.find({
+        model: model.name,
+        where: { id: { equals: id } },
+        take: 1,
+    });
+    if (row === undefined) {
+        throw new Error(`${model.name} ${id} was deleted before its after hooks.`);
+    }
+    const record = recordOf(model, row);
+    if (event.operation === 'create')
+        return { caller, record };
+    return { caller, record, previous: recordOf(model, event.before) };
+}
+/**
+ * Runs each event's `after*` hook in the transaction, and queues its
+ * `*Commit` hook, with the same facts, for after the commit (D-15, D-71).
+ */
+export async function settle(store, caller, events, commits) {
+    for (const event of events) {
+        const [now, later] = names[event.operation];
+        const afters = hooksOf(event.model, now);
+        const laters = hooksOf(event.model, later);
+        if (afters.length === 0 && laters.length === 0)
+            continue;
+        const facts = await factsOf(store, caller, event);
+        for (const hook of afters)
+            await hook.run(facts);
+        for (const hook of laters) {
+            commits.push(async () => {
+                await hook.run(facts);
+            });
+        }
+    }
+}

package/dist/hosts.d.ts

@@ -0,0 +1,3 @@
+/** A host only this machine reaches (D-66, D-105, D-115). */
+export declare function isLocalHost(hostname: string): boolean;
+//# sourceMappingURL=hosts.d.ts.map

package/dist/hosts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosts.d.ts","sourceRoot":"","sources":["../src/hosts.ts"],"names":[],"mappings":"AAEA,6DAA6D;AAC7D,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAOrD"}

package/dist/hosts.js

@@ -0,0 +1,8 @@
+// Which hosts are this machine's own, for the checks that trust them.
+/** A host only this machine reaches (D-66, D-105, D-115). */
+export function isLocalHost(hostname) {
+    return (hostname === 'localhost' ||
+        hostname.endsWith('.localhost') ||
+        hostname === '127.0.0.1' ||
+        hostname === '[::1]');
+}

package/dist/identify.d.ts

@@ -0,0 +1,15 @@
+import type { Logger, MasterKey } from './app-options.ts';
+import type { Complete } from './complete.ts';
+import type { Caller, Identity } from './rules.ts';
+/** The header a transport reads the master key from. */
+export declare const masterKeyHeader = "x-ultimabase-master-key";
+export type Identify = (request: Request) => Promise<Caller>;
+/** A plugin's `identify`, bound to its context. */
+export type PluginIdentify = (request: Request) => Promise<Identity | undefined>;
+/**
+ * Reads the master key and `NODE_ENV` once, when the application starts.
+ * `plugins` is read on each request: it is filled once their contexts exist.
+ * The caller a plugin knows is completed (D-121).
+ */
+export declare function identifier(masterKey: MasterKey, logger: Logger, plugins: readonly PluginIdentify[], complete: Complete): Identify;
+//# sourceMappingURL=identify.d.ts.map

package/dist/identify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identify.d.ts","sourceRoot":"","sources":["../src/identify.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAEzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAGlD,wDAAwD;AACxD,eAAO,MAAM,eAAe,4BAA4B,CAAA;AAExD,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;AAC5D,mDAAmD;AACnD,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CAAA;AAuBhF;;;;GAIG;AACH,wBAAgB,UAAU,CACzB,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,QAAQ,EAAE,QAAQ,GAChB,QAAQ,CA+CV"}