@decaf-ts/for-nest 0.11.2 → 0.12.1

package/lib/esm/decaf-model/FromModelController.js

@@ -7,75 +7,33 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-import { Controller, Param, Query, Response } from "@nestjs/common";
-import { ApiBadRequestResponse, ApiBody, ApiCreatedResponse, ApiExtraModels, ApiNotFoundResponse, ApiOkResponse, ApiOperation, ApiParam, ApiQuery, ApiTags, ApiUnprocessableEntityResponse, getSchemaPath, } from "@nestjs/swagger";
+var DynamicModelController_1;
+import { Controller, Param, Query, Response, SetMetadata, } from "@nestjs/common";
+import { ApiBadRequestResponse, ApiBody, ApiCreatedResponse, ApiExtraModels, ApiNoContentResponse, ApiNotFoundResponse, ApiOkResponse, ApiOperation, ApiParam, ApiQuery, ApiTags, ApiUnprocessableEntityResponse, getSchemaPath, } from "@nestjs/swagger";
 import { ModelService, OrderDirection, PersistenceKeys, PreparedStatementKeys, Repository, Service, } from "@decaf-ts/core";
 import { Model } from "@decaf-ts/decorator-validation";
 import { Logging, toKebabCase } from "@decaf-ts/logging";
-import { BulkCrudOperationKeys, DBKeys, OperationKeys, ValidationError, } from "@decaf-ts/db-decorators";
+import { DBKeys, BaseError, InternalError, OperationKeys, } from "@decaf-ts/db-decorators";
 import { Metadata } from "@decaf-ts/decoration";
-import { ApiOperationFromModel, ApiParamsFromModel, DecafBody, DecafParams, DecafQuery, } from "./decorators/index.js";
+import { ApiOperationFromModel, ApiParamsFromModel, DecafBody, DecafQuery, } from "./decorators/index.js";
+import { HttpVerbToDecorator } from "./decorators/utils.js";
 import { DecafRequestContext } from "./../request/index.js";
-import { DECAF_ROUTE } from "./../constants.js";
-import { applyApiDecorators, createRouteHandler, defineRouteMethod, getApiDecorators, resolvePersistenceMethod, } from "./utils.js";
-import { Auth } from "./decorators/decorators.js";
+import { DECAF_CONTROLLER_CONFIG, DECAF_ROUTE } from "./../constants.js";
+import { SKIP_MODEL_ROLES_KEY } from "./../auth/constants.js";
+import { Auth, Public, RequireRoles } from "./../auth/decorators.js";
 import { DecafModelController } from "./../controllers.js";
 import { DtoFor } from "./../factory/openapi/DtoBuilder.js";
 import "./../overrides/index.js";
