@antelopejs/interface-data-api 0.3.0 → 0.5.0

package/dist/components.js

@@ -1,29 +1,61 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Validation = exports.Query = exports.Parameters = void 0;
 const interface_api_util_1 = require("@antelopejs/interface-api-util");
 const common_1 = require("@antelopejs/interface-database-decorators/common");
 const decorators_1 = require("@antelopejs/interface-core/decorators");
 const interface_api_1 = require("@antelopejs/interface-api");
-const interface_database_1 = require("@antelopejs/interface-database");
+require("@antelopejs/interface-database");
 const common_2 = require("@antelopejs/interface-database-decorators/modifiers/common");
 const metadata_1 = require("./metadata");
+const computed = __importStar(require("./internal/computed"));
+const filters_1 = require("./internal/filters");
+const foreign = __importStar(require("./internal/foreign"));
+const guards_1 = require("./internal/guards");
+const joined = __importStar(require("./internal/joined"));
+const list = __importStar(require("./internal/list"));
+const properties = __importStar(require("./internal/properties"));
+const tables = __importStar(require("./internal/tables"));
+const validation = __importStar(require("./internal/validation"));
 var Parameters;
 (function (Parameters) {
     function GetOptionOverrides(reqCtx) {
         return reqCtx.dataAPIEntry?.options ?? {};
     }
     Parameters.GetOptionOverrides = GetOptionOverrides;
-    function parseFilter(searchVal) {
-        const match = searchVal.match(/([^:]+):(.*)/);
-        return match ? [match[2], match[1]] : [searchVal, "eq"];
-    }
-    function copyFilter(filter) {
-        const copies = (0, metadata_1.FilterValuesOf)(filter).map((value) => [
-            ...value,
-        ]);
-        return copies.length === 1 ? copies[0] : copies;
-    }
     /**
      * Extracts request filters and mandatory route filters, with route field
      * keys winning. A field the request filters once (`?filter_status=open`)
@@ -36,14 +68,14 @@ var Parameters;
         for (const filter of Object.keys(meta.filters)) {
             const values = reqCtx.url.searchParams
                 .getAll(`filter_${filter}`)
-                .map(parseFilter);
+                .map(filters_1.parseFilter);
             if (values.length > 0) {
                 result[filter] = values.length === 1 ? values[0] : values;
             }
         }
         const overrides = GetOptionOverrides(reqCtx);
         for (const [key, value] of Object.entries(overrides.filters ?? {})) {
-            result[key] = copyFilter(value);
+            result[key] = (0, filters_1.copyFilter)(value);
         }
         return result;
     }
@@ -54,29 +86,40 @@ var Parameters;
         bool: (val) => val !== "0",
         string: (val) => val,
     };
+    function isConverterKey(name) {
+        return Object.hasOwn(converters, name);
+    }
+    function converterOf(name) {
+        if (!isConverterKey(name)) {
+            throw new TypeError(`Unknown parameter converter "${name}"`);
+        }
+        return converters[name];
+    }
+    function extractFromSearchParams(reqCtx, key, extractor) {
+        if (extractor.startsWith("multi:")) {
+            const name = extractor.substring(6);
+            return reqCtx.url.searchParams
+                .getAll(key)
+                .map((searchVal) => converterOf(name)(searchVal));
+        }
+        const searchVal = reqCtx.url.searchParams.get(key);
+        return searchVal === null ? undefined : converterOf(extractor)(searchVal);
+    }
     function ExtractGeneric(reqCtx, meta, dynamic) {
         const overrides = GetOptionOverrides(reqCtx);
         const result = { ...overrides };
         for (const key of Object.keys(dynamic)) {
-            if (!(key in result) || dynamic[key] === ExtractFilters) {
-                const extractor = dynamic[key];
-                if (typeof extractor === "string") {
-                    if (extractor.startsWith("multi:")) {
-                        const converter = converters[extractor.substring(6)];
-                        result[key] = reqCtx.url.searchParams
-                            .getAll(key)
-                            .map((searchVal) => converter(searchVal));
-                    }
-                    else {
-                        const searchVal = reqCtx.url.searchParams.get(key);
-                        if (searchVal !== null) {
-                            result[key] = converters[extractor](searchVal);
-                        }
-                    }
-                }
-                else {
-                    result[key] = extractor(reqCtx, meta);
-                }
+            const extractor = dynamic[key];
+            if (key in result && extractor !== ExtractFilters)
+                continue;
+            if ((0, guards_1.isString)(extractor)) {
+                const value = extractFromSearchParams(reqCtx, key, extractor);
+                if (value !== undefined)
+                    result[key] = value;
+            }
+            else {
+                // SAFETY: key comes from Object.keys(dynamic), typed GenericParams<Partial<T>> (a mapped type over keyof T), so for a type-checked argument it is a keyof T; false only for a stray key on a non-literal argument, which is harmless as the key is only written on result.
+                result[key] = extractor(reqCtx, meta);
             }
         }
         return result;
@@ -101,7 +144,7 @@ var Parameters;
         const params = ExtractGeneric(context, (0, metadata_1.GetDataControllerMeta)(this), {
             id: "string",
         });
-        (0, interface_api_util_1.assert)(params.id && typeof params.id === "string", 400, "Missing id.");
+        (0, interface_api_util_1.assert)(params.id && (0, guards_1.isString)(params.id), 400, "Missing id.");
         return params;
     }));
     Parameters.New = (0, decorators_1.MakeParameterAndPropertyDecorator)((target, key, param) => (0, interface_api_1.SetParameterProvider)(target, key, param, function (context) {
@@ -112,7 +155,7 @@ var Parameters;
         const params = ExtractGeneric(context, (0, metadata_1.GetDataControllerMeta)(this), {
             id: "string",
         });
-        (0, interface_api_util_1.assert)(params.id && typeof params.id === "string", 400, "Missing id.");
+        (0, interface_api_util_1.assert)(params.id && (0, guards_1.isString)(params.id), 400, "Missing id.");
         return params;
     }));
     Parameters.Delete = (0, decorators_1.MakeParameterAndPropertyDecorator)((target, key, param) => (0, interface_api_1.SetParameterProvider)(target, key, param, function (context) {
@@ -131,394 +174,15 @@ var Query;
     }
     Query.GetModel = GetModel;
     function Foreign(db, meta, query, pluck) {
-        /**/
-        if ((0, interface_database_1.IsStream)(query)) {
-            for (const [name, field] of Object.entries(meta.fields)) {
-                if (!field.foreign || (pluck && !pluck.has(name))) {
-                    continue;
-                }
-                const [table, tableClass, index, multi, pluckField, schemaName, targetJoined,] = field.foreign;
-                const other = targetTable(db, { table, tableClass, schemaName });
-                const hasTargetJoined = !multi && !!targetJoined?.length;
-                if (pluckField) {
-                    // The join keys of the target's @Joined fields must be fetched too
-                    // (so the second lookup can resolve them), but they are NOT stored in
-                    // `foreign[4]`, so they get stripped from the response by
-                    // `ClearInternal` afterwards.
-                    const lookupPluck = hasTargetJoined
-                        ? Array.from(new Set([
-                            ...pluckField,
-                            ...targetJoined.map((g) => g.localKey),
-                        ]))
-                        : pluckField;
-                    query = query.lookup(other.pluck("_internal", ...lookupPluck), name, index || "_id");
-                }
-                else {
-                    query = query.lookup(other, name, index || "_id");
-                }
-                if (hasTargetJoined) {
-                    query = applyForeignJoinedStream(db, query, name, targetJoined);
-                }
-            }
-            return query;
-        }
-        else {
-            const oldForeign = (obj) => {
-                const changedFields = {};
-                for (const [name, field] of Object.entries(meta.fields)) {
-                    if (!field.foreign || (pluck && !pluck.has(name))) {
-                        continue;
-                    }
-                    const [table, tableClass, index, multi, pluckField, schemaName, targetJoined,] = field.foreign;
-                    const remote = targetTable(db, { table, tableClass, schemaName });
-                    if (multi) {
-                        changedFields[name] = obj.key(name)
-                            .default([])
-                            .map((val) => {
-                            let foreignObject = Get(remote, val, index);
-                            if (pluckField) {
-                                foreignObject = foreignObject.pluck("_internal", ...pluckField);
-                            }
-                            return foreignObject.default(null);
-                        });
-                    }
-                    else {
-                        let foreignObject = Get(remote, obj.key(name), index);
-                        if (targetJoined && targetJoined.length > 0) {
-                            foreignObject = applyForeignJoinedDatum(db, foreignObject, targetJoined);
-                        }
-                        changedFields[name] = foreignObject.default(null);
-                    }
-                }
-                return obj.merge(changedFields);
-            };
-            return query.do(oldForeign);
-        }
+        return foreign.Foreign(db, meta, query, pluck);
     }
     Query.Foreign = Foreign;
-    /**
-     * Re-materializes the `@Joined` fields of a relation target on the looked-up
-     * sub-object (Stream/list path). The base `Foreign` lookup only plucks the
-     * target's physical columns, so a joined label would come back empty; here we
-     * resolve each joined field with a second lookup keyed on the target's
-     * (already plucked) local key, then merge it back into the relation object.
-     */
-    function applyForeignJoinedStream(db, stream, foreignName, groups) {
-        let s = stream;
-        for (const group of groups) {
-            const remoteTable = targetTable(db, group).pluck("_internal", group.remoteIndex, group.remoteField);
-            const tmpKey = `__fjoin_${foreignName}_${group.name}`;
-            s = s
-                .map((row) => row.merge({
-                [tmpKey]: row.key(foreignName).key(group.localKey),
-            }))
-                .lookup(remoteTable, tmpKey, group.remoteIndex)
-                .map((row) => row.merge({
-                // For an orphan foreign key this yields `{ [joined]: null }`; it is
-                // normalized back to a null relation in `ClearInternal` (the DSL has
-                // no value-level conditional to do it here).
-                [foreignName]: row.key(foreignName).merge({
-                    [group.name]: row
-                        .key(tmpKey)
-                        .default({})
-                        .key(group.remoteField)
-                        .default(null),
-                }),
-            }))
-                .without(tmpKey);
-        }
-        return s;
-    }
-    /**
-     * Datum/get counterpart of {@link applyForeignJoinedStream}: resolves each of
-     * the target's `@Joined` fields with a secondary `Get` and merges it into the
-     * relation object.
-     */
-    function applyForeignJoinedDatum(db, datum, groups) {
-        let d = datum;
-        for (const group of groups) {
-            // Use the raw table here (not a plucked stream): `Get` relies on
-            // `getAll`/`get`, which exist on Selection/Table but not on a Stream.
-            const remoteTable = targetTable(db, group);
-            d = d.do((row) => row.merge({
-                [group.name]: Get(remoteTable, row.key(group.localKey), group.remoteIndex)
-                    .key(group.remoteField)
-                    .default(null),
-            }));
-        }
-        return d;
-    }
-    function collectJoinedGroups(meta) {
-        const groups = new Map();
-        for (const [name, field] of Object.entries(meta.fields)) {
-            if (!field.joined)
-                continue;
-            const j = field.joined;
-            const groupKey = `${j.schemaName ?? ""}|${j.table}|${j.localKey}|${j.remoteIndex}`;
-            let group = groups.get(groupKey);
-            if (!group) {
-                group = {
-                    table: j.table,
-                    tableClass: j.tableClass,
-                    localKey: j.localKey,
-                    remoteIndex: j.remoteIndex,
-                    schemaName: j.schemaName,
-                    fields: [],
-                };
-                groups.set(groupKey, group);
-            }
-            group.fields.push({ name, remoteField: j.remoteField });
-        }
-        return Array.from(groups.values());
-    }
-    function addAll(target, names) {
-        for (const name of names) {
-            target.add(name);
-        }
-    }
-    /**
-     * Splits the joined fields of `meta` between those {@link List} must
-     * materialize before the filter and count (`filter`) and those it only
-     * needs after the count (`sort`). Joined fields referenced by neither are
-     * left out so the list route can defer their lookups to the returned page.
-     *
-     * Computed expressions may read joined fields, so materializing a computed
-     * field pulls every remaining joined group in with it. Groups whose local
-     * key is also a foreign field must resolve before `Foreign` replaces the
-     * key with the looked-up record.
-     */
-    function splitJoinedFields(meta, sorting, filters) {
-        const split = { filter: new Set(), sort: new Set() };
-        const filterNames = Object.keys(meta.filters).filter((name) => filters && name in filters);
-        const hasComputedFilter = filterNames.some((name) => meta.fields[name]?.computed);
-        const sortField = sorting?.[0];
-        const hasComputedSort = !!sortField && !!meta.fields[sortField]?.computed;
-        for (const group of collectJoinedGroups(meta)) {
-            const names = group.fields.map((field) => field.name);
-            if (hasComputedFilter ||
-                names.some((name) => filterNames.includes(name))) {
-                addAll(split.filter, names);
-            }
-            else if (hasComputedSort ||
-                (sortField && names.includes(sortField)) ||
-                meta.fields[group.localKey]?.foreign) {
-                addAll(split.sort, names);
-            }
-        }
-        return split;
-    }
-    /**
-     * Joined field names that {@link List} does not materialize for the given
-     * split. The default list route resolves these after pagination so their
-     * lookups only run on the returned page.
-     */
-    function deferredJoinedFields(meta, split) {
-        return new Set(Object.entries(meta.fields)
-            .filter(([name, field]) => field.joined && !split.filter.has(name) && !split.sort.has(name))
-            .map(([name]) => name));
-    }
-    /**
-     * Stream returned by {@link List} when the deferred joined fields are not
-     * exposed to the caller: it resolves them itself, so consumers that
-     * destructure `[query, total]` alone still observe every `@Joined` field.
-     * The lookups are appended after `slice`/`nth`, keeping them on the
-     * requested page only; bare `count()` calls and field aggregates on
-     * non-joined fields skip them (left-join lookups never change the row
-     * count nor other fields); `changes()` attaches to the raw stream, since
-     * change feeds cannot carry the lookups. Any other operation may observe
-     * the joined fields, so it materializes them first.
-     */
-    class DeferredJoinedStream extends interface_database_1.Stream {
-    }
-    function materializeDeferredJoin(stream) {
-        const { db, meta, names, raw } = stream.deferredJoin;
-        return Joined(db, meta, raw, names);
-    }
-    function pagedDeferredJoinOperation(name) {
-        return function (...args) {
-            const { db, meta, names, raw } = this.deferredJoin;
-            const paged = raw[name](...args);
-            return Joined(db, meta, paged, names);
-        };
-    }
-    /**
-     * Resolves the joined fields through the stream form of {@link Joined}
-     * rather than its datum form: only the datum form has no way to drop the
-     * temporary key it stages (neither `Datum` nor `ValueProxy` exposes
-     * `without`), so it would leave `__joined_orig_*` on the row.
-     */
-    function nthDeferredJoinOperation() {
-        return function (n) {
-            const { db, meta, names, raw } = this.deferredJoin;
-            return Joined(db, meta, raw.slice(n, 1), names).nth(0);
-        };
-    }
-    function rawDeferredJoinOperation(name) {
-        return function (...args) {
-            return this.deferredJoin.raw[name](...args);
-        };
-    }
-    function fieldAggregateDeferredJoinOperation(name, bareCallOnRaw) {
-        return function (field) {
-            const { db, meta, names, raw } = this.deferredJoin;
-            if (!field) {
-                const bareTarget = bareCallOnRaw ? raw : materializeDeferredJoin(this);
-                return bareTarget[name]();
-            }
-            const target = names.has(field)
-                ? Joined(db, meta, raw, new Set([field]))
-                : raw;
-            return target[name](field);
-        };
-    }
-    function forwardingDeferredJoinOperation(name) {
-        return function (...args) {
-            return materializeDeferredJoin(this)[name](...args);
-        };
-    }
-    const DEFERRED_JOIN_OPERATION_FACTORIES = {
-        slice: pagedDeferredJoinOperation,
-        nth: nthDeferredJoinOperation,
-        changes: rawDeferredJoinOperation,
-        count: (name) => fieldAggregateDeferredJoinOperation(name, true),
-        sum: (name) => fieldAggregateDeferredJoinOperation(name, false),
-        avg: (name) => fieldAggregateDeferredJoinOperation(name, false),
-        min: (name) => fieldAggregateDeferredJoinOperation(name, false),
-        max: (name) => fieldAggregateDeferredJoinOperation(name, false),
-        distinct: (name) => fieldAggregateDeferredJoinOperation(name, false),
-    };
-    const DEFERRED_JOIN_INHERITED_OPERATIONS = new Set(["constructor", "cast"]);
-    function wireDeferredJoinedStream() {
-        const operationNames = [
-            ...Object.getOwnPropertyNames(interface_database_1.Stream.prototype),
-            "run",
-            "cursor",
-            "build",
-        ].filter((name) => !DEFERRED_JOIN_INHERITED_OPERATIONS.has(name));
-        for (const name of operationNames) {
-            const factory = DEFERRED_JOIN_OPERATION_FACTORIES[name] ??
-                forwardingDeferredJoinOperation;
-            DeferredJoinedStream.prototype[name] = factory(name);
-        }
-    }
-    wireDeferredJoinedStream();
-    /**
-     * Wraps `raw` into a {@link DeferredJoinedStream}. The wrapper keeps the
-     * raw stages as its own (an unobservable fallback, since every operation
-     * is overridden) while `build()` serializes the materialized pipeline, so
-     * a wrapper embedded as an argument of another query never leaks rows
-     * without the joined fields.
-     */
-    function wrapDeferredJoined(db, meta, names, raw) {
-        const wrapped = Object.create(DeferredJoinedStream.prototype);
-        wrapped.stages = raw.build();
-        wrapped.deferredJoin = { db, meta, names, raw };
-        return wrapped;
-    }
-    function listResultTuple(tmpRequest, total, meta, joinedSplit, db, options) {
-        const deferredJoined = deferredJoinedFields(meta, joinedSplit);
-        if (options?.exposeDeferredJoined || !db || deferredJoined.size === 0) {
-            return [tmpRequest, total, deferredJoined];
-        }
-        return [
-            wrapDeferredJoined(db, meta, deferredJoined, tmpRequest),
-            total,
-            new Set(),
-        ];
-    }
-    function targetTable(sourceDb, target) {
-        if (!target.schemaName)
-            return sourceDb.table(target.table);
-        (0, interface_api_util_1.assert)(target.tableClass, 500, `Table "${target.table}" of schema "${target.schemaName}" has no registered table class`);
-        return target.tableClass.table();
-    }
     function Joined(db, meta, query, only) {
-        const groups = collectJoinedGroups(meta).filter((group) => !only || group.fields.some((field) => only.has(field.name)));
-        if (groups.length === 0) {
-            return query;
-        }
-        const emptyRemote = {};
-        const tmpKeyFor = (localKey) => `__joined_orig_${localKey}`;
-        if ((0, interface_database_1.IsStream)(query)) {
-            let stream = query;
-            const tmpKeys = [];
-            for (const group of groups) {
-                const remoteFields = group.fields.map((f) => f.remoteField);
-                const remoteTable = targetTable(db, group).pluck("_internal", group.remoteIndex, ...remoteFields);
-                const tmpKey = tmpKeyFor(group.localKey);
-                tmpKeys.push(tmpKey);
-                stream = stream
-                    .map((row) => row.merge({ [tmpKey]: row.key(group.localKey) }))
-                    .lookup(remoteTable, group.localKey, group.remoteIndex)
-                    .map((row) => {
-                    const merged = {};
-                    const remote = row.key(group.localKey).default(emptyRemote);
-                    for (const f of group.fields) {
-                        merged[f.name] = remote.key(f.remoteField).default(null);
-                    }
-                    merged[group.localKey] = row.key(tmpKey);
-                    return row.merge(merged);
-                });
-            }
-            return stream.without(...tmpKeys);
-        }
-        let datum = query;
-        for (const group of groups) {
-            const remoteFields = group.fields.map((f) => f.remoteField);
-            const remoteTable = targetTable(db, group).pluck("_internal", group.remoteIndex, ...remoteFields);
-            const tmpKey = tmpKeyFor(group.localKey);
-            datum = datum
-                .do((row) => row.merge({ [tmpKey]: row.key(group.localKey) }))
-                .lookup(remoteTable, group.localKey, group.remoteIndex)
-                .do((row) => {
-                const merged = {};
-                const remote = row.key(group.localKey).default(emptyRemote);
-                for (const f of group.fields) {
-                    merged[f.name] = remote.key(f.remoteField).default(null);
-                }
-                merged[group.localKey] = row.key(tmpKey);
-                return row.merge(merged);
-            });
-        }
-        return datum;
+        return joined.Joined(db, meta, query, only);
     }
     Query.Joined = Joined;
-    function collectComputedEntries(meta, only) {
-        return Object.entries(meta.fields)
-            .filter(([name, field]) => field.computed && (!only || only.has(name)))
-            .map(([name, field]) => [name, field.computed]);
-    }
-    function buildComputedMappers(db, entries) {
-        const mergeExpressions = (row) => {
-            const merged = {};
-            for (const [name, computed] of entries) {
-                merged[name] = computed.expr(row, db);
-            }
-            return row.merge(merged);
-        };
-        const defaulted = entries.filter(([, computed]) => computed.default !== undefined);
-        if (defaulted.length === 0) {
-            return [mergeExpressions];
-        }
-        const applyDefaults = (row) => {
-            const merged = {};
-            for (const [name, computed] of defaulted) {
-                merged[name] = row.key(name).default(computed.default);
-            }
-            return row.merge(merged);
-        };
-        return [mergeExpressions, applyDefaults];
-    }
     function Computed(db, meta, query, only) {
-        const entries = collectComputedEntries(meta, only);
-        if (entries.length === 0) {
-            return query;
-        }
-        const mappers = buildComputedMappers(db, entries);
-        if ((0, interface_database_1.IsStream)(query)) {
-            return mappers.reduce((stream, mapper) => stream.map(mapper), query);
-        }
-        return mappers.reduce((datum, mapper) => datum.do(mapper), query);
+        return computed.Computed(db, meta, query, only);
     }
     Query.Computed = Computed;
     async function ReadProperties(obj, meta, dbData, action, onlyList) {
@@ -539,27 +203,11 @@ var Query;
                 continue;
             }
             const val = field.desc?.get?.apply(instance);
-            res[key] = await (typeof val === "function" ? val() : val);
+            res[key] = await ((0, guards_1.isFunction)(val) ? val() : val);
         }
         return res;
     }
     Query.ReadProperties = ReadProperties;
