ultimabase 0.0.0-stage → 0.1.0

package/dist/running.d.ts

@@ -0,0 +1,29 @@
+import type { Adapter } from './adapter.ts';
+import type { Logger } from './app-options.ts';
+import type { Complete } from './complete.ts';
+import type { FunctionDefinition } from './definition.ts';
+import type { Resolved } from './schema.ts';
+export type Running = {
+    readonly resolved: Resolved;
+    /** Its functions, by their `defineFunction` value (D-75). */
+    readonly functions: ReadonlyMap<object, FunctionDefinition>;
+    readonly adapter: Adapter;
+    readonly logger: Logger;
+    /** Each plugin's API, by its name (D-16). */
+    readonly apis: ReadonlyMap<string, unknown>;
+    readonly work: Work;
+    /** Completes a user caller with its plugins' keys (D-121). */
+    readonly complete: Complete;
+};
+/** The operations running, `*Commit` hooks included, that `stop` waits for. */
+export declare class Work {
+    private count;
+    private readonly idle;
+    run<R>(run: () => Promise<R>): Promise<R>;
+    settled(): Promise<void>;
+}
+export declare function register(app: Running): void;
+export declare function unregister(app: Running): void;
+/** The running application, `undefined` before `start`. */
+export declare function current(): Running | undefined;
+//# sourceMappingURL=running.d.ts.map

package/dist/running.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"running.d.ts","sourceRoot":"","sources":["../src/running.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAE3C,MAAM,MAAM,OAAO,GAAG;IACrB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAC3B,6DAA6D;IAC7D,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;IAC3D,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,6CAA6C;IAC7C,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC3C,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,8DAA8D;IAC9D,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;CAC3B,CAAA;AAED,+EAA+E;AAC/E,qBAAa,IAAI;IAChB,OAAO,CAAC,KAAK,CAAI;IACjB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAqB;IAEpC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAQ9C;IAEK,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAK7B;CACD;AAID,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAK3C;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAE7C;AAED,2DAA2D;AAC3D,wBAAgB,OAAO,IAAI,OAAO,GAAG,SAAS,CAE7C"}

package/dist/running.js

@@ -0,0 +1,39 @@
+/** The operations running, `*Commit` hooks included, that `stop` waits for. */
+export class Work {
+    count = 0;
+    idle = [];
+    async run(run) {
+        this.count += 1;
+        try {
+            return await run();
+        }
+        finally {
+            this.count -= 1;
+            if (this.count === 0)
+                for (const done of this.idle.splice(0))
+                    done();
+        }
+    }
+    async settled() {
+        if (this.count === 0)
+            return;
+        await new Promise((done) => {
+            this.idle.push(done);
+        });
+    }
+}
+let running;
+export function register(app) {
+    if (running !== undefined) {
+        throw new Error('An application is already running; stop it first.');
+    }
+    running = app;
+}
+export function unregister(app) {
+    if (running === app)
+        running = undefined;
+}
+/** The running application, `undefined` before `start`. */
+export function current() {
+    return running;
+}

package/dist/schema-indexes.d.ts

@@ -0,0 +1,11 @@
+import type { SchemaField } from './adapter.ts';
+import type { IndexDefinition } from './definition.ts';
+import type { ModelInfo } from './schema.ts';
+/** Refuses an index over a field that is not one of the model's columns. */
+export declare function checkIndexes(model: string, fields: ReadonlyMap<string, SchemaField>, indexes: readonly IndexDefinition[]): void;
+/**
+ * A searched field is the kernel's string, which every caller may read: a
+ * match would reveal a value its read rule hides (D-148).
+ */
+export declare function checkSearch(model: ModelInfo): void;
+//# sourceMappingURL=schema-indexes.d.ts.map

package/dist/schema-indexes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-indexes.d.ts","sourceRoot":"","sources":["../src/schema-indexes.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAqC5C,4EAA4E;AAC5E,wBAAgB,YAAY,CAC3B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,EACxC,OAAO,EAAE,SAAS,eAAe,EAAE,GACjC,IAAI,CAmBN;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAgBlD"}