-/**
- * @description
- * Factory and utilities for generating dynamic NestJS controllers from Decaf {@link Model} definitions.
- *
- * @summary
- * The `FromModelController` class provides the infrastructure necessary to automatically generate
- * strongly-typed CRUD controllers based on a given {@link ModelConstructor}. It inspects metadata from
- * the model, derives route paths, parameters, and generates a dynamic controller class at runtime with
- * full support for querying, creation, update, and deletion of model entities through a {@link Repo}.
- *
- * @template T The {@link Model} type associated with the generated controller.
- *
- * @param ModelClazz The model class to generate the controller from.
- *
- * @class FromModelController
- *
- * @example
- * ```ts
- * // Given a Decaf Model:
- * class User extends Model<User> {
- *   id!: string;
- *   name!: string;
- * }
- *
- * // Register controller:
- * const UserController = FromModelController.create(User);
- *
- * // NestJS will expose:
- * // POST   /user
- * // GET    /user/:id
- * // GET    /user/query/:method
- * // PUT    /user/:id
- * // DELETE /user/:id
- * ```
- *
- * @mermaid
- * sequenceDiagram
- *     participant Client
- *     participant Controller
- *     participant Repo
- *     participant DB
- *
- *     Client->>Controller: HTTP Request
- *     Controller->>Repo: Resolve repository for Model
- *     Repo->>DB: Execute DB operation
- *     DB-->>Repo: DB Result
- *     Repo-->>Controller: Model Instance(s)
- *     Controller-->>Client: JSON Response
- */
+import { ModelControllerFactory, } from "@decaf-ts/for-http/server";
 export class FromModelController {
     static { this.log = Logging.for(FromModelController.name); }
+    static toDecafError(error, fallbackMessage) {
+        if (error instanceof BaseError)
+            return error;
+        return new InternalError(error instanceof Error
+            ? `${fallbackMessage}: ${error.message}`
+            : fallbackMessage);
+    }
     static getPersistence(ModelClazz) {
         try {
             return Service.get(ModelClazz);
@@ -83,756 +41,537 @@ export class FromModelController {
         catch (e) {
             try {
                 return ModelService.getService(ModelClazz);
-                // eslint-disable-next-line @typescript-eslint/no-unused-vars
             }
-            catch (e) {
+            catch (e2) {
                 return Repository.forModel(ModelClazz);
             }
         }
     }
     static createQueryRoutesFromRepository(persistence, prefix = PersistenceKeys.QUERY) {
-        const log = FromModelController.log.for(FromModelController.createQueryRoutesFromRepository);
         const repo = persistence instanceof ModelService ? persistence.repo : persistence;
-        const ModelConstr = repo.class;
         const queryMethods = Metadata.get(repo.constructor, Metadata.key(PersistenceKeys.QUERY)) ?? {};
         const routeMethods = Metadata.get(persistence.constructor, Metadata.key(DECAF_ROUTE)) ?? {};
-        // create base class
         class QueryController extends DecafModelController {
             get class() {
-                throw new Error("Method not implemented.");
+                throw new InternalError("Method not implemented.");
             }
             constructor(clientContext, name) {
                 super(clientContext, name);
             }
         }
         for (const [methodName, params] of Object.entries(routeMethods)) {
-            // regex to trim slashes from start and end
             const routePath = [params.path.replace(/^\/+|\/+$/g, "")]
                 .filter((segment) => segment && segment.trim())
                 .join("/");
-            // const handler = params.handler.value;
-            const handler = createRouteHandler(methodName);
-            if (!handler) {
-                const message = `Invalid or missing handler for model ${ModelConstr.name} on decorated method ${methodName}`;
-                log.error(message);
-                throw new Error(message);
-            }
-            const descriptor = defineRouteMethod(QueryController, methodName, handler);
-            if (descriptor) {
-                const decorators = getApiDecorators(methodName, routePath, params.httpMethod);
-                applyApiDecorators(QueryController, methodName, descriptor, decorators);
-            }
+            const handler = FromModelController.createComplexQueryHandler(methodName);
+            FromModelController.defineMethod(QueryController, methodName, handler);
+            const httpDecorator = HttpVerbToDecorator(params.httpMethod)(routePath || undefined);
+            const decorators = FromModelController.getQueryDecorators(methodName, routePath, params.httpMethod);
+            FromModelController.applyDecorators(QueryController, methodName, [
+                httpDecorator,
+                ...decorators,
+            ]);
         }
         for (const [methodName, objValues] of Object.entries(queryMethods)) {
             const fields = objValues.fields ?? [];
             const routePath = [prefix, methodName, ...fields.map((f) => `:${f}`)]
                 .filter((segment) => segment && segment.trim())
                 .join("/");
-            const handler = createRouteHandler(methodName);
-            const descriptor = defineRouteMethod(QueryController, methodName, handler);
-            if (descriptor) {
-                const decorators = getApiDecorators(methodName, routePath, "GET", true);
-                applyApiDecorators(QueryController, methodName, descriptor, decorators);
-            }
+            const handler = FromModelController.createComplexQueryHandler(methodName);
+            FromModelController.defineMethod(QueryController, methodName, handler);
+            const httpDecorator = HttpVerbToDecorator("GET")(routePath || undefined);
+            const decorators = FromModelController.getQueryDecorators(methodName, routePath, "GET", true);
+            FromModelController.applyDecorators(QueryController, methodName, [
+                httpDecorator,
+                ...decorators,
+            ]);
         }
         return QueryController;
     }
-    static create(ModelConstr) {
+    static create(ModelConstr, moduleConfigOverrides, globalDefaults) {
         const log = FromModelController.log.for(FromModelController.create);
         const tableName = Model.tableName(ModelConstr);
         const routePath = toKebabCase(tableName);
         const modelClazzName = ModelConstr.name;
         const persistence = FromModelController.getPersistence(ModelConstr);
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { description, getPK, apiProperties, path } = FromModelController.getRouteParametersFromModel(ModelConstr);
-        log.debug(`Creating controller for model: ${modelClazzName}`);
-        const BaseController = FromModelController.createQueryRoutesFromRepository(persistence // instanceof ModelService ? persistence.repo : persistence
-        );
-        let DynamicModelController = class DynamicModelController extends BaseController {
+        // When persistence is a ModelService, the @query/@route metadata lives on
+        // the underlying repository class (custom repo), not on ModelService itself.
+        // Pass the repo to the factory so addComplexQueries() can discover them.
+        const factoryPersistence = persistence instanceof ModelService ? persistence.repo : persistence;
+        const decoratorConfig = Metadata.get(ModelConstr, Metadata.key(DECAF_CONTROLLER_CONFIG));
+        const moduleOverride = moduleConfigOverrides?.[ModelConstr.name];
+        const mergedConfig = {
+            ...(globalDefaults || {}),
+            ...(decoratorConfig || {}),
+            ...(moduleOverride || {}),
+        };
+        const FactoryController = ModelControllerFactory.create(ModelConstr, factoryPersistence, mergedConfig);
+        const factoryRoutes = FactoryController.__routes__;
+        const { getPK, apiProperties, path: pkPath, } = FromModelController.getRouteParametersFromModel(ModelConstr);
+        log.debug(`Creating controller for model: ${modelClazzName} with ${factoryRoutes?.length ?? 0} factory routes`);
+        const authConfig = mergedConfig.auth;
+        function applyClassAuth(target) {
+            if (authConfig?.public) {
+                Public()(target);
+            }
+            else if (authConfig?.roles?.length) {
+                RequireRoles(...authConfig.roles)(target);
+            }
+            else {
+                Auth(ModelConstr)(target);
+            }
+            if (authConfig?.skipModelRoles) {
+                SetMetadata(SKIP_MODEL_ROLES_KEY, true)(target);
+            }
+        }
+        let DynamicModelController = DynamicModelController_1 = class DynamicModelController extends DecafModelController {
             static get class() {
                 return ModelConstr;
             }
             get class() {
                 return ModelConstr;
-                // return DynamicModelController.class;
             }
             constructor(clientContext) {
-                super(clientContext);
+                super(clientContext, DynamicModelController_1.name);
                 this.pk = Model.pk(ModelConstr);
                 log.info(`Registering dynamic controller for model: ${this.class.name} route: /${routePath}`);
             }
-            //
-            // @ApiOperationFromModel(ModelClazz, "GET", "query/:condition/:orderBy")
-            // @ApiOperation({ summary: `Retrieve ${modelClazzName} records by query.` })
-            // @ApiParam({ name: "method", description: "Query method to be called" })
-            // @ApiOkResponse({
-            //   description: `${modelClazzName} retrieved successfully.`,
-            // })
-            // @ApiNotFoundResponse({
-            //   description: `No ${modelClazzName} records matches the query.`,
-            // })
-            // async query(
-            //   @Param("condition") condition: Condition<any>,
-            //   @Param("orderBy") orderBy: string,
-            //   @QueryDetails() details: DirectionLimitOffset,
-            // ) {
-            //   const {direction, limit, offset} = details;
-            //   return this.persistence.query(condition, orderBy as keyof Model, direction, limit, offset);
-            // }
-            async listBy(key, details) {
-                const { ctx } = (await this.logCtx([], PreparedStatementKeys.LIST_BY, true)).for(this.listBy);
-                return this.persistence(ctx).listBy(key, details.direction, ctx);
-            }
-            async paginateBy(key, details) {
-                const { ctx } = (await this.logCtx([], PreparedStatementKeys.PAGE_BY, true)).for(this.paginateBy);
-                return this.persistence(ctx).paginateBy(key, details.direction, details, ctx);
-            }
-            async find(value, details) {
-                const { ctx } = (await this.logCtx([], PreparedStatementKeys.FIND, true)).for(this.find);
-                const direction = (details.direction ??
-                    OrderDirection.ASC);
-                return resolvePersistenceMethod(this.persistence(ctx), this.find.name, value, direction, ctx);
-            }
-            async page(value, details) {
-                const { ctx } = (await this.logCtx([], PreparedStatementKeys.PAGE, true)).for(this.page);
-                const { direction = OrderDirection.ASC, limit, offset, bookmark, } = details;
-                const ref = {
-                    offset: offset ?? 1,
-                    limit: limit ?? 10,
-                    bookmark,
-                };
-                return resolvePersistenceMethod(this.persistence(ctx), this.page.name, value, direction, ref, ctx);
-            }
-            async findOneBy(key, value) {
-                const { ctx } = (await this.logCtx([], PreparedStatementKeys.FIND_ONE_BY, true)).for(this.findOneBy);
-                return this.persistence(ctx).findOneBy(key, value, ctx);
-            }
-            async findBy(key, value, details) {
-                const { ctx } = (await this.logCtx([], PreparedStatementKeys.FIND_BY, true)).for(this.findBy);
-                return this.persistence(ctx)
-                    .for(ctx.toOverrides())
-                    .findBy(key, value, ctx);
-            }
-            async statement(name, args, details) {
-                const { ctx } = (await this.logCtx([], PersistenceKeys.STATEMENT, true)).for(this.statement);
-                const { direction, offset, limit, bookmark } = details;
-                args = args.map((a) => (typeof a === "string" ? parseInt(a) : a) || a);
-                const pathDirection = args.length > 1 ? args[1] : undefined;
-                const resolvedDirection = (direction ?? pathDirection);
-                if (resolvedDirection && args.length > 1)
-                    args[1] = resolvedDirection;
-                switch (name) {
-                    case PreparedStatementKeys.FIND:
-                    case PreparedStatementKeys.FIND_BY:
-                        break;
-                    case PreparedStatementKeys.LIST_BY:
-                        args.push(direction);
-                        break;
-                    case PreparedStatementKeys.PAGE:
-                    case PreparedStatementKeys.PAGE_BY:
-                        args = [
-                            args[0],
-                            resolvedDirection,
-                            {
-                                limit: limit,
-                                offset: offset,
-                                bookmark: bookmark,
-                            },
-                        ];
-                        break;
-                    case PreparedStatementKeys.FIND_ONE_BY:
-                        break;
-                    case PreparedStatementKeys.COUNT_OF:
-                    case PreparedStatementKeys.MAX_OF:
-                    case PreparedStatementKeys.MIN_OF:
-                    case PreparedStatementKeys.AVG_OF:
-                    case PreparedStatementKeys.SUM_OF:
-                    case PreparedStatementKeys.DISTINCT_OF:
-                    case PreparedStatementKeys.GROUP_OF:
-                        // Aggregation methods - args[0] is the field name (if provided)
-                        break;
+        };
+        DynamicModelController = DynamicModelController_1 = __decorate([
+            Controller(routePath),
+            ApiTags(modelClazzName),
+            ApiExtraModels(ModelConstr),
+            __metadata("design:paramtypes", [DecafRequestContext])
+        ], DynamicModelController);
+        applyClassAuth(DynamicModelController);
+        if (factoryRoutes) {
+            const sortedRoutes = [...factoryRoutes].sort((a, b) => {
+                const aSegments = a.path.split("/").filter(Boolean);
+                const bSegments = b.path.split("/").filter(Boolean);
+                const aParamCount = aSegments.filter((s) => s.startsWith(":")).length;
+                const bParamCount = bSegments.filter((s) => s.startsWith(":")).length;
+                const aLiteralCount = aSegments.length - aParamCount;
+                const bLiteralCount = bSegments.length - bParamCount;
+                if (aLiteralCount !== bLiteralCount)
+                    return bLiteralCount - aLiteralCount;
+                if (aParamCount !== bParamCount)
+                    return aParamCount - bParamCount;
+                return 0;
+            });
+            for (const route of sortedRoutes) {
+                const methodName = route.implementation?.name || route.method.toLowerCase();
+                const registration = FromModelController.matchRoute(methodName, route, pkPath, apiProperties, getPK, ModelConstr, modelClazzName);
+                if (!registration)
+                    continue;
+                const { methodName: registeredMethodName, handler, decorators, paramDecorators, } = registration;
+                const descriptor = FromModelController.defineMethod(DynamicModelController, registeredMethodName, handler);
+                if (descriptor) {
+                    const httpDecorator = HttpVerbToDecorator(route.method)(route.path.replace(/^\/+|\/+$/g, "") || undefined);
+                    FromModelController.applyDecorators(DynamicModelController, registeredMethodName, [httpDecorator, ...decorators], paramDecorators);
                 }
-                return this.persistence(ctx).statement(name, ...args, ctx);
             }
-            //
-            // @ApiOperationFromModel(ModelConstr, "GET", "countOf")
-            // @ApiOperation({ summary: `Count all ${modelClazzName} records.` })
-            // @ApiOkResponse({
-            //   description: `Count of ${modelClazzName} records.`,
-            //   type: Number,
-            // })
-            // async countOf() {
-            //   const { ctx } = (
-            //     await this.logCtx([], PreparedStatementKeys.COUNT_OF, true)
-            //   ).for(this.countOf);
-            //   return this.persistence(ctx).statement(
-            //     PreparedStatementKeys.COUNT_OF,
-            //     ctx
-            //   );
-            // }
-            //
-            // @ApiOperationFromModel(ModelConstr, "GET", "countOf/:field")
-            // @ApiOperation({ summary: `Count ${modelClazzName} records by field.` })
-            // @ApiParam({ name: "field", description: "The field to count" })
-            // @ApiOkResponse({
-            //   description: `Count of ${modelClazzName} records.`,
-            //   type: Number,
-            // })
-            // async countOfField(@Param("field") field: string) {
-            //   const { ctx } = (
-            //     await this.logCtx([], PreparedStatementKeys.COUNT_OF, true)
-            //   ).for(this.countOfField);
-            //   return this.persistence(ctx).statement(
-            //     PreparedStatementKeys.COUNT_OF,
-            //     field,
-            //     ctx
-            //   );
-            // }
-            //
-            // @ApiOperationFromModel(ModelConstr, "GET", "maxOf/:field")
-            // @ApiOperation({
-            //   summary: `Find maximum value of a field in ${modelClazzName}.`,
-            // })
-            // @ApiParam({ name: "field", description: "The field to find max of" })
-            // @ApiOkResponse({
-            //   description: `Maximum value of the field in ${modelClazzName}.`,
-            // })
-            // async maxOf(@Param("field") field: string) {
-            //   const { ctx } = (
-            //     await this.logCtx([], PreparedStatementKeys.MAX_OF, true)
-            //   ).for(this.maxOf);
-            //   return this.persistence(ctx).statement(
-            //     PreparedStatementKeys.MAX_OF,
-            //     field,
-            //     ctx
-            //   );
-            // }
-            //
-            // @ApiOperationFromModel(ModelConstr, "GET", "minOf/:field")
-            // @ApiOperation({
-            //   summary: `Find minimum value of a field in ${modelClazzName}.`,
-            // })
-            // @ApiParam({ name: "field", description: "The field to find min of" })
-            // @ApiOkResponse({
-            //   description: `Minimum value of the field in ${modelClazzName}.`,
-            // })
-            // async minOf(@Param("field") field: string) {
-            //   const { ctx } = (
-            //     await this.logCtx([], PreparedStatementKeys.MIN_OF, true)
-            //   ).for(this.minOf);
-            //   return this.persistence(ctx).statement(
-            //     PreparedStatementKeys.MIN_OF,
-            //     field,
-            //     ctx
-            //   );
-            // }
-            //
-            // @ApiOperationFromModel(ModelConstr, "GET", "avgOf/:field")
-            // @ApiOperation({
-            //   summary: `Calculate average of a field in ${modelClazzName}.`,
-            // })
-            // @ApiParam({
-            //   name: "field",
-            //   description: "The field to calculate average of",
-            // })
-            // @ApiOkResponse({
-            //   description: `Average value of the field in ${modelClazzName}.`,
-            //   type: Number,
-            // })
-            // async avgOf(@Param("field") field: string) {
-            //   const { ctx } = (
-            //     await this.logCtx([], PreparedStatementKeys.AVG_OF, true)
-            //   ).for(this.avgOf);
-            //   return this.persistence(ctx).statement(
-            //     PreparedStatementKeys.AVG_OF,
-            //     field,
-            //     ctx
-            //   );
-            // }
-            //
-            // @ApiOperationFromModel(ModelConstr, "GET", "sumOf/:field")
-            // @ApiOperation({
-            //   summary: `Calculate sum of a field in ${modelClazzName}.`,
-            // })
-            // @ApiParam({ name: "field", description: "The field to calculate sum of" })
-            // @ApiOkResponse({
-            //   description: `Sum of the field in ${modelClazzName}.`,
-            //   type: Number,
-            // })
-            // async sumOf(@Param("field") field: string) {
-            //   const { ctx } = (
-            //     await this.logCtx([], PreparedStatementKeys.SUM_OF, true)
-            //   ).for(this.sumOf);
-            //   return this.persistence(ctx).statement(
-            //     PreparedStatementKeys.SUM_OF,
-            //     field,
-            //     ctx
-            //   );
-            // }
-            //
-            // @ApiOperationFromModel(ModelConstr, "GET", "distinctOf/:field")
-            // @ApiOperation({
-            //   summary: `Find distinct values of a field in ${modelClazzName}.`,
-            // })
-            // @ApiParam({
-            //   name: "field",
-            //   description: "The field to find distinct values of",
-            // })
-            // @ApiOkResponse({
-            //   description: `Distinct values of the field in ${modelClazzName}.`,
-            //   type: [String],
-            // })
-            // async distinctOf(@Param("field") field: string) {
-            //   const { ctx } = (
-            //     await this.logCtx([], PreparedStatementKeys.DISTINCT_OF, true)
-            //   ).for(this.distinctOf);
-            //   return this.persistence(ctx).statement(
-            //     PreparedStatementKeys.DISTINCT_OF,
-            //     field,
-            //     ctx
-            //   );
-            // }
-            //
-            // @ApiOperationFromModel(ModelConstr, "GET", "groupOf/:field")
-            // @ApiOperation({
-            //   summary: `Group ${modelClazzName} records by a field.`,
-            // })
-            // @ApiParam({ name: "field", description: "The field to group by" })
-            // @ApiOkResponse({
-            //   description: `${modelClazzName} records grouped by the field.`,
-            // })
-            // async groupOf(@Param("field") field: string) {
-            //   const { ctx } = (
-            //     await this.logCtx([], PreparedStatementKeys.GROUP_OF, true)
-            //   ).for(this.groupOf);
-            //   return this.persistence(ctx).statement(
-            //     PreparedStatementKeys.GROUP_OF,
-            //     field,
-            //     ctx
-            //   );
-            // }
-            async createAll(data, resp) {
-                const { ctx, log } = (await this.logCtx([], BulkCrudOperationKeys.CREATE_ALL, true)).for(this.createAll);
-                log.verbose(`creating new ${modelClazzName}`);
-                let created;
-                try {
-                    created = await this.persistence(ctx).createAll(data.map((d) => new ModelConstr(d)), ctx);
-                }
-                catch (e) {
-                    log.error(`Failed to create new ${modelClazzName}`, e);
-                    throw e;
-                }
-                log.info(`created new ${modelClazzName} with id ${created[this.pk]}`);
-                ctx.toResponse(resp);
-                return created;
+        }
+        return DynamicModelController;
+    }
+    static getRouteParametersFromModel(ModelClazz) {
+        const pk = Model.pk(ModelClazz);
+        const composed = Metadata.get(ModelClazz, Metadata.key(DBKeys.COMPOSED, pk));
+        const composedKeys = composed?.args ?? [];
+        const uniqueKeys = Array.isArray(composedKeys) && composedKeys.length > 0
+            ? Array.from(new Set([...composedKeys]))
+            : Array.from(new Set([pk]));
+        const description = Metadata.description(ModelClazz) ?? "";
+        const path = `:${uniqueKeys.join("/:")}`;
+        const apiProperties = uniqueKeys.map((key) => {
+            return {
+                name: key,
+                description: Metadata.description(ModelClazz, key),
+                required: true,
+                type: String,
+            };
+        });
+        return {
+            path,
+            description,
+            apiProperties,
+            getPK: (...params) => composed?.separator ? params.join(composed.separator) : params.join(""),
+        };
+    }
+    static routeParamDecorators(path) {
+        let paramIndex = 0;
+        return path
+            .split("/")
+            .filter(Boolean)
+            .flatMap((segment) => {
+            if (segment.startsWith(":")) {
+                return [
+                    { decorator: Param(segment.slice(1)), index: paramIndex++ },
+                ];
             }
-            async create(data, resp) {
-                const { ctx, log } = (await this.logCtx([], OperationKeys.CREATE, true)).for(this.create);
-                log.verbose(`creating new ${modelClazzName}`);
-                let created;
-                try {
-                    const persistence = this.persistence(ctx);
-                    created = await persistence.create(data, ctx);
-                }
-                catch (e) {
-                    log.error(`Failed to create new ${modelClazzName}`, e);
-                    throw e;
-                }
-                log.info(`created new ${modelClazzName} with id ${created[this.pk]}`);
-                ctx.toResponse(resp);
-                return created;
+            if (segment.startsWith("*")) {
+                return [
+                    { decorator: Param(segment.slice(1)), index: paramIndex++ },
+                ];
             }
-            async readAll(ids) {
-                const { ctx, log } = (await this.logCtx([], BulkCrudOperationKeys.READ_ALL, true)).for(this.readAll);
-                const normalizedIds = Array.isArray(ids) ? ids : [ids];
-                let read;
-                try {
-                    log.debug(`reading ${normalizedIds} ${modelClazzName}: ${normalizedIds}`);
-                    const persistence = this.persistence(ctx);
-                    read = await persistence.readAll(normalizedIds, ctx);
-                }
-                catch (e) {
-                    log.error(`Failed to ${modelClazzName} with id ${normalizedIds}`, e);
-                    throw e;
-                }
-                log.info(`read ${read.length} ${modelClazzName}`);
-                return read;
+            return [];
+        });
+    }
+    static defineMethod(target, methodName, handler) {
+        Object.defineProperty(target.prototype || target, methodName, {
+            value: handler,
+            writable: false,
+            configurable: true,
+            enumerable: false,
+        });
+        return Object.getOwnPropertyDescriptor(target.prototype || target, methodName);
+    }
+    static applyDecorators(target, methodName, methodDecorators, paramDecorators = []) {
+        const proto = target?.prototype ?? target;
+        const descriptor = Object.getOwnPropertyDescriptor(proto, methodName);
+        methodDecorators.forEach((d) => d(proto, methodName, descriptor));
+        paramDecorators.forEach(({ decorator, index }) => decorator(proto, methodName, index));
+    }
+    static matchRoute(methodName, route, pkPath, apiProperties, getPK, ModelConstr, modelClazzName) {
+        const { method, path } = route;
+        const normalizedPath = path.replace(/^\/+|\/+$/g, "");
+        const handler = route.implementation;
+        if (method === "POST" && normalizedPath === "") {
+            return FromModelController.createRegistration("create", handler, FromModelController.createCreateDecorators(ModelConstr, modelClazzName), [
+                { decorator: DecafBody(), index: 0 },
+                { decorator: Response({ passthrough: true }), index: 1 },
+            ]);
+        }
+        if (method === "POST" && normalizedPath === "bulk") {
+            return FromModelController.createRegistration("createAll", handler, FromModelController.bulkCreateDecorators(ModelConstr, modelClazzName), [
+                { decorator: DecafBody(), index: 0 },
+                { decorator: Response({ passthrough: true }), index: 1 },
+            ]);
+        }
+        if (method === "GET" && normalizedPath === "bulk") {
+            return FromModelController.createRegistration("readAll", handler, FromModelController.bulkReadDecorators(ModelConstr, modelClazzName), [{ decorator: Query("ids"), index: 0 }]);
+        }
+        if (method === "PUT" && normalizedPath === "bulk") {
+            return FromModelController.createRegistration("updateAll", handler, FromModelController.bulkUpdateDecorators(ModelConstr, modelClazzName, apiProperties), [
+                { decorator: DecafBody(), index: 0 },
+                { decorator: Response({ passthrough: true }), index: 1 },
+            ]);
+        }
+        if (method === "DELETE" && normalizedPath === "bulk") {
+            return FromModelController.createRegistration("deleteAll", handler, FromModelController.bulkDeleteDecorators(ModelConstr, modelClazzName, apiProperties), [
+                { decorator: Query("ids"), index: 0 },
+                { decorator: Response({ passthrough: true }), index: 1 },
+            ]);
+        }
+        if (method === "GET" && normalizedPath === pkPath) {
+            return FromModelController.createRegistration("read", handler, FromModelController.readDecorators(ModelConstr, modelClazzName, apiProperties, pkPath), FromModelController.routeParamDecorators(normalizedPath));
+        }
+        if (method === "PUT" && normalizedPath === pkPath) {
+            const routeParams = FromModelController.routeParamDecorators(normalizedPath);
+            return FromModelController.createRegistration("update", handler, FromModelController.updateDecorators(ModelConstr, modelClazzName, apiProperties, pkPath), [
+                { decorator: DecafBody(), index: 0 },
+                ...routeParams.map(({ decorator, index }) => ({
+                    decorator,
+                    index: index + 1,
+                })),
+            ]);
+        }
+        if (method === "DELETE" && normalizedPath === pkPath) {
+            const routeParams = FromModelController.routeParamDecorators(normalizedPath);
+            return FromModelController.createRegistration("delete", handler, FromModelController.deleteDecorators(ModelConstr, modelClazzName, apiProperties, pkPath), routeParams);
+        }
+        // Composed PK fallback routes (filterEmpty) — path differs from pkPath
+        const fallbackSegments = normalizedPath.split("/").filter(Boolean);
+        const isAllParams = fallbackSegments.length > 0 &&
+            fallbackSegments.every((s) => s.startsWith(":"));
+        if (isAllParams && normalizedPath !== pkPath) {
+            const fallbackApiProps = fallbackSegments
+                .map((s) => s.slice(1))
+                .map((name) => ({
+                name,
+                description: `${name} parameter`,
+                required: true,
+                type: String,
+            }));
+            const suffix = fallbackSegments.map((s) => s.slice(1)).join("And");
+            const routeParams = FromModelController.routeParamDecorators(normalizedPath);
+            if (method === "GET") {
+                return FromModelController.createRegistration(`readBy${suffix}`, handler, FromModelController.readDecorators(ModelConstr, modelClazzName, fallbackApiProps, normalizedPath), routeParams);
             }
-            async read(routeParams) {
-                const { ctx, log } = (await this.logCtx([], OperationKeys.READ, true)).for(this.read);
-                const id = getPK(...routeParams.valuesInOrder);
-                if (typeof id === "undefined")
-                    throw new ValidationError(`No ${this.pk} provided`);
-                let read;
-                try {
-                    log.debug(`reading ${modelClazzName} with ${this.pk} ${id}`);
-                    const persistence = this.persistence(ctx);
-                    read = await persistence.read(id, ctx);
-                }
-                catch (e) {
-                    log.error(`Failed to read ${modelClazzName} with id ${id}`, e);
-                    throw e;
-                }
-                log.info(`read ${modelClazzName} with id ${read[this.pk]}`);
-                return read;
+            if (method === "PUT") {
+                return FromModelController.createRegistration(`updateBy${suffix}`, handler, FromModelController.updateDecorators(ModelConstr, modelClazzName, fallbackApiProps, normalizedPath), [
+                    { decorator: DecafBody(), index: 0 },
+                    ...routeParams.map(({ decorator, index }) => ({
+                        decorator,
+                        index: index + 1,
+                    })),
+                ]);
             }
-            async updateAll(body, resp) {
-                const { ctx, log } = (await this.logCtx([], BulkCrudOperationKeys.UPDATE_ALL, true)).for(this.updateAll);
-                let updated;
-                try {
-                    log.info(`updating ${body.length} ${modelClazzName}`);
-                    updated = await this.persistence(ctx).updateAll(body, ctx);
-                }
-                catch (e) {
-                    log.error(e);
-                    throw e;
-                }
-                ctx.toResponse(resp);
-                return updated;
+            if (method === "DELETE") {
+                return FromModelController.createRegistration(`deleteBy${suffix}`, handler, FromModelController.deleteDecorators(ModelConstr, modelClazzName, fallbackApiProps, normalizedPath), routeParams);
             }
-            async update(routeParams, body, resp) {
-                const { ctx, log } = (await this.logCtx([], OperationKeys.UPDATE, true)).for(this.update);
-                const id = getPK(...routeParams.valuesInOrder);
-                if (typeof id === "undefined")
-                    throw new ValidationError(`No ${this.pk} provided`);
-                let updated;
-                try {
-                    log.info(`updating ${modelClazzName} with ${this.pk} ${id}`);
-                    const payload = JSON.parse(JSON.stringify(body));
-                    const persistence = this.persistence(ctx);
-                    updated = await persistence.update(new ModelConstr({
-                        ...payload,
-                        [this.pk]: id,
-                    }), ctx);
+        }
+        if (method === "GET" && normalizedPath === "statement/:method/*args") {
+            return FromModelController.createRegistration("statement", handler, FromModelController.statementDecorators(ModelConstr, modelClazzName), [
+                { decorator: Param("method"), index: 0 },
+                { decorator: Param("args"), index: 1 },
+                { decorator: DecafQuery(), index: 2 },
+            ]);
+        }
+        if (method === "GET" && normalizedPath === "findOneBy/:key/:value") {
+            return FromModelController.createRegistration("findOneBy", handler, FromModelController.statementShortcutDecorators(ModelConstr, modelClazzName, normalizedPath, PreparedStatementKeys.FIND_ONE_BY), FromModelController.statementShortcutParams(normalizedPath));
+        }
+        const statementRoutes = {
+            "listBy/:key": PreparedStatementKeys.LIST_BY,
+            "paginateBy/:key/:page": PreparedStatementKeys.PAGE_BY,
+            "find/:value": PreparedStatementKeys.FIND,
+            "page/:value": PreparedStatementKeys.PAGE,
+            "findOneBy/:key/:value": PreparedStatementKeys.FIND_ONE_BY,
+            "findBy/:key/:value": PreparedStatementKeys.FIND_BY,
+            "countOf/:field": PreparedStatementKeys.COUNT_OF,
+            "maxOf/:field": PreparedStatementKeys.MAX_OF,
+            "minOf/:field": PreparedStatementKeys.MIN_OF,
+            "avgOf/:field": PreparedStatementKeys.AVG_OF,
+            "sumOf/:field": PreparedStatementKeys.SUM_OF,
+            "distinctOf/:field": PreparedStatementKeys.DISTINCT_OF,
+            "groupOf/:field": PreparedStatementKeys.GROUP_OF,
+        };
+        const statementKey = statementRoutes[normalizedPath];
+        if (statementKey && method === "GET") {
+            return FromModelController.createRegistration(FromModelController.statementMethodName(normalizedPath), handler, FromModelController.statementShortcutDecorators(ModelConstr, modelClazzName, normalizedPath, statementKey), FromModelController.statementShortcutParams(normalizedPath));
+        }
+        if (method === "GET" && normalizedPath.startsWith("query/")) {
+            const queryMethod = normalizedPath.replace(/^query\//, "").split("/")[0];
+            return FromModelController.createRegistration(queryMethod, handler, FromModelController.getQueryDecorators(queryMethod, normalizedPath, "GET", true), FromModelController.complexQueryParams(normalizedPath));
+        }
+        const pathSegments = normalizedPath.split("/").filter(Boolean);
+        const knownPrefixes = new Set([
+            "listBy",
+            "findBy",
+            "findByPaginate",
+            "findOneBy",
+            "paginateBy",
+            "find",
+            "page",
+            "countOf",
+            "maxOf",
+            "minOf",
+            "avgOf",
+            "sumOf",
+            "distinctOf",
+            "groupOf",
+            "statement",
+            "bulk",
+            "query",
+        ]);
+        if (pathSegments.length > 0 &&
+            !normalizedPath.startsWith("query/") &&
+            !normalizedPath.startsWith("statement/") &&
+            !knownPrefixes.has(pathSegments[0])) {
+            const apiPathParams = pathSegments
+                .filter((s) => s.startsWith(":"))
+                .map((s) => s.slice(1))
+                .map((name) => ({
+                name,
+                description: `${name} parameter for the query`,
+                required: true,
+                type: String,
+            }));
+            return FromModelController.createRegistration(methodName, handler, [
+                ...apiPathParams.map((p) => ApiParam(p)),
+                ApiOperation({ summary: `Retrieve records using "${methodName}".` }),
+                ApiOkResponse({ description: "Result successfully retrieved." }),
+                ApiNoContentResponse({
+                    description: "No content returned by the method.",
+                }),
+            ], FromModelController.routeParamDecorators(normalizedPath));
+        }
+        return undefined;
+    }
+    static createRegistration(methodName, handler, decorators, paramDecorators) {
+        return { methodName, handler, decorators, paramDecorators };
+    }
+    static statementMethodName(path) {
+        const firstSegment = path.split("/")[0];
+        return firstSegment;
+    }
+    static statementShortcutParams(path) {
+        const segments = path.split("/").filter((s) => s.startsWith(":"));
+        const params = [];
+        segments.forEach((seg, i) => {
+            const name = seg.replace(":", "");
+            params.push({ decorator: Param(name), index: i });
+        });
+        if (path.startsWith("listBy/") ||
+            path.startsWith("paginateBy/") ||
+            path.startsWith("find/") ||
+            path.startsWith("page/")) {
+            params.push({ decorator: DecafQuery(), index: segments.length });
+        }
+        return params;
+    }
+    static complexQueryParams(path) {
+        const segments = path.split("/").filter((s) => s.startsWith(":"));
+        const params = [];
+        segments.forEach((seg, i) => {
+            const name = seg.replace(":", "");
+            params.push({ decorator: Param(name), index: i });
+        });
+        if (path.startsWith("query/")) {
+            params.push({ decorator: DecafQuery(), index: segments.length });
+        }
+        return params;
+    }
+    static createComplexQueryHandler(methodName) {
+        return async function complexQuery(...args) {
+            const log = this.log?.for?.(complexQuery);
+            try {
+                if (log)
+                    log.debug(`Invoking custom query "${methodName}"`);
+                const { ctx } = (await this.logCtx([], methodName, true)).for(complexQuery);
+                const persistence = this.persistence(ctx);
+                const spreadArgs = FromModelController.normalizeQueryArgs(args);
+                if (persistence?.repo &&
+                    typeof persistence.repo[methodName] === "function") {
+                    return persistence.repo[methodName](...spreadArgs);
                 }
-                catch (e) {
-                    log.error(e);
-                    throw e;
+                if (typeof persistence[methodName] === "function") {
+                    return persistence[methodName](...spreadArgs);
                 }
-                ctx.toResponse(resp);
-                return updated;
-            }
-            async deleteAll(ids, resp) {
-                const { ctx, log } = (await this.logCtx([], BulkCrudOperationKeys.DELETE_ALL, true)).for(this.deleteAll);
-                const normalizedIds = Array.isArray(ids) ? ids : [ids];
-                let read;
-                try {
-                    log.debug(`deleting ${normalizedIds.length} ${modelClazzName}: ${normalizedIds}`);
-                    read = await this.persistence(ctx).deleteAll(normalizedIds, ctx);
+                if (persistence?.query && typeof persistence.query === "function") {
+                    return persistence.query(methodName, ...spreadArgs);
                 }
-                catch (e) {
-                    log.error(`Failed to delete ${modelClazzName} with id ${normalizedIds}`, e);
-                    throw e;
+                if (typeof persistence.statement === "function") {
+                    return persistence.statement(methodName, ...spreadArgs, ctx);
                 }
-                log.info(`deleted ${read.length} ${modelClazzName}`);
-                ctx.toResponse(resp);
-                return read;
+                throw new InternalError(`Persistence method "${methodName}" not found on ${persistence?.constructor?.name}`);
             }
-            async delete(routeParams, resp) {
-                const { ctx, log } = (await this.logCtx([], OperationKeys.DELETE, true)).for(this.delete);
-                const id = getPK(...routeParams.valuesInOrder);
-                if (typeof id === "undefined")
-                    throw new ValidationError(`No ${this.pk} provided`);
-                let del;
-                try {
-                    log.debug(`deleting ${modelClazzName} with ${this.pk} ${id}`);
-                    del = await this.persistence(ctx).delete(id, ctx);
-                }
-                catch (e) {
-                    log.error(`Failed to delete ${modelClazzName} with id ${id}`, e);
-                    throw e;
-                }
-                log.info(`deleted ${modelClazzName} with id ${id}`);
-                ctx.toResponse(resp);
-                return del;
+            catch (e) {
+                if (log)
+                    log.error(`Custom query "${methodName}" failed`, e);
+                throw FromModelController.toDecafError(e, `Custom query "${methodName}" failed`);
             }
         };
-        __decorate([
-            ApiOperationFromModel(ModelConstr, "GET", "listBy/:key"),
-            ApiOperation({ summary: `Retrieve ${modelClazzName} records by query.` }),
-            ApiParam({ name: "key", description: "the model key to sort by" }),
-            ApiQuery({ name: "direction", required: true, enum: OrderDirection }),
-            ApiOkResponse({
-                description: `${modelClazzName} listed successfully.`,
-            }),
-            __param(0, Param("key")),
-            __param(1, DecafQuery()),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [String, Object]),
-            __metadata("design:returntype", Promise)
-        ], DynamicModelController.prototype, "listBy", null);
-        __decorate([
-            ApiOperationFromModel(ModelConstr, "GET", "paginateBy/:key/:page"),
-            ApiOperation({ summary: `Retrieve ${modelClazzName} records by query.` }),
-            ApiParam({ name: "key", description: "the model key to sort by" }),
-            ApiParam({
-                name: "page",
-                description: "the page to retrieve or the bookmark",
-            }),
-            ApiQuery({
-                name: "direction",
-                required: true,
-                enum: OrderDirection,
-                description: "the sort order",
-            }),
-            ApiQuery({ name: "limit", required: true, description: "the page size" }),
-            ApiQuery({ name: "offset", description: "the bookmark when necessary" }),
-            ApiOkResponse({
-                description: `${modelClazzName} listed paginated.`,
-            }),
-            __param(0, Param("key")),
-            __param(1, DecafQuery()),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [String, Object]),
-            __metadata("design:returntype", Promise)
-        ], DynamicModelController.prototype, "paginateBy", null);
-        __decorate([
-            ApiOperationFromModel(ModelConstr, "GET", "find/:value"),
-            ApiOperation({
-                summary: `Find ${modelClazzName} records using the default query attributes.`,
-            }),
-            ApiParam({
-                name: "value",
-                description: "The string to match against the default query attributes",
-            }),
-            ApiQuery({
-                name: "direction",
-                required: false,
-                enum: OrderDirection,
-                description: "the sort order for the matching results",
-            }),
-            ApiOkResponse({
-                description: `${modelClazzName} records matching the provided prefix.`,
-            }),
-            __param(0, Param("value")),
-            __param(1, DecafQuery()),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [String, Object]),
-            __metadata("design:returntype", Promise)
-        ], DynamicModelController.prototype, "find", null);
-        __decorate([
-            ApiOperationFromModel(ModelConstr, "GET", "page/:value"),
-            ApiOperation({
-                summary: `Page ${modelClazzName} records using the default query attributes.`,
-            }),
-            ApiParam({
-                name: "value",
-                description: "The string to match against the default query attributes",
-            }),
-            ApiQuery({
-                name: "direction",
-                required: false,
-                enum: OrderDirection,
-                description: "the sort order for the paged results",
-            }),
-            ApiQuery({
-                name: "limit",
-                required: false,
-                description: "page size",
-            }),
-            ApiQuery({
-                name: "offset",
-                required: false,
-                description: "page number",
-            }),
-            ApiQuery({
-                name: "bookmark",
-                required: false,
-                description: "bookmark for cursor pagination",
-            }),
-            ApiOkResponse({
-                description: `${modelClazzName} records paged by the provided prefix.`,
-            }),
-            __param(0, Param("value")),
-            __param(1, DecafQuery()),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [String, Object]),
-            __metadata("design:returntype", Promise)
-        ], DynamicModelController.prototype, "page", null);
-        __decorate([
-            ApiOperationFromModel(ModelConstr, "GET", "findOneBy/:key"),
-            ApiOperation({ summary: `Retrieve ${modelClazzName} records by query.` }),
-            ApiParam({ name: "key", description: "the model key to sort by" }),
-            ApiOkResponse({
-                description: `${modelClazzName} listed found.`,
-            }),
-            ApiNotFoundResponse({
-                description: `No ${modelClazzName} record matches the provided identifier.`,
-            }),
-            __param(0, Param("key")),
-            __param(1, Param("value")),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [String, Object]),
-            __metadata("design:returntype", Promise)
-        ], DynamicModelController.prototype, "findOneBy", null);
-        __decorate([
-            ApiOperationFromModel(ModelConstr, "GET", "findBy/:key/:value"),
-            ApiOperation({ summary: `Retrieve ${modelClazzName} records by query.` }),
-            ApiParam({ name: "key", description: "the model key to compare" }),
-            ApiParam({ name: "value", description: "the value to match" }),
-            ApiQuery({
-                name: "direction",
-                required: true,
-                enum: OrderDirection,
-                description: "the sort order when  applicable",
-            }),
-            ApiOkResponse({
-                description: `${modelClazzName} listed found.`,
-            }),
-            ApiNotFoundResponse({
-                description: `No ${modelClazzName} record matches the provided identifier.`,
-            }),
-            __param(0, Param("key")),
-            __param(1, Param("value")),
-            __param(2, DecafQuery()),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [String, Object, Object]),
-            __metadata("design:returntype", Promise)
-        ], DynamicModelController.prototype, "findBy", null);
-        __decorate([
-            ApiOperationFromModel(ModelConstr, "GET", "statement/:method/*args"),
-            ApiOperation({
-                summary: `Executes a prepared statement on ${modelClazzName}.`,
-            }),
-            ApiParam({
-                name: "method",
-                description: "the prepared statement to execute",
-            }),
-            ApiParam({
-                name: "args",
-                description: "concatenated list of arguments the prepared statement can accept",
-            }),
-            ApiQuery({
-                name: "direction",
-                required: true,
-                enum: OrderDirection,
-                description: "the sort order when  applicable",
-            }),
-            ApiQuery({
-                name: "limit",
-                required: true,
-                description: "limit or page size when applicable",
-            }),
-            ApiQuery({
-                name: "offset",
-                required: true,
-                description: "offset or bookmark when applicable",
-            }),
-            ApiOkResponse({
-                description: `${modelClazzName} listed found.`,
-            }),
-            ApiNotFoundResponse({
-                description: `No ${modelClazzName} record matches the provided identifier.`,
-            }),
-            __param(0, Param("method")),
-            __param(1, Param("args")),
-            __param(2, DecafQuery()),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [String, Array, Object]),
-            __metadata("design:returntype", Promise)
-        ], DynamicModelController.prototype, "statement", null);
-        __decorate([
-            ApiOperationFromModel(ModelConstr, "POST", "bulk"),
+    }
+    static extractQueryArgs(args) {
+        if (args.length === 0)
+            return args;
+        const last = args[args.length - 1];
+        if (last && typeof last === "object" && !Array.isArray(last)) {
+            const queryObj = args.pop();
+            const hasDirection = queryObj.direction !== undefined;
+            const hasLimit = queryObj.limit !== undefined;
+            const hasOffset = queryObj.offset !== undefined;
+            if (!hasDirection && !hasLimit && !hasOffset)
+                return args;
+            const extras = [];
+            if (hasDirection)
+                extras.push(queryObj.direction);
+            else if (hasLimit || hasOffset)
+                extras.push(undefined);
+            if (hasLimit)
+                extras.push(queryObj.limit);
+            if (hasOffset)
+                extras.push(queryObj.offset);
+            return [...args, ...extras];
+        }
+        return args;
+    }
+    static normalizeQueryArgs(args) {
+        const normalized = FromModelController.extractQueryArgs(args);
+        if (normalized.length === 0)
+            return normalized;
+        const last = normalized[normalized.length - 1];
+        if (!last || typeof last !== "object" || Array.isArray(last)) {
+            return normalized;
+        }
+        const queryObj = last;
+        const hasQueryFields = queryObj.direction !== undefined ||
+            queryObj.limit !== undefined ||
+            queryObj.offset !== undefined ||
+            queryObj.bookmark !== undefined;
+        if (!hasQueryFields) {
+            normalized.pop();
+            return normalized;
+        }
+        normalized.pop();
+        if (queryObj.direction !== undefined)
+            normalized.push(queryObj.direction);
+        if (queryObj.limit !== undefined)
+            normalized.push(queryObj.limit);
+        if (queryObj.offset !== undefined)
+            normalized.push(queryObj.offset);
+        if (queryObj.bookmark !== undefined)
+            normalized.push(queryObj.bookmark);
+        return normalized;
+    }
+    static createCreateDecorators(ModelConstr, modelClazzName) {
+        return [
+            ApiOperationFromModel(ModelConstr, "POST"),
             ApiOperation({ summary: `Create a new ${modelClazzName}.` }),
             ApiBody({
                 description: `Payload for ${modelClazzName}`,
-                schema: {
-                    type: "array",
-                    items: {
-                        $ref: getSchemaPath(ModelConstr),
-                        // $ref: getSchemaPath(DtoFor(OperationKeys.CREATE, ModelConstr)),
-                    },
-                },
+                type: DtoFor(OperationKeys.CREATE, ModelConstr),
             }),
             ApiCreatedResponse({
                 description: `${modelClazzName} created successfully.`,
-                schema: {
-                    type: "array",
-                    items: {
-                        $ref: getSchemaPath(ModelConstr),
-                    },
-                },
+                schema: { $ref: getSchemaPath(ModelConstr) },
             }),
             ApiBadRequestResponse({ description: "Payload validation failed." }),
             ApiUnprocessableEntityResponse({
                 description: "Repository rejected the provided payload.",
             }),
-            __param(0, DecafBody()),
-            __param(1, Response({ passthrough: true })),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [Array, Object]),
-            __metadata("design:returntype", Promise)
-        ], DynamicModelController.prototype, "createAll", null);
-        __decorate([
-            ApiOperationFromModel(ModelConstr, "POST"),
+        ];
+    }
+    static bulkCreateDecorators(ModelConstr, modelClazzName) {
+        return [
+            ApiOperationFromModel(ModelConstr, "POST", "bulk"),
             ApiOperation({ summary: `Create a new ${modelClazzName}.` }),
             ApiBody({
                 description: `Payload for ${modelClazzName}`,
-                type: DtoFor(OperationKeys.CREATE, ModelConstr),
+                schema: {
+                    type: "array",
+                    items: { $ref: getSchemaPath(ModelConstr) },
+                },
             }),
             ApiCreatedResponse({
                 description: `${modelClazzName} created successfully.`,
                 schema: {
-                    $ref: getSchemaPath(ModelConstr),
+                    type: "array",
+                    items: { $ref: getSchemaPath(ModelConstr) },
                 },
             }),
             ApiBadRequestResponse({ description: "Payload validation failed." }),
             ApiUnprocessableEntityResponse({
                 description: "Repository rejected the provided payload.",
             }),
-            __param(0, DecafBody()),
-            __param(1, Response({ passthrough: true })),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [Object, Object]),
-            __metadata("design:returntype", Promise)
-        ], DynamicModelController.prototype, "create", null);
-        __decorate([
+        ];
+    }
+    static bulkReadDecorators(ModelConstr, modelClazzName) {
+        return [
             ApiOperationFromModel(ModelConstr, "GET", "bulk"),
-            ApiOperation({ summary: `Retrieve a ${modelClazzName} record by id.` }),
+            ApiOperation({ summary: `Retrieve ${modelClazzName} records by ids.` }),
             ApiQuery({ name: "ids", required: true, type: "array" }),
             ApiOkResponse({
                 description: `${modelClazzName} retrieved successfully.`,
                 schema: {
                     type: "array",
-                    items: {
-                        $ref: getSchemaPath(ModelConstr),
-                    },
-                },
-            }),
-            ApiNotFoundResponse({
-                description: `No ${modelClazzName} record matches the provided identifier.`,
-            }),
-            __param(0, Query("ids")),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [Array]),
-            __metadata("design:returntype", Promise)
-        ], DynamicModelController.prototype, "readAll", null);
-        __decorate([
-            ApiOperationFromModel(ModelConstr, "GET", path),
-            ApiParamsFromModel(apiProperties),
-            ApiOperation({ summary: `Retrieve a ${modelClazzName} record by id.` }),
-            ApiOkResponse({
-                description: `${modelClazzName} retrieved successfully.`,
-                schema: {
-                    $ref: getSchemaPath(ModelConstr),
+                    items: { $ref: getSchemaPath(ModelConstr) },
                 },
             }),
             ApiNotFoundResponse({
                 description: `No ${modelClazzName} record matches the provided identifier.`,
             }),
-            __param(0, DecafParams(apiProperties)),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [Object]),
-            __metadata("design:returntype", Promise)
-        ], DynamicModelController.prototype, "read", null);
-        __decorate([
-            ApiOperationFromModel(ModelConstr, "PUT", `bulk`),
+        ];
+    }
+    static bulkUpdateDecorators(ModelConstr, modelClazzName, apiProperties) {
+        return [
+            ApiOperationFromModel(ModelConstr, "PUT", "bulk"),
             ApiParamsFromModel(apiProperties),
             ApiOperation({
-                summary: `Replace an existing ${modelClazzName} record with a new payload.`,
+                summary: `Replace existing ${modelClazzName} records with new payloads.`,
             }),
             ApiBody({
-                description: `Payload for replace a existing record of ${modelClazzName}`,
+                description: `Payload for replacing existing records of ${modelClazzName}`,
                 schema: {
                     type: "array",
                     $ref: getSchemaPath(DtoFor(OperationKeys.UPDATE, ModelConstr)),
@@ -842,123 +581,210 @@ export class FromModelController {
                 description: `${modelClazzName} updated successfully.`,
                 schema: {
                     type: "array",
-                    items: {
-                        $ref: getSchemaPath(ModelConstr),
-                    },
+                    items: { $ref: getSchemaPath(ModelConstr) },
                 },
             }),
             ApiNotFoundResponse({
                 description: `No ${modelClazzName} record matches the provided identifier.`,
             }),
             ApiBadRequestResponse({ description: "Payload validation failed." }),
-            __param(0, DecafBody()),
-            __param(1, Response({ passthrough: true })),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [Array, Object]),
-            __metadata("design:returntype", Promise)
-        ], DynamicModelController.prototype, "updateAll", null);
-        __decorate([
-            ApiOperationFromModel(ModelConstr, "PUT", path),
+        ];
+    }
+    static bulkDeleteDecorators(ModelConstr, modelClazzName, apiProperties) {
+        return [
+            ApiOperationFromModel(ModelConstr, "DELETE", "bulk"),
+            ApiParamsFromModel(apiProperties),
+            ApiOperation({ summary: `Delete ${modelClazzName} records by ids.` }),
+            ApiQuery({ name: "ids", required: true, type: "array" }),
+            ApiOkResponse({
+                description: `${modelClazzName} deleted successfully.`,
+                schema: {
+                    type: "array",
+                    items: { $ref: getSchemaPath(ModelConstr) },
+                },
+            }),
+            ApiNotFoundResponse({
+                description: `No ${modelClazzName} record matches the provided identifier.`,
+            }),
+        ];
+    }
+    static readDecorators(ModelConstr, modelClazzName, apiProperties, pkPath) {
+        return [
+            ApiOperationFromModel(ModelConstr, "GET", pkPath),
+            ApiParamsFromModel(apiProperties),
+            ApiOperation({ summary: `Retrieve a ${modelClazzName} record by id.` }),
+            ApiOkResponse({
+                description: `${modelClazzName} retrieved successfully.`,
+                schema: { $ref: getSchemaPath(ModelConstr) },
+            }),
+            ApiNotFoundResponse({
+                description: `No ${modelClazzName} record matches the provided identifier.`,
+            }),
+        ];
+    }
+    static updateDecorators(ModelConstr, modelClazzName, apiProperties, pkPath) {
+        return [
+            ApiOperationFromModel(ModelConstr, "PUT", pkPath),
             ApiParamsFromModel(apiProperties),
             ApiOperation({
                 summary: `Replace an existing ${modelClazzName} record with a new payload.`,
             }),
             ApiBody({
-                description: `Payload for replace a existing record of ${modelClazzName}`,
+                description: `Payload for replacing an existing record of ${modelClazzName}`,
                 type: DtoFor(OperationKeys.UPDATE, ModelConstr),
             }),
             ApiOkResponse({
                 description: `${modelClazzName} updated successfully.`,
-                schema: {
-                    $ref: getSchemaPath(ModelConstr),
-                },
+                schema: { $ref: getSchemaPath(ModelConstr) },
             }),
             ApiNotFoundResponse({
                 description: `No ${modelClazzName} record matches the provided identifier.`,
             }),
             ApiBadRequestResponse({ description: "Payload validation failed." }),
-            __param(0, DecafParams(apiProperties)),
-            __param(1, DecafBody()),
-            __param(2, Response({ passthrough: true })),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [Object, Object, Object]),
-            __metadata("design:returntype", Promise)
-        ], DynamicModelController.prototype, "update", null);
-        __decorate([
-            ApiOperationFromModel(ModelConstr, "DELETE", "bulk"),
+        ];
+    }
+    static deleteDecorators(ModelConstr, modelClazzName, apiProperties, pkPath) {
+        return [
+            ApiOperationFromModel(ModelConstr, "DELETE", pkPath),
             ApiParamsFromModel(apiProperties),
-            ApiOperation({ summary: `Retrieve a ${modelClazzName} record by id.` }),
-            ApiQuery({ name: "ids", required: true, type: "array" }),
+            ApiOperation({ summary: `Delete a ${modelClazzName} record by id.` }),
             ApiOkResponse({
                 description: `${modelClazzName} deleted successfully.`,
-                schema: {
-                    type: "array",
-                    items: {
-                        $ref: getSchemaPath(ModelConstr),
-                    },
-                },
+                schema: { $ref: getSchemaPath(ModelConstr) },
             }),
             ApiNotFoundResponse({
                 description: `No ${modelClazzName} record matches the provided identifier.`,
             }),
-            __param(0, Query("ids")),
-            __param(1, Response({ passthrough: true })),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [Array, Object]),
-            __metadata("design:returntype", Promise)
-        ], DynamicModelController.prototype, "deleteAll", null);
-        __decorate([
-            ApiOperationFromModel(ModelConstr, "DELETE", path),
-            ApiParamsFromModel(apiProperties),
-            ApiOperation({ summary: `Delete a ${modelClazzName} record by id.` }),
-            ApiOkResponse({
-                description: `${modelClazzName} deleted successfully.`,
-                schema: {
-                    $ref: getSchemaPath(ModelConstr),
-                },
+        ];
+    }
+    static statementDecorators(ModelConstr, modelClazzName) {
+        return [
+            ApiOperationFromModel(ModelConstr, "GET", "statement/:method/*args"),
+            ApiOperation({
+                summary: `Executes a prepared statement on ${modelClazzName}.`,
+            }),
+            ApiParam({
+                name: "method",
+                description: "the prepared statement to execute",
+            }),
+            ApiParam({
+                name: "args",
+                description: "concatenated list of arguments the prepared statement can accept",
+            }),
+            ApiQuery({
+                name: "direction",
+                required: true,
+                enum: OrderDirection,
+                description: "the sort order when applicable",
             }),
+            ApiQuery({
+                name: "limit",
+                required: true,
+                description: "limit or page size when applicable",
+            }),
+            ApiQuery({
+                name: "offset",
+                required: true,
+                description: "offset or bookmark when applicable",
+            }),
+            ApiOkResponse({ description: `${modelClazzName} listed found.` }),
             ApiNotFoundResponse({
                 description: `No ${modelClazzName} record matches the provided identifier.`,
             }),
-            __param(0, DecafParams(apiProperties)),
-            __param(1, Response({ passthrough: true })),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [Object, Object]),
-            __metadata("design:returntype", Promise)
-        ], DynamicModelController.prototype, "delete", null);
-        DynamicModelController = __decorate([
-            Controller(routePath),
-            ApiTags(modelClazzName),
-            ApiExtraModels(ModelConstr),
-            Auth(ModelConstr),
-            __metadata("design:paramtypes", [DecafRequestContext])
-        ], DynamicModelController);
-        return DynamicModelController;
+        ];
     }
-    static getRouteParametersFromModel(ModelClazz) {
-        const pk = Model.pk(ModelClazz);
-        const composed = Metadata.get(ModelClazz, Metadata.key(DBKeys.COMPOSED, pk));
-        const composedKeys = composed?.args ?? [];
-        // remove duplicates while preserving order
-        const uniqueKeys = Array.isArray(composedKeys) && composedKeys.length > 0
-            ? Array.from(new Set([...composedKeys]))
-            : Array.from(new Set([pk]));
-        const description = Metadata.description(ModelClazz);
-        const path = `:${uniqueKeys.join("/:")}`;
-        const apiProperties = uniqueKeys.map((key) => {
-            return {
-                name: key,
-                description: Metadata.description(ModelClazz, key),
-                required: true,
-                type: String,
-            };
+    static statementShortcutDecorators(ModelConstr, modelClazzName, path, statementKey) {
+        const base = [
+            ApiOperationFromModel(ModelConstr, "GET", path),
+            ApiOperation({ summary: `Retrieve ${modelClazzName} records.` }),
+            ApiOkResponse({
+                description: `${modelClazzName} retrieved successfully.`,
+            }),
+        ];
+        const segments = path.split("/").filter((s) => s.startsWith(":"));
+        segments.forEach((seg) => {
+            const name = seg.replace(":", "");
+            base.push(ApiParam({ name, description: `The ${name} parameter` }));
         });
-        return {
-            path,
-            description,
-            apiProperties,
-            getPK: (...params) => composed?.separator ? params.join(composed.separator) : params.join(""),
-        };
+        if (path.startsWith("listBy/") ||
+            path.startsWith("paginateBy/") ||
+            path.startsWith("find/") ||
+            path.startsWith("page/")) {
+            base.push(ApiQuery({
+                name: "direction",
+                required: true,
+                enum: OrderDirection,
+                description: "the sort order",
+            }));
+        }
+        if (path.startsWith("paginateBy/") || path.startsWith("page/")) {
+            base.push(ApiQuery({ name: "limit", required: false, description: "page size" }), ApiQuery({
+                name: "offset",
+                required: false,
+                description: "page number",
+            }), ApiQuery({
+                name: "bookmark",
+                required: false,
+                description: "bookmark for cursor pagination",
+            }));
+        }
+        if (path.startsWith("findOneBy/") || path.startsWith("findBy/")) {
+            base.push(ApiNotFoundResponse({
+                description: `No ${modelClazzName} record matches the provided identifier.`,
+            }));
+        }
+        if (statementKey === PreparedStatementKeys.COUNT_OF ||
+            statementKey === PreparedStatementKeys.AVG_OF ||
+            statementKey === PreparedStatementKeys.SUM_OF) {
+            base.push(ApiOkResponse({
+                description: `Result for ${modelClazzName}.`,
+                type: Number,
+            }));
+        }
+        if (statementKey === PreparedStatementKeys.DISTINCT_OF) {
+            base.push(ApiOkResponse({
+                description: `Distinct values for ${modelClazzName}.`,
+                type: [String],
+            }));
+        }
+        return base;
+    }
+    static getQueryDecorators(methodName, routePath, httpVerb, includeQueryParams = false) {
+        const extractPathParams = (p) => p
+            .split("/")
+            .filter((s) => s.startsWith(":"))
+            .map((s) => s.slice(1));
+        const apiPathParams = extractPathParams(routePath).map((name) => ({
+            name,
+            description: `${name} parameter for the query`,
+            required: true,
+            type: String,
+        }));
+        const decorators = [
+            ...apiPathParams.map((p) => ApiParam(p)),
+            ApiOperation({ summary: `Retrieve records using "${methodName}".` }),
+            ApiOkResponse({ description: "Result successfully retrieved." }),
+            ApiNoContentResponse({
+                description: "No content returned by the method.",
+            }),
+        ];
+        if (httpVerb === "GET" && includeQueryParams) {
+            decorators.push(ApiQuery({
+                name: "direction",
+                required: false,
+                enum: OrderDirection,
+                description: "the sort order when applicable",
+            }), ApiQuery({
+                name: "limit",
+                required: false,
+                description: "limit or page size",
+            }), ApiQuery({
+                name: "offset",
+                required: false,
+                description: "offset or bookmark",
+            }));
+        }
+        return decorators;
     }
 }
 //# sourceMappingURL=FromModelController.js.map