-    function writableInBody(writable, bodyData) {
-        return {
-            props: writable.props.filter(([key]) => Object.hasOwn(bodyData, key)),
-            setters: writable.setters.filter(([key]) => Object.hasOwn(bodyData, key)),
-        };
-    }
-    function writeTargetDefaults(instance, meta, dbData) {
-        for (const [key, value] of Object.entries(new meta.target())) {
-            if (value !== undefined) {
-                instance[key] = value;
-                if (key in meta.fields) {
-                    dbData[meta.fields[key].dbName || key] = value;
-                }
-            }
-        }
-    }
     /**
      * Writes the writable fields of `bodyData` into a database row.
      *
@@ -571,32 +219,11 @@ var Query;
      * `null` clears it.
      */
     async function WriteProperties(obj, meta, bodyData, action, existingDBData) {
-        const actionWritable = meta.writable[action ?? "_default"] ?? meta.writable._default;
-        const writable = existingDBData
-            ? writableInBody(actionWritable, bodyData)
-            : actionWritable;
-        const instance = { ...obj };
-        const dbData = existingDBData || {};
-        Object.setPrototypeOf(dbData, meta.tableClass.prototype);
-        if (!existingDBData) {
-            writeTargetDefaults(instance, meta, dbData);
-        }
-        for (const [key, field] of writable.props) {
-            instance[key] = bodyData[key];
-            dbData[field.dbName || key] = bodyData[key];
-        }
-        instance.table = dbData;
-        Object.setPrototypeOf(instance, meta.target.prototype);
-        for (const [key, field] of writable.setters) {
-            field.desc?.set?.apply(instance, [bodyData[key]]);
-        }
-        return dbData;
+        return properties.WriteProperties(obj, meta, bodyData, action, existingDBData);
     }
     Query.WriteProperties = WriteProperties;
     function Get(table, id, index) {
-        return index
-            ? table.getAll(id, index).nth(0)
-            : table.get(id);
+        return tables.Get(table, id, index);
     }
     Query.Get = Get;
     /**
@@ -609,83 +236,15 @@ var Query;
      * since no lookup can be built without one — the raw stream is returned
      * and the third element names the joined fields left for the caller.
      */