package/dist/schema-indexes.js

@@ -0,0 +1,59 @@
+import { readRules } from './access.js';
+import { Refused } from './errors.js';
+/** An index on a list is a GIN index of that list alone (D-120). */
+function listIndex(model, name, index) {
+    if (index.fields.length > 1) {
+        throw new Refused(`${model}: the list '${name}' is indexed alone, in an index of its own.`);
+    }
+    if (index.unique === true) {
+        throw new Refused(`${model}: the list '${name}' cannot be unique.`);
+    }
+}
+/** A `contains` index covers one string field, not a list (D-141). */
+function containsIndex(model, fields, index) {
+    const [name] = index.fields;
+    const field = name === undefined ? undefined : fields.get(name);
+    if (index.fields.length !== 1 ||
+        index.unique === true ||
+        field?.kind !== 'scalar' ||
+        field.type !== 'string' ||
+        field.list) {
+        throw new Refused(`${model}: a contains index covers one string field that is not a list, and is not unique.`);
+    }
+}
+/** Refuses an index over a field that is not one of the model's columns. */
+export function checkIndexes(model, fields, indexes) {
+    for (const index of indexes) {
+        for (const name of index.fields) {
+            const field = fields.get(name);
+            if (field === undefined ||
+                field.kind === 'many' ||
+                (field.kind === 'one' && !field.stored)) {
+                throw new Refused(`${model}: index field '${name}' is not a scalar or a stored one relation.`);
+            }
+            if (field.kind === 'scalar' && field.list) {
+                listIndex(model, name, index);
+            }
+        }
+        if (index.contains === true)
+            containsIndex(model, fields, index);
+    }
+}
+/**
+ * A searched field is the kernel's string, which every caller may read: a
+ * match would reveal a value its read rule hides (D-148).
+ */
+export function checkSearch(model) {
+    const rules = readRules(model);
+    for (const field of model.fields.values()) {
+        if (field.kind !== 'scalar' || field.search !== true)
+            continue;
+        const name = `${model.name}.${field.name}`;
+        if (field.codec !== undefined) {
+            throw new Refused(`${name}: a ${field.codec.plugin} field is not searched.`);
+        }
+        if (rules[field.name] !== undefined) {
+            throw new Refused(`${name} has a read rule, and a search would reveal its value: remove search or the rule.`);
+        }
+    }
+}

package/dist/schema-virtuals.d.ts

@@ -0,0 +1,19 @@
+import type { ModelDefinition, Output } from './definition.ts';
+import type { Standard } from './validation.ts';
+export type VirtualInfo = {
+    readonly name: string;
+    readonly model: string;
+    readonly output: Output;
+    readonly input: Standard | undefined;
+    /** The scalar fields its rule reads, `id` first. */
+    readonly needs: readonly string[];
+    /** `runMany` takes the rows at once, `run` one by one. */
+    readonly many: boolean;
+    readonly run: (facts: object) => unknown;
+    /** A value without input is in the row without `select`. */
+    readonly default: boolean;
+    readonly description: string | undefined;
+};
+/** The virtual fields of a model, checked against its fields and models. */
+export declare function virtualsOf(model: string, definition: ModelDefinition, models: ReadonlyMap<object, string>): ReadonlyMap<string, VirtualInfo>;
+//# sourceMappingURL=schema-virtuals.d.ts.map

package/dist/schema-virtuals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-virtuals.d.ts","sourceRoot":"","sources":["../src/schema-virtuals.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAI9D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAG/C,MAAM,MAAM,WAAW,GAAG;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,CAAA;IACpC,oDAAoD;IACpD,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;IACjC,0DAA0D;IAC1D,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAA;IACxC,4DAA4D;IAC5D,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;CACxC,CAAA;AAsDD,4EAA4E;AAC5E,wBAAgB,UAAU,CACzB,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,eAAe,EAC3B,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,CAoDlC"}

package/dist/schema-virtuals.js

