@appweaver/data 0.0.0-stage → 2.0.1

package/prisma/client/models/Seeder.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/prisma/client/models.d.ts

@@ -0,0 +1,8 @@
+export type * from './models/ApiKey';
+export type * from './models/ConnectedAccount';
+export type * from './models/OneTimeToken';
+export type * from './models/Permission';
+export type * from './models/Role';
+export type * from './models/Seeder';
+export type * from './models/File';
+export type * from './commonInputTypes';

package/prisma/client/models.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/resource/load-data-resources.d.ts

@@ -0,0 +1,13 @@
+import { ModuleSetupContext } from '@appweaver/common';
+/**
+ * The setup of `@appweaver/data`: loads the models, services and policies of the application, then the resources of
+ * the modules, unless the `autoLoadResources` parameter of `createApp` is `false`.
+ *
+ * @param {ModuleSetupContext} setupContext - The setup context.
+ */
+export declare function loadDataResources(setupContext: ModuleSetupContext): Promise<void>;
+/**
+ * Warns about the file fields transforming their images (`image`) when no image processor is provided, since their
+ * images are then stored as they are uploaded.
+ */
+export declare function warnUnprocessedImages(): void;

package/resource/load-data-resources.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadDataResources = loadDataResources;
+exports.warnUnprocessedImages = warnUnprocessedImages;
+const common_1 = require("@appweaver/common");
+const core_1 = require("@appweaver/core");
+const internal_1 = require("@appweaver/core/internal");
+const resource_loader_1 = require("./resource-loader");
+/**
+ * The setup of `@appweaver/data`: loads the models, services and policies of the application, then the resources of
+ * the modules, unless the `autoLoadResources` parameter of `createApp` is `false`.
+ *
+ * @param {ModuleSetupContext} setupContext - The setup context.
+ */
+async function loadDataResources(setupContext) {
+    if (setupContext.params.autoLoadResources === false) {
+        return;
+    }
+    await (0, resource_loader_1.loadResources)(setupContext.scanPath, setupContext.params.resourcePaths, setupContext.modules.flatMap((module) => module.resources ? [module.resources] : []));
+    warnUnprocessedImages();
+}
+/**
+ * Warns about the file fields transforming their images (`image`) when no image processor is provided, since their
+ * images are then stored as they are uploaded.
+ */
+function warnUnprocessedImages() {
+    if ((0, core_1.isDefined)(common_1.ImageProcessor)) {
+        return;
+    }
+    const fields = [...internal_1.context.resource.models.values()].flatMap((model) => Object.entries(model.config.files ?? {})
+        .filter(([, field]) => field?.image)
+        .map(([name]) => `${model.name}.${name}`));
+    if (fields.length > 0) {
+        common_1.logger.warn({ fields }, 'The images of these file fields are stored unprocessed, since no image processor is provided: install ' +
+            '@appweaver/sharp, or select one in IMAGE_PROVIDER');
+    }
+}

package/resource/model-schema.d.ts

@@ -0,0 +1,34 @@
+import { TObject, TSchema } from '@sinclair/typebox';
+import { IdField } from '@appweaver/common';
+export declare const ID_STRING_MAX_LENGTH = 36;
+export declare const Id: TObject<{
+    id: import("@sinclair/typebox").TInteger;
+}>;
+export declare const IdString: TObject<{
+    id: import("@sinclair/typebox").TString;
+}>;
+/**
+ * Builds the schema of a single primary key value, used wherever an id is
+ * accepted on its own (i.e. a relation input connecting an existing record).
+ *
+ * @param {IdField} [idField] - The id configuration, integer by default.
+ * @return {TSchema} The schema of the id value.
+ */
+export declare function idValueSchema(idField?: IdField): TSchema;
+/**
+ * Builds the primary key schema of a model, used as the route path parameter
+ * and as the connection shape of the relation inputs pointing at the model. A
+ * fresh object per call, since each model annotates its own schemas.
+ *
+ * @param {IdField} [idField] - The id configuration, integer by default.
+ * @return {TObject} The primary key schema of the model.
+ */
+export declare function idSchema(idField?: IdField): TObject;
+/**
+ * Builds the audit field schema of a model. The `createdById` field references
+ * the authentication model, so it follows that model's id type.
+ *
+ * @param {IdField} [authIdField] - The auth model id configuration, integer by default.
+ * @return {TObject} The schema holding all supported audit fields.
+ */
+export declare function auditSchema(authIdField?: IdField): TObject;