-    function List(obj, meta, request, reqCtx, sorting, filters, db, options) {
-        const filterList = Object.entries(meta.filters).filter(([name]) => filters && name in filters);
-        // The index serves one equality; a field filtered several times is
-        // filtered row by row, each of its filters in turn.
-        const indexFilter = filterList.find(([name]) => {
-            const values = filters ? (0, metadata_1.FilterValuesOf)(filters[name]) : [];
-            return (values.length === 1 &&
-                values[0][1] === "eq" &&
-                meta.fields[name]?.indexable);
-        })?.[0];
-        const index = indexFilter
-            ? meta.fields[indexFilter].dbName || indexFilter
-            : undefined;
-        const indexedFilter = indexFilter
-            ? (0, metadata_1.FilterValuesOf)(filters?.[indexFilter] ?? [])[0]
-            : undefined;
-        let tmpRequest = index
-            ? request.getAll(indexedFilter?.[0] ?? "", index)
-            : request;
-        const joinedSplit = splitJoinedFields(meta, sorting, filters);
-        if (db && joinedSplit.filter.size > 0) {
-            tmpRequest = Joined(db, meta, tmpRequest, joinedSplit.filter);
-        }
-        const filteredComputed = new Set(filterList
-            .map(([name]) => name)
-            .filter((name) => meta.fields[name]?.computed));
-        if (db && filteredComputed.size > 0) {
-            tmpRequest = Computed(db, meta, tmpRequest, filteredComputed);
-        }
-        const sortField = sorting?.[0];
-        const shouldSort = sortField ? meta.fields[sortField]?.sortable : undefined;
-        if (shouldSort?.indexed && sortField) {
-            tmpRequest = tmpRequest.orderBy(sortField, sorting?.[1] ?? "asc");
-        }
-        if (filterList.length > 0) {
-            // TODO: rework for modifier-affected fields (unlockrequest)
-            tmpRequest = filterList.reduce((req, [name, filter]) => {
-                const fieldFilter = filters?.[name];
-                if (!fieldFilter || name === indexFilter)
-                    return req;
-                return (0, metadata_1.FilterValuesOf)(fieldFilter).reduce((filtered, [value, mode]) => filtered.filter((row) => filter(Object.assign(reqCtx, { this: obj }), Validation.UnlockRequest(obj, meta, row, name), name, value, mode, row)), req);
-            }, tmpRequest);
-        }
-        const total = tmpRequest.count();
-        if (db && joinedSplit.sort.size > 0) {
-            tmpRequest = Joined(db, meta, tmpRequest, joinedSplit.sort);
-        }
-        if (db &&
-            sortField &&
-            meta.fields[sortField]?.computed &&
-            !filteredComputed.has(sortField)) {
-            tmpRequest = Computed(db, meta, tmpRequest, new Set([sortField]));
-        }
-        if (shouldSort && !shouldSort.indexed && sortField) {
-            tmpRequest = tmpRequest.orderBy(sortField, sorting?.[1] ?? "asc");
-        }
-        return listResultTuple(tmpRequest, total, meta, joinedSplit, db, options);
+    function List(obj, meta, request, reqCtx, ...[sorting, filters, db, options]) {
+        return list.List(obj, meta, request, reqCtx, {
+            sorting,
+            filters,
+            db,
+            options,
+        });
     }
     Query.List = List;
-    function pageComputedFields(meta, options) {
-        const merged = new Set(Object.keys(options.filters ?? {}).filter((name) => name in meta.filters));
-        if (options.sortKey)
-            merged.add(options.sortKey);
-        const names = Object.entries(meta.fields)
-            .filter(([name, field]) => field.computed &&
-            !merged.has(name) &&
-            (!options.pluck || options.pluck.has(name)))
-            .map(([name]) => name);
-        return new Set(names);
-    }
-    function pageJoinedFields(options, materializeAll) {
-        const deferred = options.deferredJoined ?? new Set();
-        if (materializeAll || !options.pluck)
-            return deferred;
-        const pluck = options.pluck;
-        return new Set(Array.from(deferred).filter((name) => pluck.has(name)));
-    }
     /**
      * One page of the stream {@link List} built, with the fields it answers:
      * the deferred joined fields, then the computed fields no filter or sort
@@ -695,19 +254,7 @@ var Query;
      * it.
      */
     function ListPage(db, meta, query, options) {
-        let page = query.slice(options.offset, options.limit);
-        const computed = pageComputedFields(meta, options);
-        // A computed expression may read any joined field, so when one is
-        // materialized every deferred joined group is merged first, whatever
-        // the pluck; the final pluck strips what the page did not ask for.
-        const joined = pageJoinedFields(options, computed.size > 0);
-        if (joined.size > 0)
-            page = Joined(db, meta, page, joined);
-        if (computed.size > 0)
-            page = Computed(db, meta, page, computed);
-        if (!options.noForeign)
-            page = Foreign(db, meta, page, options.pluck);
-        return options.pluck ? page.pluck("_internal", ...options.pluck) : page;
+        return list.ListPage(db, meta, query, options);
     }
     Query.ListPage = ListPage;
     function Delete(table, id) {
@@ -722,8 +269,8 @@ var Validation;
     function isClearingValue(value) {
         if (value === null || value === undefined)
             return true;
-        if (typeof value === "string")
-            return value.length === 0;
+        if (value === "")
+            return true;
         return Array.isArray(value) && value.length === 0;
     }
     const isAbsentFromBody = (body, name) => !(name in body);
@@ -731,28 +278,39 @@ var Validation;
     const MISSING_MANDATORY_FIELD_CHECKS = {
         edit: isClearedByBody,
     };
+    /** The `code` of a 400 naming the mandatory fields a body lacks. */
+    Validation.MISSING_MANDATORY_FIELDS = "missing_mandatory_fields";
+    /** The `code` of a 400 naming the fields whose validator refused the value. */
+    Validation.INVALID_FIELD_TYPES = "invalid_field_types";
+    function rejectFields(code, fields) {
+        if (fields.length === 0)
+            return;
+        throw new interface_api_1.HTTPResult(400, { code, fields });
+    }
     /**
      * Rejects with 400 the request bodies missing a field mandatory for `type`.
      * On `edit`, a mandatory field is missing when the body clears it (`null`,
      * `""` or `[]`); a field absent from the body keeps its stored value. On any
-     * other action, it is missing when absent from the body.
+     * other action, it is missing when absent from the body. The body of the
+     * 400 is a {@link FieldsErrorBody} with {@link MISSING_MANDATORY_FIELDS}.
      */
     function MandatoryFields(meta, obj, type) {
         const isMissing = MISSING_MANDATORY_FIELD_CHECKS[type] ?? isAbsentFromBody;
         const missing = Object.entries(meta.fields)
             .filter(([name, field]) => field.mandatory?.has(type) && isMissing(obj, name))
             .map(([name]) => name);
-        (0, interface_api_util_1.assert)(missing.length === 0, 400, `Missing mandatory fields: ${missing.join(", ")}`);
+        rejectFields(Validation.MISSING_MANDATORY_FIELDS, missing);
     }
     Validation.MandatoryFields = MandatoryFields;
     function toParseResult(result, value) {
-        if (typeof result !== "boolean")
+        if (result !== true && result !== false)
             return result;
         return result ? { success: true, data: value } : { success: false };
     }
     /**
      * Runs the validator of each field present in `obj` and rejects with 400
-     * when one fails. Returns a copy of `obj` where each validated field holds
+     * when one fails, with a {@link FieldsErrorBody} of
+     * {@link INVALID_FIELD_TYPES}. Returns a copy of `obj` where each validated field holds
      * the value its validator parsed (see {@link FieldValidationResult}).
      */
     async function ValidateTypes(meta, obj) {
@@ -769,7 +327,7 @@ var Validation;
                 invalid.push(name);
             }
         }
-        (0, interface_api_util_1.assert)(invalid.length === 0, 400, `Invalid field type(s): ${invalid.join(", ")}`);
+        rejectFields(Validation.INVALID_FIELD_TYPES, invalid);
         return parsed;
     }
     Validation.ValidateTypes = ValidateTypes;
