@appweaver/core 1.1.5 → 1.2.0

package/resource/schemas/index.d.ts

@@ -0,0 +1,3 @@
+export * from './resource-aggregate-schema';
+export * from './resource-filter-schema';
+export * from './resource-sort-schema';

package/resource/schemas/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./resource-aggregate-schema"), exports);
+__exportStar(require("./resource-filter-schema"), exports);
+__exportStar(require("./resource-sort-schema"), exports);

package/resource/schemas/resource-aggregate-schema.d.ts

@@ -0,0 +1,54 @@
+import { TObject, TSchema } from '@sinclair/typebox';
+import { ResourceModel } from '@appweaver/common';
+/** The schema name the numeric field operator object is registered under. */
+export declare const AGGREGATE_NUMERIC_SCHEMA_NAME = "AggregateNumericOperators";
+/** The schema name the date field operator object is registered under. */
+export declare const AGGREGATE_DATE_SCHEMA_NAME = "AggregateDateOperators";
+/**
+ * Resolves the schema name the aggregate selection of a model is registered
+ * under.
+ *
+ * @param {string} modelName The resource model name (i.e. `User`, `Post`).
+ * @returns {string} The aggregate selection schema name (i.e. `UserAggregateSelect`).
+ */
+export declare const aggregateSelectName: (modelName: string) => string;
+/**
+ * The operators applicable to a numeric field. Every operator selected on the
+ * same field is applied to it, and the field is left out of the response of the
+ * operators that were not selected.
+ */
+export declare const AggregateNumericSchema: TObject;
+/**
+ * The operators applicable to a date field. Dates cannot be summed or averaged,
+ * so only the counting and the ordering operators are offered.
+ */
+export declare const AggregateDateSchema: TObject;
+/**
+ * Builds the aggregate selection schema of a resource model. Only the fields
+ * the database can aggregate are declared, which are the numeric and the date
+ * scalars of the model together with its numeric id and audit fields, so the
+ * request validation keeps the known fields and strips everything else
+ * (including hidden fields, array scalars, and the virtual fields that have no
+ * column of their own).
+ *
+ * @param {ResourceModel} model The resource model to build the selection schema
+ * for.
+ * @returns {TObject} The aggregate selection schema of the model.
+ */
+export declare function buildAggregateSelectSchema(model: ResourceModel): TObject;
+/**
+ * Builds the schema of the date field property of a model, listing the date
+ * fields the aggregated range can be applied on.
+ *
+ * @param {ResourceModel} model The resource model the property belongs to.
+ * @returns {TSchema} The optional date field property schema, restricted to the
+ * date fields of the model when it declares any.
+ */
+export declare function aggregateDateFieldSchema(model: ResourceModel): TSchema;
+/**
+ * Registers the shared operator schemas and the aggregate selection schema of
+ * every loaded resource model on the server, so route schemas can reference them
+ * by name (i.e. `UserAggregateSelect`). Schemas already registered under the
+ * same name are skipped, which makes repeated calls cheap.
+ */
+export declare function registerAggregateSelectSchemas(): void;

