@antelopejs/interface-data-api 0.4.0 → 0.6.0

package/dist/components.js

@@ -1,29 +1,65 @@
 "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 extractors = __importStar(require("./internal/extractors"));
+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 prototypes_1 = require("./internal/prototypes");
+const read_properties_1 = require("./internal/read-properties");
+const tables = __importStar(require("./internal/tables"));
+const validation = __importStar(require("./internal/validation"));
 var Parameters;
 (function (Parameters) {
+    /** The options the route's `WithOptions` set, none when it set none. */
     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,60 +72,55 @@ 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;
     }
     Parameters.ExtractFilters = ExtractFilters;
-    const converters = {
-        number: (val) => parseFloat(val),
-        int: (val) => parseInt(val, 10),
-        bool: (val) => val !== "0",
-        string: (val) => val,
-    };
+    Parameters.FromSearch = extractors.FromSearch;
+    function combinesWithOptions(extractor) {
+        return extractor === ExtractFilters;
+    }
+    /**
+     * Builds a route's parameters: the options its `WithOptions` set, then each
+     * extracted field those options leave out. An extractor of `undefined` is
+     * skipped like an absent key. {@link ExtractFilters} also runs for a route
+     * that sets `filters`, since it combines them with the request's.
+     */
     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 result = { ...GetOptionOverrides(reqCtx) };
+        for (const key in dynamic) {
+            const extractor = dynamic[key];
+            if (!extractor || (key in result && !combinesWithOptions(extractor))) {
+                continue;
             }
+            const value = extractor(reqCtx, meta, key);
+            if (value !== undefined)
+                result[key] = value;
         }
         return result;
     }
     Parameters.ExtractGeneric = ExtractGeneric;
+    /**
+     * The sort direction a request sends. Any other text sorts ascending, as an
+     * absent direction does.
+     */
+    const sortDirectionOf = extractors.fromSearch((text) => text === "asc" || text === "desc" ? text : undefined);
     Parameters.List = (0, decorators_1.MakeParameterAndPropertyDecorator)((target, key, param) => (0, interface_api_1.SetParameterProvider)(target, key, param, function (context) {
         const meta = (0, metadata_1.GetDataControllerMeta)(this);
         const params = ExtractGeneric(context, meta, {
             filters: ExtractFilters,
-            offset: "int",
-            limit: "int",
-            sortKey: "string",
-            sortDirection: "string",
+            offset: Parameters.FromSearch.int,
+            limit: Parameters.FromSearch.int,
+            sortKey: Parameters.FromSearch.string,
+            sortDirection: sortDirectionOf,
         });
         (0, interface_api_util_1.assert)(!params.sortKey || meta.fields[params.sortKey]?.sortable, 400, "Field is not sortable.");
         params.limit = params.limit
@@ -99,9 +130,9 @@ var Parameters;
     }));
     Parameters.Get = (0, decorators_1.MakeParameterAndPropertyDecorator)((target, key, param) => (0, interface_api_1.SetParameterProvider)(target, key, param, function (context) {
         const params = ExtractGeneric(context, (0, metadata_1.GetDataControllerMeta)(this), {
-            id: "string",
+            id: Parameters.FromSearch.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) {
@@ -110,14 +141,14 @@ var Parameters;
     }));
     Parameters.Edit = (0, decorators_1.MakeParameterAndPropertyDecorator)((target, key, param) => (0, interface_api_1.SetParameterProvider)(target, key, param, function (context) {
         const params = ExtractGeneric(context, (0, metadata_1.GetDataControllerMeta)(this), {
-            id: "string",
+            id: Parameters.FromSearch.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) {
         const params = ExtractGeneric(context, (0, metadata_1.GetDataControllerMeta)(this), {
-            id: "multi:string",
+            id: Parameters.FromSearch.strings,
         });
         (0, interface_api_util_1.assert)(params.id && Array.isArray(params.id) && params.id.length > 0, 400, "Missing id.");
         return params;
@@ -127,439 +158,27 @@ var Query;
 (function (Query) {
     function GetModel(obj, meta) {
         (0, interface_api_util_1.assert)(meta.modelKey, 500, "Missing model key.");
-        return obj[meta.modelKey];
+        const model = (0, prototypes_1.fieldsOf)(obj)[meta.modelKey];
+        (0, interface_api_util_1.assert)(tables.isModelInstance(model), 500, "The controller holds no model.");
+        return model;
     }
     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) {
-        const readable = meta.readable[action ?? "_default"] ?? meta.readable._default;
-        const instance = { ...obj };
-        const res = {};
-        for (const [key, field] of readable.props) {
-            if (onlyList && !field.listable) {
-                continue;
-            }
-            instance[key] = dbData[field.dbName || key];
-            res[key] = dbData[field.dbName || key];
-        }
-        instance.table = dbData;
-        Object.setPrototypeOf(instance, meta.target.prototype);
-        for (const [key, field] of readable.getters) {
-            if (onlyList && !field.listable) {
-                continue;
-            }
-            const val = field.desc?.get?.apply(instance);
-            res[key] = await (typeof val === "function" ? val() : val);
-        }
-        return res;
+        return (0, read_properties_1.ReadProperties)(obj, meta, dbData, action, onlyList);
     }
     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,45 +190,13 @@ 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;
-    /** Where a list sorted on a modifier-held field keeps the value it sorts on. */
-    const MODIFIED_SORT_KEY = "__dataApiSortValue";
-    /**
-     * Whether a field is held by a modifier the controller keys (a localized
-     * field read in the request's locale): stored under the modifier, it sorts
-     * on the value the request reads, not on the stored field.
-     */
-    function isHeldByKeyedModifier(meta, field) {
-        const keyed = new Set(Array.from(meta.modifierKeys.keys(), (modifier) => modifier.name));
-        return ((0, common_1.getMetadata)(meta.tableClass, common_2.ModifiersStaticMetadata).fields[field]?.some(({ id }) => keyed.has(id)) ?? false);
-    }
     /**
      * Builds the filtered and sorted stream of a list request along with its
      * total count. Joined fields that no filter or sort references are not
@@ -620,93 +207,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;
-        const isModifiedSort = !!shouldSort && !!sortField && isHeldByKeyedModifier(meta, sortField);
-        if (shouldSort?.indexed && sortField && !isModifiedSort) {
-            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 (isModifiedSort && sortField) {
-            // Sorts on the value in the request's locale, else its fallback.
-            tmpRequest = tmpRequest
-                .map((row) => row.merge({
-                [MODIFIED_SORT_KEY]: Validation.UnlockRequest(obj, meta, row, sortField),
-            }))
-                .orderBy(MODIFIED_SORT_KEY, sorting?.[1] ?? "asc")
-                .without(MODIFIED_SORT_KEY);
-        }
-        else 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
@@ -716,19 +225,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) {
@@ -743,8 +240,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);
@@ -777,7 +274,7 @@ var Validation;
     }
     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 };
     }
@@ -810,17 +307,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;
     /**
@@ -831,85 +318,19 @@ var Validation;
      */
     function Lock(obj, meta, data) {
         const written = Object.keys((0, common_1.getMetadata)(data, common_2.ModifiersDynamicMetadata).floating);
-        for (const [modifier, field] of meta.modifierKeys.entries()) {
-            const key = obj[field];
-            (0, common_2.lock)(data, modifier, written, key);
-        }
+        validation.Lock(obj, meta, data, written);
     }
     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 = {}));