package/resource/model-schema.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdString = exports.Id = exports.ID_STRING_MAX_LENGTH = void 0;
+exports.idValueSchema = idValueSchema;
+exports.idSchema = idSchema;
+exports.auditSchema = auditSchema;
+const typebox_1 = require("@sinclair/typebox");
+const common_1 = require("@appweaver/common");
+// Maximum length of a string primary key, sized for the longest value the
+// supported generators produce (a 36-character UUID)
+exports.ID_STRING_MAX_LENGTH = 36;
+exports.Id = typebox_1.Type.Object({
+    id: typebox_1.Type.Integer({ minimum: 1, example: 1 })
+});
+exports.IdString = typebox_1.Type.Object({
+    id: typebox_1.Type.String({ maxLength: exports.ID_STRING_MAX_LENGTH, example: 'a1b2c3d4' })
+});
+/**
+ * Builds the schema of a single primary key value, used wherever an id is
+ * accepted on its own (i.e. a relation input connecting an existing record).
+ *
+ * @param {IdField} [idField] - The id configuration, integer by default.
+ * @return {TSchema} The schema of the id value.
+ */
+function idValueSchema(idField) {
+    return (0, common_1.idFieldType)(idField) === 'string'
+        ? exports.IdString.properties.id
+        : exports.Id.properties.id;
+}
+/**
+ * Builds the primary key schema of a model, used as the route path parameter
+ * and as the connection shape of the relation inputs pointing at the model. A
+ * fresh object per call, since each model annotates its own schemas.
+ *
+ * @param {IdField} [idField] - The id configuration, integer by default.
+ * @return {TObject} The primary key schema of the model.
+ */
+function idSchema(idField) {
+    return typebox_1.Type.Object({ id: idValueSchema(idField) });
+}
+/**
+ * Builds the audit field schema of a model. The `createdById` field references
+ * the authentication model, so it follows that model's id type.
+ *
+ * @param {IdField} [authIdField] - The auth model id configuration, integer by default.
+ * @return {TObject} The schema holding all supported audit fields.
+ */
+function auditSchema(authIdField) {
+    return typebox_1.Type.Object({
+        updatedAt: (0, common_1.StringDate)(),
+        createdAt: (0, common_1.StringDate)(),
+        createdById: (0, common_1.Nullable)(idValueSchema(authIdField))
+    });
+}

package/resource/resource-config.d.ts

@@ -0,0 +1,16 @@
+import { QueryMethod } from '@appweaver/common';
+export declare const resourceConfig: Readonly<{
+    MODEL_PATTERN: string;
+    SERVICE_PATTERN: string;
+    POLICY_PATTERN: string;
+    ROUTES_PATTERN: string;
+    GENERATED_TYPES_PATH: string;
+    QUERY_METHOD: QueryMethod;
+    AGGREGATE_METHOD: QueryMethod;
+    BULK_CREATE_ENABLED: boolean;
+    BULK_UPDATE_ENABLED: boolean;
+    BULK_DELETE_ENABLED: boolean;
+    BULK_MAX_ITEMS: number;
+    BULK_TRANSACTION_TIMEOUT: number;
+    BULK_RETURN_RECORDS: boolean;
+}>;