package/resource/schemas/resource-aggregate-schema.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateDateSchema = exports.AggregateNumericSchema = exports.aggregateSelectName = exports.AGGREGATE_DATE_SCHEMA_NAME = exports.AGGREGATE_NUMERIC_SCHEMA_NAME = void 0;
+exports.buildAggregateSelectSchema = buildAggregateSelectSchema;
+exports.aggregateDateFieldSchema = aggregateDateFieldSchema;
+exports.registerAggregateSelectSchemas = registerAggregateSelectSchemas;
+const typebox_1 = require("@sinclair/typebox");
+const context_1 = require("../../context");
+const utils_1 = require("../../utils");
+const utils_2 = require("../utils");
+/** The schema name the numeric field operator object is registered under. */
+exports.AGGREGATE_NUMERIC_SCHEMA_NAME = 'AggregateNumericOperators';
+/** The schema name the date field operator object is registered under. */
+exports.AGGREGATE_DATE_SCHEMA_NAME = 'AggregateDateOperators';
+/**
+ * Resolves the schema name the aggregate selection of a model is registered
+ * under.
+ *
+ * @param {string} modelName The resource model name (i.e. `User`, `Post`).
+ * @returns {string} The aggregate selection schema name (i.e. `UserAggregateSelect`).
+ */
+const aggregateSelectName = (modelName) => `${modelName}AggregateSelect`;
+exports.aggregateSelectName = aggregateSelectName;
+const Operator = (description) => typebox_1.Type.Optional(typebox_1.Type.Boolean({ description, example: true }));
+// The boundary operators read the record itself instead of aggregating the
+// range, so their value is the one the record holds, null included
+const FIRST_DESCRIPTION = 'Takes the value held by the earliest record of the range, ordered by the ' +
+    'aggregated date field';
+const LAST_DESCRIPTION = 'Takes the value held by the latest record of the range, ordered by the ' +
+    'aggregated date field';
+/**
+ * The operators applicable to a numeric field. Every operator selected on the
+ * same field is applied to it, and the field is left out of the response of the
+ * operators that were not selected.
+ */
+exports.AggregateNumericSchema = typebox_1.Type.Object({
+    count: Operator('Counts the records with a non-null value'),
+    sum: Operator('Sums the values'),
+    avg: Operator('Averages the values'),
+    min: Operator('Takes the lowest value'),
+    max: Operator('Takes the highest value'),
+    first: Operator(FIRST_DESCRIPTION),
+    last: Operator(LAST_DESCRIPTION)
+}, {
+    description: 'Aggregation operators applicable to a numeric field'
+});
+/**
+ * The operators applicable to a date field. Dates cannot be summed or averaged,
+ * so only the counting and the ordering operators are offered.
+ */
+exports.AggregateDateSchema = typebox_1.Type.Object({
+    count: Operator('Counts the records with a non-null value'),
+    min: Operator('Takes the earliest date'),
+    max: Operator('Takes the latest date'),
+    first: Operator(FIRST_DESCRIPTION),
+    last: Operator(LAST_DESCRIPTION)
+}, {
+    description: 'Aggregation operators applicable to a date field'
+});
+/**
+ * Builds the aggregate selection schema of a resource model. Only the fields
+ * the database can aggregate are declared, which are the numeric and the date
+ * scalars of the model together with its numeric id and audit fields, so the
+ * request validation keeps the known fields and strips everything else
+ * (including hidden fields, array scalars, and the virtual fields that have no
+ * column of their own).
+ *
+ * @param {ResourceModel} model The resource model to build the selection schema
+ * for.
+ * @returns {TObject} The aggregate selection schema of the model.
+ */
+function buildAggregateSelectSchema(model) {
+    const properties = {};
+    for (const [fieldName, type] of (0, utils_2.aggregateFields)(model)) {
+        properties[fieldName] = typebox_1.Type.Optional(typebox_1.Type.Ref(type === 'numeric'
+            ? exports.AGGREGATE_NUMERIC_SCHEMA_NAME
+            : exports.AGGREGATE_DATE_SCHEMA_NAME));
+    }
+    return typebox_1.Type.Object(properties, {
+        description: `Aggregate selection for the ${model.name} resource, holding the ` +
+            'operators to apply per aggregated field'
+    });
+}
+/**
+ * Builds the schema of the date field property of a model, listing the date
+ * fields the aggregated range can be applied on.
+ *
+ * @param {ResourceModel} model The resource model the property belongs to.
+ * @returns {TSchema} The optional date field property schema, restricted to the
+ * date fields of the model when it declares any.
+ */
+function aggregateDateFieldSchema(model) {
+    const dateFields = (0, utils_2.aggregateFields)(model)
+        .filter(([, type]) => type === 'date')
+        .map(([fieldName]) => fieldName);
+    const description = 'The date field the aggregated range is applied on';
+    // A model without a single date field has no range to aggregate over, so the
+    // property is left unrestricted instead of declaring an empty enum that
+    // nothing can satisfy
+    return typebox_1.Type.Optional(dateFields.length > 0
+        ? typebox_1.Type.Unsafe({
+            type: 'string',
+            enum: dateFields,
+            // The default date field of the aggregate action, when the model
+            // audits it, so the example matches what an omitted value resolves to
+            example: dateFields.includes('createdAt')
+                ? 'createdAt'
+                : dateFields[0],
+            description
+        })
+        : typebox_1.Type.String({ example: 'createdAt', description }));
+}
+/**
+ * Registers the shared operator schemas and the aggregate selection schema of
+ * every loaded resource model on the server, so route schemas can reference them
+ * by name (i.e. `UserAggregateSelect`). Schemas already registered under the
+ * same name are skipped, which makes repeated calls cheap.
+ */
+function registerAggregateSelectSchemas() {
+    (0, utils_1.createSchemaModel)(exports.AggregateNumericSchema, {
+        name: exports.AGGREGATE_NUMERIC_SCHEMA_NAME
+    });
+    (0, utils_1.createSchemaModel)(exports.AggregateDateSchema, {
+        name: exports.AGGREGATE_DATE_SCHEMA_NAME
+    });
+    for (const model of context_1.context.resource.models.values()) {
+        (0, utils_1.createSchemaModel)(buildAggregateSelectSchema(model), {
+            name: (0, exports.aggregateSelectName)(model.name)
+        });
+    }
+}

