@decaf-ts/for-nest 0.11.1 → 0.11.2-refactor.2

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

@@ -7,73 +7,24 @@ 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 { Metadata } from "@decaf-ts/decoration";
 import { ApiOperationFromModel, ApiParamsFromModel, DecafBody, DecafParams, 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 getPersistence(ModelClazz) {
@@ -83,20 +34,17 @@ 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.");
@@ -106,733 +54,700 @@ export class FromModelController {
             }
         }
         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;
-                }
-                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;
+        };
+        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 registration = FromModelController.matchRoute(route, pkPath, apiProperties, getPK, ModelConstr, modelClazzName, factoryPersistence);
+                if (!registration)
+                    continue;
+                const { methodName, handler, decorators, paramDecorators } = registration;
+                const descriptor = FromModelController.defineMethod(DynamicModelController, methodName, handler);
+                if (descriptor) {
+                    const httpDecorator = HttpVerbToDecorator(route.method)(route.path.replace(/^\/+|\/+$/g, "") || undefined);
+                    FromModelController.applyDecorators(DynamicModelController, methodName, [httpDecorator, ...decorators], paramDecorators);
                 }
-                log.info(`created new ${modelClazzName} with id ${created[this.pk]}`);
+            }
+        }
+        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 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(route, pkPath, apiProperties, getPK, ModelConstr, modelClazzName, persistence) {
+        const { method, path } = route;
+        const normalizedPath = path.replace(/^\/+|\/+$/g, "");
+        if (method === "POST" && normalizedPath === "") {
+            return FromModelController.createRegistration("create", FromModelController.createCreateHandler(ModelConstr, modelClazzName), FromModelController.createCreateDecorators(ModelConstr, modelClazzName), [{ decorator: DecafBody(), index: 0 }, { decorator: Response({ passthrough: true }), index: 1 }]);
+        }
+        if (method === "POST" && normalizedPath === "bulk") {
+            return FromModelController.createRegistration("createAll", FromModelController.createBulkCreateHandler(ModelConstr, modelClazzName), FromModelController.bulkCreateDecorators(ModelConstr, modelClazzName), [{ decorator: DecafBody(), index: 0 }, { decorator: Response({ passthrough: true }), index: 1 }]);
+        }
+        if (method === "GET" && normalizedPath === "bulk") {
+            return FromModelController.createRegistration("readAll", FromModelController.createBulkReadHandler(modelClazzName), FromModelController.bulkReadDecorators(ModelConstr, modelClazzName), [{ decorator: Query("ids"), index: 0 }]);
+        }
+        if (method === "PUT" && normalizedPath === "bulk") {
+            return FromModelController.createRegistration("updateAll", FromModelController.createBulkUpdateHandler(modelClazzName), FromModelController.bulkUpdateDecorators(ModelConstr, modelClazzName, apiProperties), [{ decorator: DecafBody(), index: 0 }, { decorator: Response({ passthrough: true }), index: 1 }]);
+        }
+        if (method === "DELETE" && normalizedPath === "bulk") {
+            return FromModelController.createRegistration("deleteAll", FromModelController.createBulkDeleteHandler(modelClazzName), 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", FromModelController.createReadHandler(getPK, modelClazzName), FromModelController.readDecorators(ModelConstr, modelClazzName, apiProperties, pkPath), [{ decorator: DecafParams(apiProperties), index: 0 }]);
+        }
+        if (method === "PUT" && normalizedPath === pkPath) {
+            return FromModelController.createRegistration("update", FromModelController.createUpdateHandler(getPK, ModelConstr, modelClazzName), FromModelController.updateDecorators(ModelConstr, modelClazzName, apiProperties, pkPath), [
+                { decorator: DecafParams(apiProperties), index: 0 },
+                { decorator: DecafBody(), index: 1 },
+                { decorator: Response({ passthrough: true }), index: 2 },
+            ]);
+        }
+        if (method === "DELETE" && normalizedPath === pkPath) {
+            return FromModelController.createRegistration("delete", FromModelController.createDeleteHandler(getPK, modelClazzName), FromModelController.deleteDecorators(ModelConstr, modelClazzName, apiProperties, pkPath), [
+                { decorator: DecafParams(apiProperties), index: 0 },
+                { decorator: Response({ passthrough: true }), index: 1 },
+            ]);
+        }
+        // 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");
+            if (method === "GET") {
+                return FromModelController.createRegistration(`readBy${suffix}`, FromModelController.createReadHandler(getPK, modelClazzName), FromModelController.readDecorators(ModelConstr, modelClazzName, fallbackApiProps, normalizedPath), [{ decorator: DecafParams(fallbackApiProps), index: 0 }]);
+            }
+            if (method === "PUT") {
+                return FromModelController.createRegistration(`updateBy${suffix}`, FromModelController.createUpdateHandler(getPK, ModelConstr, modelClazzName), FromModelController.updateDecorators(ModelConstr, modelClazzName, fallbackApiProps, normalizedPath), [
+                    { decorator: DecafParams(fallbackApiProps), index: 0 },
+                    { decorator: DecafBody(), index: 1 },
+                    { decorator: Response({ passthrough: true }), index: 2 },
+                ]);
+            }
+            if (method === "DELETE") {
+                return FromModelController.createRegistration(`deleteBy${suffix}`, FromModelController.createDeleteHandler(getPK, modelClazzName), FromModelController.deleteDecorators(ModelConstr, modelClazzName, fallbackApiProps, normalizedPath), [
+                    { decorator: DecafParams(fallbackApiProps), index: 0 },
+                    { decorator: Response({ passthrough: true }), index: 1 },
+                ]);
+            }
+        }
+        if (method === "GET" && normalizedPath === "statement/:method/*args") {
+            return FromModelController.createRegistration("statement", FromModelController.createStatementHandler(modelClazzName), FromModelController.statementDecorators(ModelConstr, modelClazzName), [
+                { decorator: Param("method"), index: 0 },
+                { decorator: Param("args"), index: 1 },
+                { decorator: DecafQuery(), index: 2 },
+            ]);
+        }
+        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), FromModelController.createStatementShortcutHandler(statementKey, modelClazzName), 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, FromModelController.createComplexQueryHandler(queryMethod), FromModelController.getQueryDecorators(queryMethod, normalizedPath, "GET", true), FromModelController.complexQueryParams(normalizedPath));
+        }
+        // Fallback for custom @route() paths (e.g. "metadata/for-product/:productCode")
+        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/") &&
+            !knownPrefixes.has(pathSegments[0])) {
+            // Look up the actual method name from @route metadata by matching the path.
+            // The @route decorator stores { path, httpMethod, handler } keyed by method name
+            // on the repository constructor.
+            const routeMetadata = Metadata.get(persistence?.constructor, Metadata.key(DECAF_ROUTE)) ?? {};
+            const matchedEntry = Object.entries(routeMetadata).find(([, info]) => info &&
+                typeof info === "object" &&
+                info.path?.replace(/^\/+|\/+$/g, "") === normalizedPath);
+            const actualMethodName = matchedEntry?.[0] || pathSegments[0];
+            const paramSegments = pathSegments.filter((s) => s.startsWith(":"));
+            const apiPathParams = paramSegments.map((s) => s.slice(1)).map((name) => ({
+                name,
+                description: `${name} parameter for the query`,
+                required: true,
+                type: String,
+            }));
+            return FromModelController.createRegistration(actualMethodName, FromModelController.createCustomRouteHandler(actualMethodName), [
+                ...apiPathParams.map((p) => ApiParam(p)),
+                ApiOperation({ summary: `Retrieve records using "${actualMethodName}".` }),
+                ApiOkResponse({ description: "Result successfully retrieved." }),
+                ApiNoContentResponse({ description: "No content returned by the method." }),
+            ], FromModelController.complexQueryParams(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 createCreateHandler(ModelConstr, modelClazzName) {
+        return async function create(data, resp) {
+            const { ctx, log } = (await this.logCtx([], OperationKeys.CREATE, true)).for(create);
+            log.verbose(`creating new ${modelClazzName}`);
+            let created;
+            try {
+                created = await this.persistence(ctx).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]}`);
+            if (resp)
                 ctx.toResponse(resp);
-                return created;
+            return created;
+        };
+    }
+    static createBulkCreateHandler(ModelConstr, modelClazzName) {
+        return async function createAll(data, resp) {
+            const { ctx, log } = (await this.logCtx([], BulkCrudOperationKeys.CREATE_ALL, true)).for(createAll);
+            log.verbose(`creating new ${modelClazzName}`);
+            let created;
+            try {
+                created = await this.persistence(ctx).createAll(data.map((d) => new ModelConstr(d)), ctx);
             }
-            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]}`);
+            catch (e) {
+                log.error(`Failed to create new ${modelClazzName}`, e);
+                throw e;
+            }
+            log.info(`created new ${modelClazzName} with id ${created[this.pk]}`);
+            if (resp)
                 ctx.toResponse(resp);
-                return created;
-            }
-            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);
+            return created;
+        };
+    }
+    static createBulkReadHandler(modelClazzName) {
+        return async function readAll(ids) {
+            const { ctx, log } = (await this.logCtx([], BulkCrudOperationKeys.READ_ALL, true)).for(readAll);
+            const normalizedIds = Array.isArray(ids) ? ids : [ids];
+            let read;
+            try {
+                log.debug(`reading ${normalizedIds} ${modelClazzName}`);
+                read = await this.persistence(ctx).readAll(normalizedIds, ctx);
+            }
+            catch (e) {
+                log.error(`Failed to read ${modelClazzName}`, e);
+                throw e;
+            }
+            log.info(`read ${read.length} ${modelClazzName}`);
+            return read;
+        };
+    }
+    static createBulkUpdateHandler(modelClazzName) {
+        return async function updateAll(body, resp) {
+            const { ctx, log } = (await this.logCtx([], BulkCrudOperationKeys.UPDATE_ALL, true)).for(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;
+            }
+            if (resp)
+                ctx.toResponse(resp);
+            return updated;
+        };
+    }
+    static createBulkDeleteHandler(modelClazzName) {
+        return async function deleteAll(ids, resp) {
+            const { ctx, log } = (await this.logCtx([], BulkCrudOperationKeys.DELETE_ALL, true)).for(deleteAll);
+            const normalizedIds = Array.isArray(ids) ? ids : [ids];
+            let read;
+            try {
+                log.debug(`deleting ${normalizedIds.length} ${modelClazzName}`);
+                read = await this.persistence(ctx).deleteAll(normalizedIds, ctx);
+            }
+            catch (e) {
+                log.error(`Failed to delete ${modelClazzName}`, e);
+                throw e;
+            }
+            log.info(`deleted ${read.length} ${modelClazzName}`);
+            if (resp)
+                ctx.toResponse(resp);
+            return read;
+        };
+    }
+    static createReadHandler(getPK, modelClazzName) {
+        return async function read(routeParams) {
+            const { ctx, log } = (await this.logCtx([], OperationKeys.READ, true)).for(read);
+            const id = getPK(...routeParams.valuesInOrder);
+            if (typeof id === "undefined")
+                throw new ValidationError(`No ${this.pk} provided`);
+            let readResult;
+            try {
+                log.debug(`reading ${modelClazzName} with ${this.pk} ${id}`);
+                readResult = await this.persistence(ctx).read(id, ctx);
+            }
+            catch (e) {
+                log.error(`Failed to read ${modelClazzName} with id ${id}`, e);
+                throw e;
+            }
+            log.info(`read ${modelClazzName} with id ${readResult[this.pk]}`);
+            return readResult;
+        };
+    }
+    static createUpdateHandler(getPK, ModelConstr, modelClazzName) {
+        return async function update(routeParams, body, resp) {
+            const { ctx, log } = (await this.logCtx([], OperationKeys.UPDATE, true)).for(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));
+                updated = await this.persistence(ctx).update(new ModelConstr({ ...payload, [this.pk]: id }), ctx);
+            }
+            catch (e) {
+                log.error(e);
+                throw e;
+            }
+            if (resp)
+                ctx.toResponse(resp);
+            return updated;
+        };
+    }
+    static createDeleteHandler(getPK, modelClazzName) {
+        return async function remove(routeParams, resp) {
+            const { ctx, log } = (await this.logCtx([], OperationKeys.DELETE, true)).for(remove);
+            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}`);
+            if (resp)
+                ctx.toResponse(resp);
+            return del;
+        };
+    }
+    static createStatementHandler(modelClazzName) {
+        return async function statement(name, args, details) {
+            const { ctx } = (await this.logCtx([], PersistenceKeys.STATEMENT, true)).for(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, offset, 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:
+                    break;
+            }
+            return this.persistence(ctx).statement(name, ...args, ctx);
+        };
+    }
+    static createStatementShortcutHandler(statementKey, modelClazzName) {
+        return async function statementShortcut(...args) {
+            const { ctx } = (await this.logCtx([], statementKey, true)).for(statementShortcut);
+            switch (statementKey) {
+                case PreparedStatementKeys.LIST_BY: {
+                    const [key, details] = args;
+                    return this.persistence(ctx).listBy(key, details?.direction, ctx);
                 }
-                catch (e) {
-                    log.error(`Failed to ${modelClazzName} with id ${normalizedIds}`, e);
-                    throw e;
+                case PreparedStatementKeys.PAGE_BY: {
+                    const [key, page, details] = args;
+                    return this.persistence(ctx).paginateBy(key, details?.direction, {
+                        limit: details?.limit,
+                        offset: details?.offset,
+                        page,
+                    }, ctx);
                 }
-                log.info(`read ${read.length} ${modelClazzName}`);
-                return read;
-            }
-            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}`);
+                case PreparedStatementKeys.FIND: {
+                    const [value, details] = args;
+                    const direction = details?.direction ?? OrderDirection.ASC;
                     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;
-            }
-            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;
+                    if (typeof persistence.find === "function")
+                        return persistence.find(value, direction, ctx);
+                    return persistence.statement(PreparedStatementKeys.FIND, value, direction, ctx);
                 }