@@ -0,0 +1,100 @@
+import { outputOf } from './definition.js';
+import { Refused } from './errors.js';
+import { isObject, systemFields } from './query-where.js';
+import { standardOf } from './validation.js';
+/** The keys that shape a model output's rows, which no input property takes. */
+const shaping = ['select', 'include', 'omit'];
+/** An input's properties, from its JSON Schema export when it has one. */
+function propertiesOf(input) {
+    const exporter = Reflect.get(input.self, 'jsonSchema');
+    const exported = isObject(exporter) ? exporter['input'] : undefined;
+    if (typeof exported !== 'function')
+        return [];
+    const node = Reflect.apply(exported, exporter, [
+        { target: 'draft-2020-12' },
+    ]);
+    const properties = isObject(node) ? node['properties'] : undefined;
+    return isObject(properties) ? Object.keys(properties) : [];
+}
+function outputFor(value, where) {
+    const standard = standardOf(value);
+    if (standard !== undefined)
+        return { kind: 'schema', schema: standard.schema };
+    if (typeof value !== 'function') {
+        throw new Refused(`${where} is a Standard Schema, or a model or a type behind an arrow.`);
+    }
+    const returned = Reflect.apply(value, undefined, []);
+    return outputOf(returned, where);
+}
+function ruleOf(given, where) {
+    const rule = given[where.slice(where.indexOf('.') + 1)];
+    if (!isObject(rule)) {
+        throw new Refused(`${where} is virtual; give its run or runMany in .with({ virtuals }).`);
+    }
+    const { run, runMany } = rule;
+    if ((typeof run === 'function') === (typeof runMany === 'function')) {
+        throw new Refused(`${where}: give run or runMany, one of them.`);
+    }
+    const chosen = typeof run === 'function' ? run : runMany;
+    if (typeof chosen !== 'function')
+        throw new TypeError('A rule is a function.');
+    return {
+        many: chosen === runMany,
+        run: (facts) => {
+            const value = Reflect.apply(chosen, rule, [facts]);
+            return value;
+        },
+    };
+}
+/** The virtual fields of a model, checked against its fields and models. */
+export function virtualsOf(model, definition, models) {
+    const rules = isObject(definition.rules)
+        ? definition.rules['virtuals']
+        : undefined;
+    const given = isObject(rules) ? rules : {};
+    const virtuals = new Map();
+    for (const name of Object.keys(given)) {
+        if (definition.fields.get(name)?.kind !== 'virtual') {
+            throw new Refused(`${model}.virtuals.${name} names no virtual field.`);
+        }
+    }
+    for (const [name, field] of definition.fields) {
+        if (field.kind !== 'virtual')
+            continue;
+        const where = `${model}.${name}`;
+        const output = outputFor(field.output, where);
+        if (output.kind === 'model' && !models.has(output.value)) {
+            throw new Refused(`${where}: its output model is not in models.`);
+        }
+        const { input: schema, needs: listed, description } = field.options;
+        const input = schema === undefined ? undefined : standardOf(schema);
+        if (schema !== undefined && input === undefined) {
+            throw new Refused(`${where}: input is a Standard Schema of an object.`);
+        }
+        for (const key of input === undefined ? [] : propertiesOf(input)) {
+            if (shaping.includes(key)) {
+                throw new Refused(`${where}: no input property is named ${key}, which shapes a model's rows.`);
+            }
+        }
+        const needs = Array.isArray(listed) ? listed : [];
+        for (const need of needs) {
+            const scalar = typeof need === 'string' &&
+                (systemFields.includes(need) ||
+                    definition.fields.get(need)?.kind === 'scalar');
+            if (!scalar) {
+                throw new Refused(`${where} needs ${String(need)}, no scalar field.`);
+            }
+        }
+        virtuals.set(name, {
+            name,
+            model,
+            output,
+            input,
+            needs: [...new Set(['id', ...needs.map(String)])],
+            ...ruleOf(given, where),
+            default: output.kind === 'schema' && input === undefined,
+            description: typeof description === 'string' ? description : undefined,
+        });
+    }
+    return virtuals;
+}

package/dist/schema.d.ts