package/resource/schemas/resource-filter-schema.d.ts

@@ -0,0 +1,39 @@
+import { TObject } from '@sinclair/typebox';
+import { ResourceModel } from '@appweaver/common';
+/** The schema name the shared field condition object is registered under. */
+export declare const QUERY_CONDITION_SCHEMA_NAME = "QueryCondition";
+/**
+ * Resolves the schema name the query filter of a model is registered under.
+ *
+ * @param {string} modelName The resource model name (i.e. `User`, `Post`).
+ * @returns {string} The query filter schema name (i.e. `UserQueryFilter`).
+ */
+export declare const queryFilterName: (modelName: string) => string;
+/**
+ * The shared schema of a field condition object, holding the comparison
+ * operators applicable to a single field. Operators combined inside the same
+ * object are merged into a single database condition, and unknown properties
+ * are stripped by the request validation.
+ */
+export declare const QueryConditionSchema: TObject;
+/**
+ * Builds the query filter schema of a resource model, mirroring the WHERE part
+ * of a database query. Every filterable field of the model is declared
+ * explicitly, so the request validation keeps the known fields and strips
+ * everything else (including hidden fields). Scalar fields accept a plain
+ * value, a list of values, or a condition object, relation and file fields
+ * additionally accept an id shorthand or the filter of the related model, and
+ * the `_`-prefixed logical operators combine nested conditions recursively.
+ *
+ * @param {ResourceModel} model The resource model to build the filter schema
+ * for.
+ * @returns {TObject} The query filter schema of the model.
+ */
+export declare function buildQueryFilterSchema(model: ResourceModel): TObject;
+/**
+ * Registers the shared field condition schema and the query filter schema of
+ * every loaded resource model on the server, so route schemas can reference
+ * them by name (i.e. `UserQueryFilter`). Schemas already registered under the
+ * same name are skipped, which makes repeated calls cheap.
+ */
+export declare function registerQueryFilterSchemas(): void;