package/resource/resource-config.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resourceConfig = void 0;
+const typebox_1 = require("@sinclair/typebox");
+const common_1 = require("@appweaver/common");
+exports.resourceConfig = (0, common_1.defineConfig)('resource', {
+    /** Glob pattern for resource model files. Default: `'<srcPath>/resources/"*"/*model.ts'`. */
+    MODEL_PATTERN: typebox_1.Type.String({
+        default: '<srcPath>/resources/*/*model.ts'
+    }),
+    /** Glob pattern for resource service files. Default: `'<srcPath>/resources/"*"/*service.ts'`. */
+    SERVICE_PATTERN: typebox_1.Type.String({
+        default: '<srcPath>/resources/*/*service.ts'
+    }),
+    /** Glob pattern for resource policy files. Default: `'<srcPath>/resources/"*"/*policy.ts'`. */
+    POLICY_PATTERN: typebox_1.Type.String({
+        default: '<srcPath>/resources/*/*policy.ts'
+    }),
+    /** Glob pattern for resource routes files. Default: `'<srcPath>/resources/"*"/*routes.ts'`. */
+    ROUTES_PATTERN: typebox_1.Type.String({
+        default: '<srcPath>/resources/*/*routes.ts'
+    }),
+    /** Output path for generated TypeScript types. Default: `'<srcPath>/types/generated.ts'`. */
+    GENERATED_TYPES_PATH: typebox_1.Type.String({
+        default: '<srcPath>/types/generated.ts'
+    }),
+    /** HTTP methods of the resource query routes. Values: `post`, `get`, `get-post`. Default: `'post'`. */
+    QUERY_METHOD: typebox_1.Type.Enum(common_1.QueryMethod, {
+        default: common_1.QueryMethod.Post
+    }),
+    /** HTTP methods of the resource aggregate routes. Values: `post`, `get`, `get-post`. Default: `'post'`. */
+    AGGREGATE_METHOD: typebox_1.Type.Enum(common_1.QueryMethod, {
+        default: common_1.QueryMethod.Post
+    }),
+    /** Register the bulk create route of every resource, unless its route sets `exclude`. Default: `false`. */
+    BULK_CREATE_ENABLED: typebox_1.Type.Boolean({ default: false }),
+    /** Register the bulk update routes of every resource, unless its route sets `exclude`. Default: `false`. */
+    BULK_UPDATE_ENABLED: typebox_1.Type.Boolean({ default: false }),
+    /** Register the bulk delete route of every resource, unless its route sets `exclude`. Default: `false`. */
+    BULK_DELETE_ENABLED: typebox_1.Type.Boolean({ default: false }),
+    /** Maximum number of items a bulk create, update, or delete request accepts, unless its route sets `maxItems`.
+     * Default: `2000`. */
+    BULK_MAX_ITEMS: typebox_1.Type.Integer({ default: 2000, minimum: 1 }),
+    /** Timeout in milliseconds of the transaction a bulk request runs in. Default: `5000`. */
+    BULK_TRANSACTION_TIMEOUT: typebox_1.Type.Integer({ default: 5000 }),
+    /** Respond to a bulk request with the records it applied, the same as their single routes, or only with
+     * `{ success, count }` when `false`, unless its route sets `returnRecords`. Default: `true`. */
+    BULK_RETURN_RECORDS: typebox_1.Type.Boolean({ default: true })
+}, {
+    // The path patterns are relative to the source directory of the application
+    transform: (values) => {
+        const withSource = (path) => path.replace('<srcPath>', common_1.appConfig.SOURCE_PATH);
+        return {
+            ...values,
+            MODEL_PATTERN: withSource(values.MODEL_PATTERN),
+            SERVICE_PATTERN: withSource(values.SERVICE_PATTERN),
+            POLICY_PATTERN: withSource(values.POLICY_PATTERN),
+            ROUTES_PATTERN: withSource(values.ROUTES_PATTERN),
+            GENERATED_TYPES_PATH: withSource(values.GENERATED_TYPES_PATH)
+        };
+    }
+});

package/resource/resource-loader.d.ts

@@ -0,0 +1,25 @@
+import { ResourceContext } from '@appweaver/core';
+export type LoadResourcePaths = {
+    /** Path pattern used for finding files that export resource models (default: `./src/resources/"*"/*model.ts`) */
+    modelPattern?: string;
+    /** Path pattern used for finding files that export resource models (default: `./src/resources/"*"/*service.ts`) */
+    servicePattern?: string;
+    /** Path pattern used for finding files that export resource models (default: `./src/resources/"*"/*policy.ts`) */
+    policyPattern?: string;
+};
+/**
+ * Loads the application resources: models, services and policies.
+ *
+ * @param {string} [baseDir] - Optional base directory path from which to load the resources.
+ *                              If not provided, defaults to the application's root directory.
+ * @param {LoadResourcePaths} [paths={}] Path patterns for loading the models, services and policies.
+ * @param {Array<() => unknown>} [moduleResources=[]] The loaders of the resources of the enabled modules, imported after
+ * the files of the application, so a module model can relate to a model of the application, i.e. its auth model.
+ * @return {Promise<ResourceContext>} A promise that resolves to an object containing
+ * the loaded resources:
+ *
+ *         - `models`: The application models.
+ *         - `services`: The application services.
+ *         - `policies`: The access policies.
+ */
+export declare function loadResources(baseDir?: string, paths?: LoadResourcePaths, moduleResources?: Array<() => unknown>): Promise<Omit<ResourceContext, 'routes'>>;