@@ -778,17 +336,7 @@ var Validation;
      * body already parsed is checked, not parsed again.
      */
     function ParseBody(body) {
-        let data = body;
-        if (Buffer.isBuffer(body)) {
-            try {
-                data = JSON.parse(body.toString());
-            }
-            catch {
-                (0, interface_api_util_1.assert)(false, 400, "Invalid JSON body.");
-            }
-        }
-        (0, interface_api_util_1.assert)(typeof data === "object" && data !== null && !Array.isArray(data), 400, "The request body must be a JSON object.");
-        return data;
+        return validation.ParseBody(body);
     }
     Validation.ParseBody = ParseBody;
     /**
@@ -806,78 +354,15 @@ var Validation;
     }
     Validation.Lock = Lock;
     function Unlock(obj, meta, dbData) {
-        for (const [name, field] of Object.entries(meta.fields)) {
-            if (field.foreign &&
-                dbData[name] &&
-                typeof dbData[name] === "object" &&
-                field.foreign[1]) {
-                const foreignSchema = field.foreign[1];
-                dbData[name] = Array.isArray(dbData[name])
-                    ? dbData[name].map((entry) => (0, common_2.fromDatabase)(entry, foreignSchema))
-                    : (0, common_2.fromDatabase)(dbData[name], field.foreign[1]);
-            }
-        }
-        for (const [modifier, field] of meta.modifierKeys.entries()) {
-            const key = obj[field];
-            (0, common_2.unlock)(dbData, modifier, undefined, key);
-            for (const [foreign, fieldData] of Object.entries(meta.fields)) {
-                if (fieldData.foreign &&
-                    dbData[foreign] &&
-                    typeof dbData[foreign] === "object") {
-                    (0, common_2.unlock)(dbData[foreign], modifier, undefined, key);
-                }
-            }
-        }
+        validation.Unlock(obj, meta, dbData);
     }
     Validation.Unlock = Unlock;
     function UnlockRequest(obj, meta, row, field) {
-        const modifiers = Array.from(meta.modifierKeys.entries()).map(([modifier, field]) => ({
-            modifier,
-            args: [obj[field]],
-        }));
-        return (0, common_2.unlockrequest)(meta.tableClass, row, field, modifiers);
+        return validation.UnlockRequest(obj, meta, row, field);
     }
     Validation.UnlockRequest = UnlockRequest;
     function ClearInternal(meta, obj) {
-        const results = Array.isArray(obj) ? obj : [obj];
-        const foreignFields = Object.entries(meta.fields).filter(([, field]) => field.foreign);
-        for (const entry of results) {
-            delete entry._internal;
-            for (const [name, { foreign }] of foreignFields) {
-                if (foreign &&
-                    entry[name] &&
-                    typeof entry[name] === "object" &&
-                    (!Array.isArray(entry[name]) || typeof entry[name][0] === "object")) {
-                    const processForeign = (data) => {
-                        const plain = (0, common_2.toPlainData)(data);
-                        if (!foreign?.[4]) {
-                            return plain;
-                        }
-                        // An orphan foreign key whose target exposes @Joined fields produces
-                        // an object with only those joined fields (all null) and none of the
-                        // physical pluck fields. Normalize it back to a null relation, so it
-                        // matches the get path and non-joined foreigns (which already null).
-                        const targetJoined = foreign[6];
-                        if (targetJoined?.length) {
-                            const joinedNames = new Set(targetJoined.map((g) => g.name));
-                            const physicalKeys = foreign[4].filter((k) => !joinedNames.has(k));
-                            if (physicalKeys.length > 0 &&
-                                physicalKeys.every((k) => plain[k] === null || plain[k] === undefined)) {
-                                return null;
-                            }
-                        }
-                        const plainPlucked = {};
-                        for (const key of foreign[4]) {
-                            plainPlucked[key] = plain[key];
-                        }
-                        return plainPlucked;
-                    };
-                    entry[name] = Array.isArray(entry[name])
-                        ? entry[name].map(processForeign)
-                        : processForeign(entry[name]);
-                }
-            }
-        }
+        validation.ClearInternal(meta, obj);
     }
     Validation.ClearInternal = ClearInternal;
 })(Validation || (exports.Validation = Validation = {}));