-                ctx.toResponse(resp);
-                return updated;
-            }
-            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));
+                case PreparedStatementKeys.PAGE: {
+                    const [value, details] = args;
+                    const ref = {
+                        offset: details?.offset ?? 1,
+                        limit: details?.limit ?? 10,
+                        bookmark: details?.bookmark,
+                    };
                     const persistence = this.persistence(ctx);
-                    updated = await persistence.update(new ModelConstr({
-                        ...payload,
-                        [this.pk]: id,
-                    }), ctx);
-                }
-                catch (e) {
-                    log.error(e);
-                    throw e;
+                    const direction = details?.direction ?? OrderDirection.ASC;
+                    if (typeof persistence.page === "function")
+                        return persistence.page(value, direction, ref, ctx);
+                    return persistence.statement(PreparedStatementKeys.PAGE, value, direction, ref, ctx);
                 }
-                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);
+                case PreparedStatementKeys.FIND_ONE_BY: {
+                    const [key, value] = args;
+                    return this.persistence(ctx).findOneBy(key, value, ctx);
                 }
-                catch (e) {
-                    log.error(`Failed to delete ${modelClazzName} with id ${normalizedIds}`, e);
-                    throw e;
+                case PreparedStatementKeys.FIND_BY: {
+                    const [key, value] = args;
+                    return this.persistence(ctx)
+                        .for(ctx.toOverrides())
+                        .findBy(key, value, ctx);
                 }
-                log.info(`deleted ${read.length} ${modelClazzName}`);
-                ctx.toResponse(resp);
-                return read;
-            }
-            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);
+                default:
+                    if (statementKey === PreparedStatementKeys.COUNT_OF ||
+                        statementKey === PreparedStatementKeys.MAX_OF ||
+                        statementKey === PreparedStatementKeys.MIN_OF ||
+                        statementKey === PreparedStatementKeys.AVG_OF ||
+                        statementKey === PreparedStatementKeys.SUM_OF ||
+                        statementKey === PreparedStatementKeys.DISTINCT_OF ||
+                        statementKey === PreparedStatementKeys.GROUP_OF) {
+                        const [field] = args;
+                        return this.persistence(ctx).statement(statementKey, field, ctx);
+                    }
+                    throw new Error(`Unknown statement: ${statementKey}`);
+            }
+        };
+    }
+    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.extractQueryArgs(args);
+                if (typeof persistence[methodName] === "function") {
+                    return persistence[methodName](...spreadArgs, ctx);
                 }
-                catch (e) {
-                    log.error(`Failed to delete ${modelClazzName} with id ${id}`, e);
-                    throw e;
+                if (typeof persistence.statement === "function") {
+                    return persistence.statement(methodName, ...spreadArgs, ctx);
                 }
-                log.info(`deleted ${modelClazzName} with id ${id}`);
-                ctx.toResponse(resp);
-                return del;
+                throw new Error(`Persistence method "${methodName}" not found on ${persistence?.constructor?.name}`);
+            }
+            catch (e) {
+                if (log)
+                    log.error(`Custom query "${methodName}" failed`, e);
+                throw e;
             }
         };
