@appweaver/data 0.0.0-stage → 2.0.1

package/factory/create-model.js

@@ -0,0 +1,479 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModel = createModel;
+const typebox_1 = require("@sinclair/typebox");
+const common_1 = require("@appweaver/common");
+const internal_1 = require("@appweaver/core/internal");
+const core_1 = require("@appweaver/core");
+const model_schema_1 = require("../resource/model-schema");
+/**
+ * Creates a resource model from its configuration and defines it in the application context. The names of the
+ * declared fields are inferred from the configuration, so the `read`, `create`, and `update` options only accept
+ * existing fields.
+ *
+ * @param {ResourceModelConfig} config - The model configuration.
+ * @param {boolean} [override=false] - Whether to replace a model already defined under the same name.
+ * @return {ResourceModel} The created resource model.
+ */
+function createModel(modelConfig, override = false) {
+    const config = normalizeRelations(modelConfig);
+    const resourceModel = buildModel(config);
+    common_1.logger.debug({ modelName: resourceModel.name }, 'Created resource model');
+    (0, core_1.define)(resourceModel, undefined, override ? 'override' : undefined);
+    // The relation inputs and audit fields reference the primary key of another
+    // model, which may not be loaded yet. Loaders call this hook once every model
+    // is registered, so those references resolve against their final id type.
+    resourceModel[common_1.RESOURCE_MODEL_RELINK] = () => {
+        Object.assign(resourceModel, buildModel(config));
+    };
+    return resourceModel;
+}
+/**
+ * Replaces every `manyToOne` relation with the `oneToMany` relation it stands for, owning the foreign key, so the
+ * rest of the framework handles a single form.
+ *
+ * @throws {Error} If a `manyToOne` relation is declared with `owner: false`.
+ */
+function normalizeRelations(config) {
+    if (!config.relations) {
+        return config;
+    }
+    const relations = {};
+    for (const [field, relation] of Object.entries(config.relations)) {
+        if (relation.type !== 'manyToOne') {
+            relations[field] = relation;
+            continue;
+        }
+        if (relation.owner === false) {
+            throw new common_1.ConfigurationError(common_1.ErrorCode.ConfigurationInvalid, `Relation '${config.name}.${field}' of type 'manyToOne' holds the foreign key, so it cannot set 'owner: false'`);
+        }
+        relations[field] = { ...relation, type: 'oneToMany', owner: true };
+    }
+    return { ...config, relations };
+}
+function buildModel(config) {
+    const name = (0, common_1.capitalize)(config.name);
+    const idSchema = (0, model_schema_1.idSchema)(config?.id);
+    const auditSchema = buildAuditSchema(config?.audit, (0, common_1.hasSoftDelete)(config));
+    const scalarsSchema = buildScalarsSchema(config?.scalars);
+    const virtualSchema = buildScalarsSchema(config?.virtual);
+    const filesSchema = buildFilesSchema(config?.files);
+    const relationsSchema = buildRelationsSchema(config?.relations);
+    const readModel = typebox_1.Type.Composite([
+        idSchema,
+        scalarsSchema,
+        virtualSchema,
+        relationsSchema,
+        filesSchema,
+        auditSchema
+    ], {
+        $id: name
+    });
+    const virtualModel = typebox_1.Type.Composite([virtualSchema], {
+        $id: `${name}Virtual`
+    });
+    const relationsModel = typebox_1.Type.Composite([relationsSchema], {
+        $id: `${name}Relations`
+    });
+    const filesModel = typebox_1.Type.Composite([filesSchema], { $id: `${name}Files` });
+    const baseReadModel = omitOrPickScalars(typebox_1.Type.Composite([idSchema, scalarsSchema, virtualSchema, auditSchema]), config.read);
+    const createModel = omitOrPickScalars(resolveDefaultScalars(typebox_1.Type.Composite([scalarsSchema, virtualSchema]), config), config.create);
+    const updateModel = omitOrPickScalars(resolveDefaultScalars(typebox_1.Type.Partial(typebox_1.Type.Composite([scalarsSchema, virtualSchema])), config), config.update);
+    // The fields of an update, its scalars required the same way as on a
+    // create, since a replacement carries the whole stored state of the
+    // resource. The virtual fields are no part of it, so they stay optional
+    const replaceModel = omitOrPickScalars(resolveDefaultScalars(typebox_1.Type.Composite([scalarsSchema, typebox_1.Type.Partial(virtualSchema)]), config), config.update);
+    const { readOneModel, readManyModel } = buildOutputModels(baseReadModel, relationsModel, filesModel, config);
+    const readOneNullableModel = buildNullableOutputModel(name);
+    const { createOneModel, updateOneModel, replaceOneModel, relationCreateModel, relationUpdateModel } = buildInputModels(createModel, updateModel, replaceModel, relationsModel, idSchema, config);
+    const { fileUploadModel, fileDeleteModel } = buildFileInputModels(config);
+    const resourceModel = {
+        name,
+        config: config,
+        idModel: idSchema,
+        readModel,
+        createModel,
+        updateModel,
+        relationsModel,
+        filesModel,
+        virtualModel,
+        readOneModel,
+        readManyModel,
+        readOneNullableModel,
+        createOneModel,
+        updateOneModel,
+        replaceOneModel,
+        relationCreateModel,
+        relationUpdateModel,
+        fileUploadModel,
+        fileDeleteModel
+    };
+    for (const value of Object.values(resourceModel)) {
+        if ((0, common_1.isPlainObject)(value)) {
+            value[common_1.RESOURCE_NAME] = name;
+        }
+    }
+    resourceModel[common_1.RESOURCE_NAME] = name;
+    resourceModel[common_1.RESOURCE_TYPE] = common_1.RESOURCE_MODEL_TYPE;
+    return resourceModel;
+}
+function referencedIdField(modelName) {
+    if (!modelName) {
+        return undefined;
+    }
+    return internal_1.context.resource.models.get((0, common_1.capitalize)(modelName))?.config?.id;
+}
+function authModel() {
+    for (const model of internal_1.context.resource.models.values()) {
+        if ((0, common_1.isResourceAuthModel)(model)) {
+            return model;
+        }
+    }
+}
+function authIdField() {
+    return authModel()?.config?.id;
+}
+function buildAuditSchema(audit = {}, softDelete = false) {
+    const defaultAudit = {
+        updatedAt: true,
+        createdAt: true,
+        createdById: true
+    };
+    const mergedAudit = { ...defaultAudit, ...audit };
+    const fields = [];
+    for (const [name, included] of Object.entries(mergedAudit)) {
+        if (included) {
+            fields.push(name);
+        }
+    }
+    const auditSchema = typebox_1.Type.Pick((0, model_schema_1.auditSchema)(authIdField()), fields);
+    if (!softDelete) {
+        return auditSchema;
+    }
+    // The soft delete columns are typed on the model, but hidden like any hidden
+    // field, so no request or response carries them
+    return typebox_1.Type.Object({
+        ...auditSchema.properties,
+        deletedAt: (0, common_1.Nullable)((0, common_1.StringDate)({ hidden: true })),
+        ...(authModel()
+            ? {
+                deletedById: (0, common_1.Nullable)({
+                    ...(0, model_schema_1.idValueSchema)(authIdField()),
+                    hidden: true
+                })
+            }
+            : {})
+    });
+}
+function buildScalarsSchema(fields = {}) {
+    const properties = {};
+    for (const [name, field] of Object.entries(fields)) {
+        properties[name] = buildScalarSchema(field);
+    }
+    return typebox_1.Type.Object(properties);
+}
+function buildScalarSchema(field) {
+    let fieldType;
+    switch (field.type) {
+        case 'string':
+            fieldType = typebox_1.Type.String((0, common_1.pickProperties)(field, [
+                'minLength',
+                'maxLength',
+                'format',
+                'pattern',
+                'hidden',
+                'example'
+            ]));
+            break;
+        case 'int':
+        case 'bigInt':
+            fieldType = typebox_1.Type.Integer((0, common_1.pickProperties)(field, ['minimum', 'maximum', 'hidden', 'example']));
+            break;
+        case 'float':
+            fieldType = typebox_1.Type.Number((0, common_1.pickProperties)(field, ['minimum', 'maximum', 'hidden', 'example']));
+            break;
+        case 'boolean':
+            fieldType = typebox_1.Type.Boolean((0, common_1.pickProperties)(field, ['hidden', 'example']));
+            break;
+        case 'dateTime':
+            fieldType = (0, common_1.StringDate)((0, common_1.pickProperties)(field, ['format', 'hidden', 'example']));
+            break;
+        case 'json':
+            fieldType = (0, common_1.AnyJson)((0, common_1.pickProperties)(field, ['hidden', 'example']));
+            break;
+        case 'enum':
+            fieldType = (0, common_1.StringEnum)(field.values ?? [], (0, common_1.pickProperties)(field, ['hidden', 'example']));
+            break;
+    }
+    if (field.array === true) {
+        fieldType = typebox_1.Type.Array(fieldType);
+    }
+    if (field.required === false) {
+        fieldType = (0, common_1.Nullable)(fieldType);
+    }
+    return fieldType;
+}
+function omitOrPickScalars(type, operationConfig) {
+    let restrictedType = type;
+    if (operationConfig?.pick) {
+        restrictedType = typebox_1.Type.Pick(type, operationConfig.pick);
+    }
+    else if (operationConfig?.omit) {
+        restrictedType = typebox_1.Type.Omit(type, operationConfig.omit);
+    }
+    return typebox_1.Type.Composite([restrictedType]);
+}
+function resolveDefaultScalars(type, config) {
+    for (const name of Object.keys(type.properties)) {
+        const field = type.properties[name];
+        if (config?.scalars?.[name]?.default !== undefined ||
+            config?.virtual?.[name]?.default !== undefined) {
+            type.properties[name] = typebox_1.Type.Optional(field);
+        }
+    }
+    return type;
+}
+function buildFilesSchema(files = {}) {
+    const properties = {};
+    for (const [name, file] of Object.entries(files)) {
+        properties[name] = buildFileSchema(file);
+    }
+    return typebox_1.Type.Object(properties);
+}
+function buildFileSchema(file) {
+    const fileSchema = typebox_1.Type.Ref('FileSingle');
+    return file.array ? typebox_1.Type.Array(fileSchema) : (0, common_1.Nullable)(fileSchema);
+}
+function buildRelationsSchema(relations = {}) {
+    const properties = {};
+    for (const [name, relation] of Object.entries(relations)) {
+        properties[name] = buildRelationSchema(relation);
+    }
+    return typebox_1.Type.Object(properties);
+}
+function buildRelationSchema(relation) {
+    const modelName = (0, common_1.capitalize)(relation.model);
+    const modelRefName = `${modelName}Single`;
+    let relationType = typebox_1.Type.Ref(modelRefName);
+    relationType = (0, common_1.isRelationArray)(relation)
+        ? typebox_1.Type.Array(relationType, (0, common_1.pickProperties)(relation, ['minItems']))
+        : relationType;
+    return relation.required === false
+        ? typebox_1.Type.Optional(relationType)
+        : relationType;
+}
+function buildOutputModels(readModel, relationsModel, filesModel, config) {
+    const virtualConfig = config.virtual;
+    const relationsConfig = config.relations;
+    const filesConfig = config.files;
+    const adjustedReadModel = removeHiddenFields(readModel);
+    const readOneModel = typebox_1.Type.Composite([
+        resolveOutputVirtualFields(adjustedReadModel, virtualConfig, 'single'),
+        relationOutputProperties(relationsModel, relationsConfig, 'single'),
+        relationOutputProperties(filesModel, filesConfig, 'single')
+    ], { $id: `${config.name}Single` });
+    const readManyModel = typebox_1.Type.Composite([
+        resolveOutputVirtualFields(adjustedReadModel, virtualConfig, 'multiple'),
+        relationOutputProperties(relationsModel, relationsConfig, 'multiple'),
+        relationOutputProperties(filesModel, filesConfig, 'multiple')
+    ], { $id: `${config.name}Multiple` });
+    return { readOneModel, readManyModel };
+}
+function buildNullableOutputModel(name) {
+    // Builds the nullable variant of the single read model, registered under its own
+    // name so a nullable relation can reference it instead of inlining the union.
+    // The response serializer cannot compile an inline `anyOf` union that cycles
+    // back to a model it is already writing, since it expands every union branch
+    // into a fresh schema. A union behind a name is expanded once and reused, which
+    // keeps a self-referencing relation (a category and its parent) serializable.
+    return typebox_1.Type.Union([typebox_1.Type.Ref(`${name}Single`), typebox_1.Type.Null()], {
+        $id: `${name}SingleNullable`
+    });
+}
+function buildInputModels(createModel, updateModel, replaceModel, relationsModel, idSchema, config) {
+    const virtualConfig = config.virtual;
+    const relationsConfig = config.relations;
+    const adjustedCreateModel = resolveInputVirtualFields(removeHiddenFields(createModel), virtualConfig, 'create');
+    const adjustedUpdateModel = resolveInputVirtualFields(removeHiddenFields(updateModel), virtualConfig, 'update');
+    const adjustedReplaceModel = resolveInputVirtualFields(removeHiddenFields(replaceModel), virtualConfig, 'update');
+    // Data models accepted when this model is written inline through another
+    // model's relation input: created without an id, or updated by its id.
+    // Relations and files are excluded, so nested writes stay limited to the
+    // model's own columns.
+    const relationCreateModel = typebox_1.Type.Composite([adjustedCreateModel], {
+        $id: `${config.name}RelationCreate`
+    });
+    const relationUpdateModel = typebox_1.Type.Composite([idSchema, adjustedUpdateModel], {
+        $id: `${config.name}RelationUpdate`
+    });
+    if (Object.keys(relationsConfig ?? {}).length === 0) {
+        return {
+            createOneModel: adjustedCreateModel,
+            updateOneModel: adjustedUpdateModel,
+            replaceOneModel: adjustedReplaceModel,
+            relationCreateModel,
+            relationUpdateModel
+        };
+    }
+    const relationCreateInputs = relationInputProperties(relationsModel, relationsConfig, 'create');
+    const createOneModel = typebox_1.Type.Composite([adjustedCreateModel, relationCreateInputs], {
+        $id: `${config.name}Create`
+    });
+    const relationUpdateInputs = relationInputProperties(relationsModel, relationsConfig, 'update');
+    const updateOneModel = typebox_1.Type.Composite([adjustedUpdateModel, typebox_1.Type.Partial(relationUpdateInputs)], { $id: `${config.name}Update` });
+    // The required relations are required, while the optional ones a
+    // replacement leaves out stay untouched
+    const replaceOneModel = typebox_1.Type.Composite([adjustedReplaceModel, relationUpdateInputs], { $id: `${config.name}Replace` });
+    return {
+        createOneModel,
+        updateOneModel,
+        replaceOneModel,
+        relationCreateModel,
+        relationUpdateModel
+    };
+}
+function buildFileInputModels(config) {
+    const fileConfig = config.files ?? {};
+    const FileUpload = typebox_1.Type.Unsafe({
+        type: 'string',
+        format: 'binary',
+        [typebox_1.Kind]: 'String'
+    });
+    const FileDelete = typebox_1.Type.String({ example: 'image_123.png' });
+    const fileUploadModel = typebox_1.Type.Object(Object.fromEntries(Object.entries(fileConfig).map(([key, conf]) => [
+        key,
+        typebox_1.Type.Optional(conf.array ? typebox_1.Type.Array(FileUpload) : FileUpload)
+    ])), { $id: `${config.name}FileUpload` });
+    const fileDeleteModel = typebox_1.Type.Object(Object.fromEntries(Object.entries(fileConfig).map(([key, conf]) => [
+        key,
+        typebox_1.Type.Optional(conf.array ? typebox_1.Type.Array(FileDelete) : FileDelete)
+    ])), { $id: `${config.name}FileDelete` });
+    return { fileUploadModel, fileDeleteModel };
+}
+function relationInputProperties(object, relationConfig, inputType) {
+    const relationInputType = (key) => {
+        const { type, ...options } = object.properties[key];
+        const config = relationConfig?.[key];
+        if (config && shouldSkipInputField(config.input?.type, inputType)) {
+            return undefined;
+        }
+        // Inline updates carry the related record id, so only parent update
+        // requests accept them, since the database updates relations only within
+        // an update action
+        const acceptsUpdate = config?.input?.allowUpdate && inputType === 'update';
+        // Existing records are connected by an id object or a bare id value, both
+        // typed after the primary key of the related model. An item with an id is
+        // an inline update when the relation accepts them (a lone id still
+        // connects), and an item without one is an inline create
+        const relatedIdField = referencedIdField(config?.model);
+        const itemSchemas = [
+            acceptsUpdate
+                ? typebox_1.Type.Ref(`${config.model}RelationUpdate`)
+                : (0, model_schema_1.idSchema)(relatedIdField),
+            ...(config?.input?.allowCreate
+                ? [typebox_1.Type.Ref(`${config.model}RelationCreate`)]
+                : []),
+            (0, model_schema_1.idValueSchema)(relatedIdField)
+        ];
+        const isArrayType = type === 'array';
+        const isOptional = config?.required === false;
+        let inputSchema;
+        if (isArrayType) {
+            // One array of union items, so connect, create, and update inputs mix
+            const arraySchema = typebox_1.Type.Array(typebox_1.Type.Union(itemSchemas), options);
+            inputSchema = isOptional ? (0, common_1.Nullable)(arraySchema) : arraySchema;
+        }
+        else {
+            inputSchema = typebox_1.Type.Union(itemSchemas.map((itemSchema) => isOptional ? (0, common_1.Nullable)(itemSchema) : itemSchema));
+        }
+        return isOptional ? typebox_1.Type.Optional(inputSchema) : inputSchema;
+    };
+    return typebox_1.Type.Object({
+        ...Object.keys(object.properties).reduce((acc, key) => {
+            const type = relationInputType(key);
+            if (type) {
+                acc[key] = type;
+            }
+            return acc;
+        }, {})
+    });
+}
+function relationOutputProperties(object, relationConfig, outputType) {
+    const relationOutputType = (key) => {
+        let schema = object.properties[key];
+        const config = relationConfig?.[key];
+        if (config) {
+            if (shouldSkipOutputField(config.output?.type, outputType)) {
+                return undefined;
+            }
+            if (config.required === false && schema.type !== 'array') {
+                schema = nullableOutputSchema(schema);
+            }
+        }
+        return schema;
+    };
+    const relationCountType = (key) => {
+        const config = relationConfig?.[key];
+        if (!config?.output?.count) {
+            return undefined;
+        }
+        return typebox_1.Type.Integer({ minimum: 0 });
+    };
+    // Relation, file, and count fields are optional in the output models: their
+    // presence depends on the inclusion depth of the query. The same schema
+    // describes a record nested in another model's output, without relations.
+    return typebox_1.Type.Object({
+        ...Object.keys(object.properties).reduce((acc, key) => {
+            const type = relationOutputType(key);
+            if (type) {
+                acc[key] = typebox_1.Type.Optional(type);
+            }
+            const countType = relationCountType(key);
+            if (countType) {
+                acc[(0, common_1.countFieldName)(key)] = typebox_1.Type.Optional(countType);
+            }
+            return acc;
+        }, {})
+    });
+}
+function nullableOutputSchema(schema) {
+    const modelRef = schema.$ref;
+    return modelRef ? typebox_1.Type.Ref(`${modelRef}Nullable`) : (0, common_1.Nullable)(schema);
+}
+function removeHiddenFields(schema) {
+    const properties = {};
+    for (const [name, field] of Object.entries(schema.properties)) {
+        if (!field.hidden) {
+            properties[name] = field;
+        }
+    }
+    return typebox_1.Type.Object(properties);
+}
+function resolveInputVirtualFields(schema, virtualConfig, inputType) {
+    const excludeFields = [];
+    for (const [name, virtual] of Object.entries(virtualConfig ?? {})) {
+        if (shouldSkipInputField(virtual.input?.type, inputType)) {
+            excludeFields.push(name);
+        }
+    }
+    return typebox_1.Type.Omit(schema, excludeFields);
+}
+function resolveOutputVirtualFields(schema, virtualConfig, outputType) {
+    const excludeFields = [];
+    for (const [name, virtual] of Object.entries(virtualConfig ?? {})) {
+        if (shouldSkipOutputField(virtual.output?.type, outputType)) {
+            excludeFields.push(name);
+        }
+    }
+    return typebox_1.Type.Omit(schema, excludeFields);
+}
+function shouldSkipInputField(fieldInputType, methodInputType) {
+    return (fieldInputType === 'none' ||
+        (methodInputType === 'create' && fieldInputType === 'update') ||
+        (methodInputType === 'update' && fieldInputType === 'create'));
+}
+function shouldSkipOutputField(fieldOutputType, methodOutputType) {
+    return (fieldOutputType === 'none' ||
+        (methodOutputType === 'single' && fieldOutputType === 'multiple') ||
+        (methodOutputType === 'multiple' && fieldOutputType === 'single'));
+}