package/resource/schemas/resource-filter-schema.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryConditionSchema = exports.queryFilterName = exports.QUERY_CONDITION_SCHEMA_NAME = void 0;
+exports.buildQueryFilterSchema = buildQueryFilterSchema;
+exports.registerQueryFilterSchemas = registerQueryFilterSchemas;
+const typebox_1 = require("@sinclair/typebox");
+const common_1 = require("@appweaver/common");
+const context_1 = require("../../context");
+const utils_1 = require("../../utils");
+/** The schema name the shared field condition object is registered under. */
+exports.QUERY_CONDITION_SCHEMA_NAME = 'QueryCondition';
+/**
+ * Resolves the schema name the query filter of a model is registered under.
+ *
+ * @param {string} modelName The resource model name (i.e. `User`, `Post`).
+ * @returns {string} The query filter schema name (i.e. `UserQueryFilter`).
+ */
+const queryFilterName = (modelName) => `${modelName}QueryFilter`;
+exports.queryFilterName = queryFilterName;
+// The primitive types a plain filter value can take. They are declared as a
+// single JSON Schema type list rather than a union of typed branches, because
+// the request validator coerces a value into the first branch of a typed
+// union that accepts it (turning 10 into '10'), while a type list leaves a
+// value that already matches one of its types untouched. The exact type of
+// each field is enforced by the database layer instead.
+const PRIMITIVE_TYPES = ['string', 'number', 'boolean', 'null'];
+const PlainValue = () => typebox_1.Type.Unsafe({ type: PRIMITIVE_TYPES });
+const PlainValueList = (options = {}) => typebox_1.Type.Unsafe({
+    type: 'array',
+    items: { type: PRIMITIVE_TYPES },
+    ...options
+});
+const Operator = (schema, description) => typebox_1.Type.Optional({ ...schema, description });
+/**
+ * The shared schema of a field condition object, holding the comparison
+ * operators applicable to a single field. Operators combined inside the same
+ * object are merged into a single database condition, and unknown properties
+ * are stripped by the request validation.
+ */
+exports.QueryConditionSchema = typebox_1.Type.Object({
+    _eq: Operator(PlainValue(), 'Matches values equal to the given value'),
+    _ne: Operator(PlainValue(), 'Matches values not equal to the given value'),
+    _gt: Operator(PlainValue(), 'Matches values greater than the given value'),
+    _gte: Operator(PlainValue(), 'Matches values greater than or equal to the given value'),
+    _lt: Operator(PlainValue(), 'Matches values lower than the given value'),
+    _lte: Operator(PlainValue(), 'Matches values lower than or equal to the given value'),
+    _in: Operator(PlainValueList(), 'Matches values included in the given list'),
+    _nin: Operator(PlainValueList(), 'Matches values not included in the given list'),
+    _between: Operator(PlainValueList({ minItems: 2, maxItems: 2 }), 'Matches values inside the inclusive [min, max] range'),
+    _like: Operator(typebox_1.Type.String(), 'Matches strings against an SQL LIKE pattern with % wildcards'),
+    _ilike: Operator(typebox_1.Type.String(), 'Case-insensitive variant of the _like operator'),
+    _starts: Operator(typebox_1.Type.String(), 'Matches strings starting with the given value'),
+    _ends: Operator(typebox_1.Type.String(), 'Matches strings ending with the given value'),
+    _contains: Operator(typebox_1.Type.String(), 'Matches strings containing the given value'),
+    _exists: Operator(typebox_1.Type.Boolean(), 'Matches values that are not null (true) or null (false)'),
+    _has: Operator(PlainValue(), 'Matches lists containing the given value'),
+    _hasSome: Operator(PlainValueList(), 'Matches lists containing at least one of the given values'),
+    _hasEvery: Operator(PlainValueList(), 'Matches lists containing all the given values'),
+    _isEmpty: Operator(typebox_1.Type.Boolean(), 'Matches empty (true) or non-empty (false) lists'),
+    _not: Operator(typebox_1.Type.Union([PlainValue(), typebox_1.Type.Ref(exports.QUERY_CONDITION_SCHEMA_NAME)]), 'Negates the nested condition or plain value')
+}, {
+    description: 'Field condition object combining comparison operators on a single field'
+});
+/**
+ * Builds the query filter schema of a resource model, mirroring the WHERE part
+ * of a database query. Every filterable field of the model is declared
+ * explicitly, so the request validation keeps the known fields and strips
+ * everything else (including hidden fields). Scalar fields accept a plain
+ * value, a list of values, or a condition object, relation and file fields
+ * additionally accept an id shorthand or the filter of the related model, and
+ * the `_`-prefixed logical operators combine nested conditions recursively.
+ *
+ * @param {ResourceModel} model The resource model to build the filter schema
+ * for.
+ * @returns {TObject} The query filter schema of the model.
+ */
+function buildQueryFilterSchema(model) {
+    const name = (0, exports.queryFilterName)(model.name);
+    const self = () => typebox_1.Type.Ref(name);
+    const logical = (description) => typebox_1.Type.Optional(typebox_1.Type.Union([self(), typebox_1.Type.Array(self())], { description }));
+    const scalarValue = (description) => typebox_1.Type.Optional(typebox_1.Type.Union([PlainValue(), PlainValueList(), typebox_1.Type.Ref(exports.QUERY_CONDITION_SCHEMA_NAME)], { description }));
+    // A list of related filters is declared as its own branch, so the validator
+    // still strips the unknown properties of the filters nested inside it
+    const relationValue = (refName, description) => typebox_1.Type.Optional(typebox_1.Type.Union([
+        PlainValue(),
+        PlainValueList(),
+        typebox_1.Type.Ref(refName),
+        typebox_1.Type.Array(typebox_1.Type.Ref(refName))
+    ], { description }));
+    const properties = {
+        id: scalarValue('Filter by the record id')
+    };
+    const auditFields = {
+        updatedAt: true,
+        createdAt: true,
+        createdById: true,
+        ...(model.config.audit ?? {})
+    };
+    for (const [fieldName, included] of Object.entries(auditFields)) {
+        if (included) {
+            properties[fieldName] = scalarValue(`Filter by the ${fieldName} field`);
+        }
+    }
+    for (const [fieldName, scalar] of Object.entries(model.config.scalars ?? {})) {
+        if (scalar.hidden) {
+            continue;
+        }
+        // JSON fields hold arbitrary nested structures, so their conditions are
+        // passed through without validation
+        properties[fieldName] =
+            scalar.type === 'json'
+                ? typebox_1.Type.Optional(typebox_1.Type.Any({ description: `Filter by the ${fieldName} field` }))
+                : scalarValue(`Filter by the ${fieldName} field`);
+    }
+    for (const [fieldName, relation] of Object.entries(model.config.relations ?? {})) {
+        properties[fieldName] = relationValue((0, exports.queryFilterName)((0, common_1.capitalize)(relation.model)), `Filter by the ${fieldName} relation, matching an id, a list of ids, ` +
+            `or a nested ${(0, common_1.capitalize)(relation.model)} filter`);
+    }
+    for (const fieldName of Object.keys(model.config.files ?? {})) {
+        properties[fieldName] = relationValue((0, exports.queryFilterName)('File'), `Filter by the ${fieldName} file field, matching an id, a list of ids, ` +
+            'or a nested File filter');
+    }
+    return typebox_1.Type.Object({
+        _and: logical('Matches records satisfying all the nested conditions'),
+        _or: logical('Matches records satisfying at least one nested condition'),
+        _not: logical('Matches records satisfying none of the nested conditions'),
+        _nor: logical('Matches records satisfying none of the nested conditions (alias of _not)'),
+        _some: Operator(self(), 'Matches records where at least one related record matches the filter'),
+        _every: Operator(self(), 'Matches records where every related record matches the filter'),
+        _none: Operator(self(), 'Matches records where no related record matches the filter'),
+        _exists: Operator(typebox_1.Type.Boolean(), 'Matches records with a related record (true) or without one (false)'),
+        searchText: Operator(typebox_1.Type.String(), 'Full-text search input resolved by the resource service'),
+        ...properties
+    }, {
+        description: `Query filter for the ${model.name} resource`
+    });
+}
+/**
+ * Registers the shared field condition schema and the query filter schema of
+ * every loaded resource model on the server, so route schemas can reference
+ * them by name (i.e. `UserQueryFilter`). Schemas already registered under the
+ * same name are skipped, which makes repeated calls cheap.
+ */
+function registerQueryFilterSchemas() {
+    (0, utils_1.createSchemaModel)(exports.QueryConditionSchema, {
+        name: exports.QUERY_CONDITION_SCHEMA_NAME
+    });
+    for (const model of context_1.context.resource.models.values()) {
+        (0, utils_1.createSchemaModel)(buildQueryFilterSchema(model), {
+            name: (0, exports.queryFilterName)(model.name)
+        });
+    }
+}