package/resource/resource-loader.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadResources = loadResources;
+const typebox_1 = require("@sinclair/typebox");
+const common_1 = require("@appweaver/common");
+const resource_config_1 = require("./resource-config");
+const file_util_1 = require("../utils/file-util");
+const model_util_1 = require("../utils/model-util");
+const internal_1 = require("@appweaver/core/internal");
+const prune_util_1 = require("./utils/prune-util");
+/**
+ * Loads the application resources: models, services and policies.
+ *
+ * @param {string} [baseDir] - Optional base directory path from which to load the resources.
+ *                              If not provided, defaults to the application's root directory.
+ * @param {LoadResourcePaths} [paths={}] Path patterns for loading the models, services and policies.
+ * @param {Array<() => unknown>} [moduleResources=[]] The loaders of the resources of the enabled modules, imported after
+ * the files of the application, so a module model can relate to a model of the application, i.e. its auth model.
+ * @return {Promise<ResourceContext>} A promise that resolves to an object containing
+ * the loaded resources:
+ *
+ *         - `models`: The application models.
+ *         - `services`: The application services.
+ *         - `policies`: The access policies.
+ */
+async function loadResources(baseDir, paths = {}, moduleResources = []) {
+    const exports = (pattern) => findExports(pattern, baseDir ?? process.cwd(), moduleResources);
+    const models = await loadModels(await exports(paths.modelPattern || resource_config_1.resourceConfig.MODEL_PATTERN));
+    const services = loadServices(await exports(paths.servicePattern || resource_config_1.resourceConfig.SERVICE_PATTERN));
+    const policies = loadPolicies(await exports(paths.policyPattern || resource_config_1.resourceConfig.POLICY_PATTERN));
+    return {
+        models: new Map(Object.entries(models)),
+        services: new Map(Object.entries(services)),
+        policies: new Map(Object.entries(policies))
+    };
+}
+async function loadModels(exports) {
+    const models = {};
+    for (const modelSchema of exports) {
+        if ((0, common_1.isResourceModel)(modelSchema)) {
+            models[modelSchema.name] = modelSchema;
+        }
+        else {
+            for (const maybeSchema of Object.values(modelSchema)) {
+                if ((0, common_1.isResourceModel)(maybeSchema)) {
+                    models[maybeSchema.name] = maybeSchema;
+                }
+            }
+        }
+    }
+    // Leave out the models of the framework the application does not use
+    for (const name of (0, prune_util_1.pruneUnusedModels)(models)) {
+        internal_1.context.resource.models.delete(name);
+        internal_1.context.resource.services.delete(name);
+        internal_1.context.resource.policies.delete(name);
+        internal_1.context.resource.routes.delete(name);
+    }
+    // Resolve the schemas referencing the primary key of another model, now that
+    // every model is registered
+    (0, common_1.relinkResourceModels)(models);
+    // Reject a default value that its own field constraints would reject, since
+    // the records it produces cannot be serialized by the routes of their model
+    (0, model_util_1.validateScalarDefaults)(models);
+    // Reject file name patterns writing into a reserved storage path before any
+    // upload can reach the storage layer.
+    (0, file_util_1.validateFileNamePatterns)(models);
+    // Reject a cascade from a soft deleted model into one that removes its
+    // records, since the database cascade never runs on a soft delete
+    (0, model_util_1.validateSoftDeleteCascades)(models);
+    // Map model variants to schemas using their corresponding suffixes
+    const resourceModels = {};
+    for (const model of Object.values(models)) {
+        for (const [suffix, property] of Object.entries(common_1.resourceModelProps)) {
+            resourceModels[`${model.name}${suffix}`] = model[property];
+        }
+    }
+    // Resolve all model references through the TypeBox module system
+    const module = typebox_1.Type.Module(resourceModels);
+    // Apply resolved models back to the resource schema definitions
+    for (const model of Object.values(models)) {
+        for (const [suffix, property] of Object.entries(common_1.resourceModelProps)) {
+            const schemaKey = `${model.name}${suffix}`;
+            const importedModel = module.Import(schemaKey);
+            model[property] = importedModel;
+        }
+    }
+    return models;
+}
+function loadServices(exports) {
+    const services = {};
+    for (const resourceService of exports) {
+        if ((0, common_1.isResourceService)(resourceService)) {
+            services[resourceService.modelName] = resourceService;
+        }
+        else {
+            for (const maybeService of Object.values(resourceService)) {
+                if ((0, common_1.isResourceService)(maybeService)) {
+                    services[maybeService.modelName] = maybeService;
+                }
+            }
+        }
+    }
+    return services;
+}
+function loadPolicies(exports) {
+    const policies = {};
+    for (const resourcePolicy of exports) {
+        if ((0, common_1.isResourcePolicy)(resourcePolicy)) {
+            policies[resourcePolicy.modelName] = resourcePolicy;
+        }
+        else {
+            for (const maybePolicy of Object.values(resourcePolicy)) {
+                if ((0, common_1.isResourcePolicy)(maybePolicy)) {
+                    policies[maybePolicy.modelName] = maybePolicy;
+                }
+            }
+        }
+    }
+    return policies;
+}
+/** The exports of the application files matching a pattern, then of the resources of the modules. */
+async function findExports(pattern, cwd, moduleResources) {
+    const exports = [];
+    for (const filePath of await (0, common_1.findFilesByPattern)(pattern, cwd)) {
+        const { value, error } = await (0, common_1.importModule)(filePath);
+        if (error) {
+            common_1.logger.error(error, 'Resource path import error');
+            continue;
+        }
+        if (value) {
+            exports.push(value);
+        }
+    }
+    for (const load of moduleResources) {
+        exports.push(await load());
+    }
+    return exports;
+}