package/factory/create-policy.d.ts

@@ -0,0 +1,12 @@
+import { ModelName, ResourcePolicyConfig, ResourceRecord } from '@appweaver/common';
+/**
+ * Creates the policy of a model, checking the access to its records and restricting the reads and writes. Once the
+ * types are generated, the records the callbacks receive are typed by the model name.
+ *
+ * @param {ResourcePolicyConfig} config - The policy configuration with the model name and the policy callbacks.
+ * @param {boolean} [override=false] - Whether to replace a policy already defined for the model.
+ * @return {ResourcePolicyConfig} The created policy, defined in the application context.
+ */
+export declare function createPolicy<N extends ModelName, T = ResourceRecord<N>>(config: ResourcePolicyConfig<T> & {
+    modelName: N;
+}, override?: boolean): ResourcePolicyConfig<T>;

package/factory/create-policy.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPolicy = createPolicy;
+const common_1 = require("@appweaver/common");
+const core_1 = require("@appweaver/core");
+/**
+ * Creates the policy of a model, checking the access to its records and restricting the reads and writes. Once the
+ * types are generated, the records the callbacks receive are typed by the model name.
+ *
+ * @param {ResourcePolicyConfig} config - The policy configuration with the model name and the policy callbacks.
+ * @param {boolean} [override=false] - Whether to replace a policy already defined for the model.
+ * @return {ResourcePolicyConfig} The created policy, defined in the application context.
+ */
+function createPolicy(config, override = false) {
+    config[common_1.RESOURCE_NAME] = (0, common_1.capitalize)(config.modelName);
+    config[common_1.RESOURCE_TYPE] = common_1.RESOURCE_POLICY_TYPE;
+    common_1.logger.debug({ modelName: config.modelName }, 'Created resource policy');
+    (0, core_1.define)(config, undefined, override ? 'override' : undefined);
+    return config;
+}