package/resource/schemas/resource-sort-schema.d.ts

@@ -0,0 +1,37 @@
+import { TObject, TSchema } from '@sinclair/typebox';
+import { ResourceModel } from '@appweaver/common';
+/**
+ * Resolves the schema name the query sort object of a model is registered under.
+ *
+ * @param {string} modelName The resource model name (i.e. `User`, `Post`).
+ * @returns {string} The query sort schema name (i.e. `UserQuerySort`).
+ */
+export declare const querySortName: (modelName: string) => string;
+/**
+ * Builds the query sort schema of a resource model, mirroring the ORDER BY part
+ * of a database query. Every sortable field of the model is declared explicitly,
+ * so the request validation keeps the known fields and strips everything else.
+ * Scalar fields accept a sort direction, to-one relations accept the sort object
+ * of the related model, and to-many relations accept a direction applied to
+ * their related record count, both under the relation name and under its count
+ * field name.
+ *
+ * @param {ResourceModel} model The resource model to build the sort schema for.
+ * @returns {TObject} The query sort schema of the model.
+ */
+export declare function buildQuerySortSchema(model: ResourceModel): TObject;
+/**
+ * Registers the query sort schema of every loaded resource model on the server,
+ * so route schemas can reference them by name (i.e. `UserQuerySort`). Schemas
+ * already registered under the same name are skipped, which makes repeated calls
+ * cheap.
+ */
+export declare function registerQuerySortSchemas(): void;
+/**
+ * Builds the schema of the sort property of a model, accepting either a
+ * comma-separated field list or the query sort object of the model.
+ *
+ * @param {string} modelName The resource model name the sort property belongs to.
+ * @returns {TSchema} The optional sort property schema.
+ */
+export declare function querySortSchema(modelName: string): TSchema;