@@ -0,0 +1,35 @@
+import type { Schema, SchemaField } from './adapter.ts';
+import type { Codec, FieldOptions, ModelDefinition, PluginCode, PluginUse } from './definition.ts';
+import type { Enum } from './fields.ts';
+import type { VirtualInfo } from './schema-virtuals.ts';
+/**
+ * A field as the kernel reads it: its schema, its builder's options, a
+ * plugin field type's codec (D-122) and its shared enum (D-150).
+ */
+export type FieldInfo = SchemaField & {
+    readonly options: FieldOptions;
+    readonly codec?: Codec;
+    readonly enum?: Enum;
+};
+export type ModelInfo = {
+    readonly name: string;
+    readonly definition: ModelDefinition;
+    readonly fields: ReadonlyMap<string, FieldInfo>;
+    /** The unique targets (D-52): `id`, unique fields, unique indexes. */
+    readonly uniques: readonly (readonly string[])[];
+    /** The plugins of its `use`, in the order of `plugins` (D-29). */
+    readonly plugins: readonly PluginUse[];
+    /** The plugin whose own model it is, if one (D-110). */
+    readonly owner: string | undefined;
+    /** Its fields computed on read, which the adapter never sees (D-151). */
+    readonly virtuals: ReadonlyMap<string, VirtualInfo>;
+};
+export type Resolved = {
+    readonly schema: Schema;
+    readonly models: ReadonlyMap<string, ModelInfo>;
+    /** The model each `defineModel` value stands for. */
+    readonly byValue: ReadonlyMap<object, ModelInfo>;
+};
+/** Resolves the application's models, or stops startup with a message. */
+export declare function resolve(values: readonly unknown[], plugins?: readonly PluginCode[]): Resolved;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAe,MAAM,cAAc,CAAA;AACpE,OAAO,KAAK,EACX,KAAK,EAEL,YAAY,EACZ,eAAe,EACf,UAAU,EACV,SAAS,EACT,MAAM,iBAAiB,CAAA;AAExB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAMvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAGvD;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG;IACrC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAA;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAA;IACpC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;IAC/C,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAA;IAChD,kEAAkE;IAClE,QAAQ,CAAC,OAAO,EAAE,SAAS,SAAS,EAAE,CAAA;IACtC,wDAAwD;IACxD,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC,yEAAyE;IACzE,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;CACnD,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;IAC/C,qDAAqD;IACrD,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;CAChD,CAAA;AA8MD,0EAA0E;AAC1E,wBAAgB,OAAO,CACtB,MAAM,EAAE,SAAS,OAAO,EAAE,EAC1B,OAAO,GAAE,SAAS,UAAU,EAAO,GACjC,QAAQ,CA0GV"}

package/dist/schema.js