package/factory/create-service.d.ts

@@ -0,0 +1,14 @@
+import { Ctor, ModelName, QueryFilter, RegistryType, ResourceServiceConfig } from '@appweaver/common';
+import { ResourceService } from '../resource/resource-service';
+/**
+ * Creates the resource service of a model, running the configured hooks around its operations and applying the
+ * policy of the model. The update hooks run around both an update and a replacement. Once the types are generated,
+ * the model, create, and update types of the hooks are inferred from the model name.
+ *
+ * @param {ResourceServiceConfig} config - The service configuration with the model name, hooks, and text search.
+ * @param {boolean} [override=false] - Whether to replace a service already defined for the model.
+ * @return {Ctor<ResourceService>} The created service class, defined in the application context.
+ */
+export declare function createService<N extends ModelName, T = RegistryType<N, 'model'>, C = RegistryType<N, 'create'>, U = RegistryType<N, 'update'>, R = RegistryType<N, 'replace', C>>(config: ResourceServiceConfig<T, C, U> & {
+    modelName: N;
+}, override?: boolean): Ctor<ResourceService<T, T, C, U, QueryFilter<T>, R>>;

package/factory/create-service.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createService = createService;
+const common_1 = require("@appweaver/common");
+const core_1 = require("@appweaver/core");
+const resource_service_1 = require("../resource/resource-service");
+const text_search_util_1 = require("../resource/utils/text-search-util");
+/**
+ * Creates the resource service of a model, running the configured hooks around its operations and applying the
+ * policy of the model. The update hooks run around both an update and a replacement. Once the types are generated,
+ * the model, create, and update types of the hooks are inferred from the model name.
+ *
+ * @param {ResourceServiceConfig} config - The service configuration with the model name, hooks, and text search.
+ * @param {boolean} [override=false] - Whether to replace a service already defined for the model.
+ * @return {Ctor<ResourceService>} The created service class, defined in the application context.
+ */
+function createService(config, override = false) {
+    const name = (0, common_1.capitalize)(config.modelName);
+    class Service extends resource_service_1.ResourceService {
+        [common_1.CONFIG] = config;
+        [common_1.RESOURCE_NAME] = name;
+        [common_1.RESOURCE_TYPE] = common_1.RESOURCE_SERVICE_TYPE;
+        constructor() {
+            super(name);
+        }
+        async find(id) {
+            await config.beforeFind?.(id);
+            const result = await super.find(id);
+            await config.afterFind?.(result);
+            return result;
+        }
+        async query(options = {}) {
+            await config.beforeQuery?.(options);
+            const result = await super.query(options);
+            await config.afterQuery?.(result);
+            return result;
+        }
+        async aggregate(options) {
+            await config.beforeAggregate?.(options);
+            const result = await super.aggregate(options);
+            // The hook is declared once for the model, so it takes the response of
+            // every selection, of which this one holds a subset of the fields
+            await config.afterAggregate?.(result);
+            return result;
+        }
+        async create(data) {
+            await config.beforeCreate?.(data);
+            const result = await super.create(data);
+            await config.afterCreate?.(result);
+            return result;
+        }
+        async update(id, data) {
+            await config.beforeUpdate?.(id, data);
+            const { previous, current } = await this.updateWithPrevious(id, data);
+            await config.afterUpdate?.(current, previous);
+            return current;
+        }
+        async replace(id, data) {
+            // The hooks receive the whole replacement, the reset fields included
+            const replacement = this.replacementData(data);
+            await config.beforeUpdate?.(id, replacement);
+            const { previous, current } = await this.updateWithPrevious(id, replacement);
+            await config.afterUpdate?.(current, previous);
+            return current;
+        }
+        async delete(id) {
+            await config.beforeDelete?.(id);
+            const result = await super.delete(id);
+            await config.afterDelete?.(result);
+            return result;
+        }
+        textSearchQuery(searchText) {
+            if ((0, common_1.isFunction)(config.textSearch)) {
+                return config.textSearch(searchText);
+            }
+            if ((0, common_1.isPlainObject)(config.textSearch)) {
+                return (0, text_search_util_1.bindTextSearch)(config.textSearch, searchText);
+            }
+            return super.textSearchQuery(searchText);
+        }
+        async readRestrictions(action, data) {
+            const policy = (0, core_1.injectPolicy)(name, false);
+            if (policy?.readRestrictions) {
+                const user = (0, core_1.currentAuthUser)() ?? null;
+                return (await policy.readRestrictions(user, data, action)) ?? {};
+            }
+            return super.readRestrictions(action, data);
+        }
+        async writeRestrictions(action, data) {
+            const policy = (0, core_1.injectPolicy)(name, false);
+            if (policy?.writeRestrictions) {
+                const user = (0, core_1.currentAuthUser)() ?? null;
+                return (await policy.writeRestrictions(user, data, action)) ?? {};
+            }
+            return super.writeRestrictions(action, data);
+        }
+        async checkAccess(action, resource) {
+            const policy = (0, core_1.injectPolicy)(name, false);
+            if (policy?.checkAccess) {
+                const user = (0, core_1.currentAuthUser)() ?? null;
+                return policy.checkAccess(user, resource, action);
+            }
+            return super.checkAccess(action, resource);
+        }
+    }
+    Object.defineProperty(Service, 'name', {
+        value: `${name}Service`,
+        configurable: true
+    });
+    Service[common_1.CONFIG] = config;
+    Service[common_1.RESOURCE_NAME] = name;
+    Service[common_1.RESOURCE_TYPE] = common_1.RESOURCE_SERVICE_TYPE;
+    common_1.logger.debug({ modelName: config.modelName }, 'Created resource service');
+    (0, core_1.define)(Service, undefined, override ? 'override' : undefined);
+    return Service;
+}

package/index.d.ts

@@ -0,0 +1,22 @@
+export * from './config';
+export * from './database';
+export * from './export/export-service';
+export * from './factory/create-model';
+export * from './factory/create-policy';
+export * from './factory/create-service';
+export * from './resource/model-schema';
+export * from './resource/resource-loader';
+export * from './resource/resource-service';
+export * from './resource/schemas';
+export * from './security/create-auth-resources';
+export * from './security/helper';
+export * from './seeder';
+export * from './storage/file-service';
+export * from './types/auth';
+export * from './types/generated';
+export * from './types/storage';
+export * from './utils/export-util';
+export * from './utils/file-util';
+export * from './utils/model-util';
+export * from './utils/policy-util';
+export * from './utils/virtual-util';