package/resource/schemas/resource-sort-schema.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.querySortName = void 0;
+exports.buildQuerySortSchema = buildQuerySortSchema;
+exports.registerQuerySortSchemas = registerQuerySortSchemas;
+exports.querySortSchema = querySortSchema;
+const typebox_1 = require("@sinclair/typebox");
+const common_1 = require("@appweaver/common");
+const context_1 = require("../../context");
+const utils_1 = require("../../utils");
+/**
+ * Resolves the schema name the query sort object of a model is registered under.
+ *
+ * @param {string} modelName The resource model name (i.e. `User`, `Post`).
+ * @returns {string} The query sort schema name (i.e. `UserQuerySort`).
+ */
+const querySortName = (modelName) => `${modelName}QuerySort`;
+exports.querySortName = querySortName;
+/** The accepted sort directions of a single field. */
+const SORT_DIRECTIONS = ['asc', 'desc'];
+const SortDirection = () => typebox_1.Type.Optional((0, common_1.StringEnum)(SORT_DIRECTIONS, { example: 'desc' }));
+/**
+ * Builds the query sort schema of a resource model, mirroring the ORDER BY part
+ * of a database query. Every sortable field of the model is declared explicitly,
+ * so the request validation keeps the known fields and strips everything else.
+ * Scalar fields accept a sort direction, to-one relations accept the sort object
+ * of the related model, and to-many relations accept a direction applied to
+ * their related record count, both under the relation name and under its count
+ * field name.
+ *
+ * @param {ResourceModel} model The resource model to build the sort schema for.
+ * @returns {TObject} The query sort schema of the model.
+ */
+function buildQuerySortSchema(model) {
+    const properties = {
+        id: SortDirection()
+    };
+    const auditFields = {
+        updatedAt: true,
+        createdAt: true,
+        createdById: true,
+        ...(model.config.audit ?? {})
+    };
+    for (const [fieldName, included] of Object.entries(auditFields)) {
+        if (included) {
+            properties[fieldName] = SortDirection();
+        }
+    }
+    // Array scalars hold no single value to order by, and virtual fields have no
+    // column of their own, so neither of them is sortable
+    for (const [fieldName, scalar] of Object.entries(model.config.scalars ?? {})) {
+        if (scalar.hidden || scalar.array) {
+            continue;
+        }
+        properties[fieldName] = SortDirection();
+    }
+    // A relation holding a list of records is ordered by their count, under the
+    // relation name and under its count field name alike
+    for (const [fieldName, relation] of Object.entries(model.config.relations ?? {})) {
+        if ((0, common_1.isRelationArray)(relation)) {
+            properties[fieldName] = SortDirection();
+            properties[(0, common_1.countFieldName)(fieldName)] = SortDirection();
+            continue;
+        }
+        properties[fieldName] = typebox_1.Type.Optional(typebox_1.Type.Ref((0, exports.querySortName)((0, common_1.capitalize)(relation.model))));
+    }
+    for (const [fieldName, file] of Object.entries(model.config.files ?? {})) {
+        if (file.array) {
+            properties[fieldName] = SortDirection();
+            properties[(0, common_1.countFieldName)(fieldName)] = SortDirection();
+            continue;
+        }
+        properties[fieldName] = typebox_1.Type.Optional(typebox_1.Type.Ref((0, exports.querySortName)('File')));
+    }
+    return typebox_1.Type.Object(properties, {
+        description: `Query sort for the ${model.name} resource, applying its fields in the ` +
+            'order they are declared. A nested object sorts by a field of a relation, ' +
+            'which has to be included in the response.'
+    });
+}
+/**
+ * Registers the query sort schema of every loaded resource model on the server,
+ * so route schemas can reference them by name (i.e. `UserQuerySort`). Schemas
+ * already registered under the same name are skipped, which makes repeated calls
+ * cheap.
+ */
+function registerQuerySortSchemas() {
+    for (const model of context_1.context.resource.models.values()) {
+        (0, utils_1.createSchemaModel)(buildQuerySortSchema(model), {
+            name: (0, exports.querySortName)(model.name)
+        });
+    }
+}
+/**
+ * Builds the schema of the sort property of a model, accepting either a
+ * comma-separated field list or the query sort object of the model.
+ *
+ * @param {string} modelName The resource model name the sort property belongs to.
+ * @returns {TSchema} The optional sort property schema.
+ */
+function querySortSchema(modelName) {
+    return typebox_1.Type.Optional(typebox_1.Type.Union([
+        typebox_1.Type.String({
+            example: '-createdAt,id',
+            description: 'Comma-separated list of fields to sort by, where a field prefixed ' +
+                'with `-` is sorted in descending order and a dot notation path ' +
+                'targets a field of an included relation (i.e. `-author.createdAt,id`)'
+        }),
+        typebox_1.Type.Ref((0, exports.querySortName)(modelName))
+    ], {
+        description: 'Fields to sort the results by, given as a comma-separated field list ' +
+            'or as an object of field directions'
+    }));
+}