@@ -0,0 +1,267 @@
+import { modelDefinitions } from './definition.js';
+import { Refused } from './errors.js';
+import { installedUses } from './plugin-use.js';
+import { checkRelations, isFiltered, viewField } from './relations.js';
+import { checkIndexes, checkSearch } from './schema-indexes.js';
+import { virtualsOf } from './schema-virtuals.js';
+function fail(message) {
+    throw new Refused(message);
+}
+function inverseOf(link, links) {
+    const { model, name, target } = link;
+    const where = `${model}.${name}`;
+    const named = link.field.options['inverse'];
+    const back = links.filter((other) => other.model === target &&
+        other.target === model &&
+        !(other.model === model && other.name === name));
+    if (typeof named === 'string') {
+        const found = links.find((other) => other.model === target && other.name === named);
+        if (found === undefined || found.target !== model) {
+            fail(`${where}: inverse '${named}' is not a relation of ${target} to ${model}.`);
+        }
+        if (found.model === model && found.name === name) {
+            fail(`${where} cannot be its own inverse.`);
+        }
+        return found;
+    }
+    const candidates = back.filter((other) => {
+        const theirs = other.field.options['inverse'];
+        return typeof theirs !== 'string' || theirs === name;
+    });
+    const [only, ...others] = candidates;
+    if (only === undefined) {
+        fail(`${where}: ${target} has no relation to ${model}; add its side.`);
+    }
+    if (others.length > 0) {
+        fail(`${where}: ${target} has several relations to ${model}; name one with \`inverse\`.`);
+    }
+    return only;
+}
+function relationField(link, inverse) {
+    const { field } = link;
+    const optional = field.options['optional'] === true;
+    const where = `${link.model}.${link.name}`;
+    if (field.kind === 'many') {
+        return {
+            kind: 'many',
+            name: link.name,
+            target: link.target,
+            inverse: inverse.name,
+            join: inverse.field.kind === 'many',
+            options: field.options,
+        };
+    }
+    let stored = inverse.field.kind === 'many';
+    if (inverse.field.kind === 'one') {
+        const theirs = inverse.field.options['optional'] === true;
+        if (optional === theirs) {
+            fail(`${where} and ${inverse.model}.${inverse.name}: make one side of a one-to-one relation optional.`);
+        }
+        stored = !optional;
+    }
+    const asked = field.options['onDelete'];
+    if (!stored && asked !== undefined) {
+        fail(`${where}: onDelete belongs on ${inverse.model}.${inverse.name}, which stores the key.`);
+    }
+    if (asked === 'setNull' && !optional) {
+        throw new Refused(`${where}: setNull needs an optional relation.`);
+    }
+    const onDelete = asked === 'cascade' || asked === 'restrict' || asked === 'setNull'
+        ? asked
+        : optional
+            ? 'setNull'
+            : 'restrict';
+    const dbName = field.options['dbName'];
+    return {
+        kind: 'one',
+        name: link.name,
+        target: link.target,
+        inverse: inverse.name,
+        stored,
+        unique: stored && inverse.field.kind === 'one',
+        optional,
+        onDelete,
+        ...(typeof dbName === 'string' ? { dbName } : {}),
+        options: field.options,
+    };
+}
+/** A decimal's precision and scale, which its builder checked (D-145). */
+const digitsOf = (options) => ({
+    precision: Number(options['precision']),
+    scale: Number(options['scale']),
+});
+function scalarField(name, field) {
+    if (field.kind !== 'scalar')
+        throw new Error('Expected a scalar field.');
+    const dbName = field.options['dbName'];
+    // A field type's default is a value code sees, never a column's; its
+    // stored field's fills the rows stored before it (D-122, D-152).
+    const fixed = field.codec === undefined ? field.options['default'] : field.codec.filled;
+    return {
+        kind: 'scalar',
+        name,
+        type: field.type,
+        ...(field.values === undefined ? {} : { values: field.values }),
+        list: field.options['list'] === true,
+        ...(field.type === 'number' && field.options['integer'] === true
+            ? { integer: true }
+            : {}),
+        ...(field.type === 'decimal' ? digitsOf(field.options) : {}),
+        optional: field.options['optional'] === true,
+        unique: field.options['unique'] === true,
+        ...(field.options['search'] === true ? { search: true } : {}),
+        ...(typeof dbName === 'string' ? { dbName } : {}),
+        // `null` is no value: a create without one stores none either.
+        ...(fixed === undefined || fixed === null || typeof fixed === 'function'
+            ? {}
+            : { default: fixed }),
+        options: field.options,
+        ...(field.codec === undefined ? {} : { codec: field.codec }),
+        ...(field.enum === undefined ? {} : { enum: field.enum }),
+    };
+}
+/** A field as the adapter reads it, without the builder's options. */
+function schemaField(model, field) {
+    const { options: _options, codec: _codec, enum: _enum, ...schema } = field;
+    if (schema.kind !== 'many' || !isFiltered(model, field.name))
+        return schema;
+    return { ...schema, filtered: true };
+}
+const whose = (owner) => owner === undefined ? 'models lists' : `${owner}.models lists`;
+/** The models, the application's then each plugin's, by name (D-110). */
+function definitionsOf(values, plugins) {
+    const definitions = new Map();
+    const names = new Map();
+    const owners = new Map();
+    const lists = [
+        [undefined, values],
+        ...plugins.map((code) => [
+            code.name,
+            code.models,
+        ]),
+    ];
+    for (const [owner, list] of lists) {
+        for (const value of list) {
+            const definition = typeof value === 'object' && value !== null
+                ? modelDefinitions.get(value)
+                : undefined;
+            if (definition === undefined ||
+                typeof value !== 'object' ||
+                value === null) {
+                throw new Refused(`${whose(owner)} a value that defineModel did not return.`);
+            }
+            const { name } = definition;
+            if (owners.has(name)) {
+                const other = owners.get(name);
+                throw new Refused(owner === other
+                    ? `${whose(owner)} two models named ${name}.`
+                    : `${whose(owner)} a model named ${name}, as ${whose(other)}; name a plugin's models after it.`);
+            }
+            definitions.set(name, definition);
+            names.set(value, name);
+            owners.set(name, owner);
+        }
+    }
+    return { definitions, names, owners };
+}
+/** Resolves the application's models, or stops startup with a message. */
+export function resolve(values, plugins = []) {
+    const { definitions, names, owners } = definitionsOf(values, plugins);
+    const links = [];
+    const views = [];
+    for (const [model, definition] of definitions) {
+        for (const [name, field] of definition.fields) {
+            if (field.kind === 'scalar' || field.kind === 'virtual')
+                continue;
+            const value = field.target();
+            const target = typeof value === 'object' && value !== null
+                ? names.get(value)
+                : undefined;
+            if (target === undefined) {
+                throw new Refused(`${model}.${name}: its target is not in models.`);
+            }
+            const owner = owners.get(model);
+            if (owner !== owners.get(target)) {
+                throw new Refused(`${model}.${name}: a plugin's model relates only to models of the same plugin; keep the id as a scalar.`);
+            }
+            // A view reads the link of another relation (D-151).
+            const from = field.kind === 'many' ? field.options['from'] : undefined;
+            const link = { model, name, field, target };
+            (typeof from === 'string' ? views : links).push(link);
+        }
+    }
+    const inverses = new Map(links.map((link) => [link, inverseOf(link, links)]));
+    for (const [link, inverse] of inverses) {
+        if (inverses.get(inverse) !== link) {
+            fail(`${link.model}.${link.name} and ${inverse.model}.${inverse.name} do not name each other.`);
+        }
+    }
+    const linkOf = (list, model, name) => list.find((each) => each.model === model && each.name === name);
+    const relationOf = (model, name) => {
+        const link = linkOf(links, model, name);
+        const inverse = link && inverses.get(link);
+        return link && inverse ? relationField(link, inverse) : undefined;
+    };
+    const fieldOf = (model, name, field) => {
+        const view = linkOf(views, model, name);
+        if (view === undefined) {
+            return relationOf(model, name) ?? scalarField(name, field);
+        }
+        const from = String(field.options['from']);
+        return viewField({ model, name, target: view.target, options: field.options }, from, linkOf(views, model, from) ? 'view' : relationOf(model, from));
+    };
+    const models = new Map();
+    const byValue = new Map();
+    const schemaModels = [];
+    for (const [model, definition] of definitions) {
+        const fields = new Map();
+        for (const [name, field] of definition.fields) {
+            // A virtual is no field of the adapter's (D-151).
+            if (field.kind === 'virtual')
+                continue;
+            const plugin = field.kind === 'scalar' ? field.codec?.plugin : undefined;
+            if (plugin !== undefined && !plugins.some((p) => p.name === plugin)) {
+                fail(`${model}.${name} is a ${plugin} field, and ${plugin} is not in plugins.`);
+            }
+            fields.set(name, fieldOf(model, name, field));
+        }
+        checkIndexes(model, fields, definition.indexes);
+        const uniques = [['id']];
+        for (const field of fields.values()) {
+            if (field.kind === 'scalar' && field.unique)
+                uniques.push([field.name]);
+        }
+        for (const index of definition.indexes) {
+            if (index.unique === true)
+                uniques.push(index.fields);
+        }
+        const info = {
+            name: model,
+            definition,
+            fields,
+            uniques,
+            plugins: installedUses(definition, plugins),
+            owner: owners.get(model),
+            virtuals: virtualsOf(model, definition, names),
+        };
+        checkSearch(info);
+        checkRelations(info);
+        models.set(model, info);
+        schemaModels.push({
+            name: model,
+            ...(definition.dbName === undefined ? {} : { dbName: definition.dbName }),
+            fields: [...fields.values()].map((field) => schemaField(info, field)),
+            indexes: definition.indexes.map((index) => ({
+                fields: index.fields,
+                unique: index.unique === true,
+                contains: index.contains === true,
+            })),
+        });
+    }
+    for (const [value, name] of names) {
+        const info = models.get(name);
+        if (info !== undefined)
+            byValue.set(value, info);
+    }
+    return { schema: { models: schemaModels }, models, byValue };
+}