-        __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 createCustomRouteHandler(methodName) {
+        return async function customRoute(...args) {
+            const log = this.log?.for?.(customRoute);
+            const { ctx } = (await this.logCtx([], methodName, true)).for(customRoute);
+            const persistence = this.persistence(ctx);
+            const spreadArgs = FromModelController.extractQueryArgs(args);
+            // Try the persistence directly (works when it's a custom Repository)
+            if (typeof persistence[methodName] === "function") {
+                return persistence[methodName](...spreadArgs, ctx);
+            }
+            // When persistence is a ModelService, the method lives on the underlying repo
+            if (persistence?.repo && typeof persistence.repo[methodName] === "function") {
+                return persistence.repo[methodName](...spreadArgs, ctx);
+            }
+            // Fall back to statement gateway
+            if (typeof persistence.statement === "function") {
+                return persistence.statement(methodName, ...spreadArgs, ctx);
+            }
+            throw new Error(`Method "${methodName}" not found on ${persistence?.constructor?.name} or its repo`);
+        };
+    }
+    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 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),
-                    },
+                    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),
-                },
-            }),
-            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 +757,170 @@ 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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FromModelController.js","sourceRoot":"","sources":["../../../src/decaf-model/FromModelController.ts"],"names":[],"mappings":"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","sourcesContent":["import { Controller, Param, Query, Response, SetMetadata } from \"@nestjs/common\";\nimport {\n  ApiBadRequestResponse,\n  ApiBody,\n  ApiCreatedResponse,\n  ApiExtraModels,\n  ApiNoContentResponse,\n  ApiNotFoundResponse,\n  ApiOkResponse,\n  ApiOperation,\n  ApiParam,\n  ApiQuery,\n  ApiTags,\n  ApiUnprocessableEntityResponse,\n  getSchemaPath,\n} from \"@nestjs/swagger\";\nimport {\n  type DirectionLimitOffset,\n  ModelService,\n  OrderDirection,\n  PersistenceKeys,\n  PreparedStatementKeys,\n  type Repo,\n  Repository,\n  Service,\n} from \"@decaf-ts/core\";\nimport { Model, ModelConstructor } from \"@decaf-ts/decorator-validation\";\nimport { Logging, toKebabCase } from \"@decaf-ts/logging\";\nimport {\n  BulkCrudOperationKeys,\n  DBKeys,\n  OperationKeys,\n  ValidationError,\n} from \"@decaf-ts/db-decorators\";\nimport { Constructor, Metadata } from \"@decaf-ts/decoration\";\nimport {\n  ApiOperationFromModel,\n  ApiParamsFromModel,\n  type DecafApiProperty,\n  DecafBody,\n  DecafParams,\n  DecafQuery,\n} from \"./decorators\";\nimport { HttpVerbToDecorator } from \"./decorators/utils\";\nimport type { HttpVerbs } from \"./decorators/types\";\nimport { DecafRequestContext } from \"../request\";\nimport { DECAF_CONTROLLER_CONFIG, DECAF_ROUTE } from \"../constants\";\nimport { SKIP_MODEL_ROLES_KEY } from \"../auth/constants\";\nimport { Auth, Public, RequireRoles } from \"../auth/decorators\";\nimport { ControllerConstructor } from \"./types\";\nimport { DecafModelController } from \"../controllers\";\nimport { DtoFor } from \"../factory/openapi/DtoBuilder\";\nimport \"../overrides\";\nimport {\n  ModelControllerFactory,\n  type ModelControllerFactoryConfig,\n  type AuthConfig,\n  type ServerRoute,\n} from \"@decaf-ts/for-http/server\";\n\nexport class FromModelController {\n  private static readonly log = Logging.for(FromModelController.name);\n\n  static getPersistence<T extends Model<boolean>>(\n    ModelClazz: ModelConstructor<T>\n  ): Repo<T> | ModelService<T> {\n    try {\n      return Service.get<ModelService<T>>(ModelClazz);\n    } catch (e: unknown) {\n      try {\n        return ModelService.getService(ModelClazz) as ModelService<T>;\n      } catch (e2: unknown) {\n        return Repository.forModel(ModelClazz) as Repo<T>;\n      }\n    }\n  }\n\n  static createQueryRoutesFromRepository<T extends Model<boolean>>(\n    persistence: Repo<T> | ModelService<T>,\n    prefix: string = PersistenceKeys.QUERY\n  ): ControllerConstructor<T> {\n    const repo: Repo<T> =\n      persistence instanceof ModelService ? persistence.repo : persistence;\n    const ModelConstr: Constructor = repo.class;\n    const queryMethods: Record<string, { fields?: string[] | undefined }> =\n      Metadata.get(\n        repo.constructor as Constructor,\n        Metadata.key(PersistenceKeys.QUERY)\n      ) ?? {};\n\n    const routeMethods: Record<string, any> =\n      Metadata.get(\n        persistence.constructor as Constructor,\n        Metadata.key(DECAF_ROUTE)\n      ) ?? {};\n\n    class QueryController extends DecafModelController<T> {\n      override get class(): ModelConstructor<T> {\n        throw new Error(\"Method not implemented.\");\n      }\n      constructor(clientContext: DecafRequestContext, name: string) {\n        super(clientContext, name);\n      }\n    }\n\n    for (const [methodName, params] of Object.entries(routeMethods)) {\n      const routePath = [params.path.replace(/^\\/+|\\/+$/g, \"\")]\n        .filter((segment: string) => segment && segment.trim())\n        .join(\"/\");\n\n      const handler = FromModelController.createComplexQueryHandler(\n        methodName\n      ) as any;\n      FromModelController.defineMethod(\n        QueryController,\n        methodName,\n        handler\n      );\n\n      const httpDecorator = HttpVerbToDecorator(params.httpMethod as HttpVerbs)(routePath || undefined);\n      const decorators = FromModelController.getQueryDecorators(\n        methodName,\n        routePath,\n        params.httpMethod\n      );\n      FromModelController.applyDecorators(\n        QueryController,\n        methodName,\n        [httpDecorator, ...decorators]\n      );\n    }\n\n    for (const [methodName, objValues] of Object.entries(queryMethods)) {\n      const fields = objValues.fields ?? [];\n      const routePath = [prefix, methodName, ...fields.map((f) => `:${f}`)]\n        .filter((segment) => segment && segment.trim())\n        .join(\"/\");\n\n      const handler = FromModelController.createComplexQueryHandler(\n        methodName\n      ) as any;\n      FromModelController.defineMethod(\n        QueryController,\n        methodName,\n        handler\n      );\n\n      const httpDecorator = HttpVerbToDecorator(\"GET\" as HttpVerbs)(routePath || undefined);\n      const decorators = FromModelController.getQueryDecorators(\n        methodName,\n        routePath,\n        \"GET\",\n        true\n      );\n      FromModelController.applyDecorators(\n        QueryController,\n        methodName,\n        [httpDecorator, ...decorators]\n      );\n    }\n\n    return QueryController;\n  }\n\n  static create<T extends Model<any>>(\n    ModelConstr: ModelConstructor<T>,\n    moduleConfigOverrides?: Record<string, ModelControllerFactoryConfig>,\n    globalDefaults?: Partial<ModelControllerFactoryConfig>\n  ): ControllerConstructor<T> {\n    const log = FromModelController.log.for(FromModelController.create);\n    const tableName = Model.tableName(ModelConstr);\n    const routePath = toKebabCase(tableName);\n    const modelClazzName = ModelConstr.name;\n    const persistence = FromModelController.getPersistence(ModelConstr);\n\n    // When persistence is a ModelService, the @query/@route metadata lives on\n    // the underlying repository class (custom repo), not on ModelService itself.\n    // Pass the repo to the factory so addComplexQueries() can discover them.\n    const factoryPersistence =\n      persistence instanceof ModelService ? persistence.repo : persistence;\n\n    const decoratorConfig = Metadata.get(\n      ModelConstr,\n      Metadata.key(DECAF_CONTROLLER_CONFIG)\n    ) as ModelControllerFactoryConfig | undefined;\n    const moduleOverride = moduleConfigOverrides?.[ModelConstr.name];\n    const mergedConfig: ModelControllerFactoryConfig = {\n      ...(globalDefaults || {}),\n      ...(decoratorConfig || {}),\n      ...(moduleOverride || {}),\n    };\n\n    const FactoryController = ModelControllerFactory.create<T>(\n      ModelConstr,\n      factoryPersistence,\n      mergedConfig\n    );\n    const factoryRoutes = (FactoryController as any).__routes__ as\n      | ServerRoute[]\n      | undefined;\n\n    const { getPK, apiProperties, path: pkPath } =\n      FromModelController.getRouteParametersFromModel(ModelConstr);\n\n    log.debug(\n      `Creating controller for model: ${modelClazzName} with ${factoryRoutes?.length ?? 0} factory routes`\n    );\n\n    const authConfig: AuthConfig | undefined = mergedConfig.auth;\n\n    function applyClassAuth(target: any) {\n      if (authConfig?.public) {\n        Public()(target);\n      } else if (authConfig?.roles?.length) {\n        RequireRoles(...authConfig.roles)(target);\n      } else {\n        Auth(ModelConstr)(target);\n      }\n      if (authConfig?.skipModelRoles) {\n        SetMetadata(SKIP_MODEL_ROLES_KEY, true)(target);\n      }\n    }\n\n    @Controller(routePath)\n    @ApiTags(modelClazzName)\n    @ApiExtraModels(ModelConstr)\n    class DynamicModelController extends DecafModelController<T> {\n      private readonly pk: string = Model.pk(ModelConstr) as string;\n\n      protected static get class() {\n        return ModelConstr;\n      }\n\n      override get class(): ModelConstructor<T> {\n        return ModelConstr;\n      }\n\n      constructor(clientContext: DecafRequestContext) {\n        super(clientContext, DynamicModelController.name);\n        log.info(\n          `Registering dynamic controller for model: ${this.class.name} route: /${routePath}`\n        );\n      }\n    }\n\n    applyClassAuth(DynamicModelController);\n\n    if (factoryRoutes) {\n      const sortedRoutes = [...factoryRoutes].sort((a, b) => {\n        const aSegments = a.path.split(\"/\").filter(Boolean);\n        const bSegments = b.path.split(\"/\").filter(Boolean);\n        const aParamCount = aSegments.filter((s) => s.startsWith(\":\")).length;\n        const bParamCount = bSegments.filter((s) => s.startsWith(\":\")).length;\n        const aLiteralCount = aSegments.length - aParamCount;\n        const bLiteralCount = bSegments.length - bParamCount;\n        if (aLiteralCount !== bLiteralCount)\n          return bLiteralCount - aLiteralCount;\n        if (aParamCount !== bParamCount)\n          return aParamCount - bParamCount;\n        return 0;\n      });\n      for (const route of sortedRoutes) {\n        const registration = FromModelController.matchRoute(\n          route,\n          pkPath,\n          apiProperties,\n          getPK,\n          ModelConstr,\n          modelClazzName,\n          factoryPersistence\n        );\n        if (!registration) continue;\n\n        const { methodName, handler, decorators, paramDecorators } =\n          registration;\n\n        const descriptor = FromModelController.defineMethod(\n          DynamicModelController,\n          methodName,\n          handler\n        );\n\n        if (descriptor) {\n          const httpDecorator = HttpVerbToDecorator(route.method as HttpVerbs)(\n            route.path.replace(/^\\/+|\\/+$/g, \"\") || undefined\n          );\n          FromModelController.applyDecorators(\n            DynamicModelController,\n            methodName,\n            [httpDecorator, ...decorators],\n            paramDecorators\n          );\n        }\n      }\n    }\n\n    return DynamicModelController as any;\n  }\n\n  static getRouteParametersFromModel<T extends Model<any>>(\n    ModelClazz: ModelConstructor<T>\n  ): {\n    path: string;\n    description: string;\n    apiProperties: DecafApiProperty[];\n    getPK: (...params: Array<string | number>) => string;\n  } {\n    const pk = Model.pk(ModelClazz) as keyof Model<any>;\n    const composed = Metadata.get(\n      ModelClazz,\n      Metadata.key(DBKeys.COMPOSED, pk)\n    );\n    const composedKeys = composed?.args ?? [];\n\n    const uniqueKeys =\n      Array.isArray(composedKeys) && composedKeys.length > 0\n        ? Array.from(new Set([...composedKeys]))\n        : Array.from(new Set([pk]));\n\n    const description = Metadata.description(ModelClazz) ?? \"\";\n    const path = `:${uniqueKeys.join(\"/:\")}`;\n    const apiProperties: DecafApiProperty[] = uniqueKeys.map((key) => {\n      return {\n        name: key,\n        description: Metadata.description(ModelClazz, key),\n        required: true,\n        type: String,\n      };\n    });\n\n    return {\n      path,\n      description,\n      apiProperties,\n      getPK: (...params: Array<string | number>) =>\n        composed?.separator ? params.join(composed.separator) : params.join(\"\"),\n    };\n  }\n\n  private static defineMethod(\n    target: any,\n    methodName: string,\n    handler: (...args: any[]) => any\n  ): PropertyDescriptor | undefined {\n    Object.defineProperty(\n      target.prototype || target,\n      methodName,\n      {\n        value: handler,\n        writable: false,\n        configurable: true,\n        enumerable: false,\n      }\n    );\n\n    return Object.getOwnPropertyDescriptor(\n      target.prototype || target,\n      methodName\n    );\n  }\n\n  private static applyDecorators(\n    target: any,\n    methodName: string,\n    methodDecorators: Array<(target: any, key: string, desc: any) => void>,\n    paramDecorators: Array<{ decorator: ParameterDecorator; index: number }> = []\n  ) {\n    const proto = target?.prototype ?? target;\n    const descriptor = Object.getOwnPropertyDescriptor(proto, methodName);\n    methodDecorators.forEach((d) => d(proto, methodName, descriptor));\n    paramDecorators.forEach(({ decorator, index }) =>\n      decorator(proto, methodName, index)\n    );\n  }\n\n  private static matchRoute(\n    route: ServerRoute,\n    pkPath: string,\n    apiProperties: DecafApiProperty[],\n    getPK: (...p: Array<string | number>) => string,\n    ModelConstr: ModelConstructor<any>,\n    modelClazzName: string,\n    persistence?: any\n  ): {\n    methodName: string;\n    handler: (...args: any[]) => any;\n    decorators: Array<(target: any, key: string, desc: any) => void>;\n    paramDecorators: Array<{ decorator: ParameterDecorator; index: number }>;\n  } | undefined {\n    const { method, path } = route;\n    const normalizedPath = path.replace(/^\\/+|\\/+$/g, \"\");\n\n    if (method === \"POST\" && normalizedPath === \"\") {\n      return FromModelController.createRegistration(\n        \"create\",\n        FromModelController.createCreateHandler(ModelConstr, modelClazzName),\n        FromModelController.createCreateDecorators(ModelConstr, modelClazzName),\n        [{ decorator: DecafBody() as any, index: 0 }, { decorator: Response({ passthrough: true }) as any, index: 1 }]\n      );\n    }\n\n    if (method === \"POST\" && normalizedPath === \"bulk\") {\n      return FromModelController.createRegistration(\n        \"createAll\",\n        FromModelController.createBulkCreateHandler(ModelConstr, modelClazzName),\n        FromModelController.bulkCreateDecorators(ModelConstr, modelClazzName),\n        [{ decorator: DecafBody() as any, index: 0 }, { decorator: Response({ passthrough: true }) as any, index: 1 }]\n      );\n    }\n\n    if (method === \"GET\" && normalizedPath === \"bulk\") {\n      return FromModelController.createRegistration(\n        \"readAll\",\n        FromModelController.createBulkReadHandler(modelClazzName),\n        FromModelController.bulkReadDecorators(ModelConstr, modelClazzName),\n        [{ decorator: Query(\"ids\") as any, index: 0 }]\n      );\n    }\n\n    if (method === \"PUT\" && normalizedPath === \"bulk\") {\n      return FromModelController.createRegistration(\n        \"updateAll\",\n        FromModelController.createBulkUpdateHandler(modelClazzName),\n        FromModelController.bulkUpdateDecorators(ModelConstr, modelClazzName, apiProperties),\n        [{ decorator: DecafBody() as any, index: 0 }, { decorator: Response({ passthrough: true }) as any, index: 1 }]\n      );\n    }\n\n    if (method === \"DELETE\" && normalizedPath === \"bulk\") {\n      return FromModelController.createRegistration(\n        \"deleteAll\",\n        FromModelController.createBulkDeleteHandler(modelClazzName),\n        FromModelController.bulkDeleteDecorators(ModelConstr, modelClazzName, apiProperties),\n        [{ decorator: Query(\"ids\") as any, index: 0 }, { decorator: Response({ passthrough: true }) as any, index: 1 }]\n      );\n    }\n\n    if (method === \"GET\" && normalizedPath === pkPath) {\n      return FromModelController.createRegistration(\n        \"read\",\n        FromModelController.createReadHandler(getPK, modelClazzName),\n        FromModelController.readDecorators(ModelConstr, modelClazzName, apiProperties, pkPath),\n        [{ decorator: DecafParams(apiProperties) as any, index: 0 }]\n      );\n    }\n\n    if (method === \"PUT\" && normalizedPath === pkPath) {\n      return FromModelController.createRegistration(\n        \"update\",\n        FromModelController.createUpdateHandler(getPK, ModelConstr, modelClazzName),\n        FromModelController.updateDecorators(ModelConstr, modelClazzName, apiProperties, pkPath),\n        [\n          { decorator: DecafParams(apiProperties) as any, index: 0 },\n          { decorator: DecafBody() as any, index: 1 },\n          { decorator: Response({ passthrough: true }) as any, index: 2 },\n        ]\n      );\n    }\n\n    if (method === \"DELETE\" && normalizedPath === pkPath) {\n      return FromModelController.createRegistration(\n        \"delete\",\n        FromModelController.createDeleteHandler(getPK, modelClazzName),\n        FromModelController.deleteDecorators(ModelConstr, modelClazzName, apiProperties, pkPath),\n        [\n          { decorator: DecafParams(apiProperties) as any, index: 0 },\n          { decorator: Response({ passthrough: true }) as any, index: 1 },\n        ]\n      );\n    }\n\n    // Composed PK fallback routes (filterEmpty) — path differs from pkPath\n    const fallbackSegments = normalizedPath.split(\"/\").filter(Boolean);\n    const isAllParams = fallbackSegments.length > 0 && fallbackSegments.every((s) => s.startsWith(\":\"));\n    if (isAllParams && normalizedPath !== pkPath) {\n      const fallbackApiProps = fallbackSegments.map((s) => s.slice(1)).map((name) => ({\n        name,\n        description: `${name} parameter`,\n        required: true,\n        type: String,\n      }));\n      const suffix = fallbackSegments.map((s) => s.slice(1)).join(\"And\");\n      if (method === \"GET\") {\n        return FromModelController.createRegistration(\n          `readBy${suffix}`,\n          FromModelController.createReadHandler(getPK, modelClazzName),\n          FromModelController.readDecorators(ModelConstr, modelClazzName, fallbackApiProps, normalizedPath),\n          [{ decorator: DecafParams(fallbackApiProps) as any, index: 0 }]\n        );\n      }\n      if (method === \"PUT\") {\n        return FromModelController.createRegistration(\n          `updateBy${suffix}`,\n          FromModelController.createUpdateHandler(getPK, ModelConstr, modelClazzName),\n          FromModelController.updateDecorators(ModelConstr, modelClazzName, fallbackApiProps, normalizedPath),\n          [\n            { decorator: DecafParams(fallbackApiProps) as any, index: 0 },\n            { decorator: DecafBody() as any, index: 1 },\n            { decorator: Response({ passthrough: true }) as any, index: 2 },\n          ]\n        );\n      }\n      if (method === \"DELETE\") {\n        return FromModelController.createRegistration(\n          `deleteBy${suffix}`,\n          FromModelController.createDeleteHandler(getPK, modelClazzName),\n          FromModelController.deleteDecorators(ModelConstr, modelClazzName, fallbackApiProps, normalizedPath),\n          [\n            { decorator: DecafParams(fallbackApiProps) as any, index: 0 },\n            { decorator: Response({ passthrough: true }) as any, index: 1 },\n          ]\n        );\n      }\n    }\n\n    if (method === \"GET\" && normalizedPath === \"statement/:method/*args\") {\n      return FromModelController.createRegistration(\n        \"statement\",\n        FromModelController.createStatementHandler(modelClazzName),\n        FromModelController.statementDecorators(ModelConstr, modelClazzName),\n        [\n          { decorator: Param(\"method\") as any, index: 0 },\n          { decorator: Param(\"args\") as any, index: 1 },\n          { decorator: DecafQuery() as any, index: 2 },\n        ]\n      );\n    }\n\n    const statementRoutes: Record<string, string> = {\n      \"listBy/:key\": PreparedStatementKeys.LIST_BY,\n      \"paginateBy/:key/:page\": PreparedStatementKeys.PAGE_BY,\n      \"find/:value\": PreparedStatementKeys.FIND,\n      \"page/:value\": PreparedStatementKeys.PAGE,\n      \"findOneBy/:key/:value\": PreparedStatementKeys.FIND_ONE_BY,\n      \"findBy/:key/:value\": PreparedStatementKeys.FIND_BY,\n      \"countOf/:field\": PreparedStatementKeys.COUNT_OF,\n      \"maxOf/:field\": PreparedStatementKeys.MAX_OF,\n      \"minOf/:field\": PreparedStatementKeys.MIN_OF,\n      \"avgOf/:field\": PreparedStatementKeys.AVG_OF,\n      \"sumOf/:field\": PreparedStatementKeys.SUM_OF,\n      \"distinctOf/:field\": PreparedStatementKeys.DISTINCT_OF,\n      \"groupOf/:field\": PreparedStatementKeys.GROUP_OF,\n    };\n\n    const statementKey = statementRoutes[normalizedPath];\n    if (statementKey && method === \"GET\") {\n      return FromModelController.createRegistration(\n        FromModelController.statementMethodName(normalizedPath),\n        FromModelController.createStatementShortcutHandler(statementKey, modelClazzName),\n        FromModelController.statementShortcutDecorators(ModelConstr, modelClazzName, normalizedPath, statementKey),\n        FromModelController.statementShortcutParams(normalizedPath)\n      );\n    }\n\n    if (method === \"GET\" && normalizedPath.startsWith(\"query/\")) {\n      const queryMethod = normalizedPath.replace(/^query\\//, \"\").split(\"/\")[0];\n      return FromModelController.createRegistration(\n        queryMethod,\n        FromModelController.createComplexQueryHandler(queryMethod),\n        FromModelController.getQueryDecorators(queryMethod, normalizedPath, \"GET\", true),\n        FromModelController.complexQueryParams(normalizedPath)\n      );\n    }\n\n    // Fallback for custom @route() paths (e.g. \"metadata/for-product/:productCode\")\n    const pathSegments = normalizedPath.split(\"/\").filter(Boolean);\n    const knownPrefixes = new Set<string>([\n      \"listBy\", \"findBy\", \"findByPaginate\", \"findOneBy\", \"paginateBy\",\n      \"find\", \"page\", \"countOf\", \"maxOf\", \"minOf\", \"avgOf\", \"sumOf\",\n      \"distinctOf\", \"groupOf\", \"statement\", \"bulk\", \"query\",\n    ]);\n    if (\n      pathSegments.length > 0 &&\n      !normalizedPath.startsWith(\"query/\") &&\n      !knownPrefixes.has(pathSegments[0])\n    ) {\n      // Look up the actual method name from @route metadata by matching the path.\n      // The @route decorator stores { path, httpMethod, handler } keyed by method name\n      // on the repository constructor.\n      const routeMetadata: Record<string, any> =\n        Metadata.get(\n          (persistence as any)?.constructor,\n          Metadata.key(DECAF_ROUTE)\n        ) ?? {};\n      const matchedEntry = Object.entries(routeMetadata).find(\n        ([, info]) =>\n          info &&\n          typeof info === \"object\" &&\n          info.path?.replace(/^\\/+|\\/+$/g, \"\") === normalizedPath\n      );\n      const actualMethodName = matchedEntry?.[0] || pathSegments[0];\n\n      const paramSegments = pathSegments.filter((s) => s.startsWith(\":\"));\n      const apiPathParams = paramSegments.map((s) => s.slice(1)).map((name) => ({\n        name,\n        description: `${name} parameter for the query`,\n        required: true,\n        type: String,\n      }));\n\n      return FromModelController.createRegistration(\n        actualMethodName,\n        FromModelController.createCustomRouteHandler(actualMethodName),\n        [\n          ...apiPathParams.map((p) => ApiParam(p)),\n          ApiOperation({ summary: `Retrieve records using \"${actualMethodName}\".` }),\n          ApiOkResponse({ description: \"Result successfully retrieved.\" }),\n          ApiNoContentResponse({ description: \"No content returned by the method.\" }),\n        ],\n        FromModelController.complexQueryParams(normalizedPath)\n      );\n    }\n\n    return undefined;\n  }\n\n  private static createRegistration(\n    methodName: string,\n    handler: (...args: any[]) => any,\n    decorators: Array<(target: any, key: string, desc: any) => void>,\n    paramDecorators: Array<{ decorator: ParameterDecorator; index: number }>\n  ) {\n    return { methodName, handler, decorators, paramDecorators };\n  }\n\n  private static statementMethodName(path: string): string {\n    const firstSegment = path.split(\"/\")[0];\n    return firstSegment;\n  }\n\n  private static statementShortcutParams(\n    path: string\n  ): Array<{ decorator: ParameterDecorator; index: number }> {\n    const segments = path.split(\"/\").filter((s) => s.startsWith(\":\"));\n    const params: Array<{ decorator: ParameterDecorator; index: number }> = [];\n    segments.forEach((seg, i) => {\n      const name = seg.replace(\":\", \"\");\n      params.push({ decorator: Param(name) as any, index: i });\n    });\n    if (\n      path.startsWith(\"listBy/\") ||\n      path.startsWith(\"paginateBy/\") ||\n      path.startsWith(\"find/\") ||\n      path.startsWith(\"page/\")\n    ) {\n      params.push({ decorator: DecafQuery() as any, index: segments.length });\n    }\n    return params;\n  }\n\n  private static complexQueryParams(\n    path: string\n  ): Array<{ decorator: ParameterDecorator; index: number }> {\n    const segments = path.split(\"/\").filter((s) => s.startsWith(\":\"));\n    const params: Array<{ decorator: ParameterDecorator; index: number }> = [];\n    segments.forEach((seg, i) => {\n      const name = seg.replace(\":\", \"\");\n      params.push({ decorator: Param(name) as any, index: i });\n    });\n    if (path.startsWith(\"query/\")) {\n      params.push({ decorator: DecafQuery() as any, index: segments.length });\n    }\n    return params;\n  }\n\n  private static createCreateHandler(\n    ModelConstr: ModelConstructor<any>,\n    modelClazzName: string\n  ) {\n    return async function create(\n      this: any,\n      data: any,\n      resp?: any\n    ): Promise<Model<any>> {\n      const { ctx, log } = (\n        await this.logCtx([], OperationKeys.CREATE, true)\n      ).for(create);\n      log.verbose(`creating new ${modelClazzName}`);\n      let created: Model;\n      try {\n        created = await this.persistence(ctx).create(data, ctx);\n      } catch (e: unknown) {\n        log.error(`Failed to create new ${modelClazzName}`, e as Error);\n        throw e;\n      }\n      log.info(`created new ${modelClazzName} with id ${(created as any)[this.pk]}`);\n      if (resp) ctx.toResponse(resp);\n      return created;\n    };\n  }\n\n  private static createBulkCreateHandler(\n    ModelConstr: ModelConstructor<any>,\n    modelClazzName: string\n  ) {\n    return async function createAll(\n      this: any,\n      data: any[],\n      resp?: any\n    ): Promise<Model[]> {\n      const { ctx, log } = (\n        await this.logCtx([], BulkCrudOperationKeys.CREATE_ALL, true)\n      ).for(createAll);\n      log.verbose(`creating new ${modelClazzName}`);\n      let created: any[];\n      try {\n        created = await this.persistence(ctx).createAll(\n          data.map((d) => new ModelConstr(d)),\n          ctx\n        );\n      } catch (e: unknown) {\n        log.error(`Failed to create new ${modelClazzName}`, e as Error);\n        throw e;\n      }\n      log.info(`created new ${modelClazzName} with id ${(created as any)[this.pk]}`);\n      if (resp) ctx.toResponse(resp);\n      return created;\n    };\n  }\n\n  private static createBulkReadHandler(modelClazzName: string) {\n    return async function readAll(\n      this: any,\n      ids: string[]\n    ): Promise<Model[]> {\n      const { ctx, log } = (\n        await this.logCtx([], BulkCrudOperationKeys.READ_ALL, true)\n      ).for(readAll);\n      const normalizedIds = Array.isArray(ids) ? ids : [ids];\n      let read: Model[];\n      try {\n        log.debug(`reading ${normalizedIds} ${modelClazzName}`);\n        read = await this.persistence(ctx).readAll(normalizedIds as any, ctx);\n      } catch (e: unknown) {\n        log.error(`Failed to read ${modelClazzName}`, e as Error);\n        throw e;\n      }\n      log.info(`read ${read.length} ${modelClazzName}`);\n      return read;\n    };\n  }\n\n  private static createBulkUpdateHandler(modelClazzName: string) {\n    return async function updateAll(\n      this: any,\n      body: any[],\n      resp?: any\n    ): Promise<any[]> {\n      const { ctx, log } = (\n        await this.logCtx([], BulkCrudOperationKeys.UPDATE_ALL, true)\n      ).for(updateAll);\n      let updated: any[];\n      try {\n        log.info(`updating ${body.length} ${modelClazzName}`);\n        updated = await this.persistence(ctx).updateAll(body, ctx);\n      } catch (e: unknown) {\n        log.error(e as Error);\n        throw e;\n      }\n      if (resp) ctx.toResponse(resp);\n      return updated;\n    };\n  }\n\n  private static createBulkDeleteHandler(modelClazzName: string) {\n    return async function deleteAll(\n      this: any,\n      ids: string[],\n      resp?: any\n    ): Promise<Model[]> {\n      const { ctx, log } = (\n        await this.logCtx([], BulkCrudOperationKeys.DELETE_ALL, true)\n      ).for(deleteAll);\n      const normalizedIds = Array.isArray(ids) ? ids : [ids];\n      let read: Model[];\n      try {\n        log.debug(`deleting ${normalizedIds.length} ${modelClazzName}`);\n        read = await this.persistence(ctx).deleteAll(normalizedIds, ctx);\n      } catch (e: unknown) {\n        log.error(`Failed to delete ${modelClazzName}`, e as Error);\n        throw e;\n      }\n      log.info(`deleted ${read.length} ${modelClazzName}`);\n      if (resp) ctx.toResponse(resp);\n      return read;\n    };\n  }\n\n  private static createReadHandler(\n    getPK: (...p: Array<string | number>) => string,\n    modelClazzName: string\n  ) {\n    return async function read(\n      this: any,\n      routeParams: any\n    ): Promise<Model> {\n      const { ctx, log } = (\n        await this.logCtx([], OperationKeys.READ, true)\n      ).for(read);\n      const id = getPK(...routeParams.valuesInOrder);\n      if (typeof id === \"undefined\")\n        throw new ValidationError(`No ${this.pk} provided`);\n      let readResult: Model;\n      try {\n        log.debug(`reading ${modelClazzName} with ${this.pk} ${id}`);\n        readResult = await this.persistence(ctx).read(id, ctx);\n      } catch (e: unknown) {\n        log.error(`Failed to read ${modelClazzName} with id ${id}`, e as Error);\n        throw e;\n      }\n      log.info(`read ${modelClazzName} with id ${(readResult as any)[this.pk]}`);\n      return readResult;\n    };\n  }\n\n  private static createUpdateHandler(\n    getPK: (...p: Array<string | number>) => string,\n    ModelConstr: ModelConstructor<any>,\n    modelClazzName: string\n  ) {\n    return async function update(\n      this: any,\n      routeParams: any,\n      body: any,\n      resp?: any\n    ): Promise<any> {\n      const { ctx, log } = (\n        await this.logCtx([], OperationKeys.UPDATE, true)\n      ).for(update);\n      const id = getPK(...routeParams.valuesInOrder);\n      if (typeof id === \"undefined\")\n        throw new ValidationError(`No ${this.pk} provided`);\n      let updated: any;\n      try {\n        log.info(`updating ${modelClazzName} with ${this.pk} ${id}`);\n        const payload = JSON.parse(JSON.stringify(body));\n        updated = await this.persistence(ctx).update(\n          new ModelConstr({ ...payload, [this.pk]: id }),\n          ctx\n        );\n      } catch (e: unknown) {\n        log.error(e as Error);\n        throw e;\n      }\n      if (resp) ctx.toResponse(resp);\n      return updated;\n    };\n  }\n\n  private static createDeleteHandler(\n    getPK: (...p: Array<string | number>) => string,\n    modelClazzName: string\n  ) {\n    return async function remove(\n      this: any,\n      routeParams: any,\n      resp?: any\n    ): Promise<Model> {\n      const { ctx, log } = (\n        await this.logCtx([], OperationKeys.DELETE, true)\n      ).for(remove);\n      const id = getPK(...routeParams.valuesInOrder);\n      if (typeof id === \"undefined\")\n        throw new ValidationError(`No ${this.pk} provided`);\n      let del: Model;\n      try {\n        log.debug(`deleting ${modelClazzName} with ${this.pk} ${id}`);\n        del = await this.persistence(ctx).delete(id, ctx);\n      } catch (e: unknown) {\n        log.error(`Failed to delete ${modelClazzName} with id ${id}`, e as Error);\n        throw e;\n      }\n      log.info(`deleted ${modelClazzName} with id ${id}`);\n      if (resp) ctx.toResponse(resp);\n      return del;\n    };\n  }\n\n  private static createStatementHandler(modelClazzName: string) {\n    return async function statement(\n      this: any,\n      name: string,\n      args: (string | number)[],\n      details: DirectionLimitOffset\n    ): Promise<any> {\n      const { ctx } = (\n        await this.logCtx([], PersistenceKeys.STATEMENT, true)\n      ).for(statement);\n      const { direction, offset, limit, bookmark } = details;\n      args = args.map(\n        (a) => (typeof a === \"string\" ? parseInt(a as string) : a) || a\n      ) as any[];\n      const pathDirection = args.length > 1 ? args[1] : undefined;\n      const resolvedDirection = (direction ?? pathDirection) as\n        | string\n        | undefined;\n      if (resolvedDirection && args.length > 1) args[1] = resolvedDirection;\n      switch (name) {\n        case PreparedStatementKeys.FIND:\n        case PreparedStatementKeys.FIND_BY:\n          break;\n        case PreparedStatementKeys.LIST_BY:\n          args.push(direction as string);\n          break;\n        case PreparedStatementKeys.PAGE:\n        case PreparedStatementKeys.PAGE_BY:\n          args = [\n            args[0],\n            resolvedDirection as any,\n            { limit, offset, bookmark },\n          ];\n          break;\n        case PreparedStatementKeys.FIND_ONE_BY:\n          break;\n        case PreparedStatementKeys.COUNT_OF:\n        case PreparedStatementKeys.MAX_OF:\n        case PreparedStatementKeys.MIN_OF:\n        case PreparedStatementKeys.AVG_OF:\n        case PreparedStatementKeys.SUM_OF:\n        case PreparedStatementKeys.DISTINCT_OF:\n        case PreparedStatementKeys.GROUP_OF:\n          break;\n      }\n      return this.persistence(ctx).statement(name, ...args, ctx);\n    };\n  }\n\n  private static createStatementShortcutHandler(\n    statementKey: string,\n    modelClazzName: string\n  ) {\n    return async function statementShortcut(\n      this: any,\n      ...args: any[]\n    ): Promise<any> {\n      const { ctx } = (\n        await this.logCtx([], statementKey, true)\n      ).for(statementShortcut);\n\n      switch (statementKey) {\n        case PreparedStatementKeys.LIST_BY: {\n          const [key, details] = args;\n          return this.persistence(ctx).listBy(\n            key,\n            (details as any)?.direction as OrderDirection,\n            ctx\n          );\n        }\n        case PreparedStatementKeys.PAGE_BY: {\n          const [key, page, details] = args;\n          return this.persistence(ctx).paginateBy(\n            key,\n            (details as any)?.direction as OrderDirection,\n            {\n              limit: (details as any)?.limit,\n              offset: (details as any)?.offset,\n              page,\n            } as any,\n            ctx\n          );\n        }\n        case PreparedStatementKeys.FIND: {\n          const [value, details] = args;\n          const direction =\n            (details as any)?.direction ?? OrderDirection.ASC;\n          const persistence = this.persistence(ctx);\n          if (typeof persistence.find === \"function\")\n            return persistence.find(value, direction, ctx);\n          return persistence.statement(PreparedStatementKeys.FIND, value, direction, ctx);\n        }\n        case PreparedStatementKeys.PAGE: {\n          const [value, details] = args;\n          const ref = {\n            offset: (details as any)?.offset ?? 1,\n            limit: (details as any)?.limit ?? 10,\n            bookmark: (details as any)?.bookmark,\n          };\n          const persistence = this.persistence(ctx);\n          const direction = (details as any)?.direction ?? OrderDirection.ASC;\n          if (typeof persistence.page === \"function\")\n            return persistence.page(value, direction, ref, ctx);\n          return persistence.statement(PreparedStatementKeys.PAGE, value, direction, ref, ctx);\n        }\n        case PreparedStatementKeys.FIND_ONE_BY: {\n          const [key, value] = args;\n          return this.persistence(ctx).findOneBy(key, value, ctx);\n        }\n        case PreparedStatementKeys.FIND_BY: {\n          const [key, value] = args;\n          return this.persistence(ctx)\n            .for(ctx.toOverrides())\n            .findBy(key, value, ctx);\n        }\n        default:\n          if (\n            statementKey === PreparedStatementKeys.COUNT_OF ||\n            statementKey === PreparedStatementKeys.MAX_OF ||\n            statementKey === PreparedStatementKeys.MIN_OF ||\n            statementKey === PreparedStatementKeys.AVG_OF ||\n            statementKey === PreparedStatementKeys.SUM_OF ||\n            statementKey === PreparedStatementKeys.DISTINCT_OF ||\n            statementKey === PreparedStatementKeys.GROUP_OF\n          ) {\n            const [field] = args;\n            return this.persistence(ctx).statement(statementKey, field, ctx);\n          }\n          throw new Error(`Unknown statement: ${statementKey}`);\n      }\n    };\n  }\n\n  private static createComplexQueryHandler(methodName: string) {\n    return async function complexQuery(\n      this: any,\n      ...args: any[]\n    ): Promise<any> {\n      const log: any = this.log?.for?.(complexQuery);\n      try {\n        if (log) log.debug(`Invoking custom query \"${methodName}\"`);\n        const { ctx } = (\n          await this.logCtx([], methodName, true)\n        ).for(complexQuery);\n        const persistence = this.persistence(ctx);\n        const spreadArgs = FromModelController.extractQueryArgs(args);\n        if (typeof persistence[methodName] === \"function\") {\n          return persistence[methodName](...spreadArgs, ctx);\n        }\n        if (typeof persistence.statement === \"function\") {\n          return persistence.statement(methodName, ...spreadArgs, ctx);\n        }\n        throw new Error(\n          `Persistence method \"${methodName}\" not found on ${persistence?.constructor?.name}`\n        );\n      } catch (e: any) {\n        if (log) log.error(`Custom query \"${methodName}\" failed`, e);\n        throw e;\n      }\n    };\n  }\n\n  private static createCustomRouteHandler(methodName: string) {\n    return async function customRoute(\n      this: any,\n      ...args: any[]\n    ): Promise<any> {\n      const log: any = this.log?.for?.(customRoute);\n      const { ctx } = (\n        await this.logCtx([], methodName, true)\n      ).for(customRoute);\n      const persistence = this.persistence(ctx);\n      const spreadArgs = FromModelController.extractQueryArgs(args);\n\n      // Try the persistence directly (works when it's a custom Repository)\n      if (typeof persistence[methodName] === \"function\") {\n        return persistence[methodName](...spreadArgs, ctx);\n      }\n      // When persistence is a ModelService, the method lives on the underlying repo\n      if (persistence?.repo && typeof persistence.repo[methodName] === \"function\") {\n        return persistence.repo[methodName](...spreadArgs, ctx);\n      }\n      // Fall back to statement gateway\n      if (typeof persistence.statement === \"function\") {\n        return persistence.statement(methodName, ...spreadArgs, ctx);\n      }\n      throw new Error(\n        `Method \"${methodName}\" not found on ${persistence?.constructor?.name} or its repo`\n      );\n    };\n  }\n\n  private static extractQueryArgs(args: any[]): any[] {\n    if (args.length === 0) return args;\n    const last = args[args.length - 1];\n    if (\n      last &&\n      typeof last === \"object\" &&\n      !Array.isArray(last)\n    ) {\n      const queryObj = args.pop();\n      const hasDirection = queryObj.direction !== undefined;\n      const hasLimit = queryObj.limit !== undefined;\n      const hasOffset = queryObj.offset !== undefined;\n      if (!hasDirection && !hasLimit && !hasOffset) return args;\n      const extras: any[] = [];\n      if (hasDirection) extras.push(queryObj.direction);\n      else if (hasLimit || hasOffset) extras.push(undefined);\n      if (hasLimit) extras.push(queryObj.limit);\n      if (hasOffset) extras.push(queryObj.offset);\n      return [...args, ...extras];\n    }\n    return args;\n  }\n\n  private static createCreateDecorators(\n    ModelConstr: ModelConstructor<any>,\n    modelClazzName: string\n  ): Array<(target: any, key: string, desc: any) => void> {\n    return [\n      ApiOperationFromModel(ModelConstr, \"POST\"),\n      ApiOperation({ summary: `Create a new ${modelClazzName}.` }),\n      ApiBody({\n        description: `Payload for ${modelClazzName}`,\n        type: DtoFor(OperationKeys.CREATE, ModelConstr),\n      }),\n      ApiCreatedResponse({\n        description: `${modelClazzName} created successfully.`,\n        schema: { $ref: getSchemaPath(ModelConstr) },\n      }),\n      ApiBadRequestResponse({ description: \"Payload validation failed.\" }),\n      ApiUnprocessableEntityResponse({\n        description: \"Repository rejected the provided payload.\",\n      }),\n    ];\n  }\n\n  private static bulkCreateDecorators(\n    ModelConstr: ModelConstructor<any>,\n    modelClazzName: string\n  ): Array<(target: any, key: string, desc: any) => void> {\n    return [\n      ApiOperationFromModel(ModelConstr, \"POST\", \"bulk\"),\n      ApiOperation({ summary: `Create a new ${modelClazzName}.` }),\n      ApiBody({\n        description: `Payload for ${modelClazzName}`,\n        schema: {\n          type: \"array\",\n          items: { $ref: getSchemaPath(ModelConstr) },\n        },\n      }),\n      ApiCreatedResponse({\n        description: `${modelClazzName} created successfully.`,\n        schema: {\n          type: \"array\",\n          items: { $ref: getSchemaPath(ModelConstr) },\n        },\n      }),\n      ApiBadRequestResponse({ description: \"Payload validation failed.\" }),\n      ApiUnprocessableEntityResponse({\n        description: \"Repository rejected the provided payload.\",\n      }),\n    ];\n  }\n\n  private static bulkReadDecorators(\n    ModelConstr: ModelConstructor<any>,\n    modelClazzName: string\n  ): Array<(target: any, key: string, desc: any) => void> {\n    return [\n      ApiOperationFromModel(ModelConstr, \"GET\", \"bulk\"),\n      ApiOperation({ summary: `Retrieve ${modelClazzName} records by ids.` }),\n      ApiQuery({ name: \"ids\", required: true, type: \"array\" }),\n      ApiOkResponse({\n        description: `${modelClazzName} retrieved successfully.`,\n        schema: {\n          type: \"array\",\n          items: { $ref: getSchemaPath(ModelConstr) },\n        },\n      }),\n      ApiNotFoundResponse({\n        description: `No ${modelClazzName} record matches the provided identifier.`,\n      }),\n    ];\n  }\n\n  private static bulkUpdateDecorators(\n    ModelConstr: ModelConstructor<any>,\n    modelClazzName: string,\n    apiProperties: DecafApiProperty[]\n  ): Array<(target: any, key: string, desc: any) => void> {\n    return [\n      ApiOperationFromModel(ModelConstr, \"PUT\", \"bulk\"),\n      ApiParamsFromModel(apiProperties),\n      ApiOperation({\n        summary: `Replace existing ${modelClazzName} records with new payloads.`,\n      }),\n      ApiBody({\n        description: `Payload for replacing existing records of ${modelClazzName}`,\n        schema: {\n          type: \"array\",\n          $ref: getSchemaPath(DtoFor(OperationKeys.UPDATE, ModelConstr)),\n        },\n      }),\n      ApiOkResponse({\n        description: `${modelClazzName} updated successfully.`,\n        schema: {\n          type: \"array\",\n          items: { $ref: getSchemaPath(ModelConstr) },\n        },\n      }),\n      ApiNotFoundResponse({\n        description: `No ${modelClazzName} record matches the provided identifier.`,\n      }),\n      ApiBadRequestResponse({ description: \"Payload validation failed.\" }),\n    ];\n  }\n\n  private static bulkDeleteDecorators(\n    ModelConstr: ModelConstructor<any>,\n    modelClazzName: string,\n    apiProperties: DecafApiProperty[]\n  ): Array<(target: any, key: string, desc: any) => void> {\n    return [\n      ApiOperationFromModel(ModelConstr, \"DELETE\", \"bulk\"),\n      ApiParamsFromModel(apiProperties),\n      ApiOperation({ summary: `Delete ${modelClazzName} records by ids.` }),\n      ApiQuery({ name: \"ids\", required: true, type: \"array\" }),\n      ApiOkResponse({\n        description: `${modelClazzName} deleted successfully.`,\n        schema: {\n          type: \"array\",\n          items: { $ref: getSchemaPath(ModelConstr) },\n        },\n      }),\n      ApiNotFoundResponse({\n        description: `No ${modelClazzName} record matches the provided identifier.`,\n      }),\n    ];\n  }\n\n  private static readDecorators(\n    ModelConstr: ModelConstructor<any>,\n    modelClazzName: string,\n    apiProperties: DecafApiProperty[],\n    pkPath: string\n  ): Array<(target: any, key: string, desc: any) => void> {\n    return [\n      ApiOperationFromModel(ModelConstr, \"GET\", pkPath),\n      ApiParamsFromModel(apiProperties),\n      ApiOperation({ summary: `Retrieve a ${modelClazzName} record by id.` }),\n      ApiOkResponse({\n        description: `${modelClazzName} retrieved successfully.`,\n        schema: { $ref: getSchemaPath(ModelConstr) },\n      }),\n      ApiNotFoundResponse({\n        description: `No ${modelClazzName} record matches the provided identifier.`,\n      }),\n    ];\n  }\n\n  private static updateDecorators(\n    ModelConstr: ModelConstructor<any>,\n    modelClazzName: string,\n    apiProperties: DecafApiProperty[],\n    pkPath: string\n  ): Array<(target: any, key: string, desc: any) => void> {\n    return [\n      ApiOperationFromModel(ModelConstr, \"PUT\", pkPath),\n      ApiParamsFromModel(apiProperties),\n      ApiOperation({\n        summary: `Replace an existing ${modelClazzName} record with a new payload.`,\n      }),\n      ApiBody({\n        description: `Payload for replacing an existing record of ${modelClazzName}`,\n        type: DtoFor(OperationKeys.UPDATE, ModelConstr),\n      }),\n      ApiOkResponse({\n        description: `${modelClazzName} updated successfully.`,\n        schema: { $ref: getSchemaPath(ModelConstr) },\n      }),\n      ApiNotFoundResponse({\n        description: `No ${modelClazzName} record matches the provided identifier.`,\n      }),\n      ApiBadRequestResponse({ description: \"Payload validation failed.\" }),\n    ];\n  }\n\n  private static deleteDecorators(\n    ModelConstr: ModelConstructor<any>,\n    modelClazzName: string,\n    apiProperties: DecafApiProperty[],\n    pkPath: string\n  ): Array<(target: any, key: string, desc: any) => void> {\n    return [\n      ApiOperationFromModel(ModelConstr, \"DELETE\", pkPath),\n      ApiParamsFromModel(apiProperties),\n      ApiOperation({ summary: `Delete a ${modelClazzName} record by id.` }),\n      ApiOkResponse({\n        description: `${modelClazzName} deleted successfully.`,\n        schema: { $ref: getSchemaPath(ModelConstr) },\n      }),\n      ApiNotFoundResponse({\n        description: `No ${modelClazzName} record matches the provided identifier.`,\n      }),\n    ];\n  }\n\n  private static statementDecorators(\n    ModelConstr: ModelConstructor<any>,\n    modelClazzName: string\n  ): Array<(target: any, key: string, desc: any) => void> {\n    return [\n      ApiOperationFromModel(ModelConstr, \"GET\", \"statement/:method/*args\"),\n      ApiOperation({\n        summary: `Executes a prepared statement on ${modelClazzName}.`,\n      }),\n      ApiParam({ name: \"method\", description: \"the prepared statement to execute\" }),\n      ApiParam({\n        name: \"args\",\n        description: \"concatenated list of arguments the prepared statement can accept\",\n      }),\n      ApiQuery({\n        name: \"direction\",\n        required: true,\n        enum: OrderDirection,\n        description: \"the sort order when applicable\",\n      }),\n      ApiQuery({ name: \"limit\", required: true, description: \"limit or page size when applicable\" }),\n      ApiQuery({ name: \"offset\", required: true, description: \"offset or bookmark when applicable\" }),\n      ApiOkResponse({ description: `${modelClazzName} listed found.` }),\n      ApiNotFoundResponse({\n        description: `No ${modelClazzName} record matches the provided identifier.`,\n      }),\n    ];\n  }\n\n  private static statementShortcutDecorators(\n    ModelConstr: ModelConstructor<any>,\n    modelClazzName: string,\n    path: string,\n    statementKey: string\n  ): Array<(target: any, key: string, desc: any) => void> {\n    const base: Array<(target: any, key: string, desc: any) => void> = [\n      ApiOperationFromModel(ModelConstr, \"GET\", path),\n      ApiOperation({ summary: `Retrieve ${modelClazzName} records.` }),\n      ApiOkResponse({ description: `${modelClazzName} retrieved successfully.` }),\n    ];\n\n    const segments = path.split(\"/\").filter((s) => s.startsWith(\":\"));\n    segments.forEach((seg) => {\n      const name = seg.replace(\":\", \"\");\n      base.push(ApiParam({ name, description: `The ${name} parameter` }));\n    });\n\n    if (\n      path.startsWith(\"listBy/\") ||\n      path.startsWith(\"paginateBy/\") ||\n      path.startsWith(\"find/\") ||\n      path.startsWith(\"page/\")\n    ) {\n      base.push(\n        ApiQuery({\n          name: \"direction\",\n          required: true,\n          enum: OrderDirection,\n          description: \"the sort order\",\n        })\n      );\n    }\n    if (path.startsWith(\"paginateBy/\") || path.startsWith(\"page/\")) {\n      base.push(\n        ApiQuery({ name: \"limit\", required: false, description: \"page size\" }),\n        ApiQuery({ name: \"offset\", required: false, description: \"page number\" }),\n        ApiQuery({ name: \"bookmark\", required: false, description: \"bookmark for cursor pagination\" })\n      );\n    }\n\n    if (path.startsWith(\"findOneBy/\") || path.startsWith(\"findBy/\")) {\n      base.push(\n        ApiNotFoundResponse({\n          description: `No ${modelClazzName} record matches the provided identifier.`,\n        })\n      );\n    }\n\n    if (\n      statementKey === PreparedStatementKeys.COUNT_OF ||\n      statementKey === PreparedStatementKeys.AVG_OF ||\n      statementKey === PreparedStatementKeys.SUM_OF\n    ) {\n      base.push(ApiOkResponse({ description: `Result for ${modelClazzName}.`, type: Number }));\n    }\n    if (statementKey === PreparedStatementKeys.DISTINCT_OF) {\n      base.push(ApiOkResponse({ description: `Distinct values for ${modelClazzName}.`, type: [String] }));\n    }\n\n    return base;\n  }\n\n  private static getQueryDecorators(\n    methodName: string,\n    routePath: string,\n    httpVerb: string,\n    includeQueryParams: boolean = false\n  ): Array<(target: any, key: string, desc: any) => void> {\n    const extractPathParams = (p: string): string[] =>\n      p.split(\"/\").filter((s) => s.startsWith(\":\")).map((s) => s.slice(1));\n\n    const apiPathParams = extractPathParams(routePath).map((name) => ({\n      name,\n      description: `${name} parameter for the query`,\n      required: true,\n      type: String,\n    }));\n\n    const decorators: Array<(target: any, key: string, desc: any) => void> = [\n      ...apiPathParams.map((p) => ApiParam(p)),\n      ApiOperation({ summary: `Retrieve records using \"${methodName}\".` }),\n      ApiOkResponse({ description: \"Result successfully retrieved.\" }),\n      ApiNoContentResponse({ description: \"No content returned by the method.\" }),\n    ];\n\n    if (httpVerb === \"GET\" && includeQueryParams) {\n      decorators.push(\n        ApiQuery({\n          name: \"direction\",\n          required: false,\n          enum: OrderDirection,\n          description: \"the sort order when applicable\",\n        }),\n        ApiQuery({ name: \"limit\", required: false, description: \"limit or page size\" }),\n        ApiQuery({ name: \"offset\", required: false, description: \"offset or bookmark\" })\n      );\n    }\n\n    return decorators;\n  }\n}\n"]}