package/dist/scope.d.ts

@@ -0,0 +1,46 @@
+import type { Access } from './access.ts';
+import type { Filter } from './adapter.ts';
+import type { FindOperation } from './model.ts';
+import type { Caller } from './rules.ts';
+import type { FieldInfo, ModelInfo } from './schema.ts';
+import type { Models, Scope, Verb } from './query-where.ts';
+/**
+ * `readable` is synchronous, as the planning that calls it, but `beforeFind`
+ * may not be: a model read before its hook ran is recorded, and `ready` runs
+ * the hooks so the query can be planned again with their filters.
+ */
+export declare class QueryScope implements Scope {
+    /** By `operation name`, as `read Post`. */
+    private readonly narrowed;
+    private readonly wanted;
+    readonly models: Models;
+    readonly caller: Caller;
+    /** `undefined` for Master, which skips access rules (D-48). */
+    readonly access: Access | undefined;
+    private readonly relations;
+    constructor(models: Models, caller: Caller, access: Access | undefined);
+    check(model: ModelInfo, field: string, path: string, verb: Verb): void;
+    ruled(model: ModelInfo, field: string): boolean;
+    /**
+     * The rows of `name` the query reads, or the write `operation` targets:
+     * its read rule and `beforeFind`.
+     */
+    readable(name: string, operation?: FindOperation): Filter | undefined;
+    related(model: ModelInfo, field: Extract<FieldInfo, {
+        readonly kind: 'many';
+    }>): Filter | undefined;
+    /**
+     * Runs the `beforeFind` hooks of the models read since the last call;
+     * whether one of them narrows, so the query must be planned again.
+     */
+    ready(): Promise<boolean>;
+    /**
+     * The rows of `name` a write reaches; `trusted` for a value a hook or a
+     * default wrote, which skips access rules but not `beforeFind` (D-67).
+     */
+    filter(name: string, trusted: boolean, operation?: FindOperation): Promise<Filter | undefined>;
+    private narrowing;
+}
+/** Plans a query, then again once the `beforeFind` hooks it reached ran. */
+export declare function planned<T>(scope: QueryScope, build: () => T): Promise<T>;
+//# sourceMappingURL=scope.d.ts.map

package/dist/scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope.d.ts","sourceRoot":"","sources":["../src/scope.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAE1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAC/C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAExC,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvD,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAG3D;;;;GAIG;AACH,qBAAa,UAAW,YAAW,KAAK;IACvC,2CAA2C;IAC3C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAwC;IACjE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAGpB;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IAErC,YAAY,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,EAKrE;IAED,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,CAErE;IAED,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAE9C;IAED;;;OAGG;IACH,QAAQ,CACP,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,aAAsB,GAC/B,MAAM,GAAG,SAAS,CAEpB;IAED,OAAO,CACN,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,OAAO,CAAC,SAAS,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,GAClD,MAAM,GAAG,SAAS,CAEpB;IAED;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC,CAgB9B;IAED;;;OAGG;IACG,MAAM,CACX,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,OAAO,EAChB,SAAS,GAAE,aAAsB,GAC/B,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAM7B;IAED,OAAO,CAAC,SAAS;CASjB;AAED,4EAA4E;AAC5E,wBAAsB,OAAO,CAAC,CAAC,EAC9B,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,MAAM,CAAC,GACZ,OAAO,CAAC,CAAC,CAAC,CAIZ"}