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

package/dist/for-nest.js

@@ -2,11 +2,11 @@ import { apply, Metadata, Decoration, DecorationKeys } from "@decaf-ts/decoratio
 
 import { InjectablesKeys, DefaultInjectablesConfig } from "@decaf-ts/injectable-decorators";
 
-import { Delete, Patch, Put, Post, Get, applyDecorators, createParamDecorator as createParamDecorator$1, InternalServerErrorException, Injectable, Scope, Inject, Optional, UseInterceptors, SetMetadata, Module, Query, Controller, Response, Param, NotFoundException, NotAcceptableException, Catch, UseFilters, Logger, Global, Sse } from "@nestjs/common";
+import { Delete, Patch, Put, Post, Get, applyDecorators, createParamDecorator as createParamDecorator$1, InternalServerErrorException, Injectable, Scope, Inject, Optional, UseInterceptors, SetMetadata, Query, Module, Controller, Response, Param, NotFoundException, NotAcceptableException, Catch, UseFilters, Logger, Global, Sse } from "@nestjs/common";
 
 import { ModelBuilder, Model, ValidationKeys } from "@decaf-ts/decorator-validation";
 
-import { isOperationBlocked, PreparedStatementKeys, UUID, Adapter, AuthorizationError, Context, DefaultAdapterFlags, OrderDirection, ModelService, Service as Service$1, Repository as Repository$1, TransactionOperationKeys, PersistenceKeys, ForbiddenError, UnsupportedError, injectableServiceKey, PersistenceService } from "@decaf-ts/core";
+import { isOperationBlocked, PreparedStatementKeys, UUID, Adapter, OrderDirection, ModelService, AuthorizationError, Context, DefaultAdapterFlags, Service as Service$1, Repository as Repository$1, TransactionOperationKeys, PersistenceKeys, ForbiddenError, UnsupportedError, injectableServiceKey, PersistenceService } from "@decaf-ts/core";
 
 import { pickBy, negate, isUndefined as isUndefined$1, isArray, isString } from "lodash";
 
@@ -420,8 +420,6 @@ const DECAF_ROUTE = "DecafRoute";
 
 const DECAF_HANDLERS = Symbol("DecafHandlers");
 
-const DECAF_ADAPTER_OPTIONS = Symbol("DecafAdapterForOptions");
-
 const DECAF_EXPOSE = "DecafExpose";
 
 const DECAF_CONTROLLER_CONFIG = "DecafControllerConfig";
@@ -450,6 +448,8 @@ const IS_PUBLIC_KEY = "isPublic";
 
 const REQUIRED_ROLES_KEY = "requiredRoles";
 
+const SKIP_MODEL_ROLES_KEY = "skipModelRoles";
+
 let DecafRequestContext = class DecafRequestContext extends RequestContext {
     constructor(req) {
         super({
@@ -487,11 +487,13 @@ let AuthInterceptor = class AuthInterceptor {
         const isPublic = this.reflector.getAllAndOverride(IS_PUBLIC_KEY, [ ctx.getHandler(), ctx.getClass() ]);
         const modelName = this.reflector.get(AUTH_META_KEY, ctx.getHandler()) ?? this.reflector.get(AUTH_META_KEY, ctx.getClass());
         const requiredRoles = this.reflector.getAllAndOverride(REQUIRED_ROLES_KEY, [ ctx.getHandler(), ctx.getClass() ]);
+        const skipModelRoles = this.reflector.getAllAndOverride(SKIP_MODEL_ROLES_KEY, [ ctx.getHandler(), ctx.getClass() ]);
+        const effectiveModel = skipModelRoles ? undefined : modelName;
         log.verbose(`Intercepted request${modelName ? ` for ${modelName}` : ""}`);
         if (isPublic) {
             log.debug(`Public route — skipping auth`);
         } else if (this.authHandler) {
-            await this.authHandler.authorize(ctx, modelName, requiredRoles, this.requestContext);
+            await this.authHandler.authorize(ctx, effectiveModel, requiredRoles, this.requestContext);
         } else {
             log.debug(`No auth handler registered`);
         }
@@ -526,24 +528,6 @@ AuthInterceptor = __decorate([ Injectable({
     scope: Scope.REQUEST
 }), __param(2, Optional()), __param(2, Inject(AUTH_HANDLER)), __metadata("design:paramtypes", [ Reflector, DecafRequestContext, Object ]) ], AuthInterceptor);
 
-class DecafAuthHandler extends AuthHandler {
-    parseRequest(req) {
-        const userRole = req.headers.authorization?.split(" ")[1];
-        return userRole;
-    }
-    extractFromAuth(ctx) {
-        const req = ctx.switchToHttp().getRequest();
-        const userRole = this.parseRequest(req);
-        if (!userRole) throw new AuthorizationError("Unauthenticated");
-        return {
-            user: userRole,
-            roles: [ userRole ]
-        };
-    }
-}
-
-class DecafRoleAuthHandler extends DecafAuthHandler {}
-
 function Auth(model) {
     const resource = model ? typeof model === "string" ? model : model.name : undefined;
     const decs = [ ApiBearerAuth(), UseInterceptors(AuthInterceptor) ];
@@ -559,39 +543,115 @@ function RequireRoles(...roles) {
     return applyDecorators(ApiSecurity("bearer"), SetMetadata(REQUIRED_ROLES_KEY, roles), UseInterceptors(AuthInterceptor));
 }
 
-var DecafHandlerExecutor_1;
+function HttpVerbToDecorator(verb) {
+    const httpToCrud = {
+        GET: Get,
+        POST: Post,
+        PUT: Put,
+        PATCH: Patch,
+        DELETE: Delete
+    };
+    const decorator = httpToCrud[verb];
+    if (!decorator) {
+        throw new Error(`Unsupported HTTP verb "${verb}". No NestJS decorator mapping was found.`);
+    }
+    return decorator;
+}
 
-let DecafHandlerExecutor = DecafHandlerExecutor_1 = class DecafHandlerExecutor {
-    constructor(handlers, context) {
-        this.handlers = handlers;
-        this.context = context;
+const extractPathParams = routePath => routePath.split("/").filter(p => p.startsWith(":")).map(p => p.slice(1));
+
+const apiParamSpec = name => ({
+    name: name,
+    description: `${name} parameter for the query`,
+    required: true,
+    type: String
+});
+
+function getApiDecorators(methodName, routePath, httpVerb, includeQueryParams = false) {
+    const NestHttpRouteDec = HttpVerbToDecorator(httpVerb);
+    const apiPathParams = extractPathParams(routePath).map(apiParamSpec);
+    const swaggerQueryParams = [];
+    if (httpVerb === "GET" && includeQueryParams) {
+        swaggerQueryParams.push(ApiQuery({
+            name: "direction",
+            required: false,
+            enum: OrderDirection,
+            description: "the sort order when applicable"
+        }), ApiQuery({
+            name: "limit",
+            required: false,
+            description: "limit or page size when applicable"
+        }), ApiQuery({
+            name: "offset",
+            required: false,
+            description: "offset or bookmark when applicable"
+        }));
     }
-    async exec(req, res) {
-        const log = Logging.for(DecafHandlerExecutor_1.name).for(this.exec);
-        log.debug(`CONTEXT ${this.context.uuid} running ${this.handlers.length} handlers for request ${req.method} ${req.url}`);
-        for (const handler of this.handlers) {
-            await handler.handle(this.context, req, res);
-        }
+    return {
+        method: [ NestHttpRouteDec(routePath), ...apiPathParams.map(ApiParam), ...swaggerQueryParams, ApiOperation({
+            summary: `Retrieve records using according to "${methodName}".`
+        }), ApiOkResponse({
+            description: `Result successfully retrieved.`
+        }), ApiNoContentResponse({
+            description: `No content returned by the method.`
+        }) ],
+        params: [ DecafParams(apiPathParams), Query() ]
+    };
+}
+
+function applyApiDecorators(target, methodName, descriptor, decorators) {
+    const proto = target?.prototype ?? target;
+    decorators.method.forEach(d => d(proto, methodName, descriptor));
+    decorators.params?.forEach((d, index) => d(proto, methodName, index));
+}
+
+function resolvePersistenceMethod(persistence, methodName, ...args) {
+    if (persistence instanceof ModelService) {
+        return typeof persistence[methodName] === "function" ? persistence[methodName](...args) : persistence.statement(methodName, ...args);
     }
-};
+    if (typeof persistence[methodName] === "function") return persistence[methodName](...args);
+    throw new Error(`Persistence method "${methodName}" not found on ${persistence?.constructor?.name}`);
+}
 
-DecafHandlerExecutor = DecafHandlerExecutor_1 = __decorate([ Injectable({
-    scope: Scope.REQUEST
-}), __param(0, Inject(DECAF_HANDLERS)), __metadata("design:paramtypes", [ Array, DecafRequestContext ]) ], DecafHandlerExecutor);
+function createRouteHandler(methodName) {
+    return async function(pathParams, queryParams) {
+        const log = this.log.for(methodName);
+        try {
+            log.debug(`Invoking persistence method "${methodName}" given parameters: ${JSON.stringify(pathParams.valuesInOrder)}`);
+            const {direction: direction, limit: limit, offset: offset} = queryParams;
+            return await resolvePersistenceMethod(this.persistence(), methodName, ...pathParams.valuesInOrder, direction, limit, offset);
+        } catch (e) {
+            log.error(`Custom query "${methodName}" failed`, e);
+            throw e;
+        }
+    };
+}
 
-let DecafResponseInterceptor = class DecafResponseInterceptor {
-    constructor(ctx) {
-        this.ctx = ctx;
+function defineRouteMethod(ControllerClass, methodName, handler) {
+    Object.defineProperty(ControllerClass.prototype || ControllerClass, methodName, {
+        value: handler,
+        writable: false
+    });
+    return Object.getOwnPropertyDescriptor(ControllerClass.prototype || ControllerClass, methodName);
+}
+
+class DecafAuthHandler extends AuthHandler {
+    parseRequest(req) {
+        const userRole = req.headers.authorization?.split(" ")[1];
+        return userRole;
     }
-    intercept(context, next) {
-        let response = context.switchToHttp().getResponse();
-        return next.handle().pipe(tap(data => {
-            response = this.ctx.toResponse(response);
-        }));
+    extractFromAuth(ctx) {
+        const req = ctx.switchToHttp().getRequest();
+        const userRole = this.parseRequest(req);
+        if (!userRole) throw new AuthorizationError("Unauthenticated");
+        return {
+            user: userRole,
+            roles: [ userRole ]
+        };
     }
-};
+}
 
-DecafResponseInterceptor = __decorate([ Injectable(), __metadata("design:paramtypes", [ DecafRequestContext ]) ], DecafResponseInterceptor);
+class DecafRoleAuthHandler extends DecafAuthHandler {}
 
 Adapter.transformerFor = function toContextFlags(adapter) {
     const alias = typeof adapter === "string" ? adapter : adapter.alias;
@@ -657,7 +717,6 @@ let DecafRequestHandlerInterceptor = DecafRequestHandlerInterceptor_1 = class De
             headers: headers,
             overrides: {}
         };
-        Object.assign(flags.overrides, req?.[DECAF_ADAPTER_OPTIONS] ?? {});
         const ip = extractIp(req);
         const logger = Logging.get().for({
             ip: ip
@@ -727,97 +786,39 @@ let DecafAuthModule = DecafAuthModule_1 = class DecafAuthModule {
 
 DecafAuthModule = DecafAuthModule_1 = __decorate([ Module({}) ], DecafAuthModule);
 
-function HttpVerbToDecorator(verb) {
-    const httpToCrud = {
-        GET: Get,
-        POST: Post,
-        PUT: Put,
-        PATCH: Patch,
-        DELETE: Delete
-    };
-    const decorator = httpToCrud[verb];
-    if (!decorator) {
-        throw new Error(`Unsupported HTTP verb "${verb}". No NestJS decorator mapping was found.`);
-    }
-    return decorator;
-}
-
-const extractPathParams = routePath => routePath.split("/").filter(p => p.startsWith(":")).map(p => p.slice(1));
-
-const apiParamSpec = name => ({
-    name: name,
-    description: `${name} parameter for the query`,
-    required: true,
-    type: String
-});
+var DecafHandlerExecutor_1;
 
-function getApiDecorators(methodName, routePath, httpVerb, includeQueryParams = false) {
-    const NestHttpRouteDec = HttpVerbToDecorator(httpVerb);
-    const apiPathParams = extractPathParams(routePath).map(apiParamSpec);
-    const swaggerQueryParams = [];
-    if (httpVerb === "GET" && includeQueryParams) {
-        swaggerQueryParams.push(ApiQuery({
-            name: "direction",
-            required: false,
-            enum: OrderDirection,
-            description: "the sort order when applicable"
-        }), ApiQuery({
-            name: "limit",
-            required: false,
-            description: "limit or page size when applicable"
-        }), ApiQuery({
-            name: "offset",
-            required: false,
-            description: "offset or bookmark when applicable"
-        }));
+let DecafHandlerExecutor = DecafHandlerExecutor_1 = class DecafHandlerExecutor {
+    constructor(handlers, context) {
+        this.handlers = handlers;
+        this.context = context;
     }
-    return {
-        method: [ NestHttpRouteDec(routePath), ...apiPathParams.map(ApiParam), ...swaggerQueryParams, ApiOperation({
-            summary: `Retrieve records using according to "${methodName}".`
-        }), ApiOkResponse({
-            description: `Result successfully retrieved.`
-        }), ApiNoContentResponse({
-            description: `No content returned by the method.`
-        }) ],
-        params: [ DecafParams(apiPathParams), Query() ]
-    };
-}
+    async exec(req, res) {
+        const log = Logging.for(DecafHandlerExecutor_1.name).for(this.exec);
+        log.debug(`CONTEXT ${this.context.uuid} running ${this.handlers.length} handlers for request ${req.method} ${req.url}`);
+        for (const handler of this.handlers) {
+            await handler.handle(this.context, req, res);
+        }
+    }
+};
 
-function applyApiDecorators(target, methodName, descriptor, decorators) {
-    const proto = target?.prototype ?? target;
-    decorators.method.forEach(d => d(proto, methodName, descriptor));
-    decorators.params?.forEach((d, index) => d(proto, methodName, index));
-}
+DecafHandlerExecutor = DecafHandlerExecutor_1 = __decorate([ Injectable({
+    scope: Scope.REQUEST
+}), __param(0, Inject(DECAF_HANDLERS)), __metadata("design:paramtypes", [ Array, DecafRequestContext ]) ], DecafHandlerExecutor);
 
-function resolvePersistenceMethod(persistence, methodName, ...args) {
-    if (persistence instanceof ModelService) {
-        return typeof persistence[methodName] === "function" ? persistence[methodName](...args) : persistence.statement(methodName, ...args);
+let DecafResponseInterceptor = class DecafResponseInterceptor {
+    constructor(ctx) {
+        this.ctx = ctx;
     }
-    if (typeof persistence[methodName] === "function") return persistence[methodName](...args);
-    throw new Error(`Persistence method "${methodName}" not found on ${persistence?.constructor?.name}`);
-}
-
-function createRouteHandler(methodName) {
-    return async function(pathParams, queryParams) {
-        const log = this.log.for(methodName);
-        try {
-            log.debug(`Invoking persistence method "${methodName}" given parameters: ${JSON.stringify(pathParams.valuesInOrder)}`);
-            const {direction: direction, limit: limit, offset: offset} = queryParams;
-            return await resolvePersistenceMethod(this.persistence(), methodName, ...pathParams.valuesInOrder, direction, limit, offset);
-        } catch (e) {
-            log.error(`Custom query "${methodName}" failed`, e);
-            throw e;
-        }
-    };
-}
+    intercept(context, next) {
+        let response = context.switchToHttp().getResponse();
+        return next.handle().pipe(tap(data => {
+            response = this.ctx.toResponse(response);
+        }));
+    }
+};
 
-function defineRouteMethod(ControllerClass, methodName, handler) {
-    Object.defineProperty(ControllerClass.prototype || ControllerClass, methodName, {
-        value: handler,
-        writable: false
-    });
-    return Object.getOwnPropertyDescriptor(ControllerClass.prototype || ControllerClass, methodName);
-}
+DecafResponseInterceptor = __decorate([ Injectable(), __metadata("design:paramtypes", [ DecafRequestContext ]) ], DecafResponseInterceptor);
 
 class DecafController extends DecafController$1 {
     constructor(clientContext, _name) {
@@ -841,11 +842,8 @@ class DecafModelController extends DecafController {
                 this._persistence = Repository$1.forModel(this.class);
             }
         }
-        const certs = this.clientContext.request[DECAF_ADAPTER_OPTIONS] || {};
-        if (ctx) {
-            this.clientContext.put(certs);
-        }
-        return ctx ? this._persistence instanceof Repository$1 ? this._persistence.override(certs) : this._persistence.for(certs) : this._persistence;
+        const overrides = this.clientContext.toOverrides();
+        return ctx ? this._persistence instanceof Repository$1 ? this._persistence.override(overrides) : this._persistence.for(overrides) : this._persistence;
     }
 }
 
@@ -1103,7 +1101,7 @@ class FromModelController {
         }
         return QueryController;
     }
-    static create(ModelConstr, moduleConfigOverrides) {
+    static create(ModelConstr, moduleConfigOverrides, globalDefaults) {
         const log = FromModelController.log.for(FromModelController.create);
         const tableName = Model.tableName(ModelConstr);
         const routePath = toKebabCase(tableName);
@@ -1113,6 +1111,7 @@ class FromModelController {
         const decoratorConfig = Metadata.get(ModelConstr, Metadata.key(DECAF_CONTROLLER_CONFIG));
         const moduleOverride = moduleConfigOverrides?.[ModelConstr.name];
         const mergedConfig = {
+            ...globalDefaults || {},
             ...decoratorConfig || {},
             ...moduleOverride || {}
         };
@@ -1120,6 +1119,19 @@ class FromModelController {
         const factoryRoutes = FactoryController.__routes__;
         const {getPK: getPK, apiProperties: 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;
@@ -1133,7 +1145,8 @@ class FromModelController {
                 log.info(`Registering dynamic controller for model: ${this.class.name} route: /${routePath}`);
             }
         };
-        DynamicModelController = DynamicModelController_1 = __decorate([ Controller(routePath), ApiTags(modelClazzName), ApiExtraModels(ModelConstr), Auth(ModelConstr), __metadata("design:paramtypes", [ DecafRequestContext ]) ], DynamicModelController);
+        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);
@@ -2019,7 +2032,11 @@ function getModuleFor(flavour) {
                 modelServices = this.createModelServices(trackedModels);
                 log.info(`Auto-services completed. ${modelServices.length} services initialized.`);
             }
-            const controllers = trackedModels.map(model => FromModelController.create(model, options.controllerConfig));
+            const globalDefaults = {};
+            if (options.aggregations === false) {
+                globalDefaults.allowGroupingQueries = false;
+            }
+            const controllers = trackedModels.map(model => FromModelController.create(model, options.controllerConfig, globalDefaults));
             log.info(`Generated ${controllers.length} controllers`);
             return {
                 module: DecafModelModule_1,
@@ -2695,7 +2712,8 @@ let DecafModule = DecafModule_1 = class DecafModule {
                 imports.push(getModuleFor(flavour).forRoot(flavour, {
                     autoServices: autoServices,
                     controllerExposure: options.controllerExposure,
-                    controllerConfig: options.controllerConfig
+                    controllerConfig: options.controllerConfig,
+                    aggregations: options.aggregations
                 }));
             });
         }
@@ -2720,11 +2738,11 @@ function repoForModel(model) {
     return repo;
 }
 
-const VERSION = "0.11.2";
+const VERSION = "0.11.2-refactor.2";
 
-const COMMIT = "0a94615";
+const COMMIT = "85f1cec";
 
-const FULL_VERSION = "0.11.2-0a94615";
+const FULL_VERSION = "0.11.2-refactor.2-85f1cec";
 
 const PACKAGE_NAME = "@decaf-ts/for-nest";
 
@@ -2734,5 +2752,5 @@ Metadata.registerLibrary(PACKAGE_NAME, VERSION);
 
 Metadata.allowReregistration(false);
 
-export { AUTH_HANDLER, AUTH_META_KEY, ApiOperationFromModel, ApiParamsFromModel, ApiProperty, Auth, AuthInterceptor, BulkApiOperationFromModel, COMMIT, CorsError, DECAF_ADAPTER_ID, DECAF_ADAPTER_OPTIONS, DECAF_CONTEXT_KEY, DECAF_CONTROLLER_CONFIG, DECAF_EXPOSE, DECAF_HANDLERS, DECAF_MODULE_OPTIONS, DECAF_ROUTE, DECAF_TASK_SERVICE_ID, DECORATORS, DECORATORS_PREFIX, DecafAuthHandler, DecafAuthModule, DecafBody, DecafController, DecafCoreModule, DecafExceptionFilter, DecafHandlerExecutor, DecafModelController, DecafModule, DecafParams, DecafRequestContext, DecafRequestHandlerInterceptor, DecafResponseInterceptor, DecafRoleAuthHandler, DecafStreamModule, DtoFor, EventsController, FULL_VERSION, FromModelController, IS_PUBLIC_KEY, NestBootstraper, PACKAGE_NAME, Public, REQUIRED_ROLES_KEY, Repository, RequireRoles, Service, SwaggerBuilder, UseDecafFilter, UseDecafHeaders, VERSION, applyApiDecorators, controllerConfig, createApiPropertyDecorator, createPropertyDecorator, createRouteHandler, defineRouteMethod, expose, getApiDecorators, getEnumType, getEnumValues, getModuleFor, getRegisteredDecafProviders, isUndefined, repoForModel, resolvePersistenceMethod, runMigrations };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"for-nest.js","sources":["../src/overrides/constants.ts","../src/overrides/helpers.ts","../src/overrides/decoration.ts","../src/decaf-model/decorators/ApiOperationFromModel.ts","../src/decaf-model/decorators/ApiParamsFromModel.ts","../src/decaf-model/decorators/DecafBody.ts","../src/decaf-model/decorators/DecafParams.ts","../src/constants.ts","../src/decaf-model/decorators/expose.ts","../src/decaf-model/decorators/controller-config.ts","../src/auth/constants.ts","../src/request/DecafRequestContext.ts","../src/auth/AuthInterceptor.ts","../src/auth/DecafAuthHandler.ts","../src/auth/decorators.ts","../src/request/DecafHandlerExecutor.ts","../src/request/DecafResponseInterceptor.ts","../src/overrides/overrides.ts","../src/overrides/ModelBuilderExtensions.ts","../src/interceptors/DecafRequestHandlerInterceptor.ts","../src/auth/DecafAuthModule.ts","../src/decaf-model/decorators/utils.ts","../src/decaf-model/utils.ts","../src/controllers.ts","../src/factory/openapi/DtoBuilder.ts","../src/decaf-model/FromModelController.ts","../src/decaf-model/DecafModelModule.ts","../src/decoration.ts","../src/factory/errors/cors.ts","../src/factory/errors/throttling.ts","../src/factory/exceptions/DecafErrorFilter.ts","../src/factory/exceptions/decorators.ts","../src/factory/openapi/constants.ts","../src/factory/openapi/SwaggerCustomUI.ts","../src/factory/openapi/SwaggerBuilder.ts","../src/factory/NestBootstraper.ts","../src/decorators.ts","../src/core-module.ts","../src/events-module/constant.ts","../src/events-module/utils.ts","../src/events-module/EventsController.ts","../src/events-module/DecafStreamModule.ts","../src/module.ts","../src/utils.ts","../src/index.ts"],"sourcesContent":["export const DECORATORS_PREFIX = \"swagger\";\nexport const DECORATORS = {\n  API_OPERATION: `${DECORATORS_PREFIX}/apiOperation`,\n  API_RESPONSE: `${DECORATORS_PREFIX}/apiResponse`,\n  API_PRODUCES: `${DECORATORS_PREFIX}/apiProduces`,\n  API_CONSUMES: `${DECORATORS_PREFIX}/apiConsumes`,\n  API_TAGS: `${DECORATORS_PREFIX}/apiUseTags`,\n  API_CALLBACKS: `${DECORATORS_PREFIX}/apiCallbacks`,\n  API_PARAMETERS: `${DECORATORS_PREFIX}/apiParameters`,\n  API_HEADERS: `${DECORATORS_PREFIX}/apiHeaders`,\n  API_MODEL_PROPERTIES: `${DECORATORS_PREFIX}/apiModelProperties`,\n  API_MODEL_PROPERTIES_ARRAY: `${DECORATORS_PREFIX}/apiModelPropertiesArray`,\n  API_SECURITY: `${DECORATORS_PREFIX}/apiSecurity`,\n  API_EXCLUDE_ENDPOINT: `${DECORATORS_PREFIX}/apiExcludeEndpoint`,\n  API_EXCLUDE_CONTROLLER: `${DECORATORS_PREFIX}/apiExcludeController`,\n  API_EXTRA_MODELS: `${DECORATORS_PREFIX}/apiExtraModels`,\n  API_EXTENSION: `${DECORATORS_PREFIX}/apiExtension`,\n  API_SCHEMA: `${DECORATORS_PREFIX}/apiSchema`,\n  API_DEFAULT_GETTER: `${DECORATORS_PREFIX}/apiDefaultGetter`,\n  API_LINK: `${DECORATORS_PREFIX}/apiLink`,\n};\n","import { isArray, isUndefined, negate, pickBy } from \"lodash\";\nimport { DECORATORS } from \"./constants\";\n\nexport const isConstructor = (val: any): boolean => val === \"constructor\";\nexport const METADATA_FACTORY_NAME = \"_OPENAPI_METADATA_FACTORY\";\n\nexport const METHOD_METADATA = \"method\";\n\nexport function createMethodDecorator<T = any>(\n  metakey: string,\n  metadata: T,\n  { overrideExisting } = { overrideExisting: true }\n): MethodDecorator {\n  return (\n    target: object,\n    key: string | symbol,\n    descriptor: PropertyDescriptor\n  ) => {\n    if (typeof metadata === \"object\") {\n      const prevValue = Reflect.getMetadata(metakey, descriptor.value);\n      if (prevValue && !overrideExisting) {\n        return descriptor;\n      }\n      Reflect.defineMetadata(\n        metakey,\n        { ...prevValue, ...metadata },\n        descriptor.value\n      );\n      return descriptor;\n    }\n    Reflect.defineMetadata(metakey, metadata, descriptor.value);\n    return descriptor;\n  };\n}\n\nexport function createClassDecorator<T extends Array<any> = any>(\n  metakey: string,\n  metadata: T = [] as any\n): ClassDecorator {\n  return (target) => {\n    const prevValue = Reflect.getMetadata(metakey, target) || [];\n    Reflect.defineMetadata(metakey, [...prevValue, ...metadata], target);\n    return target;\n  };\n}\n\nexport function createPropertyDecorator<T extends Record<string, any> = any>(\n  metakey: string,\n  metadata: T,\n  overrideExisting = true\n): PropertyDecorator {\n  return ((target: object, propertyKey: string) => {\n    const properties =\n      Reflect.getMetadata(DECORATORS.API_MODEL_PROPERTIES_ARRAY, target) || [];\n\n    const key = `:${propertyKey}`;\n    if (!properties.includes(key)) {\n      Reflect.defineMetadata(\n        DECORATORS.API_MODEL_PROPERTIES_ARRAY,\n        [...properties, `:${propertyKey}`],\n        target\n      );\n    }\n    const existingMetadata = Reflect.getMetadata(metakey, target, propertyKey);\n    if (existingMetadata) {\n      const newMetadata = pickBy(metadata, negate(isUndefined));\n      const metadataToSave = overrideExisting\n        ? {\n            ...existingMetadata,\n            ...newMetadata,\n          }\n        : {\n            ...newMetadata,\n            ...existingMetadata,\n          };\n\n      Reflect.defineMetadata(metakey, metadataToSave, target, propertyKey);\n    } else {\n      const type =\n        (target?.constructor as any)?.[METADATA_FACTORY_NAME as any]?.()[\n          propertyKey\n        ]?.type ?? Reflect.getMetadata(\"design:type\", target, propertyKey);\n\n      Reflect.defineMetadata(\n        metakey,\n        {\n          type,\n          ...pickBy(metadata, negate(isUndefined)),\n        },\n        target,\n        propertyKey\n      );\n    }\n  }) as PropertyDecorator;\n}\n\nexport function createMixedDecorator<T = any>(\n  metakey: string,\n  metadata: T\n): MethodDecorator & ClassDecorator {\n  return (\n    target: object,\n    key?: string | symbol,\n    descriptor?: TypedPropertyDescriptor<any>\n  ): any => {\n    if (descriptor) {\n      let metadatas: any;\n      if (Array.isArray(metadata)) {\n        const previousMetadata =\n          Reflect.getMetadata(metakey, descriptor.value) || [];\n        metadatas = [...previousMetadata, ...metadata];\n      } else {\n        const previousMetadata =\n          Reflect.getMetadata(metakey, descriptor.value) || {};\n        metadatas = { ...previousMetadata, ...metadata };\n      }\n      Reflect.defineMetadata(metakey, metadatas, descriptor.value);\n      return descriptor;\n    }\n\n    let metadatas: any;\n    if (Array.isArray(metadata)) {\n      const previousMetadata = Reflect.getMetadata(metakey, target) || [];\n      metadatas = [...previousMetadata, ...metadata];\n    } else {\n      const previousMetadata = Reflect.getMetadata(metakey, target) || {};\n      metadatas = Object.assign(Object.assign({}, previousMetadata), metadata);\n    }\n    Reflect.defineMetadata(metakey, metadatas, target);\n    return target;\n  };\n}\n\nexport function createParamDecorator<T extends Record<string, any> = any>(\n  metadata: T,\n  initial: Partial<T>\n): MethodDecorator & ClassDecorator {\n  return (\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n    target: object | Function,\n    key?: string | symbol,\n    descriptor?: TypedPropertyDescriptor<any>\n  ): any => {\n    const paramOptions = {\n      ...initial,\n      ...pickBy(metadata, negate(isUndefined)),\n    };\n\n    if (descriptor) {\n      const parameters =\n        Reflect.getMetadata(DECORATORS.API_PARAMETERS, descriptor.value) || [];\n      Reflect.defineMetadata(\n        DECORATORS.API_PARAMETERS,\n        [...parameters, paramOptions],\n        descriptor.value\n      );\n      return descriptor;\n    }\n\n    if (typeof target === \"object\") {\n      return target;\n    }\n\n    const propertyKeys = Object.getOwnPropertyNames(target.prototype);\n\n    for (const propertyKey of propertyKeys) {\n      if (isConstructor(propertyKey)) {\n        continue;\n      }\n\n      const methodDescriptor = Object.getOwnPropertyDescriptor(\n        target.prototype,\n        propertyKey\n      );\n\n      if (!methodDescriptor) {\n        continue;\n      }\n\n      const isApiMethod = Reflect.hasMetadata(\n        METHOD_METADATA,\n        methodDescriptor.value\n      );\n\n      if (!isApiMethod) {\n        continue;\n      }\n\n      const parameters =\n        Reflect.getMetadata(\n          DECORATORS.API_PARAMETERS,\n          methodDescriptor.value\n        ) || [];\n      Reflect.defineMetadata(\n        DECORATORS.API_PARAMETERS,\n        [...parameters, paramOptions],\n        methodDescriptor.value\n      );\n    }\n  };\n}\n\nexport function getTypeIsArrayTuple(\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  input: Function | [Function] | undefined | string | Record<string, any>,\n  isArrayFlag: boolean\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n): [Function | undefined, boolean] {\n  if (!input) {\n    return [input as undefined, isArrayFlag];\n  }\n  if (isArrayFlag) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n    return [input as Function, isArrayFlag];\n  }\n  const isInputArray = isArray(input);\n  const type = isInputArray ? input[0] : input;\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  return [type as Function, isInputArray];\n}\n","import { Type } from \"@nestjs/common\";\nimport { isString, negate, pickBy } from \"lodash\";\nimport { DECORATORS } from \"./constants\";\nimport { getTypeIsArrayTuple, METADATA_FACTORY_NAME } from \"./helpers\";\nimport type {\n  EnumAllowedTypes,\n  EnumSchemaAttributes,\n  SchemaObjectMetadata,\n  SwaggerEnumType,\n} from \"../swagger-types\";\n\nexport const isUndefined = (obj: any): obj is undefined =>\n  typeof obj === \"undefined\";\n\nexport function getEnumValues(\n  enumType: SwaggerEnumType | (() => SwaggerEnumType)\n): string[] | number[] {\n  if (typeof enumType === \"function\") {\n    return getEnumValues(enumType());\n  }\n\n  if (Array.isArray(enumType)) {\n    return enumType as string[];\n  }\n  if (typeof enumType !== \"object\") {\n    return [];\n  }\n  // Enums with numeric values\n  //   enum Size {\n  //     SMALL = 1,\n  //     BIG = 2\n  //   }\n  // are transpiled to include a reverse mapping\n  //   const Size = {\n  //     \"1\": \"SMALL\",\n  //     \"2\": \"BIG\",\n  //     \"SMALL\": 1,\n  //     \"BIG\": 2,\n  //   }\n  const numericValues = Object.values(enumType)\n    .filter((value) => typeof value === \"number\")\n    .map((value: any) => value.toString());\n\n  return Object.keys(enumType)\n    .filter((key) => !numericValues.includes(key))\n    .map((key) => enumType[key as any]);\n}\n\nexport function getEnumType(values: (string | number)[]): \"string\" | \"number\" {\n  const hasString = values.filter(isString).length > 0;\n  return hasString ? \"string\" : \"number\";\n}\n\nexport function createPropertyDecorator<T extends Record<string, any> = any>(\n  metakey: string,\n  metadata: T,\n  overrideExisting = true\n): PropertyDecorator {\n  return ((target: object, propertyKey: string) => {\n    const properties =\n      Reflect.getMetadata(DECORATORS.API_MODEL_PROPERTIES_ARRAY, target) || [];\n\n    const key = `:${propertyKey}`;\n    if (!properties.includes(key)) {\n      Reflect.defineMetadata(\n        DECORATORS.API_MODEL_PROPERTIES_ARRAY,\n        [...properties, `:${propertyKey}`],\n        target\n      );\n    }\n    const existingMetadata = Reflect.getMetadata(metakey, target, propertyKey);\n    if (existingMetadata) {\n      const newMetadata = pickBy(metadata, negate(isUndefined));\n      const metadataToSave = overrideExisting\n        ? {\n            ...existingMetadata,\n            ...newMetadata,\n          }\n        : {\n            ...newMetadata,\n            ...existingMetadata,\n          };\n\n      Reflect.defineMetadata(metakey, metadataToSave, target, propertyKey);\n    } else {\n      const type =\n        // @ts-expect-error nest js code\n        target?.constructor?.[METADATA_FACTORY_NAME]?.()[propertyKey]?.type ??\n        Reflect.getMetadata(\"design:type\", target, propertyKey);\n\n      Reflect.defineMetadata(\n        metakey,\n        {\n          type,\n          required: false, // Default to optional unless @required() is used\n          ...pickBy(metadata, negate(isUndefined)),\n        },\n        target,\n        propertyKey\n      );\n    }\n  }) as PropertyDecorator;\n}\n\nexport type ApiPropertyCommonOptions = SchemaObjectMetadata & {\n  \"x-enumNames\"?: string[];\n  /**\n   * Lazy function returning the type for which the decorated property\n   * can be used as an id\n   *\n   * Use together with @ApiDefaultGetter on the getter route of the type\n   * to generate OpenAPI link objects\n   *\n   * @see [Swagger link objects](https://swagger.io/docs/specification/links/)\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  link?: () => Type<unknown> | Function;\n};\n\nexport type ApiPropertyOptions =\n  | ApiPropertyCommonOptions\n  | (ApiPropertyCommonOptions & {\n      enumName: string;\n      enumSchema?: EnumSchemaAttributes;\n    });\n\nconst isEnumArray = (\n  opts: ApiPropertyOptions\n): opts is {\n  isArray: true;\n  enum: EnumAllowedTypes;\n  type: any;\n  items: any;\n} => (opts.isArray && \"enum\" in opts && opts.enum !== undefined) as boolean;\n\n/**\n * @publicApi\n */\nexport function ApiProperty(\n  options: ApiPropertyOptions = {}\n): PropertyDecorator {\n  return createApiPropertyDecorator(options);\n}\n\nexport function createApiPropertyDecorator(\n  options: ApiPropertyOptions = {},\n  overrideExisting = true\n): PropertyDecorator {\n  const [type, isArray] = getTypeIsArrayTuple(\n    options.type,\n    options.isArray as any\n  );\n  options = {\n    ...options,\n    type,\n    isArray,\n  } as ApiPropertyOptions;\n\n  if (isEnumArray(options)) {\n    options.type = \"array\";\n\n    const enumValues = getEnumValues(options.enum);\n    options.items = {\n      type: getEnumType(enumValues),\n      enum: enumValues,\n    };\n    // @ts-expect-error nest js code\n    delete options.enum;\n  } else if (\"enum\" in options && options.enum !== undefined) {\n    const enumValues = getEnumValues(options.enum);\n\n    options.enum = enumValues;\n    options.type = getEnumType(enumValues);\n  }\n\n  if (Array.isArray(options.type)) {\n    options.type = \"array\";\n    options.items = {\n      type: \"array\",\n      items: {\n        type: options.type[0],\n      },\n    };\n  }\n\n  return createPropertyDecorator(\n    DECORATORS.API_MODEL_PROPERTIES,\n    options,\n    overrideExisting\n  );\n}\n","import { apply, Metadata } from \"@decaf-ts/decoration\";\nimport { ApiExcludeEndpoint } from \"@nestjs/swagger\";\nimport {\n  BulkCrudOperationKeys,\n  OperationKeys,\n  CrudOperations,\n} from \"@decaf-ts/db-decorators\";\nimport { ModelConstructor } from \"@decaf-ts/decorator-validation\";\nimport { Delete, Get, Patch, Post, Put } from \"@nestjs/common\";\n\nimport { isOperationBlocked as coreIsOperationBlocked } from \"@decaf-ts/core\";\nimport { PreparedStatementKeys } from \"@decaf-ts/core\";\nimport { HttpVerbs } from \"./types\";\n\n/**\n * @description Determines if a given CRUD operation is blocked for a specific model constructor.\n * @summary Retrieves the operation-blocking handler metadata stored on the provided model constructor (under `OperationKeys.REFLECT + OperationKeys.BLOCK`), executes it (if present) with its persisted arguments plus the requested operation, and returns whether the operation is blocked. If no handler exists, the operation is considered allowed (returns `false`).\n * @param {ModelConstructor<any>} ModelConstructor - The target model constructor whose metadata may include a blocking handler.\n * @param {CrudOperations} op - The CRUD operation to evaluate (e.g., `OperationKeys.CREATE`, `OperationKeys.READ`, `OperationKeys.UPDATE`, `OperationKeys.DELETE`).\n * @return {boolean} `true` when the operation is explicitly blocked by the model's handler; otherwise `false`.\n * @function isOperationBlocked\n */\n/**\n * @description Conditionally applies an HTTP method decorator for a given model and verb, hiding the endpoint in Swagger (and not registering the route) when the model blocks that CRUD operation.\n * @summary Maps an HTTP verb to its corresponding `CrudOperations` key and Nest HTTP decorator (`@Get`, `@Post`, etc.). It checks `isOperationBlocked(ModelConstructor, crudOp)` and, if blocked, applies only `@ApiExcludeEndpoint()` (Swagger-hidden, no Nest route). If permitted, it applies the appropriate HTTP decorator with the optional `path`.\n * @param {ModelConstructor<any>} ModelConstructor - The model constructor used to resolve operation-blocking rules.\n * @param {HttpVerbs} verb - The HTTP verb to map (e.g., `\"GET\" | \"POST\" | \"PUT\" | \"PATCH\" | \"DELETE\"`).\n * @param {string} [path] - Optional route path passed through to the corresponding Nest HTTP method decorator.\n * @return {MethodDecorator} A method decorator that either excludes the endpoint from Swagger (and route registration) or applies the correct HTTP decorator.\n */\nexport function ApiOperationFromModel(\n  ModelConstructor: ModelConstructor<any>,\n  verb: HttpVerbs,\n  path?: string\n): MethodDecorator {\n  const httpToCrud: Record<\n    HttpVerbs,\n    [CrudOperations, (path?: string) => MethodDecorator]\n  > = {\n    GET: [OperationKeys.READ, Get],\n    POST: [OperationKeys.CREATE, Post],\n    PUT: [OperationKeys.UPDATE, Put],\n    PATCH: [OperationKeys.UPDATE, Patch],\n    DELETE: [OperationKeys.DELETE, Delete],\n  };\n\n  const [crudOp, HttpMethodDecorator] = httpToCrud[verb];\n  const target = resolveBlockTarget(verb, path);\n  return target\n    ? coreIsOperationBlocked(ModelConstructor, target.kind as any, target.value)\n      ? apply(ApiExcludeEndpoint())\n      : apply(HttpMethodDecorator(path))\n    : coreIsOperationBlocked(ModelConstructor, crudOp)\n    ? apply(ApiExcludeEndpoint())\n    : apply(HttpMethodDecorator(path));\n}\n/**\n * @description Conditionally applies an HTTP method decorator for a given model and verb, hiding the endpoint in Swagger (and not registering the route) when the model blocks that CRUD operation.\n * @summary Maps an HTTP verb to its corresponding `CrudOperations` key and Nest HTTP decorator (`@Get`, `@Post`, etc.). It checks `isOperationBlocked(ModelConstructor, crudOp)` and, if blocked, applies only `@ApiExcludeEndpoint()` (Swagger-hidden, no Nest route). If permitted, it applies the appropriate HTTP decorator with the optional `path`.\n * @param {ModelConstructor<any>} ModelConstructor - The model constructor used to resolve operation-blocking rules.\n * @param {HttpVerbs} verb - The HTTP verb to map (e.g., `\"GET\" | \"POST\" | \"PUT\" | \"PATCH\" | \"DELETE\"`).\n * @param {string} [path] - Optional route path passed through to the corresponding Nest HTTP method decorator.\n * @return {MethodDecorator} A method decorator that either excludes the endpoint from Swagger (and route registration) or applies the correct HTTP decorator.\n */\nexport function BulkApiOperationFromModel(\n  ModelConstructor: ModelConstructor<any>,\n  verb: HttpVerbs,\n  path?: string\n): MethodDecorator {\n  const httpToCrud: Record<\n    HttpVerbs,\n    [BulkCrudOperationKeys, (path?: string) => MethodDecorator]\n  > = {\n    GET: [BulkCrudOperationKeys.READ_ALL, Get],\n    POST: [BulkCrudOperationKeys.CREATE_ALL, Post],\n    PUT: [BulkCrudOperationKeys.UPDATE_ALL, Put],\n    PATCH: [BulkCrudOperationKeys.UPDATE_ALL, Patch],\n    DELETE: [BulkCrudOperationKeys.DELETE_ALL, Delete],\n  };\n\n  const [crudOp, HttpMethodDecorator] = httpToCrud[verb];\n  const target = path ? resolveBlockTarget(verb, path) : undefined;\n  return target\n    ? coreIsOperationBlocked(ModelConstructor, target.kind as any, target.value)\n      ? apply(ApiExcludeEndpoint())\n      : apply(HttpMethodDecorator(path))\n    : coreIsOperationBlocked(ModelConstructor, \"bulk\" as any, crudOp as any)\n    ? apply(ApiExcludeEndpoint())\n    : apply(HttpMethodDecorator(path));\n}\nfunction resolveBlockTarget(\n  verb: HttpVerbs,\n  path?: string\n): { kind: \"crud\" | \"statement\" | \"query\" | \"bulk\"; value: string } | undefined {\n  if (!path) return undefined;\n\n  const normalized = path.replace(/^\\/+|\\/+$/g, \"\");\n  const statementTargets: 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    \"statement/:method/*args\": \"statement\",\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  if (normalized.startsWith(\"query/\")) {\n    return { kind: \"query\", value: normalized.replace(/^query\\//, \"\") };\n  }\n\n  const statementValue = statementTargets[normalized];\n  if (statementValue) {\n    return { kind: \"statement\", value: statementValue };\n  }\n\n  if (verb === \"GET\" && normalized === \"\") {\n    return { kind: \"crud\", value: OperationKeys.READ };\n  }\n\n  return undefined;\n}\n","import { applyDecorators } from \"@nestjs/common\";\nimport { ApiParam as ApiParamDec } from \"@nestjs/swagger\";\nimport type { DecafApiProperty } from \"./types\";\n\n/**\n * @description Applies a set of Swagger `@ApiParam` decorators generated from a typed specification array.\n * @summary Transforms each entry of the provided `ApiParam[]` into a corresponding `@ApiParam()` decorator (defaulting `description`, `required`, and `type` when omitted) and composes them into a single decorator via Nest's `applyDecorators`. Useful for synchronizing runtime route params with OpenAPI documentation in a concise, declarative way.\n * @param {ApiParam[]} [props=[]] Array describing path parameters to be documented.\n * @param {string} props[].name The parameter's name as it appears in the route template (e.g., `:id`).\n * @param {string} [props[].description] Human-readable explanation of the parameter; defaults to `\"Path parameter: <name>\"`.\n * @param {boolean} [props[].required=true] Whether the parameter is required; defaults to `true`.\n * @param {Constructor<any>} [props[].type=String] Constructor/type used by Swagger to infer schema (e.g., `String`, `Number`, `UUID`, custom class).\n * @return {any} A composed decorator applying all generated `@ApiParam` decorators to the target method or controller.\n * @function ApiParamsFromModel\n */\nexport function ApiParamsFromModel(\n  props: DecafApiProperty[] = []\n): MethodDecorator & ClassDecorator {\n  const decorators = props.map((p) =>\n    ApiParamDec({\n      name: p.name,\n      description: p.description ?? `Path parameter: ${p.name}`,\n      required: p.required ?? true,\n      // schema: { type: 'string' },\n      type: p.type ?? String,\n    })\n  );\n  return applyDecorators(...decorators);\n}\n","import {\n  createParamDecorator,\n  ExecutionContext,\n  InternalServerErrorException,\n} from \"@nestjs/common\";\n\n/**\n * @description Custom decorator that extracts the request body and instantiates it using the Model constructor\n * found on the controller. Handles both single objects and arrays.\n */\nexport const DecafBody = createParamDecorator(\n  (data: unknown, ctx: ExecutionContext) => {\n    const request = ctx.switchToHttp().getRequest();\n    const body = request.body;\n\n    // The DynamicModelController will have 'ModelConstr' available\n    const controller = ctx.getClass();\n    // We access the static property we will add to the DynamicModelController\n    const ModelConstr = (controller as any).class;\n\n    if (!ModelConstr) {\n      throw new InternalServerErrorException(\n        `ModelConstructor not found on controller ${controller.name}. Ensure the controller was created via FromModelController.`\n      );\n    }\n\n    if (!body) return body;\n\n    if (Array.isArray(body)) {\n      return body.map((item) => new ModelConstr(item));\n    }\n\n    return new ModelConstr(body);\n  }\n);\n","import { createParamDecorator, ExecutionContext } from \"@nestjs/common\";\nimport { DecafParamProps, DecafApiProperty } from \"./types\";\n/**\n * @description Creates a custom NestJS parameter decorator that extracts and returns route parameters ordered by a specific key sequence.\n * @summary The `OrderedParams` decorator reads the incoming HTTP request's `params` object, optionally orders it according to a provided list of parameter names, and returns an object containing the original params, the ordered values, and the applied order list. This ensures deterministic parameter access for routes with multiple path parameters.\n * @template {string[]} TOrder - Represents the expected sequence of parameter names.\n * @param {TOrder | undefined} order An optional array specifying the parameter names' desired order. If not provided, the decorator will preserve the order of the keys as they appear in the original `req.params` object.\n * @param {ExecutionContext} ctx The NestJS execution context, used to retrieve the current HTTP request object.\n * @return {DecafParamProps} An object containing:\n * - `original`: the raw parameter map from `req.params`;\n * - `ordered`: an array of parameter values in the requested order;\n * - `order`: the effective order list used.\n * @function OrderedParams\n */\nconst OrderedParams = createParamDecorator(\n  (order: string[] | undefined, ctx: ExecutionContext): DecafParamProps => {\n    const req = ctx.switchToHttp().getRequest();\n    const original = (req?.params ?? {}) as Record<string, any>;\n    const orderList = order ?? Object.keys(original);\n    const ordered = orderList.map((k) => original[k]);\n    return { raw: original, valuesInOrder: ordered, keysInOrder: orderList };\n  }\n);\n\n/**\n * @description A higher-level decorator factory that leverages `OrderedParams` to extract route parameters in a specific order derived from a list of `ApiParam` definitions.\n * @summary `DecafParams` computes the order of route parameters based on the provided `ApiParam[]` specification (using each element’s `name`), then applies `OrderedParams(order)` as a parameter decorator. This enables parameter-level binding that remains consistent with the documented API parameter metadata.\n * @param {ApiParam[]} [props=[]] Array of `ApiParam` definitions whose `name` fields determine the parameter extraction order.\n * @return {ParameterDecorator} A NestJS parameter decorator that injects an ordered list of parameters and metadata into the controller method argument.\n */\nexport function DecafParams(\n  props: DecafApiProperty[] = []\n): ParameterDecorator {\n  const order = props.map((p) => p.name);\n  return OrderedParams(order);\n}\n\nexport const DecafQuery = createParamDecorator(\n  (_: unknown, ctx: ExecutionContext) => {\n    const req = ctx.switchToHttp().getRequest();\n    const query = req.query ?? {};\n\n    const parsed: any = { ...query };\n\n    // Parse limit & offset\n    if (parsed.limit !== undefined) {\n      const n = Number(parsed.limit);\n      if (!Number.isNaN(n)) parsed.limit = n;\n    }\n\n    if (parsed.offset !== undefined) {\n      const n = Number(parsed.offset);\n      if (!Number.isNaN(n)) parsed.offset = n;\n    }\n\n    // Parse bookmark only if numeric\n    if (parsed.bookmark !== undefined) {\n      const n = Number(parsed.bookmark);\n      parsed.bookmark = Number.isNaN(n) ? parsed.bookmark : n;\n    }\n\n    return parsed;\n  }\n);\n","import { AdapterFlags, Context } from \"@decaf-ts/core\";\nimport { Logger } from \"@decaf-ts/logging\";\n\nexport const DECAF_MODULE_OPTIONS = \"DecafModuleOptions\";\nexport const DECAF_ADAPTER_ID = \"DecafAdapter\";\nexport const DECAF_TASK_SERVICE_ID = \"DecafTaskService\";\n\nexport const DECAF_ROUTE = \"DecafRoute\";\nexport const DECAF_HANDLERS = Symbol(\"DecafHandlers\");\nexport const DECAF_ADAPTER_OPTIONS = Symbol(\"DecafAdapterForOptions\");\nexport const DECAF_EXPOSE = \"DecafExpose\";\nexport const DECAF_CONTROLLER_CONFIG = \"DecafControllerConfig\";\n\nexport const DECAF_CONTEXT_KEY = Symbol(\"decaf:context\");\n\nexport type DecafServerFlags<LOG extends Logger = Logger> =\n  AdapterFlags<LOG> & {\n    headers: Record<string, any>;\n    overrides: Record<string, any>;\n  };\n\nexport type DecafServerCtx = Context<DecafServerFlags>;\n","import { Metadata } from \"@decaf-ts/decoration\";\n\nimport { DECAF_EXPOSE } from \"../../constants\";\n\nexport function expose(...flavours: string[]) {\n  return function expose(target: any) {\n    Metadata.set(\n      target,\n      DECAF_EXPOSE,\n      (flavours.length ? flavours : true) as any\n    );\n    return target;\n  };\n}\n","import { Metadata } from \"@decaf-ts/decoration\";\nimport type { ModelControllerFactoryConfig } from \"@decaf-ts/for-http/server\";\n\nimport { DECAF_CONTROLLER_CONFIG } from \"../../constants\";\n\n/**\n * Class decorator that attaches a {@link ModelControllerFactoryConfig} to a Model,\n * so `FromModelController.create()` can pass it to `ModelControllerFactory.create()`.\n *\n * The per-model config can be overridden by the module-level `controllerConfig`\n * option in `DecafModuleOptions`.\n *\n * @example\n * ```ts\n * @controllerConfig({ allowGroupingQueries: true, allowBulkStatement: { create: true, read: true, update: false, delete: true } })\n * @model()\n * class Order extends Model<Order> { ... }\n * ```\n *\n * @param config - Factory configuration knobs (allowStatementlessQuery, allowGroupingQueries, allowBulkStatement).\n */\nexport function controllerConfig(config: ModelControllerFactoryConfig) {\n  return function controllerConfigDecorator(target: any) {\n    Metadata.set(target, DECAF_CONTROLLER_CONFIG, config as any);\n    return target;\n  };\n}\n","export const AUTH_HANDLER = Symbol(\"AUTH_HANDLER\");\nexport const AUTH_META_KEY = \"auth:meta\";\nexport const IS_PUBLIC_KEY = \"isPublic\";\nexport const REQUIRED_ROLES_KEY = \"requiredRoles\";\n","import { Inject, Injectable, Scope } from \"@nestjs/common\";\nimport { REQUEST } from \"@nestjs/core\";\nimport { UUID } from \"@decaf-ts/core\";\nimport { RequestContext } from \"@decaf-ts/for-http/server\";\nimport { type Request } from \"express\";\n\nimport { DecafServerCtx } from \"../constants\";\n\n@Injectable({ scope: Scope.REQUEST })\nexport class DecafRequestContext<C extends DecafServerCtx = DecafServerCtx> extends RequestContext<Request> {\n  uuid = UUID.instance.generate();\n  override readonly request: Request;\n\n  constructor(@Inject(REQUEST) private readonly req: Request) {\n    super(\n      {\n        headersOf: (request: Request) => (request as any)?.headers || undefined,\n      } as any,\n      req\n    );\n    this.request = req;\n  }\n\n  put(record: Record<any, any>) {\n    let overrides: any;\n    try {\n      overrides = this.get(\"overrides\");\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e: unknown) {\n      overrides = {};\n    }\n\n    this.accumulate({\n      overrides: Object.assign(overrides, record),\n    });\n  }\n}\n","import {\n  Injectable,\n  NestInterceptor,\n  ExecutionContext,\n  CallHandler,\n  Inject,\n  Optional,\n  Scope,\n} from \"@nestjs/common\";\nimport { Reflector } from \"@nestjs/core\";\nimport { Observable } from \"rxjs\";\n\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport { Logging } from \"@decaf-ts/logging\";\nimport { Adapter } from \"@decaf-ts/core\";\nimport { RequestToContextTransformer } from \"@decaf-ts/for-http/server\";\n\nimport { AUTH_HANDLER, AUTH_META_KEY, IS_PUBLIC_KEY, REQUIRED_ROLES_KEY } from \"./constants\";\nimport type { AuthHandler } from \"../types\";\nimport { DecafRequestContext } from \"../request/DecafRequestContext\";\n\n@Injectable({ scope: Scope.REQUEST })\nexport class AuthInterceptor implements NestInterceptor {\n  constructor(\n    private readonly reflector: Reflector,\n    protected readonly requestContext: DecafRequestContext,\n    @Optional() @Inject(AUTH_HANDLER) private readonly authHandler?: AuthHandler\n  ) {}\n\n  async intercept(\n    ctx: ExecutionContext,\n    next: CallHandler\n  ): Promise<Observable<any>> {\n    const log = Logging.for(this as any).for(this.intercept);\n\n    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [\n      ctx.getHandler(),\n      ctx.getClass(),\n    ]);\n\n    const modelName =\n      this.reflector.get<string | Constructor>(\n        AUTH_META_KEY,\n        ctx.getHandler()\n      ) ??\n      this.reflector.get<string | Constructor>(AUTH_META_KEY, ctx.getClass());\n\n    const requiredRoles = this.reflector.getAllAndOverride<string[]>(\n      REQUIRED_ROLES_KEY,\n      [ctx.getHandler(), ctx.getClass()]\n    );\n\n    log.verbose(`Intercepted request${modelName ? ` for ${modelName}` : \"\"}`);\n\n    if (isPublic) {\n      log.debug(`Public route — skipping auth`);\n    } else if (this.authHandler) {\n      await this.authHandler.authorize(\n        ctx,\n        modelName as string | Constructor,\n        requiredRoles,\n        this.requestContext\n      );\n    } else {\n      log.debug(`No auth handler registered`);\n    }\n\n    // Transformers run AFTER auth so they can read auth-populated fields\n    // (e.g. `user`) from the context and map them to adapter-specific keys\n    // (e.g. `UUID` for RamAdapter's @createdBy/@updatedBy handlers).\n    await this.applyTransformers();\n\n    const user = this.requestContext.getOrUndefined(\"user\" as any);\n    const organization = this.requestContext.getOrUndefined(\"organization\" as any);\n    if (user || organization) {\n      const currentLog = this.requestContext.get(\"logger\" as any);\n      const childLog = currentLog.for({ user, organization });\n      this.requestContext.accumulate({ logger: childLog } as any);\n    }\n\n    return next.handle();\n  }\n\n  protected async applyTransformers(): Promise<void> {\n    const flavours = Adapter.flavoursToTransform();\n    if (!flavours) return;\n\n    for (const flavour of flavours) {\n      const transformer = Adapter.transformerFor(\n        flavour\n      ) as RequestToContextTransformer<any>;\n      if (!transformer) continue;\n      const from = await transformer.from(this.requestContext);\n      if (from) this.requestContext.accumulate(from);\n    }\n  }\n}\n","import { ExecutionContext } from \"@nestjs/common\";\nimport { AuthorizationError } from \"@decaf-ts/core\";\nimport { AuthHandler, AuthData } from \"@decaf-ts/for-http/server\";\nimport { DecafRequestContext } from \"../request/DecafRequestContext\";\n\n/**\n * Simple auth handler that reads a role string from the `Authorization: Bearer <role>` header.\n *\n * Only overrides {@link AuthHandler.extractFromAuth} to return the bearer token as\n * both the user identifier and the single role. The base class `bindToContext`\n * (`ctx.accumulate(data)`) is sufficient — the transformer/adapter is responsible\n * for mapping context fields to adapter-specific keys like `UUID`.\n */\nexport class DecafAuthHandler extends AuthHandler<\n  ExecutionContext,\n  DecafRequestContext,\n  AuthData\n> {\n  protected parseRequest(req: any): string {\n    const userRole = req.headers.authorization?.split(\" \")[1] as string;\n    return userRole;\n  }\n\n  protected extractFromAuth(ctx: ExecutionContext): AuthData {\n    const req = ctx.switchToHttp().getRequest();\n    const userRole = this.parseRequest(req);\n    if (!userRole) throw new AuthorizationError(\"Unauthenticated\");\n    return { user: userRole, roles: [userRole] };\n  }\n}\n\n/**\n * Alias for {@link DecafAuthHandler} kept for backward compatibility.\n * The \"role\" variant previously returned roles from `authorize`; with the base\n * class now orchestrating role checks internally, the two classes are equivalent.\n */\nexport class DecafRoleAuthHandler extends DecafAuthHandler {}\n","import { applyDecorators, SetMetadata, UseInterceptors } from \"@nestjs/common\";\nimport { ApiBearerAuth, ApiSecurity } from \"@nestjs/swagger\";\nimport { Constructor } from \"@decaf-ts/decoration\";\n\nimport { AUTH_META_KEY, IS_PUBLIC_KEY, REQUIRED_ROLES_KEY } from \"./constants\";\nimport { AuthInterceptor } from \"./AuthInterceptor\";\n\nexport function Auth(model?: string | Constructor) {\n  const resource = model\n    ? typeof model === \"string\"\n      ? model\n      : model.name\n    : undefined;\n  const decs = [ApiBearerAuth(), UseInterceptors(AuthInterceptor)];\n  if (resource) decs.push(SetMetadata(AUTH_META_KEY, resource));\n  return applyDecorators(...decs);\n}\n\nexport function Public() {\n  return applyDecorators(SetMetadata(IS_PUBLIC_KEY, true));\n}\n\nexport function RequireRoles(...roles: string[]) {\n  return applyDecorators(\n    ApiSecurity(\"bearer\"),\n    SetMetadata(REQUIRED_ROLES_KEY, roles),\n    UseInterceptors(AuthInterceptor)\n  );\n}\n","import { Inject, Injectable, Scope } from \"@nestjs/common\";\nimport { DecafRequestContext } from \"./DecafRequestContext\";\nimport { type DecafRequestHandler } from \"../types\";\nimport { DECAF_HANDLERS } from \"../constants\";\nimport { Logging } from \"@decaf-ts/logging\";\n\n/**\n * @description\n * Executes all registered {@link DecafRequestHandler} instances for the current request,\n * providing them with a shared {@link DecafRequestContext}.\n *\n * @summary\n * The {@link DecafHandlerExecutor} class is responsible for orchestrating and executing\n * a sequence of request handlers. Each handler receives the same request-scoped context,\n * allowing coordinated processing such as authentication, metadata extraction, auditing,\n * and custom pipeline behavior. Handlers are injected via the {@link DECAF_HANDLERS} token,\n * ensuring extensibility and loose coupling.\n *\n * @class DecafHandlerExecutor\n *\n * @example\n * ```ts\n * // Example handler:\n * class AuthHandler implements DecafRequestHandler {\n *   async handle(context: DecafRequestContext, req: Request) {\n *     const token = req.headers[\"authorization\"];\n *     const result = MyService.doSomething(token);\n *     context.set(\"my-key\", result);\n *   }\n * }\n *\n * // Executor usage in a request:\n * await executor.exec(request);\n * // All handlers will run in sequence\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *     participant Client\n *     participant Executor\n *     participant HandlerA\n *     participant HandlerB\n *\n *     Client->>Executor: exec(req)\n *     Executor->>HandlerA: handle(context, req)\n *     HandlerA-->>Executor: completed\n *     Executor->>HandlerB: handle(context, req)\n *     HandlerB-->>Executor: completed\n *     Executor-->>Client: processing finished\n */\n@Injectable({ scope: Scope.REQUEST })\nexport class DecafHandlerExecutor {\n  constructor(\n    @Inject(DECAF_HANDLERS) private readonly handlers: DecafRequestHandler[],\n    private readonly context: DecafRequestContext\n  ) {}\n\n  async exec(req: Request, res: Response) {\n    const log = Logging.for(DecafHandlerExecutor.name).for(this.exec);\n    log.debug(\n      `CONTEXT ${this.context.uuid} running ${this.handlers.length} handlers for request ${req.method} ${req.url}`\n    );\n    for (const handler of this.handlers) {\n      await handler.handle(this.context, req, res);\n    }\n  }\n}\n","import {\n  Injectable,\n  NestInterceptor,\n  ExecutionContext,\n  CallHandler,\n} from \"@nestjs/common\";\nimport { Observable, tap } from \"rxjs\";\nimport { DecafRequestContext } from \"./DecafRequestContext\";\n\n@Injectable()\nexport class DecafResponseInterceptor implements NestInterceptor {\n  constructor(protected ctx: DecafRequestContext) {}\n\n  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {\n    let response = context.switchToHttp().getResponse();\n\n    return next.handle().pipe(\n      tap((data) => {\n        response = this.ctx.toResponse(response);\n      })\n    );\n  }\n}\n","import { Constructor, Metadata } from \"@decaf-ts/decoration\";\nimport { RequestToContextTransformer } from \"@decaf-ts/for-http/server\";\nimport { Adapter, ContextOf, Context } from \"@decaf-ts/core\";\n\n(Adapter as any).transformerFor = function toContextFlags<\n  A extends Adapter<any, any, any, any>,\n>(adapter: A | string): Constructor<RequestToContextTransformer<ContextOf<A>>> {\n  const alias =\n    typeof adapter === \"string\" ? adapter : (adapter.alias as string);\n  return Metadata[\"innerGet\"](Symbol.for(\"transformers\"), alias);\n}.bind(Adapter);\n\n(Adapter as any).flavoursToTransform = function requestTransformers():\n  | string[]\n  | undefined {\n  const meta = Metadata[\"innerGet\"](Symbol.for(\"transformers\"));\n  if (!meta) return undefined;\n  return Object.keys(meta);\n}.bind(Adapter);\n\n(Context as any).prototype.toResponse = function toResponse<\n  RES extends { header: any },\n>(this: Context, res: RES): RES {\n  const pending = this.pending();\n  if (pending) res.header(\"x-pending-task\", JSON.stringify(pending));\n  return res;\n};\n","import \"@decaf-ts/decorator-validation\";\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport { ModelBuilder } from \"@decaf-ts/decorator-validation\";\nimport { Auth } from \"../decaf-model/decorators/decorators\";\n\ndeclare module \"@decaf-ts/decorator-validation\" {\n  export interface ModelBuilder<M> {\n    Auth(model: string | Constructor): ModelBuilder<M>;\n    decorateClass(decorator: ClassDecorator): ModelBuilder<M>;\n  }\n}\n\nconst prototype = ModelBuilder.prototype as ModelBuilder<any> & {\n  Auth: (model: string | Constructor) => ModelBuilder<any>;\n};\n\nif (!prototype.decorateClass) {\n  prototype.decorateClass = function (decorator: ClassDecorator) {\n    if (!(this as any)._classDecorators) {\n      (this as any)._classDecorators = [];\n    }\n    (this as any)._classDecorators.push(decorator);\n    return this;\n  };\n}\n\nprototype.Auth = function (model: string | Constructor) {\n  return this.decorateClass(Auth(model));\n};\n\nif (!(prototype as any).__hasClassDecoratorSupport) {\n  const originalBuild = prototype.build;\n  prototype.build = function () {\n    let result = originalBuild.call(this);\n    const decorators = (this as any)._classDecorators;\n    if (decorators?.length) {\n      for (const decorator of decorators) {\n        const decorated = decorator(result as any) as typeof result | void;\n        if (decorated) {\n          result = decorated;\n        }\n      }\n    }\n    return result;\n  };\n  (prototype as any).__hasClassDecoratorSupport = true;\n}\n","import {\n  CallHandler,\n  ExecutionContext,\n  Injectable,\n  NestInterceptor,\n  Scope,\n} from \"@nestjs/common\";\nimport { DecafHandlerExecutor, DecafRequestContext } from \"../request\";\nimport { DefaultAdapterFlags } from \"@decaf-ts/core\";\nimport {\n  DECAF_ADAPTER_OPTIONS,\n  DecafServerFlags,\n} from \"../constants\";\nimport \"../overrides\";\nimport { Logging } from \"@decaf-ts/logging\";\n\n/**\n * @description\n * Interceptor responsible for executing all registered Decaf request handlers\n * before the controller method is invoked.\n *\n * @summary\n * The {@link DecafRequestHandlerInterceptor} integrates the Decaf request-handling pipeline\n * into NestJS' interceptor mechanism. Before passing execution to the next handler in the\n * NestJS chain, it delegates request processing to the {@link DecafHandlerExecutor}, which\n * sequentially runs all registered {@link DecafRequestHandler} instances. This allows\n * behaviors such as authentication, logging, tenant resolution, or metadata enrichment\n * to occur prior to controller execution.\n *\n * @class DecafRequestHandlerInterceptor\n *\n * @example\n * ```ts\n * // Apply globally:\n * app.useGlobalInterceptors(new DecafRequestHandlerInterceptor(executor));\n *\n * // Or in a module:\n * @Module({\n *   providers: [\n *     DecafHandlerExecutor,\n *     {\n *       provide: APP_INTERCEPTOR,\n *       useClass: DecafRequestHandlerInterceptor,\n *     },\n *   ],\n * })\n * export class AppModule {}\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *     participant Client\n *     participant Interceptor\n *     participant Executor\n *     participant Controller\n *\n *     Client->>Interceptor: HTTP Request\n *     Interceptor->>Executor: exec(request)\n *     Executor-->>Interceptor: handlers completed\n *     Interceptor->>Controller: next.handle()\n *     Controller-->>Client: Response\n */\n@Injectable({ scope: Scope.REQUEST })\nexport class DecafRequestHandlerInterceptor implements NestInterceptor {\n  constructor(\n    protected readonly requestContext: DecafRequestContext,\n    protected readonly executor: DecafHandlerExecutor\n  ) {}\n\n  protected async contextualize(req: any): Promise<void> {\n    const headers = req.headers;\n    const flags: DecafServerFlags = {\n      headers: headers,\n      overrides: {},\n    } as any;\n    Object.assign(flags.overrides, req?.[DECAF_ADAPTER_OPTIONS] ?? {});\n\n    const ip = extractIp(req);\n    const logger = Logging.get().for({ ip });\n\n    this.requestContext.accumulate(\n      Object.assign(\n        {},\n        DefaultAdapterFlags,\n        {\n          logger,\n          timestamp: new Date(),\n          operation: `${req.method} ${req.url}`,\n        },\n        flags\n      )\n    );\n  }\n\n  async intercept(context: ExecutionContext, next: CallHandler) {\n    const req = context.switchToHttp().getRequest();\n    const res = context.switchToHttp().getResponse();\n    const log = Logging.for(DecafRequestHandlerInterceptor).for(this.intercept);\n    log.debug(\n      `CONTEXT ${this.requestContext.uuid} - request: ${req.method} ${req.url}`\n    );\n    await this.contextualize(req);\n    log.debug(\n      `CONTEXT ${this.requestContext.uuid} contextualized - request: ${req.method} ${req.url}`\n    );\n\n    await this.executor.exec(req, res);\n    log.debug(\n      `CONTEXT ${this.requestContext.uuid} executors finished - request: ${req.method} ${req.url}`\n    );\n    return next.handle();\n  }\n}\n\nfunction extractIp(req: any): string | undefined {\n  const headers = req.headers;\n  function parseIpHeader(value?: string | string[]): string | undefined {\n    if (!value) return undefined;\n    const candidate = Array.isArray(value) ? value[0] : value;\n    return candidate\n      .split(\",\")\n      .map((segment) => segment.trim())\n      .filter(Boolean)[0];\n  }\n  return (\n    parseIpHeader(headers?.[\"x-forwarded-for\"]) ??\n    parseIpHeader(headers?.[\"x-real-ip\"]) ??\n    parseIpHeader(headers?.[\"X-Forwarded-For\"]) ??\n    parseIpHeader(headers?.[\"X-Real-IP\"]) ??\n    req.ip\n  );\n}\n","import { DynamicModule, Module, Type } from \"@nestjs/common\";\nimport { APP_INTERCEPTOR } from \"@nestjs/core\";\n\nimport { AuthInterceptor } from \"./AuthInterceptor\";\nimport { AUTH_HANDLER } from \"./constants\";\nimport { DecafRequestHandlerInterceptor } from \"../interceptors/DecafRequestHandlerInterceptor\";\nimport { AuthHandler } from \"../types\";\n\nexport type DecafAuthModuleOptions = {\n  global?: boolean;\n  handler?: Type<AuthHandler>;\n};\n\n@Module({})\nexport class DecafAuthModule {\n  static forRoot(\n    options: DecafAuthModuleOptions = {}\n  ): DynamicModule {\n    const providers: DynamicModule[\"providers\"] = [\n      AuthInterceptor,\n      DecafRequestHandlerInterceptor,\n      {\n        provide: APP_INTERCEPTOR,\n        useClass: DecafRequestHandlerInterceptor,\n      },\n    ];\n\n    if (options.handler) {\n      providers.push(options.handler);\n      providers.push({\n        provide: AUTH_HANDLER,\n        useClass: options.handler,\n      });\n    }\n\n    if (options.global) {\n      (providers as any[]).push({\n        provide: APP_INTERCEPTOR,\n        useExisting: AuthInterceptor,\n      });\n    }\n\n    return {\n      module: DecafAuthModule,\n      global: options.global ?? false,\n      providers,\n      exports: [AuthInterceptor, AUTH_HANDLER],\n    };\n  }\n}\n","import { Delete, Get, Patch, Post, Put } from \"@nestjs/common\";\nimport { HttpVerbs } from \"./types\";\n\n/**\n * Maps an HTTP verb to its corresponding NestJS method decorator.\n *\n * @param verb - HTTP verb to be converted (e.g. GET, POST, PUT, PATCH, DELETE).\n * @returns A NestJS method decorator matching the provided HTTP verb.\n *\n * @throws {Error} If the provided HTTP verb is not supported or not mapped\n * to a NestJS decorator.\n */\nexport function HttpVerbToDecorator(\n  verb: HttpVerbs\n): (path?: string) => MethodDecorator {\n  const httpToCrud: Record<HttpVerbs, (path?: string) => MethodDecorator> = {\n    GET: Get,\n    POST: Post,\n    PUT: Put,\n    PATCH: Patch,\n    DELETE: Delete,\n  };\n\n  const decorator = httpToCrud[verb];\n\n  if (!decorator) {\n    throw new Error(\n      `Unsupported HTTP verb \"${verb}\". No NestJS decorator mapping was found.`\n    );\n  }\n\n  return decorator;\n}\n","import { Query } from \"@nestjs/common\";\nimport { Logger } from \"@decaf-ts/logging\";\nimport { type DecoratorBundle } from \"./types\";\nimport {\n  ApiNoContentResponse,\n  ApiOkResponse,\n  ApiOperation,\n  ApiParam,\n  ApiQuery,\n} from \"@nestjs/swagger\";\nimport {\n  DecafApiProperty,\n  type DecafParamProps,\n  DecafParams,\n} from \"./decorators\";\nimport type { HttpVerbs } from \"./decorators/types\";\nimport {\n  DirectionLimitOffset,\n  ModelService,\n  OrderDirection,\n  Repo,\n} from \"@decaf-ts/core\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { HttpVerbToDecorator } from \"./decorators/utils\";\nimport { DecafModelController } from \"../controllers\";\n\nconst extractPathParams = (routePath: string): string[] => {\n  return routePath\n    .split(\"/\")\n    .filter((p) => p.startsWith(\":\"))\n    .map((p) => p.slice(1));\n};\n\nconst apiParamSpec = (name: string): DecafApiProperty => ({\n  name,\n  description: `${name} parameter for the query`,\n  required: true,\n  type: String,\n});\n\nexport function getApiDecorators(\n  methodName: string,\n  routePath: string,\n  httpVerb: HttpVerbs,\n  includeQueryParams: boolean = false\n): DecoratorBundle {\n  const NestHttpRouteDec = HttpVerbToDecorator(httpVerb);\n  const apiPathParams = extractPathParams(routePath).map(apiParamSpec);\n\n  const swaggerQueryParams = [];\n  if (httpVerb === \"GET\" && includeQueryParams) {\n    swaggerQueryParams.push(\n      ApiQuery({\n        name: \"direction\",\n        required: false,\n        enum: OrderDirection,\n        description: \"the sort order when applicable\",\n      }),\n      ApiQuery({\n        name: \"limit\",\n        required: false,\n        description: \"limit or page size when applicable\",\n      }),\n      ApiQuery({\n        name: \"offset\",\n        required: false,\n        description: \"offset or bookmark when applicable\",\n      })\n    );\n  }\n\n  return {\n    method: [\n      NestHttpRouteDec(routePath),\n      ...apiPathParams.map(ApiParam),\n      ...swaggerQueryParams,\n      ApiOperation({\n        summary: `Retrieve records using according to \"${methodName}\".`,\n      }),\n      ApiOkResponse({\n        description: `Result successfully retrieved.`,\n      }),\n      ApiNoContentResponse({\n        description: `No content returned by the method.`,\n      }),\n    ],\n    params: [DecafParams(apiPathParams), Query()], // , DecafBody()],\n  };\n}\n\nexport function applyApiDecorators(\n  target: any,\n  methodName: string,\n  descriptor: PropertyDescriptor,\n  decorators: DecoratorBundle\n) {\n  const proto = target?.prototype ?? target;\n  decorators.method.forEach((d) => d(proto, methodName, descriptor));\n  decorators.params?.forEach((d, index) => d(proto, methodName, index));\n}\n\nexport function resolvePersistenceMethod<T extends Model<boolean>>(\n  persistence: Repo<T> | ModelService<T>,\n  methodName: string,\n  ...args: any[]\n): any {\n  if (persistence instanceof ModelService) {\n    return typeof (persistence as any)[methodName] === \"function\"\n      ? (persistence as any)[methodName](...args)\n      : persistence.statement(methodName, ...args);\n  }\n\n  if (typeof (persistence as any)[methodName] === \"function\")\n    return (persistence as any)[methodName](...args);\n\n  throw new Error(\n    `Persistence method \"${methodName}\" not found on ${persistence?.constructor?.name}`\n  );\n}\n\nexport function createRouteHandler<T>(methodName: string) {\n  return async function (\n    this: DecafModelController<any>,\n    pathParams: DecafParamProps,\n    queryParams: DirectionLimitOffset\n  ): Promise<T> {\n    const log: Logger = this.log.for(methodName);\n\n    try {\n      log.debug(\n        `Invoking persistence method \"${methodName}\" given parameters: ${JSON.stringify(pathParams.valuesInOrder)}`\n      );\n      const { direction, limit, offset } = queryParams;\n      return await resolvePersistenceMethod(\n        this.persistence(),\n        methodName,\n        ...pathParams.valuesInOrder,\n        direction,\n        limit,\n        offset\n      );\n    } catch (e: any) {\n      log.error(`Custom query \"${methodName}\" failed`, e);\n      throw e;\n    }\n  };\n}\n\nexport function defineRouteMethod(\n  ControllerClass: new (...args: any[]) => any,\n  methodName: string,\n  handler: (...args: any[]) => any\n): PropertyDescriptor | undefined {\n  Object.defineProperty(\n    ControllerClass.prototype || ControllerClass,\n    methodName,\n    {\n      value: handler,\n      writable: false,\n    }\n  );\n\n  return Object.getOwnPropertyDescriptor(\n    ControllerClass.prototype || ControllerClass,\n    methodName\n  );\n}\n","import { type Request } from \"express\";\nimport { DecafController as HttpDecafController } from \"@decaf-ts/for-http/server\";\nimport {\n  Context,\n  ModelService,\n  Repo,\n  Repository,\n  Service,\n} from \"@decaf-ts/core\";\nimport { Model, type ModelConstructor } from \"@decaf-ts/decorator-validation\";\n\nimport { DECAF_ADAPTER_OPTIONS, DecafServerCtx } from \"./constants\";\nimport { DecafRequestContext } from \"./request/DecafRequestContext\";\n\nexport abstract class DecafController<\n  CONTEXT extends DecafServerCtx = DecafServerCtx,\n> extends HttpDecafController<Request, any, DecafRequestContext> {\n  protected constructor(\n    protected readonly clientContext: DecafRequestContext,\n    _name: string\n  ) {\n    super(clientContext);\n  }\n}\n\nexport abstract class DecafModelController<\n  M extends Model<boolean>,\n  C extends DecafServerCtx = DecafServerCtx,\n> extends DecafController<C> {\n  private _persistence?: Repo<M> | ModelService<M>;\n\n  protected constructor(\n    protected override readonly clientContext: DecafRequestContext,\n    _name: string\n  ) {\n    super(clientContext, _name);\n  }\n\n  abstract get class(): ModelConstructor<M>;\n\n  persistence(ctx?: Context<any>): Repo<M> | ModelService<M> {\n    if (!this._persistence)\n      try {\n        this._persistence = Service.get<ModelService<M>>(this.class);\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      } catch (e: unknown) {\n        try {\n          this._persistence = ModelService.getService(\n            this.class\n          ) as ModelService<M>;\n          // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        } catch (e: unknown) {\n          this._persistence = Repository.forModel(this.class) as Repo<M>;\n        }\n      }\n\n    const certs = (this.clientContext.request as any)[DECAF_ADAPTER_OPTIONS] || {};\n    if (ctx) {\n      this.clientContext.put(certs);\n    }\n\n    return ctx\n      ? this._persistence instanceof Repository\n        ? this._persistence.override(certs)\n        : this._persistence.for(certs)\n      : this._persistence;\n  }\n}\n","import {\n  BulkCrudOperationKeys,\n  InternalError,\n  OperationKeys,\n} from \"@decaf-ts/db-decorators\";\nimport { Constructor, Metadata } from \"@decaf-ts/decoration\";\nimport { ApiProperty } from \"../../overrides/decoration\";\nimport { Model, ValidationKeys } from \"@decaf-ts/decorator-validation\";\nimport { TransactionOperationKeys } from \"@decaf-ts/core\";\nimport { toPascalCase } from \"@decaf-ts/logging\";\nimport { DECORATORS } from \"../../overrides/constants\";\n\nconst dtoCache = new Map<\n  OperationKeys,\n  WeakMap<Constructor<any>, Constructor<any>>\n>();\n\n/**\n * Builds a Nest/Swagger DTO class for the given model and CRUD operation.\n *\n * Rules:\n *  - Only CREATE and UPDATE (and their bulk variants) produce a DTO;\n *    all other operations return the original model class unchanged.\n *  - @generated() properties (createdAt, updatedAt, createdBy, updatedBy,\n *    uuid, version, @composed pks, …) are **never** exposed in any DTO.\n *  - The @pk() property:\n *      • UPDATE – always included.\n *      • CREATE  – included only when the pk is NOT auto-generated\n *                  (checked via Model.pkProps().generated AND Model.generated()).\n *  - Relation properties (@oneToOne, @oneToMany, …):\n *      • CREATE  – nested as DtoFor(CREATE, RelatedModel). When the relation\n *                  creates a circular reference (model A → model B → model A),\n *                  the back-reference uses the related model's PK type\n *                  (string/integer) instead of the full DTO to break the cycle.\n *      • UPDATE  – union of DtoFor(UPDATE, RelatedModel) **or** the\n *                  related model's primary-key type (string / integer),\n *                  expressed as a Swagger oneOf. Circular back-references\n *                  omit the DTO $ref and only include the PK type.\n *\n * Metadata.properties() now returns ALL properties across the prototype chain,\n * so DTO inheritance is no longer needed; every DTO is a flat class.\n */\nexport function DtoFor<M extends Model>(\n  op: OperationKeys,\n  model: Constructor<M>,\n  stack: Set<Constructor<any>> = new Set()\n): Constructor<any> {\n  if (!TransactionOperationKeys.includes(op)) {\n    return model;\n  }\n\n  const cache = getDtoCache(op);\n  const cached = cache.get(model);\n  if (cached) return cached;\n\n  const isUpdateOp = [\n    OperationKeys.UPDATE,\n    BulkCrudOperationKeys.UPDATE_ALL,\n  ].includes(op as any);\n\n  class DynamicDTO {}\n  cache.set(model, DynamicDTO);\n\n  Object.defineProperty(DynamicDTO, \"name\", {\n    value: `${toPascalCase(model.name)}${toPascalCase(op)}DTO`,\n  });\n\n  const pkProp = (() => {\n    try {\n      return Model.pk(model);\n    } catch {\n      return undefined;\n    }\n  })();\n\n  const pkPropsMetadata = pkProp ? Model.pkProps(model as any) : undefined;\n  const pkDesignType = pkProp\n    ? Reflect.getMetadata(\"design:type\", model.prototype, pkProp as string)\n    : undefined;\n  const pkTypeIsNumeric =\n    pkDesignType === Number || pkDesignType === BigInt;\n  const pkIsGenerated =\n    !!pkPropsMetadata?.generated ||\n    (pkProp\n      ? Model.generatedBySequence(model as any, pkProp as any) ||\n        isPropertyGeneratedAcrossInheritance(model, pkProp as string) ||\n        pkTypeIsNumeric\n      : false);\n\n  const allProps = Array.from(new Set(Metadata.properties(model) || []));\n  const relations = new Set<string>((Model.relations(model) as string[]) || []);\n  const scalarProps: string[] = [];\n\n  for (const prop of allProps) {\n    if (!prop) continue;\n    if (relations.has(prop)) continue;\n\n    if (prop === pkProp && !isUpdateOp && pkIsGenerated) continue;\n    if (prop !== pkProp && isPropertyGeneratedAcrossInheritance(model, prop))\n      continue;\n\n    scalarProps.push(prop);\n  }\n\n  for (const prop of scalarProps) {\n    const validation = getValidationAcrossInheritance(model, prop);\n    const isRequired = !!validation?.[ValidationKeys.REQUIRED];\n    const typeHint =\n      getTypeAcrossInheritance(model, prop) ??\n      Reflect.getMetadata(\"design:type\", model.prototype, prop);\n\n    const apiOptions: Parameters<typeof ApiProperty>[0] = {\n      required: isRequired,\n    };\n    if (typeHint) apiOptions.type = typeHint;\n\n    ApiProperty(apiOptions)(DynamicDTO.prototype, prop);\n\n    const designType =\n      Reflect.getMetadata(\"design:type\", model.prototype, prop) ?? typeHint;\n    if (typeof designType !== \"undefined\") {\n      Reflect.defineMetadata(\n        \"design:type\",\n        designType,\n        DynamicDTO.prototype,\n        prop\n      );\n    }\n\n    Object.defineProperty(DynamicDTO.prototype, prop, {\n      value: undefined,\n      writable: true,\n      enumerable: true,\n      configurable: true,\n    });\n  }\n\n  for (const relation of relations) {\n    const relationMeta = Metadata.relations(model, relation as any);\n    if (!relationMeta) {\n      throw new InternalError(`Metadata for relation ${relation} not found`);\n    }\n\n    let relationType: Constructor<any> | undefined =\n      relationMeta.class as Constructor<any>;\n    if (typeof relationType === \"function\" && !relationType.name) {\n      relationType = (relationType as any)();\n    }\n    if (!relationType || typeof relationType !== \"function\") {\n      throw new InternalError(`Type for relation ${relation} not found`);\n    }\n    if (!Model.get(relationType.name)) {\n      continue;\n    }\n\n    const meta = Metadata.validationFor(model, relation as any);\n    const isArray = !!(meta as any)?.[ValidationKeys.LIST];\n    const isRequired = !!(meta as any)?.[ValidationKeys.REQUIRED];\n\n    // Detect circular reference: if the related model is already in the\n    // recursion stack, use the PK type instead of the full DTO to break\n    // the cycle. This prevents @nestjs/swagger's SchemaObjectFactory from\n    // infinitely recursing when exploring the schemas.\n    const isCircular = stack.has(relationType);\n\n    if (isCircular) {\n      const pkTypeName = getPkOpenApiType(relationType);\n      addRelationPkRef(DynamicDTO, relation, pkTypeName, isArray, isRequired);\n      continue;\n    }\n\n    const relationDto = DtoFor(op, relationType, new Set(stack).add(model));\n\n    if (isUpdateOp) {\n      addRelationUpdate(\n        DynamicDTO,\n        relation,\n        relationType,\n        relationDto,\n        isArray,\n        isRequired\n      );\n    } else {\n      addRelation(DynamicDTO, relation, relationDto, isArray, isRequired);\n    }\n  }\n\n  return DynamicDTO;\n}\n\nfunction addRelation(\n  DtoClass: any,\n  relation: string,\n  relationDto: any,\n  isArray: boolean,\n  isRequired: boolean\n): void {\n  const apiOptions: Parameters<typeof ApiProperty>[0] = {\n    type: relationDto,\n    required: isRequired,\n    isArray,\n  };\n  ApiProperty(apiOptions)(DtoClass.prototype, relation);\n  Reflect.defineMetadata(\n    \"design:type\",\n    isArray ? Array : relationDto,\n    DtoClass.prototype,\n    relation\n  );\n  Object.defineProperty(DtoClass.prototype, relation, {\n    value: undefined,\n    writable: true,\n    enumerable: true,\n    configurable: true,\n  });\n}\n\n/**\n * Adds a relation property that uses the PK type (string/integer) instead of\n * a full DTO class. Used to break circular references (e.g. Customer → Order → Customer).\n */\nfunction addRelationPkRef(\n  DtoClass: any,\n  relation: string,\n  pkTypeName: string,\n  isArray: boolean,\n  isRequired: boolean\n): void {\n  const apiOptions: Parameters<typeof ApiProperty>[0] = isArray\n    ? ({ type: \"array\", items: { type: pkTypeName }, required: isRequired } as any)\n    : ({ type: pkTypeName === \"integer\" ? Number : String, required: isRequired } as any);\n  ApiProperty(apiOptions)(DtoClass.prototype, relation);\n  Reflect.defineMetadata(\n    \"design:type\",\n    isArray ? Array : (pkTypeName === \"integer\" ? Number : String),\n    DtoClass.prototype,\n    relation\n  );\n  Object.defineProperty(DtoClass.prototype, relation, {\n    value: undefined,\n    writable: true,\n    enumerable: true,\n    configurable: true,\n  });\n}\n\nfunction addRelationUpdate(\n  DtoClass: any,\n  relation: string,\n  relationType: Constructor<any>,\n  relationDto: any,\n  isArray: boolean,\n  isRequired: boolean\n): void {\n  const extraModels =\n    Reflect.getMetadata(DECORATORS.API_EXTRA_MODELS, DtoClass) || [];\n  if (!extraModels.includes(relationDto)) {\n    Reflect.defineMetadata(\n      DECORATORS.API_EXTRA_MODELS,\n      [...extraModels, relationDto],\n      DtoClass\n    );\n  }\n\n  const dtoRef = `#/components/schemas/${relationDto.name}`;\n  const pkTypeName = getPkOpenApiType(relationType);\n  const oneOfItems = [{ $ref: dtoRef }, { type: pkTypeName }];\n\n  const apiOptions: Parameters<typeof ApiProperty>[0] = isArray\n    ? ({ type: \"array\", required: isRequired, oneOf: oneOfItems } as any)\n    : ({ type: Object, required: isRequired, oneOf: oneOfItems } as any);\n\n  ApiProperty(apiOptions)(DtoClass.prototype, relation);\n  Reflect.defineMetadata(\n    \"design:type\",\n    isArray ? Array : Object,\n    DtoClass.prototype,\n    relation\n  );\n  Object.defineProperty(DtoClass.prototype, relation, {\n    value: undefined,\n    writable: true,\n    enumerable: true,\n    configurable: true,\n  });\n}\n\nfunction getPkOpenApiType(relationType: Constructor<any>): string {\n  try {\n    const pkPropsMetadata = Model.pkProps(relationType as any);\n    const pkType = pkPropsMetadata?.type;\n    if (pkType === Number || pkType === BigInt) return \"integer\";\n    return \"string\";\n  } catch {\n    return \"string\";\n  }\n}\n\nfunction isPropertyGeneratedAcrossInheritance(\n  model: Constructor<any>,\n  prop: string\n): boolean {\n  let current: any = model;\n  while (current && current !== Object && current !== Function) {\n    if (Model.generated(current, prop as any)) return true;\n    current = Object.getPrototypeOf(current);\n  }\n  return false;\n}\n\nfunction getValidationAcrossInheritance(\n  model: Constructor<any>,\n  prop: string\n): Record<string, any> | undefined {\n  let current: any = model;\n  while (current && current !== Object && current !== Function) {\n    const validation = Metadata.validationFor(current, prop as any);\n    if (validation) return validation as any;\n    current = Object.getPrototypeOf(current);\n  }\n  return undefined;\n}\n\nfunction getTypeAcrossInheritance(model: Constructor<any>, prop: string): any {\n  let current: any = model;\n  while (current && current !== Object && current !== Function) {\n    const type = Metadata.type(current, prop);\n    if (type) return type;\n    current = Object.getPrototypeOf(current);\n  }\n  return undefined;\n}\n\nfunction getDtoCache(\n  op: OperationKeys\n): WeakMap<Constructor<any>, Constructor<any>> {\n  if (!dtoCache.has(op)) {\n    dtoCache.set(op, new WeakMap());\n  }\n  return dtoCache.get(op)!;\n}\n","import { Controller, Param, Query, Response } 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 { Auth } from \"./decorators/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 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  ): 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      ...(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    @Controller(routePath)\n    @ApiTags(modelClazzName)\n    @ApiExtraModels(ModelConstr)\n    @Auth(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    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","import { DynamicModule, Module, Provider } from \"@nestjs/common\";\nimport { Adapter, ModelService } from \"@decaf-ts/core\";\nimport { Logging } from \"@decaf-ts/logging\";\nimport { FromModelController } from \"./FromModelController\";\nimport { DecafModuleOptions } from \"../types\";\nimport { Model, ModelConstructor } from \"@decaf-ts/decorator-validation\";\nimport { Metadata } from \"@decaf-ts/decoration\";\nimport { DECAF_EXPOSE } from \"../constants\";\n\nexport function getModuleFor(flavour: string) {\n  @Module({})\n  class DecafModelModule {\n    static readonly log = Logging.for(DecafModelModule.name).for(flavour);\n\n    static createModelServices<T extends Model<boolean>>(\n      models: ModelConstructor<T>[]\n    ): Provider[] {\n      return models.map((model) => ({\n        provide: `${model.name}Service`,\n        useFactory: () => ModelService.forModel(model as any),\n      }));\n    }\n\n    static isExposed(\n      model: ModelConstructor<any>,\n      exposure?: Record<string, boolean | string[]>\n    ): boolean {\n      const override = exposure?.[model.name];\n      const value =\n        typeof override !== \"undefined\"\n          ? override\n          : Metadata.get(model, Metadata.key(DECAF_EXPOSE));\n\n      if (typeof value === \"undefined\") return true;\n      if (value === true) return true;\n      if (Array.isArray(value)) return value.includes(flavour);\n      return false;\n    }\n\n    static forRoot(\n      flavour: string,\n      options: Partial<DecafModuleOptions> = {}\n    ): DynamicModule {\n      const log = this.log.for(this.forRoot);\n      log.info(`Generating controllers for flavour...`);\n\n      const trackedModels = Adapter.models(flavour).filter((model) =>\n        this.isExposed(model, options.controllerExposure)\n      );\n\n      let modelServices: Provider[] = [];\n      if (options.autoServices) {\n        log.info(\"Auto-services enabled. Initializing service generation.\");\n        modelServices = this.createModelServices(trackedModels);\n        log.info(\n          `Auto-services completed. ${modelServices.length} services initialized.`\n        );\n      }\n\n      const controllers = trackedModels.map((model) =>\n        FromModelController.create(model, options.controllerConfig)\n      );\n      log.info(`Generated ${controllers.length} controllers`);\n\n      return {\n        module: DecafModelModule,\n        controllers,\n        providers: [\n          ...modelServices,\n        ],\n      };\n    }\n  }\n  Object.assign(DecafModelModule, \"name\", {\n    value: `DecafModule${flavour}`,\n  });\n  return DecafModelModule;\n}\n","import {\n  DefaultInjectablesConfig,\n  InjectableConfig,\n  InjectablesKeys,\n  InjectOptions,\n} from \"@decaf-ts/injectable-decorators\";\nimport { Inject, Injectable, Scope } from \"@nestjs/common\";\nimport { Constructor, Decoration, DecorationKeys } from \"@decaf-ts/decoration\";\nimport { ValidationKeys } from \"@decaf-ts/decorator-validation\";\nimport { PersistenceKeys } from \"@decaf-ts/core\";\nimport { ApiProperty } from \"./overrides/decoration\";\nimport { Auth } from \"./decaf-model\";\n\nDecoration.for(InjectablesKeys.INJECTABLE)\n  .extend({\n    decorator: function nestInjectable(\n      category: string | Constructor,\n      cfg?: InjectableConfig\n    ) {\n      cfg =\n        cfg ||\n        (typeof category === \"object\"\n          ? Object.assign(\n              category as Record<any, any>,\n              DefaultInjectablesConfig\n            )\n          : DefaultInjectablesConfig);\n      return Injectable({\n        scope: cfg.singleton ? Scope.DEFAULT : Scope.REQUEST,\n        durable: cfg.singleton ? undefined : true,\n      });\n    },\n  })\n  .apply();\n\nDecoration.for(InjectablesKeys.INJECT)\n  .extend({\n    decorator: function nestInject(\n      category: symbol | string | Constructor,\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      cfg: InjectOptions\n    ) {\n      return function innerNestInject(\n        target: object,\n        propertyKey?: any,\n        descriptor?: any\n      ) {\n        return Inject(category || (target as Constructor))(\n          target,\n          propertyKey,\n          descriptor\n        );\n      };\n    },\n  })\n  .apply();\n\nDecoration.for(ValidationKeys.REQUIRED)\n  .extend(\n    ApiProperty({\n      required: true,\n    })\n  )\n  .apply();\n\nDecoration.for(ValidationKeys.MAX)\n  .extend({\n    decorator: function maxDec(max: number) {\n      return ApiProperty({ maximum: max, required: false });\n    },\n  })\n  .apply();\n\nDecoration.for(ValidationKeys.MIN)\n  .extend({\n    decorator: function minDec(min: number) {\n      return ApiProperty({ minimum: min, required: false });\n    },\n  })\n  .apply();\n\nDecoration.for(ValidationKeys.MAX_LENGTH)\n  .extend({\n    decorator: function maxLengthDec(max: number) {\n      return ApiProperty({ maxLength: max, required: false });\n    },\n  })\n  .apply();\n\nDecoration.for(ValidationKeys.MIN_LENGTH)\n  .extend({\n    decorator: function minLengthDec(min: number) {\n      return ApiProperty({ minLength: min, required: false });\n    },\n  })\n  .apply();\n\nDecoration.for(ValidationKeys.TYPE)\n  .extend({\n    decorator: function typeDec(\n      type:\n        | (Constructor | (() => Constructor))[]\n        | Constructor\n        | (() => Constructor)\n    ) {\n      return (target: object, prop: any) => {\n        type = Array.isArray(type) ? type[0] : type;\n        if (typeof type === \"function\" && !type.name)\n          type = (type as () => Constructor)();\n        return ApiProperty({\n          type: type as any,\n          required: false,\n        })(target, prop);\n      };\n    },\n  })\n  .apply();\n//\n// Decoration.for(ValidationKeys.LIST)\n//   .extend({\n//     decorator: function listDec(\n//       clazz:\n//         | Constructor\n//         | (() => Constructor)\n//         | (Constructor | (() => Constructor))[],\n//       // eslint-disable-next-line @typescript-eslint/no-unused-vars\n//       collection: \"Array\" | \"Set\" = \"Array\"\n//     ) {\n//       return (target: object, prop: any) => {\n//         clazz = Array.isArray(clazz) ? clazz[0] : clazz;\n//         if (typeof clazz === \"function\" && !clazz.name)\n//           clazz = (clazz as () => Constructor)();\n//         return ApiProperty({ type: [clazz as any] })(target, prop);\n//       };\n//     },\n//   })\n//   .apply();\n// //\nDecoration.for(ValidationKeys.DATE)\n  .extend({\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    decorator: function dateDec(format: string) {\n      return ApiProperty({\n        type: String,\n        format: \"date-time\",\n        required: false,\n        // example: parseDate(format, new Date()),\n      });\n    },\n  })\n  .apply();\n\nDecoration.for(ValidationKeys.ENUM)\n  .extend({\n    decorator: function optionDec(options: string[] | Record<string, any>) {\n      const opts = Array.isArray(options) ? options : Object.values(options);\n      return ApiProperty({\n        enum: opts,\n        required: false,\n      });\n    },\n  })\n  .apply();\n\nDecoration.for(ValidationKeys.PATTERN)\n  .extend({\n    decorator: function patternDec(pat: RegExp | string) {\n      return ApiProperty({\n        pattern: typeof pat === \"string\" ? pat : pat.source,\n        required: false,\n      });\n    },\n  })\n  .apply();\n\nDecoration.for(PersistenceKeys.COLUMN)\n  .extend({\n    decorator: function columnDec(name: string) {\n      return ApiProperty({\n        name: name,\n        required: false,\n      });\n    },\n  })\n  .apply();\n\nDecoration.for(DecorationKeys.DESCRIPTION)\n  .extend({\n    decorator: function descriptionDec(description: string) {\n      return ApiProperty({\n        description: description,\n        required: false,\n      });\n    },\n  })\n  .apply();\n\nDecoration.for(PersistenceKeys.AUTH).extend({ decorator: Auth }).apply();\n","import { ForbiddenError } from \"@decaf-ts/core\";\n\nexport class CorsError extends ForbiddenError {\n  constructor(msg: string | Error) {\n    super(msg, CorsError.name);\n  }\n}\n","import { BaseError } from \"@decaf-ts/db-decorators\";\n\nexport class ToManyRequestsError extends BaseError {\n  constructor(msg: string | Error ) {\n    super(ToManyRequestsError.name, msg , 429);\n  }\n}","import {\n  ArgumentsHost,\n  Catch,\n  ExceptionFilter,\n  NotAcceptableException,\n  NotFoundException,\n} from \"@nestjs/common\";\nimport { BaseError, InternalError } from \"@decaf-ts/db-decorators\";\nimport { LoggedEnvironment } from \"@decaf-ts/logging\";\nimport { UnsupportedError } from \"@decaf-ts/core\";\nimport { ToManyRequestsError } from \"../errors/throttling\";\n\n@Catch()\nexport class DecafExceptionFilter implements ExceptionFilter {\n  catch(exception: Error, host: ArgumentsHost) {\n    const ctx = host.switchToHttp();\n    const response = ctx.getResponse();\n    const request = ctx.getRequest();\n\n    const isProduction = LoggedEnvironment.env === \"production\";\n    let statusCode;\n\n    if (\n      exception instanceof NotFoundException ||\n      exception instanceof UnsupportedError\n    ) {\n      exception = new NotAcceptableException(exception.message);\n      statusCode = (exception as NotAcceptableException).getStatus();\n    } else if (!(exception instanceof BaseError)) {\n      if((exception as any).status === 429){\n        exception = new ToManyRequestsError(exception.message);\n      }else{\n        exception = new InternalError(exception.message);\n      }\n    }\n\n    response.status((exception as BaseError).code || statusCode).json({\n      status: (exception as BaseError).code || statusCode,\n      error: isProduction ? exception.name : exception.message,\n      timestamp: new Date().toISOString(),\n      path: request.url,\n      method: request.method,\n    });\n  }\n}\n","import { UseFilters, UseInterceptors } from \"@nestjs/common\";\nimport { DecafExceptionFilter } from \"./DecafErrorFilter\";\nimport { DecafResponseInterceptor } from \"../../request/index\";\n\nexport function UseDecafFilter() {\n  return UseFilters(new DecafExceptionFilter());\n}\n\nexport function UseDecafHeaders() {\n  return UseInterceptors(DecafResponseInterceptor);\n}\n","import { Constructor } from \"@decaf-ts/decoration\";\nimport { SecuritySchemeObject } from \"../../swagger-types\";\n\nexport interface SwaggerOptions {\n  title: string;\n  description: string;\n  version?: string;\n  assetsPath?: string;\n  faviconFilePath?: string;\n  topbarIconFilePath?: string;\n  persistAuthorization?: boolean;\n  path: string;\n  auth?: SecuritySchemeObject;\n  topbarBgColor?: string;\n  extraModels?: Constructor[];\n\n  /**\n   * Path to expose the OpenAPI specification in JSON format.\n   * Example: /api/openapi.json\n   */\n  openApiJsonPath?: string;\n\n  /**\n   * Path to expose the OpenAPI specification in YAML format.\n   * Requires 'yaml' package as peer dependency.\n   * Example: /api/openapi.yaml\n   */\n  openApiYamlPath?: string;\n}\n\nexport const SWAGGER_UI_CONSTANTS: SwaggerOptions = {\n  title: \"Swagger | OpenAPI Specification (OAS)\",\n  description: \"Standardized format for describing RESTful APIs\",\n  version: \"0.0.1\",\n  path: \"docs\",\n  faviconFilePath: \"\",\n  topbarIconFilePath: \"\",\n  auth: {\n    type: \"http\",\n    scheme: \"bearer\",\n    bearerFormat: \"JWT\",\n    name: \"Authorization\",\n    description: \"Enter JWT token\",\n    in: \"header\",\n  },\n  persistAuthorization: true,\n  topbarBgColor: \"#000000\",\n};\n","import { SWAGGER_UI_CONSTANTS } from \"./constants\";\nimport { readFileSync } from \"fs\";\nimport * as path from \"path\";\n\nexport interface SwaggerUIOptions {\n  title?: string;\n  path?: string;\n  persistAuthorization: boolean;\n  assetsPath?: string;\n  faviconPath?: string;\n  topbarIconPath?: string;\n  topbarBgColor?: string;\n}\n\nexport class SwaggerCustomUI {\n  readonly options: SwaggerUIOptions;\n  // private readonly assetsPath: string = path.join(\n  //   __dirname,\n  //   \"..\",\n  //   \"..\",\n  //   \"workdocs\",\n  //   \"assets\"\n  // );\n\n  constructor(options: SwaggerUIOptions) {\n    this.options = {\n      ...options,\n    };\n  }\n\n  private customCSS() {\n    let css = \"\";\n    if (this.options.topbarIconPath) {\n      const img = this.b64(this.options.topbarIconPath);\n      css += `.topbar-wrapper { content: url('data:image/png;base64,${img}'); width: 200px; height: auto; }\\n`;\n    }\n    return (\n      css +\n      `\n        .topbar-wrapper svg { visibility: hidden; }\n        .swagger-ui .topbar { background-color: ${this.options.topbarBgColor || SWAGGER_UI_CONSTANTS.topbarBgColor}; }\n      `\n    );\n  }\n\n  getCustomOptions() {\n    const favicon: Record<string, any> = {};\n    if (this.options.faviconPath) {\n      favicon[\"customfavIcon\"] = this.b64(this.options.faviconPath, true);\n    }\n\n    return {\n      customSiteTitle: this.options.title,\n      ...favicon,\n      customCss: this.customCSS(),\n      swaggerOptions: {\n        persistAuthorization: this.options.persistAuthorization,\n      },\n    };\n  }\n\n  b64(file: string, img: boolean = false) {\n    const filePath = path.join(this.options.assetsPath || \"\", file);\n    const b64 = readFileSync(filePath, { encoding: \"base64\" });\n    return img ? \"data:image/png;base64,\" + b64 : b64;\n  }\n}\n","import { INestApplication } from \"@nestjs/common\";\nimport { DocumentBuilder, SwaggerModule } from \"@nestjs/swagger\";\nimport { SwaggerCustomUI } from \"./SwaggerCustomUI\";\nimport { SWAGGER_UI_CONSTANTS, SwaggerOptions } from \"./constants\";\nimport YAML from \"yaml\";\n\nexport class SwaggerBuilder {\n  constructor(\n    private readonly app: INestApplication,\n    private readonly options: SwaggerOptions\n  ) {}\n\n  private createDocument() {\n    const description = this.options.path\n      ? this.options.description +\n        \"\" +\n        `<br><br><a href=\"${this.options.openApiJsonPath}\">OpenAPI JSON Spec</a> | ` +\n        `<a href=\"${this.options.openApiYamlPath}\">OpenAPI YAML Spec</a>`\n      : this.options.description;\n\n    const config = new DocumentBuilder()\n      .setTitle(this.options.title)\n      .setDescription(description)\n      .setVersion(this.options.version || \"0.0.1\")\n      .addBearerAuth(this.options.auth || SWAGGER_UI_CONSTANTS.auth)\n      .build();\n\n    return SwaggerModule.createDocument(this.app, config, {\n      extraModels: this.options.extraModels || [],\n    });\n  }\n\n  private registerOpenApiRoute(\n    path: string | undefined,\n    contentType: \"application/json\" | \"application/x-yaml\",\n    bodyFactory: () => void\n  ): void {\n    if (!path) return;\n\n    const httpAdapter = this.app.getHttpAdapter() as any;\n    path = path.startsWith(\"/\") ? path : `/${path}`;\n    httpAdapter.get(path, (_req: any, res: any) => {\n      httpAdapter.reply(res, bodyFactory(), 200, {\n        \"Content-Type\": contentType,\n      });\n    });\n  }\n\n  public setupSwagger() {\n    const document = this.createDocument();\n    const swaggerUI = new SwaggerCustomUI({\n      title: this.options.title,\n      path: this.options.path || SWAGGER_UI_CONSTANTS.path,\n      persistAuthorization: this.options.persistAuthorization ?? true,\n      assetsPath: this.options.assetsPath,\n      faviconPath: this.options.faviconFilePath,\n      topbarIconPath: this.options.topbarIconFilePath,\n      topbarBgColor: this.options.topbarBgColor,\n    });\n    SwaggerModule.setup(\n      this.options.path || SWAGGER_UI_CONSTANTS.path,\n      this.app,\n      document,\n      {\n        ...swaggerUI.getCustomOptions(),\n        jsonDocumentUrl: this.options.openApiJsonPath\n          ? `${this.options.openApiJsonPath}`\n          : undefined,\n        yamlDocumentUrl: this.options.openApiYamlPath\n          ? `${this.options.openApiYamlPath}`\n          : undefined,\n      }\n    );\n\n    this.registerOpenApiRoute(\n      this.options.openApiJsonPath,\n      \"application/json\",\n      () => document\n    );\n\n    this.registerOpenApiRoute(\n      this.options.openApiYamlPath,\n      \"application/x-yaml\",\n      () => YAML.stringify(document)\n    );\n  }\n\n  // private getVersion() {\n  //   // const packageJson = path.join(__dirname, \"..\", \"..\", \"package.json\");\n  //   // const {version} = require(packageJson);\n  //   return \"version\";\n  // }\n}\n","import {\n  INestApplication,\n  Logger,\n  NestInterceptor,\n  PipeTransform,\n} from \"@nestjs/common\";\nimport { DecafExceptionFilter } from \"./exceptions\";\nimport { SwaggerBuilder } from \"./openapi\";\nimport { CorsOptions } from \"@nestjs/common/interfaces/external/cors-options.interface\";\nimport { CorsError } from \"./errors\";\n\n/**\n * @description\n * Defines all customizable parameters for Swagger setup.\n *\n * @summary\n * This interface allows developers to customize how Swagger UI is configured\n * within the NestJS application. It includes parameters for titles, paths,\n * color schemes, and asset paths to tailor the API documentation experience.\n *\n * @param {string} title - Title displayed in Swagger UI.\n * @param {string} description - Description shown below the title.\n * @param {string} version - API version displayed in the documentation.\n * @param {string} [path] - Optional path where Swagger will be available.\n * @param {boolean} [persistAuthorization] - Whether authorization tokens persist across reloads.\n * @param {string} [assetsPath] - Path to custom assets for Swagger UI.\n * @param {string} [topbarBgColor] - Custom background color for the Swagger top bar.\n * @param {string} [topbarIconPath] - Path to a custom icon displayed in the top bar.\n * @param {string} [faviconPath] - Path to a custom favicon.\n */\nexport interface SwaggerSetupOptions {\n  title: string;\n  description: string;\n  version: string;\n  path?: string;\n  persistAuthorization?: boolean;\n  assetsPath?: string;\n  topbarBgColor?: string;\n  topbarIconPath?: string;\n  faviconPath?: string;\n  /**\n   * Path to expose the OpenAPI specification in JSON format.\n   * Example: /api/openapi.json\n   */\n  openApiJsonPath?: string;\n  /**\n   * Path to expose the OpenAPI specification in YAML format.\n   * Requires 'yaml' package as peer dependency.\n   * Example: /api/openapi.yaml\n   */\n  openApiYamlPath?: string;\n}\n\n/**\n * @description\n * A fluent, static bootstrap class for initializing and configuring a NestJS application.\n *\n * @summary\n * The `NestBootstraper` class provides a chainable API for configuring\n * a NestJS application instance. It includes built-in methods for enabling\n * CORS, Helmet security, Swagger documentation, global pipes, filters,\n * interceptors, and starting the server.\n *\n * This class promotes consistency and reduces repetitive setup code\n * across multiple NestJS projects.\n *\n * @example\n * ```ts\n * import { NestFactory } from \"@nestjs/core\";\n * import { AppModule } from \"./app.module\";\n * import { MyLogger } from \"./MyLogger\";\n * import { NestBootstraper } from \"@decaf-ts/for-nest\";\n *\n * async function bootstrap() {\n *   const app = await NestFactory.create(AppModule);\n *\n *   await NestBootstraper\n *     .initialize(app)\n *     .enableLogger(new MyLogger())\n *     .enableCors([\"http://localhost:4200\"])\n *     .useHelmet()\n *     .setupSwagger({\n *       title: \"OpenAPI by TradeMark™\",\n *       description: \"TradeMark™ API documentation\",\n *       version: \"1.0.0\",\n *       path: \"api\",\n *       persistAuthorization: true,\n *       topbarBgColor: \"#2C3E50\",\n *       topbarIconPath: \"/assets/logo.svg\",\n *       faviconPath: \"/assets/favicon.ico\"\n *     })\n *     .useGlobalFilters()\n *     .useGlobalPipes(...)\n *     .useGlobalInterceptors(...)\n *     .start(3000);\n * }\n *\n * bootstrap();\n * ```\n * @class\n */\nexport class NestBootstraper {\n  private static app: INestApplication;\n  private static _logger: Logger;\n\n  /**\n   * @description\n   * Returns the current logger instance, creating a default one if not set.\n   *\n   * @summary\n   * Ensures that a valid `Logger` instance is always available\n   * for logging bootstrap-related messages.\n   *\n   * @return {Logger} The active logger instance.\n   */\n  private static get logger(): Logger {\n    if (!this._logger) {\n      // fallback\n      this._logger = new Logger(\"NestBootstrap\");\n    }\n    return this._logger;\n  }\n\n  /**\n   * @description\n   * Initializes the bootstrapper with a given NestJS application.\n   *\n   * @summary\n   * Binds the provided NestJS app instance to the bootstrapper, enabling\n   * chained configuration methods.\n   *\n   * @param {INestApplication} app - The NestJS application instance to initialize.\n   * @return {NestBootstraper} Returns the class for chaining configuration methods.\n   */\n  static initialize(app: INestApplication) {\n    this.app = app;\n    return this;\n  }\n\n  /**\n   * @description\n   * Enables or replaces the global logger for the NestJS application.\n   *\n   * @summary\n   * If a custom logger is provided, it replaces the default logger. Otherwise,\n   * a new logger named `\"NestBootstrap\"` is used. This logger is also registered\n   * with the NestJS application.\n   *\n   * @param {Logger} [customLogger] - Optional custom logger instance.\n   * @return {NestBootstraper} Returns the class for chaining.\n   */\n  static enableLogger(customLogger?: Logger) {\n    this._logger = customLogger || new Logger(\"NestBootstrap\");\n    this.app.useLogger(this._logger);\n    return this;\n  }\n\n  /**\n   * @description\n   * Enables Cross-Origin Resource Sharing (CORS) for the application.\n   *\n   * @summary\n   * Allows defining either a wildcard origin (`\"*\"`) or a list of allowed origins.\n   * Automatically accepts local development requests and those without origin headers.\n   * Throws a `CorsError` for unauthorized origins.\n   *\n   * @param {'*' | string[]} [origins=[]] - List of allowed origins or `\"*\"` to allow all.\n   * @param {string[]} [allowMethods=['GET', 'POST', 'PUT', 'DELETE']] - Allowed HTTP methods.\n   * @return {NestBootstraper} Returns the class for chaining configuration.\n   *\n   */\n  static enableCors(\n    origins: \"*\" | string[] = [],\n    allowMethods: string[] = [\"GET\", \"POST\", \"PUT\", \"DELETE\"]\n  ) {\n    const allowedOrigins =\n      origins === \"*\" ? \"*\" : origins.map((o) => o.trim().toLowerCase());\n\n    const corsOptions: CorsOptions = {\n      origin: (origin, callback) => {\n        // Allow request without origin...\n        if (!origin) return callback(null, true);\n\n        if (\n          allowedOrigins === \"*\" ||\n          (Array.isArray(allowedOrigins) &&\n            allowedOrigins.includes(origin.toLowerCase()))\n        ) {\n          return callback(null, true);\n        }\n\n        callback(new CorsError(`Origin ${origin} not allowed`));\n      },\n      credentials: true,\n      methods: allowMethods.join(\",\"),\n    };\n\n    this.app.enableCors(corsOptions);\n    return this;\n  }\n\n  /**\n   * @description\n   * Applies the Helmet middleware for enhanced security.\n   *\n   * @summary\n   * Dynamically loads the `helmet` package if available and registers it\n   * as middleware to improve HTTP header security. If not installed, logs a warning\n   * and continues execution without throwing errors.\n   *\n   * @param {Record<string, any>} [options] - Optional configuration passed to Helmet.\n   * @return {NestBootstraper} Returns the class for chaining configuration.\n   */\n  static useHelmet(options?: Record<string, any>) {\n    try {\n      // eslint-disable-next-line @typescript-eslint/no-require-imports\n      const helmet = require(\"helmet\"); // Dynamic import to avoid hard dependency\n      this.app.use(helmet(options));\n      this.logger.log(\"Helmet middleware enabled successfully.\");\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e: any) {\n      this.logger.warn(\"Helmet not installed. Skipping middleware.\");\n    }\n\n    return this;\n  }\n\n  /**\n   * @description\n   * Configures and initializes Swagger UI for API documentation.\n   *\n   * @summary\n   * Uses the `SwaggerBuilder` utility to configure API documentation\n   * with detailed customization for title, version, paths, and colors.\n   * Swagger is automatically exposed at the configured path.\n   *\n   * @param {SwaggerSetupOptions} options - Swagger configuration options.\n   * @return {NestBootstraper} Returns the class for chaining configuration.\n   */\n  static setupSwagger(options: SwaggerSetupOptions) {\n    const swagger = new SwaggerBuilder(this.app, {\n      title: options.title,\n      description: options.description,\n      version: options.version,\n      path: options.path || \"api\",\n      persistAuthorization: options.persistAuthorization ?? true,\n      assetsPath: options.assetsPath,\n      faviconFilePath: options.faviconPath,\n      topbarIconFilePath: options.topbarIconPath,\n      topbarBgColor: options.topbarBgColor,\n      openApiJsonPath: options.openApiJsonPath,\n      openApiYamlPath: options.openApiYamlPath,\n    });\n    swagger.setupSwagger();\n    return this;\n  }\n\n  /**\n   * @description\n   * Registers one or more global validation pipes.\n   *\n   * @summary\n   * Enables request payload validation and transformation globally across\n   * the entire NestJS application. Multiple pipes can be chained together\n   * for modular input validation.\n   *\n   * @param {...PipeTransform[]} pipes - Pipe instances to register globally.\n   * @return {NestBootstraper} Returns the class for chaining.\n   */\n  static useGlobalPipes(...pipes: PipeTransform[]) {\n    if (pipes.length > 0) this.app.useGlobalPipes(...pipes);\n    return this;\n  }\n\n  /**\n   * @description\n   * Registers one or more global exception filters.\n   *\n   * @summary\n   * If no filters are provided, it automatically registers a default\n   * set of standard exception filters for common error types like\n   * `HttpException`, `ValidationException`, `ConflictException`, and others.\n   *\n   * @param {...ExceptionFilter[]} filters - Optional filters to apply globally.\n   */\n  static useGlobalFilters(...filters: any[]) {\n    this.app.useGlobalFilters(\n      ...(filters.length > 0 ? filters : [new DecafExceptionFilter()])\n    );\n    return this;\n  }\n\n  /**\n   * @description\n   * Registers global interceptors for request and response transformation.\n   *\n   * @summary\n   * Interceptors allow advanced request/response manipulation such as\n   * serialization, logging, or transformation. Multiple interceptors\n   * can be added for modular configuration.\n   *\n   * @param {...NestInterceptor[]} interceptors - Interceptor instances to register.\n   * @return {NestBootstraper} Returns the class for chaining configuration.\n   */\n  static useGlobalInterceptors(...interceptors: NestInterceptor[]) {\n    if (interceptors.length > 0)\n      this.app.useGlobalInterceptors(...interceptors);\n    return this;\n  }\n\n  /**\n   * @description\n   * Starts the NestJS application and binds it to the given port and host.\n   *\n   * @summary\n   * Listens on the specified port and optionally a host. Once started,\n   * logs the application URL for easy access. The startup process resolves\n   * once the application is successfully running.\n   *\n   * @param {number} [port=3000] - Port number to listen on.\n   * @param {string} [host] - Optional host or IP address to bind to.\n   * @param {boolean} [log=true] - Whether to log the application URL upon startup.\n   * @return {Promise<void>} Resolves once the application starts successfully.\n   */\n  static async start(\n    port: number = Number(process.env.PORT) || 3000,\n    host: string | undefined = undefined,\n    log: boolean = true\n  ) {\n    this.app.listen(port, host as any).then(async () => {\n      if (log) {\n        const url = await this.app.getUrl();\n        this.logger.log(`🚀 Application is running at: ${url}`);\n      }\n    });\n  }\n}\n","import { Inject } from \"@nestjs/common\";\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport {\n  injectableServiceKey,\n  ModelService,\n  Repository as CoreRepository,\n  Service as CoreService,\n} from \"@decaf-ts/core\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\n\nexport type DecafFactoryProvider = {\n  provide: string;\n  useFactory: () => unknown;\n};\n\nconst pendingProviders = new Map<string, DecafFactoryProvider>();\n\n/**\n * @description Drains the providers registered by {@link Service}/{@link Repository} usages.\n * @summary Consumed by {@link DecafCoreModule.forRoot} to wire the tokens that those parameter\n * decorators reference back into Nest's DI container, since a parameter decorator alone cannot\n * supply a provider.\n */\nexport function getRegisteredDecafProviders(): DecafFactoryProvider[] {\n  return Array.from(pendingProviders.values());\n}\n\nfunction registerProvider(token: string, useFactory: () => unknown): void {\n  if (pendingProviders.has(token)) return;\n  pendingProviders.set(token, { provide: token, useFactory });\n}\n\nfunction isModelConstructor(value: unknown): value is Constructor<any> {\n  return typeof value === \"function\" && value.prototype instanceof Model;\n}\n\nfunction modelServiceToken(model: Constructor<any>): string {\n  return `${model.name}Service`;\n}\n\nfunction modelRepositoryToken(\n  model: Constructor<any>,\n  flavour?: string\n): string {\n  return flavour ? `${model.name}Repository@${flavour}` : `${model.name}Repository`;\n}\n\n/**\n * @description Constructor parameter decorator that injects a decaf service.\n * @summary Translates decaf's service resolution APIs into a Nest `@Inject()` call:\n * - `@Service(SomeModel)` injects the `ModelService<SomeModel>` singleton for that model\n *   (via {@link ModelService.forModel}).\n * - `@Service(SomeServiceClass)` or `@Service(\"alias\")` injects the matching `@service()`-decorated\n *   decaf {@link CoreService} (via {@link CoreService.get}).\n * - `@Service()` infers the parameter's type from emitted constructor metadata and resolves it the\n *   same way, provided the parameter is typed as a concrete class (generics like `ModelService<X>`\n *   are erased at runtime, so the model-service form always requires an explicit argument).\n * @param key the model class, service class, or alias to resolve. Omit to infer from the parameter type.\n */\nexport function Service(key?: string | Constructor<any>): ParameterDecorator {\n  return (\n    target: object,\n    propertyKey: string | symbol | undefined,\n    parameterIndex: number\n  ): void => {\n    let resolved: string | Constructor<any> | undefined = key;\n    if (typeof resolved === \"undefined\") {\n      const paramTypes: any[] =\n        Reflect.getMetadata(\"design:paramtypes\", target) || [];\n      resolved = paramTypes[parameterIndex];\n    }\n    if (typeof resolved === \"undefined\") {\n      throw new Error(\n        `@Service() could not determine an injection type for parameter ${parameterIndex} of ${(target as Constructor<any>).name}. Provide an explicit argument, e.g. @Service(SomeService).`\n      );\n    }\n\n    const asModel = typeof resolved !== \"string\" && isModelConstructor(resolved);\n    const token = asModel\n      ? modelServiceToken(resolved as Constructor<any>)\n      : injectableServiceKey(resolved as string | Constructor<any>);\n\n    registerProvider(token, () => {\n      if (asModel) return ModelService.forModel(resolved as Constructor<any>);\n      return typeof resolved === \"string\"\n        ? CoreService.get(resolved)\n        : CoreService.get(resolved as Constructor<any>);\n    });\n\n    return Inject(token)(target, propertyKey, parameterIndex);\n  };\n}\n\n/**\n * @description Constructor parameter decorator that injects a decaf {@link CoreRepository} for `model`.\n * @summary Unlike {@link Service}, `model` is always treated as a Model class: the same class passed\n * to `@Service(model)` and `@Repository(model)` resolves to two different injected objects (a\n * `ModelService<M>` vs a `Repository<M>` respectively), via {@link CoreRepository.forModel}.\n * @param model the model class to resolve a repository for.\n * @param flavour optional adapter flavour/alias, forwarded to {@link CoreRepository.forModel}.\n */\nexport function Repository(\n  model: Constructor<any>,\n  flavour?: string\n): ParameterDecorator {\n  return (\n    target: object,\n    propertyKey: string | symbol | undefined,\n    parameterIndex: number\n  ): void => {\n    const token = modelRepositoryToken(model, flavour);\n    registerProvider(token, () => CoreRepository.forModel(model, flavour));\n    return Inject(token)(target, propertyKey, parameterIndex);\n  };\n}\n","import {\n  DynamicModule,\n  Global,\n  Inject,\n  Module,\n  OnApplicationShutdown,\n} from \"@nestjs/common\";\nimport { APP_INTERCEPTOR, ModuleRef } from \"@nestjs/core\";\nimport type { DecafModuleOptions } from \"./types\";\nimport {\n  DECAF_ADAPTER_ID,\n  DECAF_HANDLERS,\n  DECAF_MODULE_OPTIONS,\n} from \"./constants\";\nimport {\n  DecafRequestHandlerInterceptor,\n} from \"./interceptors\";\nimport { DecafHandlerExecutor, DecafRequestContext } from \"./request\";\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport { Adapter, PersistenceService, Service } from \"@decaf-ts/core\";\nimport { getRegisteredDecafProviders } from \"./decorators\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\nimport {\n  RequestToContextTransformer,\n  requestToContextTransformer,\n} from \"@decaf-ts/for-http/server\";\n\n@Global()\n@Module({})\nexport class DecafCoreModule<CONF, ADAPTER extends Adapter<CONF, any, any, any>>\n  implements OnApplicationShutdown\n{\n  private static _logger: Logger;\n\n  private static _persistence?: PersistenceService<Adapter<any, any, any, any>>;\n\n  protected static get persistence(): PersistenceService<Adapter<any, any, any, any>> {\n    if (!this._persistence)\n      throw new InternalError(\"Persistence service not initialized\");\n    return this._persistence;\n  }\n\n  protected static get log(): Logger {\n    if (!this._logger) this._logger = Logging.for(DecafCoreModule);\n    return this._logger;\n  }\n\n  constructor(\n    @Inject(DECAF_MODULE_OPTIONS)\n    private readonly options: DecafModuleOptions<CONF, ADAPTER>,\n    private readonly moduleRef: ModuleRef\n  ) {}\n\n  static forRoot(options: DecafModuleOptions): DynamicModule {\n    const log = this.log.for(this.forRoot);\n    const decafProviders = getRegisteredDecafProviders();\n    return {\n      module: DecafCoreModule,\n      providers: [\n        { provide: DECAF_MODULE_OPTIONS, useValue: options },\n        { provide: DECAF_ADAPTER_ID, useValue: this.persistence?.client },\n        {\n          provide: DECAF_HANDLERS,\n          useFactory: () =>\n            options.handlers?.map((H) => {\n              log.info(`Registered request handler: ${H.name}`);\n              return new H();\n            }) ?? [],\n        },\n        DecafRequestContext,\n        DecafHandlerExecutor,\n        {\n          provide: APP_INTERCEPTOR,\n          useClass: DecafRequestHandlerInterceptor,\n        },\n        ...decafProviders,\n      ],\n      exports: [\n        DECAF_MODULE_OPTIONS,\n        DECAF_ADAPTER_ID,\n        DECAF_HANDLERS,\n        DecafRequestContext,\n        DecafHandlerExecutor,\n        ...decafProviders.map((provider) => provider.provide),\n      ],\n    };\n  }\n\n  static async bootPersistence(\n    options: DecafModuleOptions\n  ): Promise<Adapter<any, any, any, any>[]> {\n    const log = this.log.for(this.bootPersistence);\n\n    if (!this._persistence) {\n      const trimmed = options.conf.map(([contr, cfg, ...args]) => {\n        const possible = args.pop();\n        if (!possible) return [contr, cfg];\n        return [contr, cfg, ...args];\n      });\n      this._persistence = new PersistenceService();\n      await this._persistence.boot(trimmed);\n      const clients = this._persistence.client;\n      for (let i = 0; i < clients.length; i++) {\n        const c = options.conf[i];\n        const possibleTransf = c.slice(2, c.length);\n        let transformer = possibleTransf.pop();\n        if (\n          !transformer ||\n          !(transformer as RequestToContextTransformer<any>).from\n        ) {\n          const contr = Adapter.transformerFor(clients[i].flavour);\n          if (!contr)\n            throw new InternalError(\n              `No transformer found for flavour ${clients[i].flavour}. you should either @requestToContextTransformer or provide a transformer in the config`\n            );\n          try {\n            transformer = (contr as RequestToContextTransformer<any>).from\n              ? contr\n              : new (contr as Constructor<RequestToContextTransformer<any>>)();\n          } catch (e: unknown) {\n            throw new InternalError(\n              `Failed to boot transformer for ${clients[i].flavour}: ${e}`\n            );\n          }\n        }\n        requestToContextTransformer(clients[i].flavour)(transformer);\n      }\n      log.info(\"persistence layer created successfully!\");\n\n      if (options.initialization) {\n        try {\n          await options.initialization();\n        } catch (e: unknown) {\n          throw new InternalError(`Failed to initialize application: ${e}`);\n        }\n      }\n    }\n\n    return this.persistence.client;\n  }\n\n  async onApplicationShutdown(): Promise<void> {\n    const log = DecafCoreModule.log.for(this.onApplicationShutdown);\n    const adapters: Adapter<any, any, any, any>[] =\n      this.moduleRef.get<any>(DECAF_ADAPTER_ID);\n    for (const adapter of adapters)\n      try {\n        if (adapter) {\n          log.info(`Shutting down ${adapter.toString()}`);\n          await adapter.shutdown();\n        }\n      } catch (e: unknown) {\n        log.error(`Failed to shutdown application`, e as Error);\n      }\n    try {\n      await Service.shutdown();\n    } catch (e: unknown) {\n      log.error(`Failed to shutdown services`, e as Error);\n    }\n  }\n}\n","export const LISTENING_ADAPTERS_FLAVOURS = Symbol(\n  \"LISTENING_ADAPTERS_FLAVOURS\"\n);\n","import { Model } from \"@decaf-ts/decorator-validation\";\n\nexport function normalizeEventResponse(args: any[]): unknown[] {\n  const [modelConstr, operation, id, payload] = args;\n\n  const modelName = modelConstr?.name ?? modelConstr;\n\n  const serializedPayload = Array.isArray(payload)\n    ? payload.map((e) => {\n        try {\n          if (typeof e.serialize === \"function\") return e.serialize();\n\n          console.warn(\n            `Payload item for ${modelName} does not have serialize method and is an ${typeof e}, attempting to stringify directly. Item: ${e}`\n          );\n          return typeof e === \"string\" ? e : JSON.stringify(e);\n        } catch (err: unknown) {\n          console.warn(`Failed to serialize payload for ${modelName}: ${err}`);\n          return undefined;\n        }\n      })\n    : payload && typeof payload.serialize === \"function\"\n      ? payload.serialize()\n      : typeof payload === \"string\"\n        ? payload\n        : JSON.stringify(payload);\n\n  console.debug(\n    `Normalized event response for model ${modelName}, operation ${operation}, id ${id}:`,\n    serializedPayload\n  );\n\n  return [modelName, operation, id, serializedPayload];\n}\n","import { DecafController } from \"../controllers\";\nimport { DecafRequestContext } from \"../request\";\nimport { Adapter, Observer } from \"@decaf-ts/core\";\nimport { Controller, Inject, MessageEvent, Query, Sse } from \"@nestjs/common\";\nimport { interval, merge, Observable } from \"rxjs\";\nimport { Logging } from \"@decaf-ts/logging\";\nimport { LISTENING_ADAPTERS_FLAVOURS } from \"./constant\";\nimport { DecafServerCtx } from \"../constants\";\nimport { normalizeEventResponse } from \"./utils\";\nimport { map, tap } from \"rxjs/operators\";\n\n@Controller()\nexport class EventsController extends DecafController<DecafServerCtx> {\n  private readonly adapters: Adapter<any, any, any, any>[];\n\n  constructor(\n    clientContext: DecafRequestContext,\n    @Inject(LISTENING_ADAPTERS_FLAVOURS) flavours: string[]\n  ) {\n    super(clientContext, EventsController.name);\n    this.adapters = flavours.map((flavour) => (Adapter as any).get(flavour)); // change to Adapter.cache(\"\")\n  }\n\n  @Sse()\n  listen(): Observable<MessageEvent> {\n    const logger = Logging.for(EventsController.name);\n\n    const events$ = new Observable<MessageEvent>((observer) => {\n      const observerId =\n        `B-${Math.random().toString(36).slice(2, 8)}`.toUpperCase();\n\n      logger.info(\n        `Creating SSE observer: ${observerId} for client ${this.clientContext.uuid}`\n      );\n      const cb = new (class implements Observer {\n        observerId = observerId;\n        refresh(...args: any[]): Promise<void> {\n          logger.debug(\n            `SSE observer ${this.observerId} received refresh event`\n          );\n          return Promise.resolve().then(() => {\n            const data = normalizeEventResponse(args);\n            observer.next({ type: \"message\", data });\n            logger.debug(\n              `SSE observer ${this.observerId} event pushed to client`\n            );\n          });\n        }\n      })();\n\n      logger.verbose(\n        `Registering observer ${observerId} across ${this.adapters.length} adapter(s)`\n      );\n      for (const adapter of this.adapters) {\n        const adapterName = adapter?.constructor?.name ?? \"UnknownAdapter\";\n        try {\n          logger.debug(\n            `Registering observer ${observerId} in adapter ${adapterName}`\n          );\n          adapter.observe(cb);\n        } catch (e: any) {\n          logger.debug(\n            `Failed to register observer ${observerId} in adapter ${adapterName}: ${e?.message || e}`\n          );\n          logger.error(e);\n        }\n      }\n\n      return () => {\n        logger.debug(`Cleaning up SSE observer ${observerId}`);\n\n        for (const adapter of this.adapters) {\n          const adapterName = adapter?.constructor?.name ?? \"UnknownAdapter\";\n          try {\n            logger.debug(\n              `Unregistering observer ${observerId} from adapter ${adapterName}`\n            );\n            adapter.unObserve(cb);\n          } catch (e: any) {\n            logger.debug(\n              `Failed during cleanup of observer ${observerId} in adapter ${adapterName}: ${e?.message || e}`\n            );\n            logger.error(e);\n          }\n        }\n      };\n    });\n\n    const HEARTBEAT_INTERVAL_MS = 15000;\n    const heartbeat$ = interval(HEARTBEAT_INTERVAL_MS).pipe(\n      tap(() => {\n        logger.debug(\"Sending heartbeat\");\n      }),\n      map(\n        (): MessageEvent => ({\n          type: \"heartbeat\",\n          data: {\n            ts: new Date().toISOString(),\n          },\n        })\n      )\n    );\n\n    return merge(events$, heartbeat$);\n  }\n\n  @Sse(\"/:model\")\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  listenForModel(@Query(\"model\") model: string): Observable<MessageEvent> {\n    const logger = Logging.for(EventsController.name);\n\n    return new Observable<MessageEvent>((observer) => {\n      const cb = new (class implements Observer {\n        refresh(...args: any[]): Promise<void> {\n          return Promise.resolve().then(() => {\n            observer.next({ data: args } as any);\n          });\n        }\n      })();\n\n      try {\n        for (const adapter of this.adapters) {\n          adapter.observe(cb);\n        }\n      } catch (e: any) {\n        observer.error(`Failed to observe event: ${e.message || e}`);\n      }\n\n      return () => {\n        try {\n          for (const adapter of this.adapters) {\n            adapter.unObserve(cb);\n          }\n        } catch (e: any) {\n          logger.error(e);\n        }\n      };\n    });\n  }\n}\n","import { DynamicModule, Module } from \"@nestjs/common\";\nimport { EventsController } from \"./EventsController\";\nimport { RouterModule } from \"@nestjs/core\";\nimport { LISTENING_ADAPTERS_FLAVOURS } from \"./constant\";\nimport { DecafRequestContext } from \"../request\";\n\n@Module({})\nexport class DecafStreamModule {\n  static forFlavours(\n    flavours: string[],\n    path: string = \"events\"\n  ): DynamicModule {\n    return {\n      module: DecafStreamModule,\n      controllers: [EventsController],\n      imports: [\n        RouterModule.register([\n          {\n            path: path.replace(/^\\//, \"\"),\n            module: DecafStreamModule,\n          },\n        ]),\n      ],\n      providers: [\n        DecafRequestContext,\n        {\n          provide: LISTENING_ADAPTERS_FLAVOURS,\n          useValue: flavours ?? [],\n        },\n      ],\n    };\n  }\n}\n","import { DynamicModule, ForwardReference, Module, Type } from \"@nestjs/common\";\nimport { DecafModuleOptions } from \"./types\";\nimport { DecafCoreModule } from \"./core-module\";\nimport { Adapter } from \"@decaf-ts/core\";\nimport { getModuleFor } from \"./decaf-model/index\";\nimport { DecafStreamModule } from \"./events-module\";\n\n/**\n * @publicApi\n */\n@Module({})\nexport class DecafModule {\n  static async forRootAsync(\n    options: DecafModuleOptions\n  ): Promise<DynamicModule> {\n    const { autoControllers, autoServices } = options;\n\n    const adapters: Adapter<any, any, any, any>[] =\n      await DecafCoreModule.bootPersistence(options);\n    const flavours = adapters.map((adapter) => adapter.flavour);\n\n    const imports:\n      | (\n          | DynamicModule\n          | Type<any>\n          | Promise<DynamicModule>\n          | ForwardReference<any>\n        )[]\n      | undefined = [DecafCoreModule.forRoot(options)];\n\n    if (autoControllers) {\n        flavours.forEach((flavour) => {\n          imports.push(\n            getModuleFor(flavour).forRoot(flavour, {\n              autoServices,\n              controllerExposure: options.controllerExposure,\n              controllerConfig: options.controllerConfig,\n            })\n          );\n        });\n      }\n\n    if (options.observerOptions?.enableObserverEvents) {\n      imports.push(\n        DecafStreamModule.forFlavours(\n          options.observerOptions.observerFlavours || flavours\n        )\n      );\n    }\n\n    return {\n      module: DecafModule,\n      imports: imports,\n    };\n  }\n}\n\nexport async function runMigrations(): Promise<void> {}\n","import {Model} from \"@decaf-ts/decorator-validation\";\nimport {InternalError} from \"@decaf-ts/db-decorators\";\nimport {Repository} from \"@decaf-ts/core\";\n\nexport function repoForModel(model: string) {\n\tconst m = Model.get(model);\n\tif (!m)\n\t\tthrow new InternalError(`Failed to find repository for ${model}`)\n\tconst repo = Repository.forModel(m);\n\treturn repo;\n}","/**\n * @module for-nest\n * @description This module serves as the main entry point for the ts-workspace library. It aggregates and exports\n * functionality from various submodules and utilities within the project.\n *\n * The module includes:\n * 1. Utility functions and types from the \"./utils\" directory:\n *    - These likely contain helper functions, common types, and shared functionality used throughout the project.\n *    - May include operations for data manipulation, type checking, or other general-purpose utilities.\n *\n * 2. A namespace and related types from the \"./namespace\" directory:\n *    - This could contain domain-specific code or a collection of related functionality.\n *    - Might include interfaces, types, or classes that represent core concepts in the library.\n *\n * 3. A VERSION constant:\n *    - Represents the current version of the module.\n *    - Useful for version checking and compatibility purposes.\n *\n * This structure provides a clean and organized export of the module's functionality, allowing consumers\n * to easily import and use specific parts of the library as needed.\n */\n\nimport { Metadata } from \"@decaf-ts/decoration\";\nimport \"./decoration\";\n\nexport * from \"./decoration\"; // on top on purpose\nexport * from \"./decaf-model\";\nexport * from \"./auth\";\nexport * from \"./factory\";\nexport * from \"./interceptors\";\nexport * from \"./overrides\";\nexport * from \"./request\";\nexport * from \"./constants\";\nexport * from \"./controllers\";\nexport * from \"./module\";\nexport * from \"./core-module\";\nexport * from \"./types\";\nexport * from \"./decorators\";\nexport * from \"./utils\";\nexport * from \"./events-module\";\n// export * from \"./webhooks\";\n\n/**\n * Represents the current version of the ts-workspace module.\n * The actual version number is replaced during the build process.\n * @constant\n * @type {string}\n */\nexport const VERSION = \"##VERSION##\";\n\n/**\n * @description Represents the current commit hash of the module build.\n * @summary Stores the current git commit hash for the package. The build replaces\n * the placeholder with the actual commit hash at publish time.\n * @const COMMIT\n */\nexport const COMMIT = \"##COMMIT##\";\n\n/**\n * @description Represents the full version string of the module.\n * @summary Stores the semver version and commit hash for the package.\n * The build replaces the placeholder with the actual `<version>-<commit>` value at publish time.\n * @const FULL_VERSION\n */\nexport const FULL_VERSION = \"##FULL_VERSION##\";\n\nexport const PACKAGE_NAME = \"##PACKAGE##\";\n\nMetadata.allowReregistration(true);\nMetadata.registerLibrary(PACKAGE_NAME, VERSION);\nMetadata.allowReregistration(false);\n"],"names":["DECORATORS_PREFIX","DECORATORS","API_OPERATION","API_RESPONSE","API_PRODUCES","API_CONSUMES","API_TAGS","API_CALLBACKS","API_PARAMETERS","API_HEADERS","API_MODEL_PROPERTIES","API_MODEL_PROPERTIES_ARRAY","API_SECURITY","API_EXCLUDE_ENDPOINT","API_EXCLUDE_CONTROLLER","API_EXTRA_MODELS","API_EXTENSION","API_SCHEMA","API_DEFAULT_GETTER","API_LINK","isConstructor","val","METADATA_FACTORY_NAME","METHOD_METADATA","createMethodDecorator","metakey","metadata","overrideExisting","target","key","descriptor","prevValue","Reflect","getMetadata","value","defineMetadata","createClassDecorator","createPropertyDecorator","propertyKey","properties","includes","existingMetadata","newMetadata","pickBy","negate","isUndefined","metadataToSave","type","constructor","createMixedDecorator","metadatas","Array","isArray","previousMetadata","Object","assign","createParamDecorator","initial","paramOptions","parameters","propertyKeys","getOwnPropertyNames","prototype","methodDescriptor","getOwnPropertyDescriptor","isApiMethod","hasMetadata","getTypeIsArrayTuple","input","isArrayFlag","isInputArray","obj","getEnumValues","enumType","numericValues","values","filter","map","toString","keys","getEnumType","hasString","isString","length","required","isEnumArray","opts","enum","undefined","ApiProperty","options","createApiPropertyDecorator","enumValues","items","ApiOperationFromModel","ModelConstructor","verb","path","httpToCrud","GET","OperationKeys","READ","Get","POST","CREATE","Post","PUT","UPDATE","Put","PATCH","Patch","DELETE","Delete","crudOp","HttpMethodDecorator","resolveBlockTarget","coreIsOperationBlocked","kind","apply","ApiExcludeEndpoint","BulkApiOperationFromModel","BulkCrudOperationKeys","READ_ALL","CREATE_ALL","UPDATE_ALL","DELETE_ALL","normalized","replace","statementTargets","PreparedStatementKeys","LIST_BY","PAGE_BY","FIND","PAGE","FIND_ONE_BY","FIND_BY","COUNT_OF","MAX_OF","MIN_OF","AVG_OF","SUM_OF","DISTINCT_OF","GROUP_OF","startsWith","statementValue","ApiParamsFromModel","props","decorators","p","ApiParamDec","name","description","String","applyDecorators","DecafBody","data","ctx","request","switchToHttp","getRequest","body","controller","getClass","ModelConstr","class","InternalServerErrorException","item","OrderedParams","order","req","original","params","orderList","ordered","k","raw","valuesInOrder","keysInOrder","DecafParams","DecafQuery","_","query","parsed","limit","n","Number","isNaN","offset","bookmark","DECAF_MODULE_OPTIONS","DECAF_ADAPTER_ID","DECAF_TASK_SERVICE_ID","DECAF_ROUTE","DECAF_HANDLERS","Symbol","DECAF_ADAPTER_OPTIONS","DECAF_EXPOSE","DECAF_CONTROLLER_CONFIG","DECAF_CONTEXT_KEY","expose","flavours","Metadata","set","controllerConfig","config","controllerConfigDecorator","AUTH_HANDLER","AUTH_META_KEY","IS_PUBLIC_KEY","REQUIRED_ROLES_KEY","DecafRequestContext","RequestContext","super","headersOf","headers","this","uuid","UUID","instance","generate","put","record","overrides","get","e","accumulate","__decorate","Injectable","scope","Scope","REQUEST","__param","Inject","AuthInterceptor","reflector","requestContext","authHandler","intercept","next","log","Logging","for","isPublic","getAllAndOverride","getHandler","modelName","requiredRoles","verbose","debug","authorize","applyTransformers","user","getOrUndefined","organization","currentLog","childLog","logger","handle","Adapter","flavoursToTransform","flavour","transformer","transformerFor","from","Optional","Reflector","DecafAuthHandler","AuthHandler","parseRequest","userRole","authorization","split","extractFromAuth","AuthorizationError","roles","DecafRoleAuthHandler","Auth","model","resource","decs","ApiBearerAuth","UseInterceptors","push","SetMetadata","Public","RequireRoles","ApiSecurity","DecafHandlerExecutor","DecafHandlerExecutor_1","handlers","context","exec","res","method","url","handler","DecafResponseInterceptor","response","getResponse","pipe","tap","toResponse","toContextFlags","adapter","alias","bind","requestTransformers","meta","Context","pending","header","JSON","stringify","ModelBuilder","decorateClass","decorator","_classDecorators","__hasClassDecoratorSupport","originalBuild","build","result","call","decorated","DecafRequestHandlerInterceptor","DecafRequestHandlerInterceptor_1","executor","contextualize","flags","ip","extractIp","DefaultAdapterFlags","timestamp","Date","operation","parseIpHeader","candidate","segment","trim","Boolean","DecafAuthModule","DecafAuthModule_1","forRoot","providers","provide","APP_INTERCEPTOR","useClass","global","useExisting","module","exports","Module","HttpVerbToDecorator","Error","extractPathParams","routePath","slice","apiParamSpec","getApiDecorators","methodName","httpVerb","includeQueryParams","NestHttpRouteDec","apiPathParams","swaggerQueryParams","ApiQuery","OrderDirection","ApiParam","ApiOperation","summary","ApiOkResponse","ApiNoContentResponse","Query","applyApiDecorators","proto","forEach","d","index","resolvePersistenceMethod","persistence","args","ModelService","statement","createRouteHandler","async","pathParams","queryParams","direction","error","defineRouteMethod","ControllerClass","defineProperty","writable","DecafController","HttpDecafController","clientContext","_name","DecafModelController","_persistence","Service","getService","Repository","forModel","certs","override","dtoCache","Map","DtoFor","op","stack","Set","TransactionOperationKeys","cache","getDtoCache","cached","isUpdateOp","DynamicDTO","toPascalCase","pkProp","Model","pk","pkPropsMetadata","pkProps","pkDesignType","pkTypeIsNumeric","BigInt","pkIsGenerated","generated","generatedBySequence","isPropertyGeneratedAcrossInheritance","allProps","relations","scalarProps","prop","has","validation","getValidationAcrossInheritance","isRequired","ValidationKeys","REQUIRED","typeHint","getTypeAcrossInheritance","apiOptions","designType","enumerable","configurable","relation","relationMeta","InternalError","relationType","validationFor","LIST","isCircular","pkTypeName","getPkOpenApiType","addRelationPkRef","relationDto","add","addRelationUpdate","addRelation","DtoClass","extraModels","dtoRef","oneOfItems","$ref","oneOf","pkType","current","Function","getPrototypeOf","WeakMap","FromModelController","getPersistence","ModelClazz","e2","createQueryRoutesFromRepository","prefix","PersistenceKeys","QUERY","repo","queryMethods","routeMethods","QueryController","entries","join","createComplexQueryHandler","defineMethod","httpDecorator","httpMethod","getQueryDecorators","objValues","fields","f","create","moduleConfigOverrides","tableName","toKebabCase","modelClazzName","factoryPersistence","decoratorConfig","moduleOverride","mergedConfig","FactoryController","ModelControllerFactory","factoryRoutes","__routes__","getPK","apiProperties","pkPath","getRouteParametersFromModel","DynamicModelController","DynamicModelController_1","info","Controller","ApiTags","ApiExtraModels","sortedRoutes","sort","a","b","aSegments","bSegments","aParamCount","s","bParamCount","aLiteralCount","bLiteralCount","route","registration","matchRoute","paramDecorators","composed","DBKeys","COMPOSED","composedKeys","uniqueKeys","separator","methodDecorators","normalizedPath","createRegistration","createCreateHandler","createCreateDecorators","Response","passthrough","createBulkCreateHandler","bulkCreateDecorators","createBulkReadHandler","bulkReadDecorators","createBulkUpdateHandler","bulkUpdateDecorators","createBulkDeleteHandler","bulkDeleteDecorators","createReadHandler","readDecorators","createUpdateHandler","updateDecorators","createDeleteHandler","deleteDecorators","fallbackSegments","isAllParams","every","fallbackApiProps","suffix","createStatementHandler","statementDecorators","Param","statementRoutes","statementKey","statementMethodName","createStatementShortcutHandler","statementShortcutDecorators","statementShortcutParams","queryMethod","complexQueryParams","pathSegments","knownPrefixes","routeMetadata","matchedEntry","find","actualMethodName","paramSegments","createCustomRouteHandler","firstSegment","segments","seg","i","resp","logCtx","created","createAll","readAll","ids","normalizedIds","read","updateAll","updated","deleteAll","routeParams","id","ValidationError","readResult","update","payload","parse","remove","del","delete","details","STATEMENT","parseInt","pathDirection","resolvedDirection","statementShortcut","listBy","page","paginateBy","ASC","ref","findOneBy","toOverrides","findBy","field","complexQuery","spreadArgs","extractQueryArgs","customRoute","last","queryObj","pop","hasDirection","hasLimit","hasOffset","extras","ApiBody","ApiCreatedResponse","schema","getSchemaPath","ApiBadRequestResponse","ApiUnprocessableEntityResponse","ApiNotFoundResponse","base","getModuleFor","DecafModelModule","DecafModelModule_1","createModelServices","models","useFactory","isExposed","exposure","trackedModels","controllerExposure","modelServices","autoServices","controllers","Decoration","InjectablesKeys","INJECTABLE","extend","nestInjectable","category","cfg","DefaultInjectablesConfig","singleton","DEFAULT","durable","INJECT","nestInject","innerNestInject","MAX","maxDec","max","maximum","MIN","minDec","min","minimum","MAX_LENGTH","maxLengthDec","maxLength","MIN_LENGTH","minLengthDec","minLength","TYPE","typeDec","DATE","dateDec","format","ENUM","optionDec","PATTERN","patternDec","pat","pattern","source","COLUMN","columnDec","DecorationKeys","DESCRIPTION","descriptionDec","AUTH","CorsError","ForbiddenError","msg","ToManyRequestsError","BaseError","DecafExceptionFilter","exception","host","isProduction","LoggedEnvironment","env","statusCode","NotFoundException","UnsupportedError","NotAcceptableException","message","getStatus","status","code","json","toISOString","Catch","UseDecafFilter","UseFilters","UseDecafHeaders","SWAGGER_UI_CONSTANTS","title","version","faviconFilePath","topbarIconFilePath","auth","scheme","bearerFormat","in","persistAuthorization","topbarBgColor","SwaggerCustomUI","customCSS","css","topbarIconPath","img","b64","getCustomOptions","favicon","faviconPath","customSiteTitle","customCss","swaggerOptions","file","filePath","assetsPath","readFileSync","encoding","SwaggerBuilder","app","createDocument","openApiJsonPath","openApiYamlPath","DocumentBuilder","setTitle","setDescription","setVersion","addBearerAuth","SwaggerModule","registerOpenApiRoute","contentType","bodyFactory","httpAdapter","getHttpAdapter","_req","reply","setupSwagger","document","swaggerUI","setup","jsonDocumentUrl","yamlDocumentUrl","YAML","NestBootstraper","_logger","Logger","initialize","enableLogger","customLogger","useLogger","enableCors","origins","allowMethods","allowedOrigins","o","toLowerCase","corsOptions","origin","callback","credentials","methods","useHelmet","helmet","require","use","warn","swagger","useGlobalPipes","pipes","useGlobalFilters","filters","useGlobalInterceptors","interceptors","start","port","process","PORT","listen","then","getUrl","pendingProviders","getRegisteredDecafProviders","registerProvider","token","isModelConstructor","modelServiceToken","modelRepositoryToken","parameterIndex","resolved","paramTypes","asModel","injectableServiceKey","CoreService","CoreRepository","DecafCoreModule","DecafCoreModule_1","moduleRef","decafProviders","useValue","client","H","provider","bootPersistence","trimmed","conf","contr","possible","PersistenceService","boot","clients","c","possibleTransf","requestToContextTransformer","initialization","onApplicationShutdown","adapters","shutdown","Global","ModuleRef","LISTENING_ADAPTERS_FLAVOURS","normalizeEventResponse","modelConstr","serializedPayload","serialize","console","err","EventsController","EventsController_1","events$","Observable","observer","observerId","Math","random","toUpperCase","cb","refresh","Promise","resolve","adapterName","observe","unObserve","HEARTBEAT_INTERVAL_MS","heartbeat$","interval","ts","merge","listenForModel","Sse","DecafStreamModule","DecafStreamModule_1","forFlavours","imports","RouterModule","register","DecafModule","DecafModule_1","forRootAsync","autoControllers","observerOptions","enableObserverEvents","observerFlavours","runMigrations","repoForModel","m","VERSION","COMMIT","FULL_VERSION","PACKAGE_NAME","allowReregistration","registerLibrary"],"mappings":"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"}
+export { AUTH_HANDLER, AUTH_META_KEY, ApiOperationFromModel, ApiParamsFromModel, ApiProperty, Auth, AuthInterceptor, BulkApiOperationFromModel, COMMIT, CorsError, DECAF_ADAPTER_ID, DECAF_CONTEXT_KEY, DECAF_CONTROLLER_CONFIG, DECAF_EXPOSE, DECAF_HANDLERS, DECAF_MODULE_OPTIONS, DECAF_ROUTE, DECAF_TASK_SERVICE_ID, DECORATORS, DECORATORS_PREFIX, DecafAuthHandler, DecafAuthModule, DecafBody, DecafController, DecafCoreModule, DecafExceptionFilter, DecafHandlerExecutor, DecafModelController, DecafModule, DecafParams, DecafRequestContext, DecafRequestHandlerInterceptor, DecafResponseInterceptor, DecafRoleAuthHandler, DecafStreamModule, DtoFor, EventsController, FULL_VERSION, FromModelController, IS_PUBLIC_KEY, NestBootstraper, PACKAGE_NAME, Public, REQUIRED_ROLES_KEY, Repository, RequireRoles, SKIP_MODEL_ROLES_KEY, Service, SwaggerBuilder, UseDecafFilter, UseDecafHeaders, VERSION, applyApiDecorators, controllerConfig, createApiPropertyDecorator, createPropertyDecorator, createRouteHandler, defineRouteMethod, expose, getApiDecorators, getEnumType, getEnumValues, getModuleFor, getRegisteredDecafProviders, isUndefined, repoForModel, resolvePersistenceMethod, runMigrations };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"for-nest.js","sources":["../src/overrides/constants.ts","../src/overrides/helpers.ts","../src/overrides/decoration.ts","../src/decaf-model/decorators/ApiOperationFromModel.ts","../src/decaf-model/decorators/ApiParamsFromModel.ts","../src/decaf-model/decorators/DecafBody.ts","../src/decaf-model/decorators/DecafParams.ts","../src/constants.ts","../src/decaf-model/decorators/expose.ts","../src/decaf-model/decorators/controller-config.ts","../src/auth/constants.ts","../src/request/DecafRequestContext.ts","../src/auth/AuthInterceptor.ts","../src/auth/decorators.ts","../src/decaf-model/decorators/utils.ts","../src/decaf-model/utils.ts","../src/auth/DecafAuthHandler.ts","../src/overrides/overrides.ts","../src/overrides/ModelBuilderExtensions.ts","../src/interceptors/DecafRequestHandlerInterceptor.ts","../src/auth/DecafAuthModule.ts","../src/request/DecafHandlerExecutor.ts","../src/request/DecafResponseInterceptor.ts","../src/controllers.ts","../src/factory/openapi/DtoBuilder.ts","../src/decaf-model/FromModelController.ts","../src/decaf-model/DecafModelModule.ts","../src/decoration.ts","../src/factory/errors/cors.ts","../src/factory/errors/throttling.ts","../src/factory/exceptions/DecafErrorFilter.ts","../src/factory/exceptions/decorators.ts","../src/factory/openapi/constants.ts","../src/factory/openapi/SwaggerCustomUI.ts","../src/factory/openapi/SwaggerBuilder.ts","../src/factory/NestBootstraper.ts","../src/decorators.ts","../src/core-module.ts","../src/events-module/constant.ts","../src/events-module/utils.ts","../src/events-module/EventsController.ts","../src/events-module/DecafStreamModule.ts","../src/module.ts","../src/utils.ts","../src/index.ts"],"sourcesContent":["export const DECORATORS_PREFIX = \"swagger\";\nexport const DECORATORS = {\n  API_OPERATION: `${DECORATORS_PREFIX}/apiOperation`,\n  API_RESPONSE: `${DECORATORS_PREFIX}/apiResponse`,\n  API_PRODUCES: `${DECORATORS_PREFIX}/apiProduces`,\n  API_CONSUMES: `${DECORATORS_PREFIX}/apiConsumes`,\n  API_TAGS: `${DECORATORS_PREFIX}/apiUseTags`,\n  API_CALLBACKS: `${DECORATORS_PREFIX}/apiCallbacks`,\n  API_PARAMETERS: `${DECORATORS_PREFIX}/apiParameters`,\n  API_HEADERS: `${DECORATORS_PREFIX}/apiHeaders`,\n  API_MODEL_PROPERTIES: `${DECORATORS_PREFIX}/apiModelProperties`,\n  API_MODEL_PROPERTIES_ARRAY: `${DECORATORS_PREFIX}/apiModelPropertiesArray`,\n  API_SECURITY: `${DECORATORS_PREFIX}/apiSecurity`,\n  API_EXCLUDE_ENDPOINT: `${DECORATORS_PREFIX}/apiExcludeEndpoint`,\n  API_EXCLUDE_CONTROLLER: `${DECORATORS_PREFIX}/apiExcludeController`,\n  API_EXTRA_MODELS: `${DECORATORS_PREFIX}/apiExtraModels`,\n  API_EXTENSION: `${DECORATORS_PREFIX}/apiExtension`,\n  API_SCHEMA: `${DECORATORS_PREFIX}/apiSchema`,\n  API_DEFAULT_GETTER: `${DECORATORS_PREFIX}/apiDefaultGetter`,\n  API_LINK: `${DECORATORS_PREFIX}/apiLink`,\n};\n","import { isArray, isUndefined, negate, pickBy } from \"lodash\";\nimport { DECORATORS } from \"./constants\";\n\nexport const isConstructor = (val: any): boolean => val === \"constructor\";\nexport const METADATA_FACTORY_NAME = \"_OPENAPI_METADATA_FACTORY\";\n\nexport const METHOD_METADATA = \"method\";\n\nexport function createMethodDecorator<T = any>(\n  metakey: string,\n  metadata: T,\n  { overrideExisting } = { overrideExisting: true }\n): MethodDecorator {\n  return (\n    target: object,\n    key: string | symbol,\n    descriptor: PropertyDescriptor\n  ) => {\n    if (typeof metadata === \"object\") {\n      const prevValue = Reflect.getMetadata(metakey, descriptor.value);\n      if (prevValue && !overrideExisting) {\n        return descriptor;\n      }\n      Reflect.defineMetadata(\n        metakey,\n        { ...prevValue, ...metadata },\n        descriptor.value\n      );\n      return descriptor;\n    }\n    Reflect.defineMetadata(metakey, metadata, descriptor.value);\n    return descriptor;\n  };\n}\n\nexport function createClassDecorator<T extends Array<any> = any>(\n  metakey: string,\n  metadata: T = [] as any\n): ClassDecorator {\n  return (target) => {\n    const prevValue = Reflect.getMetadata(metakey, target) || [];\n    Reflect.defineMetadata(metakey, [...prevValue, ...metadata], target);\n    return target;\n  };\n}\n\nexport function createPropertyDecorator<T extends Record<string, any> = any>(\n  metakey: string,\n  metadata: T,\n  overrideExisting = true\n): PropertyDecorator {\n  return ((target: object, propertyKey: string) => {\n    const properties =\n      Reflect.getMetadata(DECORATORS.API_MODEL_PROPERTIES_ARRAY, target) || [];\n\n    const key = `:${propertyKey}`;\n    if (!properties.includes(key)) {\n      Reflect.defineMetadata(\n        DECORATORS.API_MODEL_PROPERTIES_ARRAY,\n        [...properties, `:${propertyKey}`],\n        target\n      );\n    }\n    const existingMetadata = Reflect.getMetadata(metakey, target, propertyKey);\n    if (existingMetadata) {\n      const newMetadata = pickBy(metadata, negate(isUndefined));\n      const metadataToSave = overrideExisting\n        ? {\n            ...existingMetadata,\n            ...newMetadata,\n          }\n        : {\n            ...newMetadata,\n            ...existingMetadata,\n          };\n\n      Reflect.defineMetadata(metakey, metadataToSave, target, propertyKey);\n    } else {\n      const type =\n        (target?.constructor as any)?.[METADATA_FACTORY_NAME as any]?.()[\n          propertyKey\n        ]?.type ?? Reflect.getMetadata(\"design:type\", target, propertyKey);\n\n      Reflect.defineMetadata(\n        metakey,\n        {\n          type,\n          ...pickBy(metadata, negate(isUndefined)),\n        },\n        target,\n        propertyKey\n      );\n    }\n  }) as PropertyDecorator;\n}\n\nexport function createMixedDecorator<T = any>(\n  metakey: string,\n  metadata: T\n): MethodDecorator & ClassDecorator {\n  return (\n    target: object,\n    key?: string | symbol,\n    descriptor?: TypedPropertyDescriptor<any>\n  ): any => {\n    if (descriptor) {\n      let metadatas: any;\n      if (Array.isArray(metadata)) {\n        const previousMetadata =\n          Reflect.getMetadata(metakey, descriptor.value) || [];\n        metadatas = [...previousMetadata, ...metadata];\n      } else {\n        const previousMetadata =\n          Reflect.getMetadata(metakey, descriptor.value) || {};\n        metadatas = { ...previousMetadata, ...metadata };\n      }\n      Reflect.defineMetadata(metakey, metadatas, descriptor.value);\n      return descriptor;\n    }\n\n    let metadatas: any;\n    if (Array.isArray(metadata)) {\n      const previousMetadata = Reflect.getMetadata(metakey, target) || [];\n      metadatas = [...previousMetadata, ...metadata];\n    } else {\n      const previousMetadata = Reflect.getMetadata(metakey, target) || {};\n      metadatas = Object.assign(Object.assign({}, previousMetadata), metadata);\n    }\n    Reflect.defineMetadata(metakey, metadatas, target);\n    return target;\n  };\n}\n\nexport function createParamDecorator<T extends Record<string, any> = any>(\n  metadata: T,\n  initial: Partial<T>\n): MethodDecorator & ClassDecorator {\n  return (\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n    target: object | Function,\n    key?: string | symbol,\n    descriptor?: TypedPropertyDescriptor<any>\n  ): any => {\n    const paramOptions = {\n      ...initial,\n      ...pickBy(metadata, negate(isUndefined)),\n    };\n\n    if (descriptor) {\n      const parameters =\n        Reflect.getMetadata(DECORATORS.API_PARAMETERS, descriptor.value) || [];\n      Reflect.defineMetadata(\n        DECORATORS.API_PARAMETERS,\n        [...parameters, paramOptions],\n        descriptor.value\n      );\n      return descriptor;\n    }\n\n    if (typeof target === \"object\") {\n      return target;\n    }\n\n    const propertyKeys = Object.getOwnPropertyNames(target.prototype);\n\n    for (const propertyKey of propertyKeys) {\n      if (isConstructor(propertyKey)) {\n        continue;\n      }\n\n      const methodDescriptor = Object.getOwnPropertyDescriptor(\n        target.prototype,\n        propertyKey\n      );\n\n      if (!methodDescriptor) {\n        continue;\n      }\n\n      const isApiMethod = Reflect.hasMetadata(\n        METHOD_METADATA,\n        methodDescriptor.value\n      );\n\n      if (!isApiMethod) {\n        continue;\n      }\n\n      const parameters =\n        Reflect.getMetadata(\n          DECORATORS.API_PARAMETERS,\n          methodDescriptor.value\n        ) || [];\n      Reflect.defineMetadata(\n        DECORATORS.API_PARAMETERS,\n        [...parameters, paramOptions],\n        methodDescriptor.value\n      );\n    }\n  };\n}\n\nexport function getTypeIsArrayTuple(\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  input: Function | [Function] | undefined | string | Record<string, any>,\n  isArrayFlag: boolean\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n): [Function | undefined, boolean] {\n  if (!input) {\n    return [input as undefined, isArrayFlag];\n  }\n  if (isArrayFlag) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n    return [input as Function, isArrayFlag];\n  }\n  const isInputArray = isArray(input);\n  const type = isInputArray ? input[0] : input;\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  return [type as Function, isInputArray];\n}\n","import { Type } from \"@nestjs/common\";\nimport { isString, negate, pickBy } from \"lodash\";\nimport { DECORATORS } from \"./constants\";\nimport { getTypeIsArrayTuple, METADATA_FACTORY_NAME } from \"./helpers\";\nimport type {\n  EnumAllowedTypes,\n  EnumSchemaAttributes,\n  SchemaObjectMetadata,\n  SwaggerEnumType,\n} from \"../swagger-types\";\n\nexport const isUndefined = (obj: any): obj is undefined =>\n  typeof obj === \"undefined\";\n\nexport function getEnumValues(\n  enumType: SwaggerEnumType | (() => SwaggerEnumType)\n): string[] | number[] {\n  if (typeof enumType === \"function\") {\n    return getEnumValues(enumType());\n  }\n\n  if (Array.isArray(enumType)) {\n    return enumType as string[];\n  }\n  if (typeof enumType !== \"object\") {\n    return [];\n  }\n  // Enums with numeric values\n  //   enum Size {\n  //     SMALL = 1,\n  //     BIG = 2\n  //   }\n  // are transpiled to include a reverse mapping\n  //   const Size = {\n  //     \"1\": \"SMALL\",\n  //     \"2\": \"BIG\",\n  //     \"SMALL\": 1,\n  //     \"BIG\": 2,\n  //   }\n  const numericValues = Object.values(enumType)\n    .filter((value) => typeof value === \"number\")\n    .map((value: any) => value.toString());\n\n  return Object.keys(enumType)\n    .filter((key) => !numericValues.includes(key))\n    .map((key) => enumType[key as any]);\n}\n\nexport function getEnumType(values: (string | number)[]): \"string\" | \"number\" {\n  const hasString = values.filter(isString).length > 0;\n  return hasString ? \"string\" : \"number\";\n}\n\nexport function createPropertyDecorator<T extends Record<string, any> = any>(\n  metakey: string,\n  metadata: T,\n  overrideExisting = true\n): PropertyDecorator {\n  return ((target: object, propertyKey: string) => {\n    const properties =\n      Reflect.getMetadata(DECORATORS.API_MODEL_PROPERTIES_ARRAY, target) || [];\n\n    const key = `:${propertyKey}`;\n    if (!properties.includes(key)) {\n      Reflect.defineMetadata(\n        DECORATORS.API_MODEL_PROPERTIES_ARRAY,\n        [...properties, `:${propertyKey}`],\n        target\n      );\n    }\n    const existingMetadata = Reflect.getMetadata(metakey, target, propertyKey);\n    if (existingMetadata) {\n      const newMetadata = pickBy(metadata, negate(isUndefined));\n      const metadataToSave = overrideExisting\n        ? {\n            ...existingMetadata,\n            ...newMetadata,\n          }\n        : {\n            ...newMetadata,\n            ...existingMetadata,\n          };\n\n      Reflect.defineMetadata(metakey, metadataToSave, target, propertyKey);\n    } else {\n      const type =\n        // @ts-expect-error nest js code\n        target?.constructor?.[METADATA_FACTORY_NAME]?.()[propertyKey]?.type ??\n        Reflect.getMetadata(\"design:type\", target, propertyKey);\n\n      Reflect.defineMetadata(\n        metakey,\n        {\n          type,\n          required: false, // Default to optional unless @required() is used\n          ...pickBy(metadata, negate(isUndefined)),\n        },\n        target,\n        propertyKey\n      );\n    }\n  }) as PropertyDecorator;\n}\n\nexport type ApiPropertyCommonOptions = SchemaObjectMetadata & {\n  \"x-enumNames\"?: string[];\n  /**\n   * Lazy function returning the type for which the decorated property\n   * can be used as an id\n   *\n   * Use together with @ApiDefaultGetter on the getter route of the type\n   * to generate OpenAPI link objects\n   *\n   * @see [Swagger link objects](https://swagger.io/docs/specification/links/)\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  link?: () => Type<unknown> | Function;\n};\n\nexport type ApiPropertyOptions =\n  | ApiPropertyCommonOptions\n  | (ApiPropertyCommonOptions & {\n      enumName: string;\n      enumSchema?: EnumSchemaAttributes;\n    });\n\nconst isEnumArray = (\n  opts: ApiPropertyOptions\n): opts is {\n  isArray: true;\n  enum: EnumAllowedTypes;\n  type: any;\n  items: any;\n} => (opts.isArray && \"enum\" in opts && opts.enum !== undefined) as boolean;\n\n/**\n * @publicApi\n */\nexport function ApiProperty(\n  options: ApiPropertyOptions = {}\n): PropertyDecorator {\n  return createApiPropertyDecorator(options);\n}\n\nexport function createApiPropertyDecorator(\n  options: ApiPropertyOptions = {},\n  overrideExisting = true\n): PropertyDecorator {\n  const [type, isArray] = getTypeIsArrayTuple(\n    options.type,\n    options.isArray as any\n  );\n  options = {\n    ...options,\n    type,\n    isArray,\n  } as ApiPropertyOptions;\n\n  if (isEnumArray(options)) {\n    options.type = \"array\";\n\n    const enumValues = getEnumValues(options.enum);\n    options.items = {\n      type: getEnumType(enumValues),\n      enum: enumValues,\n    };\n    // @ts-expect-error nest js code\n    delete options.enum;\n  } else if (\"enum\" in options && options.enum !== undefined) {\n    const enumValues = getEnumValues(options.enum);\n\n    options.enum = enumValues;\n    options.type = getEnumType(enumValues);\n  }\n\n  if (Array.isArray(options.type)) {\n    options.type = \"array\";\n    options.items = {\n      type: \"array\",\n      items: {\n        type: options.type[0],\n      },\n    };\n  }\n\n  return createPropertyDecorator(\n    DECORATORS.API_MODEL_PROPERTIES,\n    options,\n    overrideExisting\n  );\n}\n","import { apply, Metadata } from \"@decaf-ts/decoration\";\nimport { ApiExcludeEndpoint } from \"@nestjs/swagger\";\nimport {\n  BulkCrudOperationKeys,\n  OperationKeys,\n  CrudOperations,\n} from \"@decaf-ts/db-decorators\";\nimport { ModelConstructor } from \"@decaf-ts/decorator-validation\";\nimport { Delete, Get, Patch, Post, Put } from \"@nestjs/common\";\n\nimport { isOperationBlocked as coreIsOperationBlocked } from \"@decaf-ts/core\";\nimport { PreparedStatementKeys } from \"@decaf-ts/core\";\nimport { HttpVerbs } from \"./types\";\n\n/**\n * @description Determines if a given CRUD operation is blocked for a specific model constructor.\n * @summary Retrieves the operation-blocking handler metadata stored on the provided model constructor (under `OperationKeys.REFLECT + OperationKeys.BLOCK`), executes it (if present) with its persisted arguments plus the requested operation, and returns whether the operation is blocked. If no handler exists, the operation is considered allowed (returns `false`).\n * @param {ModelConstructor<any>} ModelConstructor - The target model constructor whose metadata may include a blocking handler.\n * @param {CrudOperations} op - The CRUD operation to evaluate (e.g., `OperationKeys.CREATE`, `OperationKeys.READ`, `OperationKeys.UPDATE`, `OperationKeys.DELETE`).\n * @return {boolean} `true` when the operation is explicitly blocked by the model's handler; otherwise `false`.\n * @function isOperationBlocked\n */\n/**\n * @description Conditionally applies an HTTP method decorator for a given model and verb, hiding the endpoint in Swagger (and not registering the route) when the model blocks that CRUD operation.\n * @summary Maps an HTTP verb to its corresponding `CrudOperations` key and Nest HTTP decorator (`@Get`, `@Post`, etc.). It checks `isOperationBlocked(ModelConstructor, crudOp)` and, if blocked, applies only `@ApiExcludeEndpoint()` (Swagger-hidden, no Nest route). If permitted, it applies the appropriate HTTP decorator with the optional `path`.\n * @param {ModelConstructor<any>} ModelConstructor - The model constructor used to resolve operation-blocking rules.\n * @param {HttpVerbs} verb - The HTTP verb to map (e.g., `\"GET\" | \"POST\" | \"PUT\" | \"PATCH\" | \"DELETE\"`).\n * @param {string} [path] - Optional route path passed through to the corresponding Nest HTTP method decorator.\n * @return {MethodDecorator} A method decorator that either excludes the endpoint from Swagger (and route registration) or applies the correct HTTP decorator.\n */\nexport function ApiOperationFromModel(\n  ModelConstructor: ModelConstructor<any>,\n  verb: HttpVerbs,\n  path?: string\n): MethodDecorator {\n  const httpToCrud: Record<\n    HttpVerbs,\n    [CrudOperations, (path?: string) => MethodDecorator]\n  > = {\n    GET: [OperationKeys.READ, Get],\n    POST: [OperationKeys.CREATE, Post],\n    PUT: [OperationKeys.UPDATE, Put],\n    PATCH: [OperationKeys.UPDATE, Patch],\n    DELETE: [OperationKeys.DELETE, Delete],\n  };\n\n  const [crudOp, HttpMethodDecorator] = httpToCrud[verb];\n  const target = resolveBlockTarget(verb, path);\n  return target\n    ? coreIsOperationBlocked(ModelConstructor, target.kind as any, target.value)\n      ? apply(ApiExcludeEndpoint())\n      : apply(HttpMethodDecorator(path))\n    : coreIsOperationBlocked(ModelConstructor, crudOp)\n    ? apply(ApiExcludeEndpoint())\n    : apply(HttpMethodDecorator(path));\n}\n/**\n * @description Conditionally applies an HTTP method decorator for a given model and verb, hiding the endpoint in Swagger (and not registering the route) when the model blocks that CRUD operation.\n * @summary Maps an HTTP verb to its corresponding `CrudOperations` key and Nest HTTP decorator (`@Get`, `@Post`, etc.). It checks `isOperationBlocked(ModelConstructor, crudOp)` and, if blocked, applies only `@ApiExcludeEndpoint()` (Swagger-hidden, no Nest route). If permitted, it applies the appropriate HTTP decorator with the optional `path`.\n * @param {ModelConstructor<any>} ModelConstructor - The model constructor used to resolve operation-blocking rules.\n * @param {HttpVerbs} verb - The HTTP verb to map (e.g., `\"GET\" | \"POST\" | \"PUT\" | \"PATCH\" | \"DELETE\"`).\n * @param {string} [path] - Optional route path passed through to the corresponding Nest HTTP method decorator.\n * @return {MethodDecorator} A method decorator that either excludes the endpoint from Swagger (and route registration) or applies the correct HTTP decorator.\n */\nexport function BulkApiOperationFromModel(\n  ModelConstructor: ModelConstructor<any>,\n  verb: HttpVerbs,\n  path?: string\n): MethodDecorator {\n  const httpToCrud: Record<\n    HttpVerbs,\n    [BulkCrudOperationKeys, (path?: string) => MethodDecorator]\n  > = {\n    GET: [BulkCrudOperationKeys.READ_ALL, Get],\n    POST: [BulkCrudOperationKeys.CREATE_ALL, Post],\n    PUT: [BulkCrudOperationKeys.UPDATE_ALL, Put],\n    PATCH: [BulkCrudOperationKeys.UPDATE_ALL, Patch],\n    DELETE: [BulkCrudOperationKeys.DELETE_ALL, Delete],\n  };\n\n  const [crudOp, HttpMethodDecorator] = httpToCrud[verb];\n  const target = path ? resolveBlockTarget(verb, path) : undefined;\n  return target\n    ? coreIsOperationBlocked(ModelConstructor, target.kind as any, target.value)\n      ? apply(ApiExcludeEndpoint())\n      : apply(HttpMethodDecorator(path))\n    : coreIsOperationBlocked(ModelConstructor, \"bulk\" as any, crudOp as any)\n    ? apply(ApiExcludeEndpoint())\n    : apply(HttpMethodDecorator(path));\n}\nfunction resolveBlockTarget(\n  verb: HttpVerbs,\n  path?: string\n): { kind: \"crud\" | \"statement\" | \"query\" | \"bulk\"; value: string } | undefined {\n  if (!path) return undefined;\n\n  const normalized = path.replace(/^\\/+|\\/+$/g, \"\");\n  const statementTargets: 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    \"statement/:method/*args\": \"statement\",\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  if (normalized.startsWith(\"query/\")) {\n    return { kind: \"query\", value: normalized.replace(/^query\\//, \"\") };\n  }\n\n  const statementValue = statementTargets[normalized];\n  if (statementValue) {\n    return { kind: \"statement\", value: statementValue };\n  }\n\n  if (verb === \"GET\" && normalized === \"\") {\n    return { kind: \"crud\", value: OperationKeys.READ };\n  }\n\n  return undefined;\n}\n","import { applyDecorators } from \"@nestjs/common\";\nimport { ApiParam as ApiParamDec } from \"@nestjs/swagger\";\nimport type { DecafApiProperty } from \"./types\";\n\n/**\n * @description Applies a set of Swagger `@ApiParam` decorators generated from a typed specification array.\n * @summary Transforms each entry of the provided `ApiParam[]` into a corresponding `@ApiParam()` decorator (defaulting `description`, `required`, and `type` when omitted) and composes them into a single decorator via Nest's `applyDecorators`. Useful for synchronizing runtime route params with OpenAPI documentation in a concise, declarative way.\n * @param {ApiParam[]} [props=[]] Array describing path parameters to be documented.\n * @param {string} props[].name The parameter's name as it appears in the route template (e.g., `:id`).\n * @param {string} [props[].description] Human-readable explanation of the parameter; defaults to `\"Path parameter: <name>\"`.\n * @param {boolean} [props[].required=true] Whether the parameter is required; defaults to `true`.\n * @param {Constructor<any>} [props[].type=String] Constructor/type used by Swagger to infer schema (e.g., `String`, `Number`, `UUID`, custom class).\n * @return {any} A composed decorator applying all generated `@ApiParam` decorators to the target method or controller.\n * @function ApiParamsFromModel\n */\nexport function ApiParamsFromModel(\n  props: DecafApiProperty[] = []\n): MethodDecorator & ClassDecorator {\n  const decorators = props.map((p) =>\n    ApiParamDec({\n      name: p.name,\n      description: p.description ?? `Path parameter: ${p.name}`,\n      required: p.required ?? true,\n      // schema: { type: 'string' },\n      type: p.type ?? String,\n    })\n  );\n  return applyDecorators(...decorators);\n}\n","import {\n  createParamDecorator,\n  ExecutionContext,\n  InternalServerErrorException,\n} from \"@nestjs/common\";\n\n/**\n * @description Custom decorator that extracts the request body and instantiates it using the Model constructor\n * found on the controller. Handles both single objects and arrays.\n */\nexport const DecafBody = createParamDecorator(\n  (data: unknown, ctx: ExecutionContext) => {\n    const request = ctx.switchToHttp().getRequest();\n    const body = request.body;\n\n    // The DynamicModelController will have 'ModelConstr' available\n    const controller = ctx.getClass();\n    // We access the static property we will add to the DynamicModelController\n    const ModelConstr = (controller as any).class;\n\n    if (!ModelConstr) {\n      throw new InternalServerErrorException(\n        `ModelConstructor not found on controller ${controller.name}. Ensure the controller was created via FromModelController.`\n      );\n    }\n\n    if (!body) return body;\n\n    if (Array.isArray(body)) {\n      return body.map((item) => new ModelConstr(item));\n    }\n\n    return new ModelConstr(body);\n  }\n);\n","import { createParamDecorator, ExecutionContext } from \"@nestjs/common\";\nimport { DecafParamProps, DecafApiProperty } from \"./types\";\n/**\n * @description Creates a custom NestJS parameter decorator that extracts and returns route parameters ordered by a specific key sequence.\n * @summary The `OrderedParams` decorator reads the incoming HTTP request's `params` object, optionally orders it according to a provided list of parameter names, and returns an object containing the original params, the ordered values, and the applied order list. This ensures deterministic parameter access for routes with multiple path parameters.\n * @template {string[]} TOrder - Represents the expected sequence of parameter names.\n * @param {TOrder | undefined} order An optional array specifying the parameter names' desired order. If not provided, the decorator will preserve the order of the keys as they appear in the original `req.params` object.\n * @param {ExecutionContext} ctx The NestJS execution context, used to retrieve the current HTTP request object.\n * @return {DecafParamProps} An object containing:\n * - `original`: the raw parameter map from `req.params`;\n * - `ordered`: an array of parameter values in the requested order;\n * - `order`: the effective order list used.\n * @function OrderedParams\n */\nconst OrderedParams = createParamDecorator(\n  (order: string[] | undefined, ctx: ExecutionContext): DecafParamProps => {\n    const req = ctx.switchToHttp().getRequest();\n    const original = (req?.params ?? {}) as Record<string, any>;\n    const orderList = order ?? Object.keys(original);\n    const ordered = orderList.map((k) => original[k]);\n    return { raw: original, valuesInOrder: ordered, keysInOrder: orderList };\n  }\n);\n\n/**\n * @description A higher-level decorator factory that leverages `OrderedParams` to extract route parameters in a specific order derived from a list of `ApiParam` definitions.\n * @summary `DecafParams` computes the order of route parameters based on the provided `ApiParam[]` specification (using each element’s `name`), then applies `OrderedParams(order)` as a parameter decorator. This enables parameter-level binding that remains consistent with the documented API parameter metadata.\n * @param {ApiParam[]} [props=[]] Array of `ApiParam` definitions whose `name` fields determine the parameter extraction order.\n * @return {ParameterDecorator} A NestJS parameter decorator that injects an ordered list of parameters and metadata into the controller method argument.\n */\nexport function DecafParams(\n  props: DecafApiProperty[] = []\n): ParameterDecorator {\n  const order = props.map((p) => p.name);\n  return OrderedParams(order);\n}\n\nexport const DecafQuery = createParamDecorator(\n  (_: unknown, ctx: ExecutionContext) => {\n    const req = ctx.switchToHttp().getRequest();\n    const query = req.query ?? {};\n\n    const parsed: any = { ...query };\n\n    // Parse limit & offset\n    if (parsed.limit !== undefined) {\n      const n = Number(parsed.limit);\n      if (!Number.isNaN(n)) parsed.limit = n;\n    }\n\n    if (parsed.offset !== undefined) {\n      const n = Number(parsed.offset);\n      if (!Number.isNaN(n)) parsed.offset = n;\n    }\n\n    // Parse bookmark only if numeric\n    if (parsed.bookmark !== undefined) {\n      const n = Number(parsed.bookmark);\n      parsed.bookmark = Number.isNaN(n) ? parsed.bookmark : n;\n    }\n\n    return parsed;\n  }\n);\n","import { AdapterFlags, Context } from \"@decaf-ts/core\";\nimport { Logger } from \"@decaf-ts/logging\";\n\nexport const DECAF_MODULE_OPTIONS = \"DecafModuleOptions\";\nexport const DECAF_ADAPTER_ID = \"DecafAdapter\";\nexport const DECAF_TASK_SERVICE_ID = \"DecafTaskService\";\n\nexport const DECAF_ROUTE = \"DecafRoute\";\nexport const DECAF_HANDLERS = Symbol(\"DecafHandlers\");\nexport const DECAF_EXPOSE = \"DecafExpose\";\nexport const DECAF_CONTROLLER_CONFIG = \"DecafControllerConfig\";\n\nexport const DECAF_CONTEXT_KEY = Symbol(\"decaf:context\");\n\nexport type DecafServerFlags<LOG extends Logger = Logger> =\n  AdapterFlags<LOG> & {\n    headers: Record<string, any>;\n    overrides: Record<string, any>;\n  };\n\nexport type DecafServerCtx = Context<DecafServerFlags>;\n","import { Metadata } from \"@decaf-ts/decoration\";\n\nimport { DECAF_EXPOSE } from \"../../constants\";\n\nexport function expose(...flavours: string[]) {\n  return function expose(target: any) {\n    Metadata.set(\n      target,\n      DECAF_EXPOSE,\n      (flavours.length ? flavours : true) as any\n    );\n    return target;\n  };\n}\n","import { Metadata } from \"@decaf-ts/decoration\";\nimport type { ModelControllerFactoryConfig } from \"@decaf-ts/for-http/server\";\n\nimport { DECAF_CONTROLLER_CONFIG } from \"../../constants\";\n\n/**\n * Class decorator that attaches a {@link ModelControllerFactoryConfig} to a Model,\n * so `FromModelController.create()` can pass it to `ModelControllerFactory.create()`.\n *\n * The per-model config can be overridden by the module-level `controllerConfig`\n * option in `DecafModuleOptions`.\n *\n * @example\n * ```ts\n * @controllerConfig({ allowGroupingQueries: true, allowBulkStatement: { create: true, read: true, update: false, delete: true } })\n * @model()\n * class Order extends Model<Order> { ... }\n * ```\n *\n * @param config - Factory configuration knobs (allowStatementlessQuery, allowGroupingQueries, allowBulkStatement).\n */\nexport function controllerConfig(config: ModelControllerFactoryConfig) {\n  return function controllerConfigDecorator(target: any) {\n    Metadata.set(target, DECAF_CONTROLLER_CONFIG, config as any);\n    return target;\n  };\n}\n","export const AUTH_HANDLER = Symbol(\"AUTH_HANDLER\");\nexport const AUTH_META_KEY = \"auth:meta\";\nexport const IS_PUBLIC_KEY = \"isPublic\";\nexport const REQUIRED_ROLES_KEY = \"requiredRoles\";\nexport const SKIP_MODEL_ROLES_KEY = \"skipModelRoles\";\n","import { Inject, Injectable, Scope } from \"@nestjs/common\";\nimport { REQUEST } from \"@nestjs/core\";\nimport { UUID } from \"@decaf-ts/core\";\nimport { RequestContext } from \"@decaf-ts/for-http/server\";\nimport { type Request } from \"express\";\n\nimport { DecafServerCtx } from \"../constants\";\n\n@Injectable({ scope: Scope.REQUEST })\nexport class DecafRequestContext<C extends DecafServerCtx = DecafServerCtx> extends RequestContext<Request> {\n  uuid = UUID.instance.generate();\n  override readonly request: Request;\n\n  constructor(@Inject(REQUEST) private readonly req: Request) {\n    super(\n      {\n        headersOf: (request: Request) => (request as any)?.headers || undefined,\n      } as any,\n      req\n    );\n    this.request = req;\n  }\n\n  put(record: Record<any, any>) {\n    let overrides: any;\n    try {\n      overrides = this.get(\"overrides\");\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e: unknown) {\n      overrides = {};\n    }\n\n    this.accumulate({\n      overrides: Object.assign(overrides, record),\n    });\n  }\n}\n","import {\n  Injectable,\n  NestInterceptor,\n  ExecutionContext,\n  CallHandler,\n  Inject,\n  Optional,\n  Scope,\n} from \"@nestjs/common\";\nimport { Reflector } from \"@nestjs/core\";\nimport { Observable } from \"rxjs\";\n\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport { Logging } from \"@decaf-ts/logging\";\nimport { Adapter } from \"@decaf-ts/core\";\nimport { RequestToContextTransformer } from \"@decaf-ts/for-http/server\";\n\nimport { AUTH_HANDLER, AUTH_META_KEY, IS_PUBLIC_KEY, REQUIRED_ROLES_KEY, SKIP_MODEL_ROLES_KEY } from \"./constants\";\nimport type { AuthHandler } from \"../types\";\nimport { DecafRequestContext } from \"../request/DecafRequestContext\";\n\n@Injectable({ scope: Scope.REQUEST })\nexport class AuthInterceptor implements NestInterceptor {\n  constructor(\n    private readonly reflector: Reflector,\n    protected readonly requestContext: DecafRequestContext,\n    @Optional() @Inject(AUTH_HANDLER) private readonly authHandler?: AuthHandler\n  ) {}\n\n  async intercept(\n    ctx: ExecutionContext,\n    next: CallHandler\n  ): Promise<Observable<any>> {\n    const log = Logging.for(this as any).for(this.intercept);\n\n    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [\n      ctx.getHandler(),\n      ctx.getClass(),\n    ]);\n\n    const modelName =\n      this.reflector.get<string | Constructor>(\n        AUTH_META_KEY,\n        ctx.getHandler()\n      ) ??\n      this.reflector.get<string | Constructor>(AUTH_META_KEY, ctx.getClass());\n\n    const requiredRoles = this.reflector.getAllAndOverride<string[]>(\n      REQUIRED_ROLES_KEY,\n      [ctx.getHandler(), ctx.getClass()]\n    );\n\n    const skipModelRoles = this.reflector.getAllAndOverride<boolean>(\n      SKIP_MODEL_ROLES_KEY,\n      [ctx.getHandler(), ctx.getClass()]\n    );\n\n    const effectiveModel = skipModelRoles ? undefined : modelName;\n\n    log.verbose(`Intercepted request${modelName ? ` for ${modelName}` : \"\"}`);\n\n    if (isPublic) {\n      log.debug(`Public route — skipping auth`);\n    } else if (this.authHandler) {\n      await this.authHandler.authorize(\n        ctx,\n        effectiveModel as string | Constructor,\n        requiredRoles,\n        this.requestContext\n      );\n    } else {\n      log.debug(`No auth handler registered`);\n    }\n\n    // Transformers run AFTER auth so they can read auth-populated fields\n    // (e.g. `user`) from the context and map them to adapter-specific keys\n    // (e.g. `UUID` for RamAdapter's @createdBy/@updatedBy handlers).\n    await this.applyTransformers();\n\n    const user = this.requestContext.getOrUndefined(\"user\" as any);\n    const organization = this.requestContext.getOrUndefined(\"organization\" as any);\n    if (user || organization) {\n      const currentLog = this.requestContext.get(\"logger\" as any);\n      const childLog = currentLog.for({ user, organization });\n      this.requestContext.accumulate({ logger: childLog } as any);\n    }\n\n    return next.handle();\n  }\n\n  protected async applyTransformers(): Promise<void> {\n    const flavours = Adapter.flavoursToTransform();\n    if (!flavours) return;\n\n    for (const flavour of flavours) {\n      const transformer = Adapter.transformerFor(\n        flavour\n      ) as RequestToContextTransformer<any>;\n      if (!transformer) continue;\n      const from = await transformer.from(this.requestContext);\n      if (from) this.requestContext.accumulate(from);\n    }\n  }\n}\n","import { applyDecorators, SetMetadata, UseInterceptors } from \"@nestjs/common\";\nimport { ApiBearerAuth, ApiSecurity } from \"@nestjs/swagger\";\nimport { Constructor } from \"@decaf-ts/decoration\";\n\nimport { AUTH_META_KEY, IS_PUBLIC_KEY, REQUIRED_ROLES_KEY } from \"./constants\";\nimport { AuthInterceptor } from \"./AuthInterceptor\";\n\nexport function Auth(model?: string | Constructor) {\n  const resource = model\n    ? typeof model === \"string\"\n      ? model\n      : model.name\n    : undefined;\n  const decs = [ApiBearerAuth(), UseInterceptors(AuthInterceptor)];\n  if (resource) decs.push(SetMetadata(AUTH_META_KEY, resource));\n  return applyDecorators(...decs);\n}\n\nexport function Public() {\n  return applyDecorators(SetMetadata(IS_PUBLIC_KEY, true));\n}\n\nexport function RequireRoles(...roles: string[]) {\n  return applyDecorators(\n    ApiSecurity(\"bearer\"),\n    SetMetadata(REQUIRED_ROLES_KEY, roles),\n    UseInterceptors(AuthInterceptor)\n  );\n}\n","import { Delete, Get, Patch, Post, Put } from \"@nestjs/common\";\nimport { HttpVerbs } from \"./types\";\n\n/**\n * Maps an HTTP verb to its corresponding NestJS method decorator.\n *\n * @param verb - HTTP verb to be converted (e.g. GET, POST, PUT, PATCH, DELETE).\n * @returns A NestJS method decorator matching the provided HTTP verb.\n *\n * @throws {Error} If the provided HTTP verb is not supported or not mapped\n * to a NestJS decorator.\n */\nexport function HttpVerbToDecorator(\n  verb: HttpVerbs\n): (path?: string) => MethodDecorator {\n  const httpToCrud: Record<HttpVerbs, (path?: string) => MethodDecorator> = {\n    GET: Get,\n    POST: Post,\n    PUT: Put,\n    PATCH: Patch,\n    DELETE: Delete,\n  };\n\n  const decorator = httpToCrud[verb];\n\n  if (!decorator) {\n    throw new Error(\n      `Unsupported HTTP verb \"${verb}\". No NestJS decorator mapping was found.`\n    );\n  }\n\n  return decorator;\n}\n","import { Query } from \"@nestjs/common\";\nimport { Logger } from \"@decaf-ts/logging\";\nimport { type DecoratorBundle } from \"./types\";\nimport {\n  ApiNoContentResponse,\n  ApiOkResponse,\n  ApiOperation,\n  ApiParam,\n  ApiQuery,\n} from \"@nestjs/swagger\";\nimport {\n  DecafApiProperty,\n  type DecafParamProps,\n  DecafParams,\n} from \"./decorators\";\nimport type { HttpVerbs } from \"./decorators/types\";\nimport {\n  DirectionLimitOffset,\n  ModelService,\n  OrderDirection,\n  Repo,\n} from \"@decaf-ts/core\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { HttpVerbToDecorator } from \"./decorators/utils\";\nimport { DecafModelController } from \"../controllers\";\n\nconst extractPathParams = (routePath: string): string[] => {\n  return routePath\n    .split(\"/\")\n    .filter((p) => p.startsWith(\":\"))\n    .map((p) => p.slice(1));\n};\n\nconst apiParamSpec = (name: string): DecafApiProperty => ({\n  name,\n  description: `${name} parameter for the query`,\n  required: true,\n  type: String,\n});\n\nexport function getApiDecorators(\n  methodName: string,\n  routePath: string,\n  httpVerb: HttpVerbs,\n  includeQueryParams: boolean = false\n): DecoratorBundle {\n  const NestHttpRouteDec = HttpVerbToDecorator(httpVerb);\n  const apiPathParams = extractPathParams(routePath).map(apiParamSpec);\n\n  const swaggerQueryParams = [];\n  if (httpVerb === \"GET\" && includeQueryParams) {\n    swaggerQueryParams.push(\n      ApiQuery({\n        name: \"direction\",\n        required: false,\n        enum: OrderDirection,\n        description: \"the sort order when applicable\",\n      }),\n      ApiQuery({\n        name: \"limit\",\n        required: false,\n        description: \"limit or page size when applicable\",\n      }),\n      ApiQuery({\n        name: \"offset\",\n        required: false,\n        description: \"offset or bookmark when applicable\",\n      })\n    );\n  }\n\n  return {\n    method: [\n      NestHttpRouteDec(routePath),\n      ...apiPathParams.map(ApiParam),\n      ...swaggerQueryParams,\n      ApiOperation({\n        summary: `Retrieve records using according to \"${methodName}\".`,\n      }),\n      ApiOkResponse({\n        description: `Result successfully retrieved.`,\n      }),\n      ApiNoContentResponse({\n        description: `No content returned by the method.`,\n      }),\n    ],\n    params: [DecafParams(apiPathParams), Query()], // , DecafBody()],\n  };\n}\n\nexport function applyApiDecorators(\n  target: any,\n  methodName: string,\n  descriptor: PropertyDescriptor,\n  decorators: DecoratorBundle\n) {\n  const proto = target?.prototype ?? target;\n  decorators.method.forEach((d) => d(proto, methodName, descriptor));\n  decorators.params?.forEach((d, index) => d(proto, methodName, index));\n}\n\nexport function resolvePersistenceMethod<T extends Model<boolean>>(\n  persistence: Repo<T> | ModelService<T>,\n  methodName: string,\n  ...args: any[]\n): any {\n  if (persistence instanceof ModelService) {\n    return typeof (persistence as any)[methodName] === \"function\"\n      ? (persistence as any)[methodName](...args)\n      : persistence.statement(methodName, ...args);\n  }\n\n  if (typeof (persistence as any)[methodName] === \"function\")\n    return (persistence as any)[methodName](...args);\n\n  throw new Error(\n    `Persistence method \"${methodName}\" not found on ${persistence?.constructor?.name}`\n  );\n}\n\nexport function createRouteHandler<T>(methodName: string) {\n  return async function (\n    this: DecafModelController<any>,\n    pathParams: DecafParamProps,\n    queryParams: DirectionLimitOffset\n  ): Promise<T> {\n    const log: Logger = this.log.for(methodName);\n\n    try {\n      log.debug(\n        `Invoking persistence method \"${methodName}\" given parameters: ${JSON.stringify(pathParams.valuesInOrder)}`\n      );\n      const { direction, limit, offset } = queryParams;\n      return await resolvePersistenceMethod(\n        this.persistence(),\n        methodName,\n        ...pathParams.valuesInOrder,\n        direction,\n        limit,\n        offset\n      );\n    } catch (e: any) {\n      log.error(`Custom query \"${methodName}\" failed`, e);\n      throw e;\n    }\n  };\n}\n\nexport function defineRouteMethod(\n  ControllerClass: new (...args: any[]) => any,\n  methodName: string,\n  handler: (...args: any[]) => any\n): PropertyDescriptor | undefined {\n  Object.defineProperty(\n    ControllerClass.prototype || ControllerClass,\n    methodName,\n    {\n      value: handler,\n      writable: false,\n    }\n  );\n\n  return Object.getOwnPropertyDescriptor(\n    ControllerClass.prototype || ControllerClass,\n    methodName\n  );\n}\n","import { ExecutionContext } from \"@nestjs/common\";\nimport { AuthorizationError } from \"@decaf-ts/core\";\nimport { AuthHandler, AuthData } from \"@decaf-ts/for-http/server\";\nimport { DecafRequestContext } from \"../request/DecafRequestContext\";\n\n/**\n * Simple auth handler that reads a role string from the `Authorization: Bearer <role>` header.\n *\n * Only overrides {@link AuthHandler.extractFromAuth} to return the bearer token as\n * both the user identifier and the single role. The base class `bindToContext`\n * (`ctx.accumulate(data)`) is sufficient — the transformer/adapter is responsible\n * for mapping context fields to adapter-specific keys like `UUID`.\n */\nexport class DecafAuthHandler extends AuthHandler<\n  ExecutionContext,\n  DecafRequestContext,\n  AuthData\n> {\n  protected parseRequest(req: any): string {\n    const userRole = req.headers.authorization?.split(\" \")[1] as string;\n    return userRole;\n  }\n\n  protected extractFromAuth(ctx: ExecutionContext): AuthData {\n    const req = ctx.switchToHttp().getRequest();\n    const userRole = this.parseRequest(req);\n    if (!userRole) throw new AuthorizationError(\"Unauthenticated\");\n    return { user: userRole, roles: [userRole] };\n  }\n}\n\n/**\n * Alias for {@link DecafAuthHandler} kept for backward compatibility.\n * The \"role\" variant previously returned roles from `authorize`; with the base\n * class now orchestrating role checks internally, the two classes are equivalent.\n */\nexport class DecafRoleAuthHandler extends DecafAuthHandler {}\n","import { Constructor, Metadata } from \"@decaf-ts/decoration\";\nimport { RequestToContextTransformer } from \"@decaf-ts/for-http/server\";\nimport { Adapter, ContextOf, Context } from \"@decaf-ts/core\";\n\n(Adapter as any).transformerFor = function toContextFlags<\n  A extends Adapter<any, any, any, any>,\n>(adapter: A | string): Constructor<RequestToContextTransformer<ContextOf<A>>> {\n  const alias =\n    typeof adapter === \"string\" ? adapter : (adapter.alias as string);\n  return Metadata[\"innerGet\"](Symbol.for(\"transformers\"), alias);\n}.bind(Adapter);\n\n(Adapter as any).flavoursToTransform = function requestTransformers():\n  | string[]\n  | undefined {\n  const meta = Metadata[\"innerGet\"](Symbol.for(\"transformers\"));\n  if (!meta) return undefined;\n  return Object.keys(meta);\n}.bind(Adapter);\n\n(Context as any).prototype.toResponse = function toResponse<\n  RES extends { header: any },\n>(this: Context, res: RES): RES {\n  const pending = this.pending();\n  if (pending) res.header(\"x-pending-task\", JSON.stringify(pending));\n  return res;\n};\n","import \"@decaf-ts/decorator-validation\";\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport { ModelBuilder } from \"@decaf-ts/decorator-validation\";\nimport { Auth } from \"../decaf-model/decorators/decorators\";\n\ndeclare module \"@decaf-ts/decorator-validation\" {\n  export interface ModelBuilder<M> {\n    Auth(model: string | Constructor): ModelBuilder<M>;\n    decorateClass(decorator: ClassDecorator): ModelBuilder<M>;\n  }\n}\n\nconst prototype = ModelBuilder.prototype as ModelBuilder<any> & {\n  Auth: (model: string | Constructor) => ModelBuilder<any>;\n};\n\nif (!prototype.decorateClass) {\n  prototype.decorateClass = function (decorator: ClassDecorator) {\n    if (!(this as any)._classDecorators) {\n      (this as any)._classDecorators = [];\n    }\n    (this as any)._classDecorators.push(decorator);\n    return this;\n  };\n}\n\nprototype.Auth = function (model: string | Constructor) {\n  return this.decorateClass(Auth(model));\n};\n\nif (!(prototype as any).__hasClassDecoratorSupport) {\n  const originalBuild = prototype.build;\n  prototype.build = function () {\n    let result = originalBuild.call(this);\n    const decorators = (this as any)._classDecorators;\n    if (decorators?.length) {\n      for (const decorator of decorators) {\n        const decorated = decorator(result as any) as typeof result | void;\n        if (decorated) {\n          result = decorated;\n        }\n      }\n    }\n    return result;\n  };\n  (prototype as any).__hasClassDecoratorSupport = true;\n}\n","import {\n  CallHandler,\n  ExecutionContext,\n  Injectable,\n  NestInterceptor,\n  Scope,\n} from \"@nestjs/common\";\nimport { DecafHandlerExecutor, DecafRequestContext } from \"../request\";\nimport { DefaultAdapterFlags } from \"@decaf-ts/core\";\nimport { DecafServerFlags } from \"../constants\";\nimport \"../overrides\";\nimport { Logging } from \"@decaf-ts/logging\";\n\n/**\n * @description\n * Interceptor responsible for executing all registered Decaf request handlers\n * before the controller method is invoked.\n *\n * @summary\n * The {@link DecafRequestHandlerInterceptor} integrates the Decaf request-handling pipeline\n * into NestJS' interceptor mechanism. Before passing execution to the next handler in the\n * NestJS chain, it delegates request processing to the {@link DecafHandlerExecutor}, which\n * sequentially runs all registered {@link DecafRequestHandler} instances. This allows\n * behaviors such as authentication, logging, tenant resolution, or metadata enrichment\n * to occur prior to controller execution.\n *\n * @class DecafRequestHandlerInterceptor\n *\n * @example\n * ```ts\n * // Apply globally:\n * app.useGlobalInterceptors(new DecafRequestHandlerInterceptor(executor));\n *\n * // Or in a module:\n * @Module({\n *   providers: [\n *     DecafHandlerExecutor,\n *     {\n *       provide: APP_INTERCEPTOR,\n *       useClass: DecafRequestHandlerInterceptor,\n *     },\n *   ],\n * })\n * export class AppModule {}\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *     participant Client\n *     participant Interceptor\n *     participant Executor\n *     participant Controller\n *\n *     Client->>Interceptor: HTTP Request\n *     Interceptor->>Executor: exec(request)\n *     Executor-->>Interceptor: handlers completed\n *     Interceptor->>Controller: next.handle()\n *     Controller-->>Client: Response\n */\n@Injectable({ scope: Scope.REQUEST })\nexport class DecafRequestHandlerInterceptor implements NestInterceptor {\n  constructor(\n    protected readonly requestContext: DecafRequestContext,\n    protected readonly executor: DecafHandlerExecutor\n  ) {}\n\n  protected async contextualize(req: any): Promise<void> {\n    const headers = req.headers;\n    const flags: DecafServerFlags = {\n      headers: headers,\n      overrides: {},\n    } as any;\n\n    const ip = extractIp(req);\n    const logger = Logging.get().for({ ip });\n\n    this.requestContext.accumulate(\n      Object.assign(\n        {},\n        DefaultAdapterFlags,\n        {\n          logger,\n          timestamp: new Date(),\n          operation: `${req.method} ${req.url}`,\n        },\n        flags\n      )\n    );\n  }\n\n  async intercept(context: ExecutionContext, next: CallHandler) {\n    const req = context.switchToHttp().getRequest();\n    const res = context.switchToHttp().getResponse();\n    const log = Logging.for(DecafRequestHandlerInterceptor).for(this.intercept);\n    log.debug(\n      `CONTEXT ${this.requestContext.uuid} - request: ${req.method} ${req.url}`\n    );\n    await this.contextualize(req);\n    log.debug(\n      `CONTEXT ${this.requestContext.uuid} contextualized - request: ${req.method} ${req.url}`\n    );\n\n    await this.executor.exec(req, res);\n    log.debug(\n      `CONTEXT ${this.requestContext.uuid} executors finished - request: ${req.method} ${req.url}`\n    );\n    return next.handle();\n  }\n}\n\nfunction extractIp(req: any): string | undefined {\n  const headers = req.headers;\n  function parseIpHeader(value?: string | string[]): string | undefined {\n    if (!value) return undefined;\n    const candidate = Array.isArray(value) ? value[0] : value;\n    return candidate\n      .split(\",\")\n      .map((segment) => segment.trim())\n      .filter(Boolean)[0];\n  }\n  return (\n    parseIpHeader(headers?.[\"x-forwarded-for\"]) ??\n    parseIpHeader(headers?.[\"x-real-ip\"]) ??\n    parseIpHeader(headers?.[\"X-Forwarded-For\"]) ??\n    parseIpHeader(headers?.[\"X-Real-IP\"]) ??\n    req.ip\n  );\n}\n","import { DynamicModule, Module, Type } from \"@nestjs/common\";\nimport { APP_INTERCEPTOR } from \"@nestjs/core\";\n\nimport { AuthInterceptor } from \"./AuthInterceptor\";\nimport { AUTH_HANDLER } from \"./constants\";\nimport { DecafRequestHandlerInterceptor } from \"../interceptors/DecafRequestHandlerInterceptor\";\nimport { AuthHandler } from \"../types\";\n\nexport type DecafAuthModuleOptions = {\n  global?: boolean;\n  handler?: Type<AuthHandler>;\n};\n\n@Module({})\nexport class DecafAuthModule {\n  static forRoot(\n    options: DecafAuthModuleOptions = {}\n  ): DynamicModule {\n    const providers: DynamicModule[\"providers\"] = [\n      AuthInterceptor,\n      DecafRequestHandlerInterceptor,\n      {\n        provide: APP_INTERCEPTOR,\n        useClass: DecafRequestHandlerInterceptor,\n      },\n    ];\n\n    if (options.handler) {\n      providers.push(options.handler);\n      providers.push({\n        provide: AUTH_HANDLER,\n        useClass: options.handler,\n      });\n    }\n\n    if (options.global) {\n      (providers as any[]).push({\n        provide: APP_INTERCEPTOR,\n        useExisting: AuthInterceptor,\n      });\n    }\n\n    return {\n      module: DecafAuthModule,\n      global: options.global ?? false,\n      providers,\n      exports: [AuthInterceptor, AUTH_HANDLER],\n    };\n  }\n}\n","import { Inject, Injectable, Scope } from \"@nestjs/common\";\nimport { DecafRequestContext } from \"./DecafRequestContext\";\nimport { type DecafRequestHandler } from \"../types\";\nimport { DECAF_HANDLERS } from \"../constants\";\nimport { Logging } from \"@decaf-ts/logging\";\n\n/**\n * @description\n * Executes all registered {@link DecafRequestHandler} instances for the current request,\n * providing them with a shared {@link DecafRequestContext}.\n *\n * @summary\n * The {@link DecafHandlerExecutor} class is responsible for orchestrating and executing\n * a sequence of request handlers. Each handler receives the same request-scoped context,\n * allowing coordinated processing such as authentication, metadata extraction, auditing,\n * and custom pipeline behavior. Handlers are injected via the {@link DECAF_HANDLERS} token,\n * ensuring extensibility and loose coupling.\n *\n * @class DecafHandlerExecutor\n *\n * @example\n * ```ts\n * // Example handler:\n * class AuthHandler implements DecafRequestHandler {\n *   async handle(context: DecafRequestContext, req: Request) {\n *     const token = req.headers[\"authorization\"];\n *     const result = MyService.doSomething(token);\n *     context.set(\"my-key\", result);\n *   }\n * }\n *\n * // Executor usage in a request:\n * await executor.exec(request);\n * // All handlers will run in sequence\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *     participant Client\n *     participant Executor\n *     participant HandlerA\n *     participant HandlerB\n *\n *     Client->>Executor: exec(req)\n *     Executor->>HandlerA: handle(context, req)\n *     HandlerA-->>Executor: completed\n *     Executor->>HandlerB: handle(context, req)\n *     HandlerB-->>Executor: completed\n *     Executor-->>Client: processing finished\n */\n@Injectable({ scope: Scope.REQUEST })\nexport class DecafHandlerExecutor {\n  constructor(\n    @Inject(DECAF_HANDLERS) private readonly handlers: DecafRequestHandler[],\n    private readonly context: DecafRequestContext\n  ) {}\n\n  async exec(req: Request, res: Response) {\n    const log = Logging.for(DecafHandlerExecutor.name).for(this.exec);\n    log.debug(\n      `CONTEXT ${this.context.uuid} running ${this.handlers.length} handlers for request ${req.method} ${req.url}`\n    );\n    for (const handler of this.handlers) {\n      await handler.handle(this.context, req, res);\n    }\n  }\n}\n","import {\n  Injectable,\n  NestInterceptor,\n  ExecutionContext,\n  CallHandler,\n} from \"@nestjs/common\";\nimport { Observable, tap } from \"rxjs\";\nimport { DecafRequestContext } from \"./DecafRequestContext\";\n\n@Injectable()\nexport class DecafResponseInterceptor implements NestInterceptor {\n  constructor(protected ctx: DecafRequestContext) {}\n\n  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {\n    let response = context.switchToHttp().getResponse();\n\n    return next.handle().pipe(\n      tap((data) => {\n        response = this.ctx.toResponse(response);\n      })\n    );\n  }\n}\n","import { type Request } from \"express\";\nimport { DecafController as HttpDecafController } from \"@decaf-ts/for-http/server\";\nimport {\n  Context,\n  ModelService,\n  Repo,\n  Repository,\n  Service,\n} from \"@decaf-ts/core\";\nimport { Model, type ModelConstructor } from \"@decaf-ts/decorator-validation\";\n\nimport { DecafServerCtx } from \"./constants\";\nimport { DecafRequestContext } from \"./request/DecafRequestContext\";\n\nexport abstract class DecafController<\n  CONTEXT extends DecafServerCtx = DecafServerCtx,\n> extends HttpDecafController<Request, any, DecafRequestContext> {\n  protected constructor(\n    protected readonly clientContext: DecafRequestContext,\n    _name: string\n  ) {\n    super(clientContext);\n  }\n}\n\nexport abstract class DecafModelController<\n  M extends Model<boolean>,\n  C extends DecafServerCtx = DecafServerCtx,\n> extends DecafController<C> {\n  private _persistence?: Repo<M> | ModelService<M>;\n\n  protected constructor(\n    protected override readonly clientContext: DecafRequestContext,\n    _name: string\n  ) {\n    super(clientContext, _name);\n  }\n\n  abstract get class(): ModelConstructor<M>;\n\n  persistence(ctx?: Context<any>): Repo<M> | ModelService<M> {\n    if (!this._persistence)\n      try {\n        this._persistence = Service.get<ModelService<M>>(this.class);\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      } catch (e: unknown) {\n        try {\n          this._persistence = ModelService.getService(\n            this.class\n          ) as ModelService<M>;\n          // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        } catch (e: unknown) {\n          this._persistence = Repository.forModel(this.class) as Repo<M>;\n        }\n      }\n\n    const overrides = this.clientContext.toOverrides();\n\n    return ctx\n      ? this._persistence instanceof Repository\n        ? this._persistence.override(overrides)\n        : this._persistence.for(overrides)\n      : this._persistence;\n  }\n}\n","import {\n  BulkCrudOperationKeys,\n  InternalError,\n  OperationKeys,\n} from \"@decaf-ts/db-decorators\";\nimport { Constructor, Metadata } from \"@decaf-ts/decoration\";\nimport { ApiProperty } from \"../../overrides/decoration\";\nimport { Model, ValidationKeys } from \"@decaf-ts/decorator-validation\";\nimport { TransactionOperationKeys } from \"@decaf-ts/core\";\nimport { toPascalCase } from \"@decaf-ts/logging\";\nimport { DECORATORS } from \"../../overrides/constants\";\n\nconst dtoCache = new Map<\n  OperationKeys,\n  WeakMap<Constructor<any>, Constructor<any>>\n>();\n\n/**\n * Builds a Nest/Swagger DTO class for the given model and CRUD operation.\n *\n * Rules:\n *  - Only CREATE and UPDATE (and their bulk variants) produce a DTO;\n *    all other operations return the original model class unchanged.\n *  - @generated() properties (createdAt, updatedAt, createdBy, updatedBy,\n *    uuid, version, @composed pks, …) are **never** exposed in any DTO.\n *  - The @pk() property:\n *      • UPDATE – always included.\n *      • CREATE  – included only when the pk is NOT auto-generated\n *                  (checked via Model.pkProps().generated AND Model.generated()).\n *  - Relation properties (@oneToOne, @oneToMany, …):\n *      • CREATE  – nested as DtoFor(CREATE, RelatedModel). When the relation\n *                  creates a circular reference (model A → model B → model A),\n *                  the back-reference uses the related model's PK type\n *                  (string/integer) instead of the full DTO to break the cycle.\n *      • UPDATE  – union of DtoFor(UPDATE, RelatedModel) **or** the\n *                  related model's primary-key type (string / integer),\n *                  expressed as a Swagger oneOf. Circular back-references\n *                  omit the DTO $ref and only include the PK type.\n *\n * Metadata.properties() now returns ALL properties across the prototype chain,\n * so DTO inheritance is no longer needed; every DTO is a flat class.\n */\nexport function DtoFor<M extends Model>(\n  op: OperationKeys,\n  model: Constructor<M>,\n  stack: Set<Constructor<any>> = new Set()\n): Constructor<any> {\n  if (!TransactionOperationKeys.includes(op)) {\n    return model;\n  }\n\n  const cache = getDtoCache(op);\n  const cached = cache.get(model);\n  if (cached) return cached;\n\n  const isUpdateOp = [\n    OperationKeys.UPDATE,\n    BulkCrudOperationKeys.UPDATE_ALL,\n  ].includes(op as any);\n\n  class DynamicDTO {}\n  cache.set(model, DynamicDTO);\n\n  Object.defineProperty(DynamicDTO, \"name\", {\n    value: `${toPascalCase(model.name)}${toPascalCase(op)}DTO`,\n  });\n\n  const pkProp = (() => {\n    try {\n      return Model.pk(model);\n    } catch {\n      return undefined;\n    }\n  })();\n\n  const pkPropsMetadata = pkProp ? Model.pkProps(model as any) : undefined;\n  const pkDesignType = pkProp\n    ? Reflect.getMetadata(\"design:type\", model.prototype, pkProp as string)\n    : undefined;\n  const pkTypeIsNumeric =\n    pkDesignType === Number || pkDesignType === BigInt;\n  const pkIsGenerated =\n    !!pkPropsMetadata?.generated ||\n    (pkProp\n      ? Model.generatedBySequence(model as any, pkProp as any) ||\n        isPropertyGeneratedAcrossInheritance(model, pkProp as string) ||\n        pkTypeIsNumeric\n      : false);\n\n  const allProps = Array.from(new Set(Metadata.properties(model) || []));\n  const relations = new Set<string>((Model.relations(model) as string[]) || []);\n  const scalarProps: string[] = [];\n\n  for (const prop of allProps) {\n    if (!prop) continue;\n    if (relations.has(prop)) continue;\n\n    if (prop === pkProp && !isUpdateOp && pkIsGenerated) continue;\n    if (prop !== pkProp && isPropertyGeneratedAcrossInheritance(model, prop))\n      continue;\n\n    scalarProps.push(prop);\n  }\n\n  for (const prop of scalarProps) {\n    const validation = getValidationAcrossInheritance(model, prop);\n    const isRequired = !!validation?.[ValidationKeys.REQUIRED];\n    const typeHint =\n      getTypeAcrossInheritance(model, prop) ??\n      Reflect.getMetadata(\"design:type\", model.prototype, prop);\n\n    const apiOptions: Parameters<typeof ApiProperty>[0] = {\n      required: isRequired,\n    };\n    if (typeHint) apiOptions.type = typeHint;\n\n    ApiProperty(apiOptions)(DynamicDTO.prototype, prop);\n\n    const designType =\n      Reflect.getMetadata(\"design:type\", model.prototype, prop) ?? typeHint;\n    if (typeof designType !== \"undefined\") {\n      Reflect.defineMetadata(\n        \"design:type\",\n        designType,\n        DynamicDTO.prototype,\n        prop\n      );\n    }\n\n    Object.defineProperty(DynamicDTO.prototype, prop, {\n      value: undefined,\n      writable: true,\n      enumerable: true,\n      configurable: true,\n    });\n  }\n\n  for (const relation of relations) {\n    const relationMeta = Metadata.relations(model, relation as any);\n    if (!relationMeta) {\n      throw new InternalError(`Metadata for relation ${relation} not found`);\n    }\n\n    let relationType: Constructor<any> | undefined =\n      relationMeta.class as Constructor<any>;\n    if (typeof relationType === \"function\" && !relationType.name) {\n      relationType = (relationType as any)();\n    }\n    if (!relationType || typeof relationType !== \"function\") {\n      throw new InternalError(`Type for relation ${relation} not found`);\n    }\n    if (!Model.get(relationType.name)) {\n      continue;\n    }\n\n    const meta = Metadata.validationFor(model, relation as any);\n    const isArray = !!(meta as any)?.[ValidationKeys.LIST];\n    const isRequired = !!(meta as any)?.[ValidationKeys.REQUIRED];\n\n    // Detect circular reference: if the related model is already in the\n    // recursion stack, use the PK type instead of the full DTO to break\n    // the cycle. This prevents @nestjs/swagger's SchemaObjectFactory from\n    // infinitely recursing when exploring the schemas.\n    const isCircular = stack.has(relationType);\n\n    if (isCircular) {\n      const pkTypeName = getPkOpenApiType(relationType);\n      addRelationPkRef(DynamicDTO, relation, pkTypeName, isArray, isRequired);\n      continue;\n    }\n\n    const relationDto = DtoFor(op, relationType, new Set(stack).add(model));\n\n    if (isUpdateOp) {\n      addRelationUpdate(\n        DynamicDTO,\n        relation,\n        relationType,\n        relationDto,\n        isArray,\n        isRequired\n      );\n    } else {\n      addRelation(DynamicDTO, relation, relationDto, isArray, isRequired);\n    }\n  }\n\n  return DynamicDTO;\n}\n\nfunction addRelation(\n  DtoClass: any,\n  relation: string,\n  relationDto: any,\n  isArray: boolean,\n  isRequired: boolean\n): void {\n  const apiOptions: Parameters<typeof ApiProperty>[0] = {\n    type: relationDto,\n    required: isRequired,\n    isArray,\n  };\n  ApiProperty(apiOptions)(DtoClass.prototype, relation);\n  Reflect.defineMetadata(\n    \"design:type\",\n    isArray ? Array : relationDto,\n    DtoClass.prototype,\n    relation\n  );\n  Object.defineProperty(DtoClass.prototype, relation, {\n    value: undefined,\n    writable: true,\n    enumerable: true,\n    configurable: true,\n  });\n}\n\n/**\n * Adds a relation property that uses the PK type (string/integer) instead of\n * a full DTO class. Used to break circular references (e.g. Customer → Order → Customer).\n */\nfunction addRelationPkRef(\n  DtoClass: any,\n  relation: string,\n  pkTypeName: string,\n  isArray: boolean,\n  isRequired: boolean\n): void {\n  const apiOptions: Parameters<typeof ApiProperty>[0] = isArray\n    ? ({ type: \"array\", items: { type: pkTypeName }, required: isRequired } as any)\n    : ({ type: pkTypeName === \"integer\" ? Number : String, required: isRequired } as any);\n  ApiProperty(apiOptions)(DtoClass.prototype, relation);\n  Reflect.defineMetadata(\n    \"design:type\",\n    isArray ? Array : (pkTypeName === \"integer\" ? Number : String),\n    DtoClass.prototype,\n    relation\n  );\n  Object.defineProperty(DtoClass.prototype, relation, {\n    value: undefined,\n    writable: true,\n    enumerable: true,\n    configurable: true,\n  });\n}\n\nfunction addRelationUpdate(\n  DtoClass: any,\n  relation: string,\n  relationType: Constructor<any>,\n  relationDto: any,\n  isArray: boolean,\n  isRequired: boolean\n): void {\n  const extraModels =\n    Reflect.getMetadata(DECORATORS.API_EXTRA_MODELS, DtoClass) || [];\n  if (!extraModels.includes(relationDto)) {\n    Reflect.defineMetadata(\n      DECORATORS.API_EXTRA_MODELS,\n      [...extraModels, relationDto],\n      DtoClass\n    );\n  }\n\n  const dtoRef = `#/components/schemas/${relationDto.name}`;\n  const pkTypeName = getPkOpenApiType(relationType);\n  const oneOfItems = [{ $ref: dtoRef }, { type: pkTypeName }];\n\n  const apiOptions: Parameters<typeof ApiProperty>[0] = isArray\n    ? ({ type: \"array\", required: isRequired, oneOf: oneOfItems } as any)\n    : ({ type: Object, required: isRequired, oneOf: oneOfItems } as any);\n\n  ApiProperty(apiOptions)(DtoClass.prototype, relation);\n  Reflect.defineMetadata(\n    \"design:type\",\n    isArray ? Array : Object,\n    DtoClass.prototype,\n    relation\n  );\n  Object.defineProperty(DtoClass.prototype, relation, {\n    value: undefined,\n    writable: true,\n    enumerable: true,\n    configurable: true,\n  });\n}\n\nfunction getPkOpenApiType(relationType: Constructor<any>): string {\n  try {\n    const pkPropsMetadata = Model.pkProps(relationType as any);\n    const pkType = pkPropsMetadata?.type;\n    if (pkType === Number || pkType === BigInt) return \"integer\";\n    return \"string\";\n  } catch {\n    return \"string\";\n  }\n}\n\nfunction isPropertyGeneratedAcrossInheritance(\n  model: Constructor<any>,\n  prop: string\n): boolean {\n  let current: any = model;\n  while (current && current !== Object && current !== Function) {\n    if (Model.generated(current, prop as any)) return true;\n    current = Object.getPrototypeOf(current);\n  }\n  return false;\n}\n\nfunction getValidationAcrossInheritance(\n  model: Constructor<any>,\n  prop: string\n): Record<string, any> | undefined {\n  let current: any = model;\n  while (current && current !== Object && current !== Function) {\n    const validation = Metadata.validationFor(current, prop as any);\n    if (validation) return validation as any;\n    current = Object.getPrototypeOf(current);\n  }\n  return undefined;\n}\n\nfunction getTypeAcrossInheritance(model: Constructor<any>, prop: string): any {\n  let current: any = model;\n  while (current && current !== Object && current !== Function) {\n    const type = Metadata.type(current, prop);\n    if (type) return type;\n    current = Object.getPrototypeOf(current);\n  }\n  return undefined;\n}\n\nfunction getDtoCache(\n  op: OperationKeys\n): WeakMap<Constructor<any>, Constructor<any>> {\n  if (!dtoCache.has(op)) {\n    dtoCache.set(op, new WeakMap());\n  }\n  return dtoCache.get(op)!;\n}\n","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","import { DynamicModule, Module, Provider } from \"@nestjs/common\";\nimport { Adapter, ModelService } from \"@decaf-ts/core\";\nimport { Logging } from \"@decaf-ts/logging\";\nimport { FromModelController } from \"./FromModelController\";\nimport { DecafModuleOptions } from \"../types\";\nimport { Model, ModelConstructor } from \"@decaf-ts/decorator-validation\";\nimport { Metadata } from \"@decaf-ts/decoration\";\nimport { DECAF_EXPOSE } from \"../constants\";\nimport type { ModelControllerFactoryConfig } from \"@decaf-ts/for-http/server\";\n\nexport function getModuleFor(flavour: string) {\n  @Module({})\n  class DecafModelModule {\n    static readonly log = Logging.for(DecafModelModule.name).for(flavour);\n\n    static createModelServices<T extends Model<boolean>>(\n      models: ModelConstructor<T>[]\n    ): Provider[] {\n      return models.map((model) => ({\n        provide: `${model.name}Service`,\n        useFactory: () => ModelService.forModel(model as any),\n      }));\n    }\n\n    static isExposed(\n      model: ModelConstructor<any>,\n      exposure?: Record<string, boolean | string[]>\n    ): boolean {\n      const override = exposure?.[model.name];\n      const value =\n        typeof override !== \"undefined\"\n          ? override\n          : Metadata.get(model, Metadata.key(DECAF_EXPOSE));\n\n      if (typeof value === \"undefined\") return true;\n      if (value === true) return true;\n      if (Array.isArray(value)) return value.includes(flavour);\n      return false;\n    }\n\n    static forRoot(\n      flavour: string,\n      options: Partial<DecafModuleOptions> = {}\n    ): DynamicModule {\n      const log = this.log.for(this.forRoot);\n      log.info(`Generating controllers for flavour...`);\n\n      const trackedModels = Adapter.models(flavour).filter((model) =>\n        this.isExposed(model, options.controllerExposure)\n      );\n\n      let modelServices: Provider[] = [];\n      if (options.autoServices) {\n        log.info(\"Auto-services enabled. Initializing service generation.\");\n        modelServices = this.createModelServices(trackedModels);\n        log.info(\n          `Auto-services completed. ${modelServices.length} services initialized.`\n        );\n      }\n\n      const globalDefaults: Partial<ModelControllerFactoryConfig> = {};\n      if (options.aggregations === false) {\n        globalDefaults.allowGroupingQueries = false;\n      }\n\n      const controllers = trackedModels.map((model) =>\n        FromModelController.create(model, options.controllerConfig, globalDefaults)\n      );\n      log.info(`Generated ${controllers.length} controllers`);\n\n      return {\n        module: DecafModelModule,\n        controllers,\n        providers: [\n          ...modelServices,\n        ],\n      };\n    }\n  }\n  Object.assign(DecafModelModule, \"name\", {\n    value: `DecafModule${flavour}`,\n  });\n  return DecafModelModule;\n}\n","import {\n  DefaultInjectablesConfig,\n  InjectableConfig,\n  InjectablesKeys,\n  InjectOptions,\n} from \"@decaf-ts/injectable-decorators\";\nimport { Inject, Injectable, Scope } from \"@nestjs/common\";\nimport { Constructor, Decoration, DecorationKeys } from \"@decaf-ts/decoration\";\nimport { ValidationKeys } from \"@decaf-ts/decorator-validation\";\nimport { PersistenceKeys } from \"@decaf-ts/core\";\nimport { ApiProperty } from \"./overrides/decoration\";\nimport { Auth } from \"./decaf-model\";\n\nDecoration.for(InjectablesKeys.INJECTABLE)\n  .extend({\n    decorator: function nestInjectable(\n      category: string | Constructor,\n      cfg?: InjectableConfig\n    ) {\n      cfg =\n        cfg ||\n        (typeof category === \"object\"\n          ? Object.assign(\n              category as Record<any, any>,\n              DefaultInjectablesConfig\n            )\n          : DefaultInjectablesConfig);\n      return Injectable({\n        scope: cfg.singleton ? Scope.DEFAULT : Scope.REQUEST,\n        durable: cfg.singleton ? undefined : true,\n      });\n    },\n  })\n  .apply();\n\nDecoration.for(InjectablesKeys.INJECT)\n  .extend({\n    decorator: function nestInject(\n      category: symbol | string | Constructor,\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      cfg: InjectOptions\n    ) {\n      return function innerNestInject(\n        target: object,\n        propertyKey?: any,\n        descriptor?: any\n      ) {\n        return Inject(category || (target as Constructor))(\n          target,\n          propertyKey,\n          descriptor\n        );\n      };\n    },\n  })\n  .apply();\n\nDecoration.for(ValidationKeys.REQUIRED)\n  .extend(\n    ApiProperty({\n      required: true,\n    })\n  )\n  .apply();\n\nDecoration.for(ValidationKeys.MAX)\n  .extend({\n    decorator: function maxDec(max: number) {\n      return ApiProperty({ maximum: max, required: false });\n    },\n  })\n  .apply();\n\nDecoration.for(ValidationKeys.MIN)\n  .extend({\n    decorator: function minDec(min: number) {\n      return ApiProperty({ minimum: min, required: false });\n    },\n  })\n  .apply();\n\nDecoration.for(ValidationKeys.MAX_LENGTH)\n  .extend({\n    decorator: function maxLengthDec(max: number) {\n      return ApiProperty({ maxLength: max, required: false });\n    },\n  })\n  .apply();\n\nDecoration.for(ValidationKeys.MIN_LENGTH)\n  .extend({\n    decorator: function minLengthDec(min: number) {\n      return ApiProperty({ minLength: min, required: false });\n    },\n  })\n  .apply();\n\nDecoration.for(ValidationKeys.TYPE)\n  .extend({\n    decorator: function typeDec(\n      type:\n        | (Constructor | (() => Constructor))[]\n        | Constructor\n        | (() => Constructor)\n    ) {\n      return (target: object, prop: any) => {\n        type = Array.isArray(type) ? type[0] : type;\n        if (typeof type === \"function\" && !type.name)\n          type = (type as () => Constructor)();\n        return ApiProperty({\n          type: type as any,\n          required: false,\n        })(target, prop);\n      };\n    },\n  })\n  .apply();\n//\n// Decoration.for(ValidationKeys.LIST)\n//   .extend({\n//     decorator: function listDec(\n//       clazz:\n//         | Constructor\n//         | (() => Constructor)\n//         | (Constructor | (() => Constructor))[],\n//       // eslint-disable-next-line @typescript-eslint/no-unused-vars\n//       collection: \"Array\" | \"Set\" = \"Array\"\n//     ) {\n//       return (target: object, prop: any) => {\n//         clazz = Array.isArray(clazz) ? clazz[0] : clazz;\n//         if (typeof clazz === \"function\" && !clazz.name)\n//           clazz = (clazz as () => Constructor)();\n//         return ApiProperty({ type: [clazz as any] })(target, prop);\n//       };\n//     },\n//   })\n//   .apply();\n// //\nDecoration.for(ValidationKeys.DATE)\n  .extend({\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    decorator: function dateDec(format: string) {\n      return ApiProperty({\n        type: String,\n        format: \"date-time\",\n        required: false,\n        // example: parseDate(format, new Date()),\n      });\n    },\n  })\n  .apply();\n\nDecoration.for(ValidationKeys.ENUM)\n  .extend({\n    decorator: function optionDec(options: string[] | Record<string, any>) {\n      const opts = Array.isArray(options) ? options : Object.values(options);\n      return ApiProperty({\n        enum: opts,\n        required: false,\n      });\n    },\n  })\n  .apply();\n\nDecoration.for(ValidationKeys.PATTERN)\n  .extend({\n    decorator: function patternDec(pat: RegExp | string) {\n      return ApiProperty({\n        pattern: typeof pat === \"string\" ? pat : pat.source,\n        required: false,\n      });\n    },\n  })\n  .apply();\n\nDecoration.for(PersistenceKeys.COLUMN)\n  .extend({\n    decorator: function columnDec(name: string) {\n      return ApiProperty({\n        name: name,\n        required: false,\n      });\n    },\n  })\n  .apply();\n\nDecoration.for(DecorationKeys.DESCRIPTION)\n  .extend({\n    decorator: function descriptionDec(description: string) {\n      return ApiProperty({\n        description: description,\n        required: false,\n      });\n    },\n  })\n  .apply();\n\nDecoration.for(PersistenceKeys.AUTH).extend({ decorator: Auth }).apply();\n","import { ForbiddenError } from \"@decaf-ts/core\";\n\nexport class CorsError extends ForbiddenError {\n  constructor(msg: string | Error) {\n    super(msg, CorsError.name);\n  }\n}\n","import { BaseError } from \"@decaf-ts/db-decorators\";\n\nexport class ToManyRequestsError extends BaseError {\n  constructor(msg: string | Error ) {\n    super(ToManyRequestsError.name, msg , 429);\n  }\n}","import {\n  ArgumentsHost,\n  Catch,\n  ExceptionFilter,\n  NotAcceptableException,\n  NotFoundException,\n} from \"@nestjs/common\";\nimport { BaseError, InternalError } from \"@decaf-ts/db-decorators\";\nimport { LoggedEnvironment } from \"@decaf-ts/logging\";\nimport { UnsupportedError } from \"@decaf-ts/core\";\nimport { ToManyRequestsError } from \"../errors/throttling\";\n\n@Catch()\nexport class DecafExceptionFilter implements ExceptionFilter {\n  catch(exception: Error, host: ArgumentsHost) {\n    const ctx = host.switchToHttp();\n    const response = ctx.getResponse();\n    const request = ctx.getRequest();\n\n    const isProduction = LoggedEnvironment.env === \"production\";\n    let statusCode;\n\n    if (\n      exception instanceof NotFoundException ||\n      exception instanceof UnsupportedError\n    ) {\n      exception = new NotAcceptableException(exception.message);\n      statusCode = (exception as NotAcceptableException).getStatus();\n    } else if (!(exception instanceof BaseError)) {\n      if((exception as any).status === 429){\n        exception = new ToManyRequestsError(exception.message);\n      }else{\n        exception = new InternalError(exception.message);\n      }\n    }\n\n    response.status((exception as BaseError).code || statusCode).json({\n      status: (exception as BaseError).code || statusCode,\n      error: isProduction ? exception.name : exception.message,\n      timestamp: new Date().toISOString(),\n      path: request.url,\n      method: request.method,\n    });\n  }\n}\n","import { UseFilters, UseInterceptors } from \"@nestjs/common\";\nimport { DecafExceptionFilter } from \"./DecafErrorFilter\";\nimport { DecafResponseInterceptor } from \"../../request/index\";\n\nexport function UseDecafFilter() {\n  return UseFilters(new DecafExceptionFilter());\n}\n\nexport function UseDecafHeaders() {\n  return UseInterceptors(DecafResponseInterceptor);\n}\n","import { Constructor } from \"@decaf-ts/decoration\";\nimport { SecuritySchemeObject } from \"../../swagger-types\";\n\nexport interface SwaggerOptions {\n  title: string;\n  description: string;\n  version?: string;\n  assetsPath?: string;\n  faviconFilePath?: string;\n  topbarIconFilePath?: string;\n  persistAuthorization?: boolean;\n  path: string;\n  auth?: SecuritySchemeObject;\n  topbarBgColor?: string;\n  extraModels?: Constructor[];\n\n  /**\n   * Path to expose the OpenAPI specification in JSON format.\n   * Example: /api/openapi.json\n   */\n  openApiJsonPath?: string;\n\n  /**\n   * Path to expose the OpenAPI specification in YAML format.\n   * Requires 'yaml' package as peer dependency.\n   * Example: /api/openapi.yaml\n   */\n  openApiYamlPath?: string;\n}\n\nexport const SWAGGER_UI_CONSTANTS: SwaggerOptions = {\n  title: \"Swagger | OpenAPI Specification (OAS)\",\n  description: \"Standardized format for describing RESTful APIs\",\n  version: \"0.0.1\",\n  path: \"docs\",\n  faviconFilePath: \"\",\n  topbarIconFilePath: \"\",\n  auth: {\n    type: \"http\",\n    scheme: \"bearer\",\n    bearerFormat: \"JWT\",\n    name: \"Authorization\",\n    description: \"Enter JWT token\",\n    in: \"header\",\n  },\n  persistAuthorization: true,\n  topbarBgColor: \"#000000\",\n};\n","import { SWAGGER_UI_CONSTANTS } from \"./constants\";\nimport { readFileSync } from \"fs\";\nimport * as path from \"path\";\n\nexport interface SwaggerUIOptions {\n  title?: string;\n  path?: string;\n  persistAuthorization: boolean;\n  assetsPath?: string;\n  faviconPath?: string;\n  topbarIconPath?: string;\n  topbarBgColor?: string;\n}\n\nexport class SwaggerCustomUI {\n  readonly options: SwaggerUIOptions;\n  // private readonly assetsPath: string = path.join(\n  //   __dirname,\n  //   \"..\",\n  //   \"..\",\n  //   \"workdocs\",\n  //   \"assets\"\n  // );\n\n  constructor(options: SwaggerUIOptions) {\n    this.options = {\n      ...options,\n    };\n  }\n\n  private customCSS() {\n    let css = \"\";\n    if (this.options.topbarIconPath) {\n      const img = this.b64(this.options.topbarIconPath);\n      css += `.topbar-wrapper { content: url('data:image/png;base64,${img}'); width: 200px; height: auto; }\\n`;\n    }\n    return (\n      css +\n      `\n        .topbar-wrapper svg { visibility: hidden; }\n        .swagger-ui .topbar { background-color: ${this.options.topbarBgColor || SWAGGER_UI_CONSTANTS.topbarBgColor}; }\n      `\n    );\n  }\n\n  getCustomOptions() {\n    const favicon: Record<string, any> = {};\n    if (this.options.faviconPath) {\n      favicon[\"customfavIcon\"] = this.b64(this.options.faviconPath, true);\n    }\n\n    return {\n      customSiteTitle: this.options.title,\n      ...favicon,\n      customCss: this.customCSS(),\n      swaggerOptions: {\n        persistAuthorization: this.options.persistAuthorization,\n      },\n    };\n  }\n\n  b64(file: string, img: boolean = false) {\n    const filePath = path.join(this.options.assetsPath || \"\", file);\n    const b64 = readFileSync(filePath, { encoding: \"base64\" });\n    return img ? \"data:image/png;base64,\" + b64 : b64;\n  }\n}\n","import { INestApplication } from \"@nestjs/common\";\nimport { DocumentBuilder, SwaggerModule } from \"@nestjs/swagger\";\nimport { SwaggerCustomUI } from \"./SwaggerCustomUI\";\nimport { SWAGGER_UI_CONSTANTS, SwaggerOptions } from \"./constants\";\nimport YAML from \"yaml\";\n\nexport class SwaggerBuilder {\n  constructor(\n    private readonly app: INestApplication,\n    private readonly options: SwaggerOptions\n  ) {}\n\n  private createDocument() {\n    const description = this.options.path\n      ? this.options.description +\n        \"\" +\n        `<br><br><a href=\"${this.options.openApiJsonPath}\">OpenAPI JSON Spec</a> | ` +\n        `<a href=\"${this.options.openApiYamlPath}\">OpenAPI YAML Spec</a>`\n      : this.options.description;\n\n    const config = new DocumentBuilder()\n      .setTitle(this.options.title)\n      .setDescription(description)\n      .setVersion(this.options.version || \"0.0.1\")\n      .addBearerAuth(this.options.auth || SWAGGER_UI_CONSTANTS.auth)\n      .build();\n\n    return SwaggerModule.createDocument(this.app, config, {\n      extraModels: this.options.extraModels || [],\n    });\n  }\n\n  private registerOpenApiRoute(\n    path: string | undefined,\n    contentType: \"application/json\" | \"application/x-yaml\",\n    bodyFactory: () => void\n  ): void {\n    if (!path) return;\n\n    const httpAdapter = this.app.getHttpAdapter() as any;\n    path = path.startsWith(\"/\") ? path : `/${path}`;\n    httpAdapter.get(path, (_req: any, res: any) => {\n      httpAdapter.reply(res, bodyFactory(), 200, {\n        \"Content-Type\": contentType,\n      });\n    });\n  }\n\n  public setupSwagger() {\n    const document = this.createDocument();\n    const swaggerUI = new SwaggerCustomUI({\n      title: this.options.title,\n      path: this.options.path || SWAGGER_UI_CONSTANTS.path,\n      persistAuthorization: this.options.persistAuthorization ?? true,\n      assetsPath: this.options.assetsPath,\n      faviconPath: this.options.faviconFilePath,\n      topbarIconPath: this.options.topbarIconFilePath,\n      topbarBgColor: this.options.topbarBgColor,\n    });\n    SwaggerModule.setup(\n      this.options.path || SWAGGER_UI_CONSTANTS.path,\n      this.app,\n      document,\n      {\n        ...swaggerUI.getCustomOptions(),\n        jsonDocumentUrl: this.options.openApiJsonPath\n          ? `${this.options.openApiJsonPath}`\n          : undefined,\n        yamlDocumentUrl: this.options.openApiYamlPath\n          ? `${this.options.openApiYamlPath}`\n          : undefined,\n      }\n    );\n\n    this.registerOpenApiRoute(\n      this.options.openApiJsonPath,\n      \"application/json\",\n      () => document\n    );\n\n    this.registerOpenApiRoute(\n      this.options.openApiYamlPath,\n      \"application/x-yaml\",\n      () => YAML.stringify(document)\n    );\n  }\n\n  // private getVersion() {\n  //   // const packageJson = path.join(__dirname, \"..\", \"..\", \"package.json\");\n  //   // const {version} = require(packageJson);\n  //   return \"version\";\n  // }\n}\n","import {\n  INestApplication,\n  Logger,\n  NestInterceptor,\n  PipeTransform,\n} from \"@nestjs/common\";\nimport { DecafExceptionFilter } from \"./exceptions\";\nimport { SwaggerBuilder } from \"./openapi\";\nimport { CorsOptions } from \"@nestjs/common/interfaces/external/cors-options.interface\";\nimport { CorsError } from \"./errors\";\n\n/**\n * @description\n * Defines all customizable parameters for Swagger setup.\n *\n * @summary\n * This interface allows developers to customize how Swagger UI is configured\n * within the NestJS application. It includes parameters for titles, paths,\n * color schemes, and asset paths to tailor the API documentation experience.\n *\n * @param {string} title - Title displayed in Swagger UI.\n * @param {string} description - Description shown below the title.\n * @param {string} version - API version displayed in the documentation.\n * @param {string} [path] - Optional path where Swagger will be available.\n * @param {boolean} [persistAuthorization] - Whether authorization tokens persist across reloads.\n * @param {string} [assetsPath] - Path to custom assets for Swagger UI.\n * @param {string} [topbarBgColor] - Custom background color for the Swagger top bar.\n * @param {string} [topbarIconPath] - Path to a custom icon displayed in the top bar.\n * @param {string} [faviconPath] - Path to a custom favicon.\n */\nexport interface SwaggerSetupOptions {\n  title: string;\n  description: string;\n  version: string;\n  path?: string;\n  persistAuthorization?: boolean;\n  assetsPath?: string;\n  topbarBgColor?: string;\n  topbarIconPath?: string;\n  faviconPath?: string;\n  /**\n   * Path to expose the OpenAPI specification in JSON format.\n   * Example: /api/openapi.json\n   */\n  openApiJsonPath?: string;\n  /**\n   * Path to expose the OpenAPI specification in YAML format.\n   * Requires 'yaml' package as peer dependency.\n   * Example: /api/openapi.yaml\n   */\n  openApiYamlPath?: string;\n}\n\n/**\n * @description\n * A fluent, static bootstrap class for initializing and configuring a NestJS application.\n *\n * @summary\n * The `NestBootstraper` class provides a chainable API for configuring\n * a NestJS application instance. It includes built-in methods for enabling\n * CORS, Helmet security, Swagger documentation, global pipes, filters,\n * interceptors, and starting the server.\n *\n * This class promotes consistency and reduces repetitive setup code\n * across multiple NestJS projects.\n *\n * @example\n * ```ts\n * import { NestFactory } from \"@nestjs/core\";\n * import { AppModule } from \"./app.module\";\n * import { MyLogger } from \"./MyLogger\";\n * import { NestBootstraper } from \"@decaf-ts/for-nest\";\n *\n * async function bootstrap() {\n *   const app = await NestFactory.create(AppModule);\n *\n *   await NestBootstraper\n *     .initialize(app)\n *     .enableLogger(new MyLogger())\n *     .enableCors([\"http://localhost:4200\"])\n *     .useHelmet()\n *     .setupSwagger({\n *       title: \"OpenAPI by TradeMark™\",\n *       description: \"TradeMark™ API documentation\",\n *       version: \"1.0.0\",\n *       path: \"api\",\n *       persistAuthorization: true,\n *       topbarBgColor: \"#2C3E50\",\n *       topbarIconPath: \"/assets/logo.svg\",\n *       faviconPath: \"/assets/favicon.ico\"\n *     })\n *     .useGlobalFilters()\n *     .useGlobalPipes(...)\n *     .useGlobalInterceptors(...)\n *     .start(3000);\n * }\n *\n * bootstrap();\n * ```\n * @class\n */\nexport class NestBootstraper {\n  private static app: INestApplication;\n  private static _logger: Logger;\n\n  /**\n   * @description\n   * Returns the current logger instance, creating a default one if not set.\n   *\n   * @summary\n   * Ensures that a valid `Logger` instance is always available\n   * for logging bootstrap-related messages.\n   *\n   * @return {Logger} The active logger instance.\n   */\n  private static get logger(): Logger {\n    if (!this._logger) {\n      // fallback\n      this._logger = new Logger(\"NestBootstrap\");\n    }\n    return this._logger;\n  }\n\n  /**\n   * @description\n   * Initializes the bootstrapper with a given NestJS application.\n   *\n   * @summary\n   * Binds the provided NestJS app instance to the bootstrapper, enabling\n   * chained configuration methods.\n   *\n   * @param {INestApplication} app - The NestJS application instance to initialize.\n   * @return {NestBootstraper} Returns the class for chaining configuration methods.\n   */\n  static initialize(app: INestApplication) {\n    this.app = app;\n    return this;\n  }\n\n  /**\n   * @description\n   * Enables or replaces the global logger for the NestJS application.\n   *\n   * @summary\n   * If a custom logger is provided, it replaces the default logger. Otherwise,\n   * a new logger named `\"NestBootstrap\"` is used. This logger is also registered\n   * with the NestJS application.\n   *\n   * @param {Logger} [customLogger] - Optional custom logger instance.\n   * @return {NestBootstraper} Returns the class for chaining.\n   */\n  static enableLogger(customLogger?: Logger) {\n    this._logger = customLogger || new Logger(\"NestBootstrap\");\n    this.app.useLogger(this._logger);\n    return this;\n  }\n\n  /**\n   * @description\n   * Enables Cross-Origin Resource Sharing (CORS) for the application.\n   *\n   * @summary\n   * Allows defining either a wildcard origin (`\"*\"`) or a list of allowed origins.\n   * Automatically accepts local development requests and those without origin headers.\n   * Throws a `CorsError` for unauthorized origins.\n   *\n   * @param {'*' | string[]} [origins=[]] - List of allowed origins or `\"*\"` to allow all.\n   * @param {string[]} [allowMethods=['GET', 'POST', 'PUT', 'DELETE']] - Allowed HTTP methods.\n   * @return {NestBootstraper} Returns the class for chaining configuration.\n   *\n   */\n  static enableCors(\n    origins: \"*\" | string[] = [],\n    allowMethods: string[] = [\"GET\", \"POST\", \"PUT\", \"DELETE\"]\n  ) {\n    const allowedOrigins =\n      origins === \"*\" ? \"*\" : origins.map((o) => o.trim().toLowerCase());\n\n    const corsOptions: CorsOptions = {\n      origin: (origin, callback) => {\n        // Allow request without origin...\n        if (!origin) return callback(null, true);\n\n        if (\n          allowedOrigins === \"*\" ||\n          (Array.isArray(allowedOrigins) &&\n            allowedOrigins.includes(origin.toLowerCase()))\n        ) {\n          return callback(null, true);\n        }\n\n        callback(new CorsError(`Origin ${origin} not allowed`));\n      },\n      credentials: true,\n      methods: allowMethods.join(\",\"),\n    };\n\n    this.app.enableCors(corsOptions);\n    return this;\n  }\n\n  /**\n   * @description\n   * Applies the Helmet middleware for enhanced security.\n   *\n   * @summary\n   * Dynamically loads the `helmet` package if available and registers it\n   * as middleware to improve HTTP header security. If not installed, logs a warning\n   * and continues execution without throwing errors.\n   *\n   * @param {Record<string, any>} [options] - Optional configuration passed to Helmet.\n   * @return {NestBootstraper} Returns the class for chaining configuration.\n   */\n  static useHelmet(options?: Record<string, any>) {\n    try {\n      // eslint-disable-next-line @typescript-eslint/no-require-imports\n      const helmet = require(\"helmet\"); // Dynamic import to avoid hard dependency\n      this.app.use(helmet(options));\n      this.logger.log(\"Helmet middleware enabled successfully.\");\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e: any) {\n      this.logger.warn(\"Helmet not installed. Skipping middleware.\");\n    }\n\n    return this;\n  }\n\n  /**\n   * @description\n   * Configures and initializes Swagger UI for API documentation.\n   *\n   * @summary\n   * Uses the `SwaggerBuilder` utility to configure API documentation\n   * with detailed customization for title, version, paths, and colors.\n   * Swagger is automatically exposed at the configured path.\n   *\n   * @param {SwaggerSetupOptions} options - Swagger configuration options.\n   * @return {NestBootstraper} Returns the class for chaining configuration.\n   */\n  static setupSwagger(options: SwaggerSetupOptions) {\n    const swagger = new SwaggerBuilder(this.app, {\n      title: options.title,\n      description: options.description,\n      version: options.version,\n      path: options.path || \"api\",\n      persistAuthorization: options.persistAuthorization ?? true,\n      assetsPath: options.assetsPath,\n      faviconFilePath: options.faviconPath,\n      topbarIconFilePath: options.topbarIconPath,\n      topbarBgColor: options.topbarBgColor,\n      openApiJsonPath: options.openApiJsonPath,\n      openApiYamlPath: options.openApiYamlPath,\n    });\n    swagger.setupSwagger();\n    return this;\n  }\n\n  /**\n   * @description\n   * Registers one or more global validation pipes.\n   *\n   * @summary\n   * Enables request payload validation and transformation globally across\n   * the entire NestJS application. Multiple pipes can be chained together\n   * for modular input validation.\n   *\n   * @param {...PipeTransform[]} pipes - Pipe instances to register globally.\n   * @return {NestBootstraper} Returns the class for chaining.\n   */\n  static useGlobalPipes(...pipes: PipeTransform[]) {\n    if (pipes.length > 0) this.app.useGlobalPipes(...pipes);\n    return this;\n  }\n\n  /**\n   * @description\n   * Registers one or more global exception filters.\n   *\n   * @summary\n   * If no filters are provided, it automatically registers a default\n   * set of standard exception filters for common error types like\n   * `HttpException`, `ValidationException`, `ConflictException`, and others.\n   *\n   * @param {...ExceptionFilter[]} filters - Optional filters to apply globally.\n   */\n  static useGlobalFilters(...filters: any[]) {\n    this.app.useGlobalFilters(\n      ...(filters.length > 0 ? filters : [new DecafExceptionFilter()])\n    );\n    return this;\n  }\n\n  /**\n   * @description\n   * Registers global interceptors for request and response transformation.\n   *\n   * @summary\n   * Interceptors allow advanced request/response manipulation such as\n   * serialization, logging, or transformation. Multiple interceptors\n   * can be added for modular configuration.\n   *\n   * @param {...NestInterceptor[]} interceptors - Interceptor instances to register.\n   * @return {NestBootstraper} Returns the class for chaining configuration.\n   */\n  static useGlobalInterceptors(...interceptors: NestInterceptor[]) {\n    if (interceptors.length > 0)\n      this.app.useGlobalInterceptors(...interceptors);\n    return this;\n  }\n\n  /**\n   * @description\n   * Starts the NestJS application and binds it to the given port and host.\n   *\n   * @summary\n   * Listens on the specified port and optionally a host. Once started,\n   * logs the application URL for easy access. The startup process resolves\n   * once the application is successfully running.\n   *\n   * @param {number} [port=3000] - Port number to listen on.\n   * @param {string} [host] - Optional host or IP address to bind to.\n   * @param {boolean} [log=true] - Whether to log the application URL upon startup.\n   * @return {Promise<void>} Resolves once the application starts successfully.\n   */\n  static async start(\n    port: number = Number(process.env.PORT) || 3000,\n    host: string | undefined = undefined,\n    log: boolean = true\n  ) {\n    this.app.listen(port, host as any).then(async () => {\n      if (log) {\n        const url = await this.app.getUrl();\n        this.logger.log(`🚀 Application is running at: ${url}`);\n      }\n    });\n  }\n}\n","import { Inject } from \"@nestjs/common\";\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport {\n  injectableServiceKey,\n  ModelService,\n  Repository as CoreRepository,\n  Service as CoreService,\n} from \"@decaf-ts/core\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\n\nexport type DecafFactoryProvider = {\n  provide: string;\n  useFactory: () => unknown;\n};\n\nconst pendingProviders = new Map<string, DecafFactoryProvider>();\n\n/**\n * @description Drains the providers registered by {@link Service}/{@link Repository} usages.\n * @summary Consumed by {@link DecafCoreModule.forRoot} to wire the tokens that those parameter\n * decorators reference back into Nest's DI container, since a parameter decorator alone cannot\n * supply a provider.\n */\nexport function getRegisteredDecafProviders(): DecafFactoryProvider[] {\n  return Array.from(pendingProviders.values());\n}\n\nfunction registerProvider(token: string, useFactory: () => unknown): void {\n  if (pendingProviders.has(token)) return;\n  pendingProviders.set(token, { provide: token, useFactory });\n}\n\nfunction isModelConstructor(value: unknown): value is Constructor<any> {\n  return typeof value === \"function\" && value.prototype instanceof Model;\n}\n\nfunction modelServiceToken(model: Constructor<any>): string {\n  return `${model.name}Service`;\n}\n\nfunction modelRepositoryToken(\n  model: Constructor<any>,\n  flavour?: string\n): string {\n  return flavour ? `${model.name}Repository@${flavour}` : `${model.name}Repository`;\n}\n\n/**\n * @description Constructor parameter decorator that injects a decaf service.\n * @summary Translates decaf's service resolution APIs into a Nest `@Inject()` call:\n * - `@Service(SomeModel)` injects the `ModelService<SomeModel>` singleton for that model\n *   (via {@link ModelService.forModel}).\n * - `@Service(SomeServiceClass)` or `@Service(\"alias\")` injects the matching `@service()`-decorated\n *   decaf {@link CoreService} (via {@link CoreService.get}).\n * - `@Service()` infers the parameter's type from emitted constructor metadata and resolves it the\n *   same way, provided the parameter is typed as a concrete class (generics like `ModelService<X>`\n *   are erased at runtime, so the model-service form always requires an explicit argument).\n * @param key the model class, service class, or alias to resolve. Omit to infer from the parameter type.\n */\nexport function Service(key?: string | Constructor<any>): ParameterDecorator {\n  return (\n    target: object,\n    propertyKey: string | symbol | undefined,\n    parameterIndex: number\n  ): void => {\n    let resolved: string | Constructor<any> | undefined = key;\n    if (typeof resolved === \"undefined\") {\n      const paramTypes: any[] =\n        Reflect.getMetadata(\"design:paramtypes\", target) || [];\n      resolved = paramTypes[parameterIndex];\n    }\n    if (typeof resolved === \"undefined\") {\n      throw new Error(\n        `@Service() could not determine an injection type for parameter ${parameterIndex} of ${(target as Constructor<any>).name}. Provide an explicit argument, e.g. @Service(SomeService).`\n      );\n    }\n\n    const asModel = typeof resolved !== \"string\" && isModelConstructor(resolved);\n    const token = asModel\n      ? modelServiceToken(resolved as Constructor<any>)\n      : injectableServiceKey(resolved as string | Constructor<any>);\n\n    registerProvider(token, () => {\n      if (asModel) return ModelService.forModel(resolved as Constructor<any>);\n      return typeof resolved === \"string\"\n        ? CoreService.get(resolved)\n        : CoreService.get(resolved as Constructor<any>);\n    });\n\n    return Inject(token)(target, propertyKey, parameterIndex);\n  };\n}\n\n/**\n * @description Constructor parameter decorator that injects a decaf {@link CoreRepository} for `model`.\n * @summary Unlike {@link Service}, `model` is always treated as a Model class: the same class passed\n * to `@Service(model)` and `@Repository(model)` resolves to two different injected objects (a\n * `ModelService<M>` vs a `Repository<M>` respectively), via {@link CoreRepository.forModel}.\n * @param model the model class to resolve a repository for.\n * @param flavour optional adapter flavour/alias, forwarded to {@link CoreRepository.forModel}.\n */\nexport function Repository(\n  model: Constructor<any>,\n  flavour?: string\n): ParameterDecorator {\n  return (\n    target: object,\n    propertyKey: string | symbol | undefined,\n    parameterIndex: number\n  ): void => {\n    const token = modelRepositoryToken(model, flavour);\n    registerProvider(token, () => CoreRepository.forModel(model, flavour));\n    return Inject(token)(target, propertyKey, parameterIndex);\n  };\n}\n","import {\n  DynamicModule,\n  Global,\n  Inject,\n  Module,\n  OnApplicationShutdown,\n} from \"@nestjs/common\";\nimport { APP_INTERCEPTOR, ModuleRef } from \"@nestjs/core\";\nimport type { DecafModuleOptions } from \"./types\";\nimport {\n  DECAF_ADAPTER_ID,\n  DECAF_HANDLERS,\n  DECAF_MODULE_OPTIONS,\n} from \"./constants\";\nimport {\n  DecafRequestHandlerInterceptor,\n} from \"./interceptors\";\nimport { DecafHandlerExecutor, DecafRequestContext } from \"./request\";\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport { Adapter, PersistenceService, Service } from \"@decaf-ts/core\";\nimport { getRegisteredDecafProviders } from \"./decorators\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\nimport {\n  RequestToContextTransformer,\n  requestToContextTransformer,\n} from \"@decaf-ts/for-http/server\";\n\n@Global()\n@Module({})\nexport class DecafCoreModule<CONF, ADAPTER extends Adapter<CONF, any, any, any>>\n  implements OnApplicationShutdown\n{\n  private static _logger: Logger;\n\n  private static _persistence?: PersistenceService<Adapter<any, any, any, any>>;\n\n  protected static get persistence(): PersistenceService<Adapter<any, any, any, any>> {\n    if (!this._persistence)\n      throw new InternalError(\"Persistence service not initialized\");\n    return this._persistence;\n  }\n\n  protected static get log(): Logger {\n    if (!this._logger) this._logger = Logging.for(DecafCoreModule);\n    return this._logger;\n  }\n\n  constructor(\n    @Inject(DECAF_MODULE_OPTIONS)\n    private readonly options: DecafModuleOptions<CONF, ADAPTER>,\n    private readonly moduleRef: ModuleRef\n  ) {}\n\n  static forRoot(options: DecafModuleOptions): DynamicModule {\n    const log = this.log.for(this.forRoot);\n    const decafProviders = getRegisteredDecafProviders();\n    return {\n      module: DecafCoreModule,\n      providers: [\n        { provide: DECAF_MODULE_OPTIONS, useValue: options },\n        { provide: DECAF_ADAPTER_ID, useValue: this.persistence?.client },\n        {\n          provide: DECAF_HANDLERS,\n          useFactory: () =>\n            options.handlers?.map((H) => {\n              log.info(`Registered request handler: ${H.name}`);\n              return new H();\n            }) ?? [],\n        },\n        DecafRequestContext,\n        DecafHandlerExecutor,\n        {\n          provide: APP_INTERCEPTOR,\n          useClass: DecafRequestHandlerInterceptor,\n        },\n        ...decafProviders,\n      ],\n      exports: [\n        DECAF_MODULE_OPTIONS,\n        DECAF_ADAPTER_ID,\n        DECAF_HANDLERS,\n        DecafRequestContext,\n        DecafHandlerExecutor,\n        ...decafProviders.map((provider) => provider.provide),\n      ],\n    };\n  }\n\n  static async bootPersistence(\n    options: DecafModuleOptions\n  ): Promise<Adapter<any, any, any, any>[]> {\n    const log = this.log.for(this.bootPersistence);\n\n    if (!this._persistence) {\n      const trimmed = options.conf.map(([contr, cfg, ...args]) => {\n        const possible = args.pop();\n        if (!possible) return [contr, cfg];\n        return [contr, cfg, ...args];\n      });\n      this._persistence = new PersistenceService();\n      await this._persistence.boot(trimmed);\n      const clients = this._persistence.client;\n      for (let i = 0; i < clients.length; i++) {\n        const c = options.conf[i];\n        const possibleTransf = c.slice(2, c.length);\n        let transformer = possibleTransf.pop();\n        if (\n          !transformer ||\n          !(transformer as RequestToContextTransformer<any>).from\n        ) {\n          const contr = Adapter.transformerFor(clients[i].flavour);\n          if (!contr)\n            throw new InternalError(\n              `No transformer found for flavour ${clients[i].flavour}. you should either @requestToContextTransformer or provide a transformer in the config`\n            );\n          try {\n            transformer = (contr as RequestToContextTransformer<any>).from\n              ? contr\n              : new (contr as Constructor<RequestToContextTransformer<any>>)();\n          } catch (e: unknown) {\n            throw new InternalError(\n              `Failed to boot transformer for ${clients[i].flavour}: ${e}`\n            );\n          }\n        }\n        requestToContextTransformer(clients[i].flavour)(transformer);\n      }\n      log.info(\"persistence layer created successfully!\");\n\n      if (options.initialization) {\n        try {\n          await options.initialization();\n        } catch (e: unknown) {\n          throw new InternalError(`Failed to initialize application: ${e}`);\n        }\n      }\n    }\n\n    return this.persistence.client;\n  }\n\n  async onApplicationShutdown(): Promise<void> {\n    const log = DecafCoreModule.log.for(this.onApplicationShutdown);\n    const adapters: Adapter<any, any, any, any>[] =\n      this.moduleRef.get<any>(DECAF_ADAPTER_ID);\n    for (const adapter of adapters)\n      try {\n        if (adapter) {\n          log.info(`Shutting down ${adapter.toString()}`);\n          await adapter.shutdown();\n        }\n      } catch (e: unknown) {\n        log.error(`Failed to shutdown application`, e as Error);\n      }\n    try {\n      await Service.shutdown();\n    } catch (e: unknown) {\n      log.error(`Failed to shutdown services`, e as Error);\n    }\n  }\n}\n","export const LISTENING_ADAPTERS_FLAVOURS = Symbol(\n  \"LISTENING_ADAPTERS_FLAVOURS\"\n);\n","import { Model } from \"@decaf-ts/decorator-validation\";\n\nexport function normalizeEventResponse(args: any[]): unknown[] {\n  const [modelConstr, operation, id, payload] = args;\n\n  const modelName = modelConstr?.name ?? modelConstr;\n\n  const serializedPayload = Array.isArray(payload)\n    ? payload.map((e) => {\n        try {\n          if (typeof e.serialize === \"function\") return e.serialize();\n\n          console.warn(\n            `Payload item for ${modelName} does not have serialize method and is an ${typeof e}, attempting to stringify directly. Item: ${e}`\n          );\n          return typeof e === \"string\" ? e : JSON.stringify(e);\n        } catch (err: unknown) {\n          console.warn(`Failed to serialize payload for ${modelName}: ${err}`);\n          return undefined;\n        }\n      })\n    : payload && typeof payload.serialize === \"function\"\n      ? payload.serialize()\n      : typeof payload === \"string\"\n        ? payload\n        : JSON.stringify(payload);\n\n  console.debug(\n    `Normalized event response for model ${modelName}, operation ${operation}, id ${id}:`,\n    serializedPayload\n  );\n\n  return [modelName, operation, id, serializedPayload];\n}\n","import { DecafController } from \"../controllers\";\nimport { DecafRequestContext } from \"../request\";\nimport { Adapter, Observer } from \"@decaf-ts/core\";\nimport { Controller, Inject, MessageEvent, Query, Sse } from \"@nestjs/common\";\nimport { interval, merge, Observable } from \"rxjs\";\nimport { Logging } from \"@decaf-ts/logging\";\nimport { LISTENING_ADAPTERS_FLAVOURS } from \"./constant\";\nimport { DecafServerCtx } from \"../constants\";\nimport { normalizeEventResponse } from \"./utils\";\nimport { map, tap } from \"rxjs/operators\";\n\n@Controller()\nexport class EventsController extends DecafController<DecafServerCtx> {\n  private readonly adapters: Adapter<any, any, any, any>[];\n\n  constructor(\n    clientContext: DecafRequestContext,\n    @Inject(LISTENING_ADAPTERS_FLAVOURS) flavours: string[]\n  ) {\n    super(clientContext, EventsController.name);\n    this.adapters = flavours.map((flavour) => (Adapter as any).get(flavour)); // change to Adapter.cache(\"\")\n  }\n\n  @Sse()\n  listen(): Observable<MessageEvent> {\n    const logger = Logging.for(EventsController.name);\n\n    const events$ = new Observable<MessageEvent>((observer) => {\n      const observerId =\n        `B-${Math.random().toString(36).slice(2, 8)}`.toUpperCase();\n\n      logger.info(\n        `Creating SSE observer: ${observerId} for client ${this.clientContext.uuid}`\n      );\n      const cb = new (class implements Observer {\n        observerId = observerId;\n        refresh(...args: any[]): Promise<void> {\n          logger.debug(\n            `SSE observer ${this.observerId} received refresh event`\n          );\n          return Promise.resolve().then(() => {\n            const data = normalizeEventResponse(args);\n            observer.next({ type: \"message\", data });\n            logger.debug(\n              `SSE observer ${this.observerId} event pushed to client`\n            );\n          });\n        }\n      })();\n\n      logger.verbose(\n        `Registering observer ${observerId} across ${this.adapters.length} adapter(s)`\n      );\n      for (const adapter of this.adapters) {\n        const adapterName = adapter?.constructor?.name ?? \"UnknownAdapter\";\n        try {\n          logger.debug(\n            `Registering observer ${observerId} in adapter ${adapterName}`\n          );\n          adapter.observe(cb);\n        } catch (e: any) {\n          logger.debug(\n            `Failed to register observer ${observerId} in adapter ${adapterName}: ${e?.message || e}`\n          );\n          logger.error(e);\n        }\n      }\n\n      return () => {\n        logger.debug(`Cleaning up SSE observer ${observerId}`);\n\n        for (const adapter of this.adapters) {\n          const adapterName = adapter?.constructor?.name ?? \"UnknownAdapter\";\n          try {\n            logger.debug(\n              `Unregistering observer ${observerId} from adapter ${adapterName}`\n            );\n            adapter.unObserve(cb);\n          } catch (e: any) {\n            logger.debug(\n              `Failed during cleanup of observer ${observerId} in adapter ${adapterName}: ${e?.message || e}`\n            );\n            logger.error(e);\n          }\n        }\n      };\n    });\n\n    const HEARTBEAT_INTERVAL_MS = 15000;\n    const heartbeat$ = interval(HEARTBEAT_INTERVAL_MS).pipe(\n      tap(() => {\n        logger.debug(\"Sending heartbeat\");\n      }),\n      map(\n        (): MessageEvent => ({\n          type: \"heartbeat\",\n          data: {\n            ts: new Date().toISOString(),\n          },\n        })\n      )\n    );\n\n    return merge(events$, heartbeat$);\n  }\n\n  @Sse(\"/:model\")\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  listenForModel(@Query(\"model\") model: string): Observable<MessageEvent> {\n    const logger = Logging.for(EventsController.name);\n\n    return new Observable<MessageEvent>((observer) => {\n      const cb = new (class implements Observer {\n        refresh(...args: any[]): Promise<void> {\n          return Promise.resolve().then(() => {\n            observer.next({ data: args } as any);\n          });\n        }\n      })();\n\n      try {\n        for (const adapter of this.adapters) {\n          adapter.observe(cb);\n        }\n      } catch (e: any) {\n        observer.error(`Failed to observe event: ${e.message || e}`);\n      }\n\n      return () => {\n        try {\n          for (const adapter of this.adapters) {\n            adapter.unObserve(cb);\n          }\n        } catch (e: any) {\n          logger.error(e);\n        }\n      };\n    });\n  }\n}\n","import { DynamicModule, Module } from \"@nestjs/common\";\nimport { EventsController } from \"./EventsController\";\nimport { RouterModule } from \"@nestjs/core\";\nimport { LISTENING_ADAPTERS_FLAVOURS } from \"./constant\";\nimport { DecafRequestContext } from \"../request\";\n\n@Module({})\nexport class DecafStreamModule {\n  static forFlavours(\n    flavours: string[],\n    path: string = \"events\"\n  ): DynamicModule {\n    return {\n      module: DecafStreamModule,\n      controllers: [EventsController],\n      imports: [\n        RouterModule.register([\n          {\n            path: path.replace(/^\\//, \"\"),\n            module: DecafStreamModule,\n          },\n        ]),\n      ],\n      providers: [\n        DecafRequestContext,\n        {\n          provide: LISTENING_ADAPTERS_FLAVOURS,\n          useValue: flavours ?? [],\n        },\n      ],\n    };\n  }\n}\n","import { DynamicModule, ForwardReference, Module, Type } from \"@nestjs/common\";\nimport { DecafModuleOptions } from \"./types\";\nimport { DecafCoreModule } from \"./core-module\";\nimport { Adapter } from \"@decaf-ts/core\";\nimport { getModuleFor } from \"./decaf-model/index\";\nimport { DecafStreamModule } from \"./events-module\";\n\n/**\n * @publicApi\n */\n@Module({})\nexport class DecafModule {\n  static async forRootAsync(\n    options: DecafModuleOptions\n  ): Promise<DynamicModule> {\n    const { autoControllers, autoServices } = options;\n\n    const adapters: Adapter<any, any, any, any>[] =\n      await DecafCoreModule.bootPersistence(options);\n    const flavours = adapters.map((adapter) => adapter.flavour);\n\n    const imports:\n      | (\n          | DynamicModule\n          | Type<any>\n          | Promise<DynamicModule>\n          | ForwardReference<any>\n        )[]\n      | undefined = [DecafCoreModule.forRoot(options)];\n\n    if (autoControllers) {\n        flavours.forEach((flavour) => {\n          imports.push(\n            getModuleFor(flavour).forRoot(flavour, {\n              autoServices,\n              controllerExposure: options.controllerExposure,\n              controllerConfig: options.controllerConfig,\n              aggregations: options.aggregations,\n            })\n          );\n        });\n      }\n\n    if (options.observerOptions?.enableObserverEvents) {\n      imports.push(\n        DecafStreamModule.forFlavours(\n          options.observerOptions.observerFlavours || flavours\n        )\n      );\n    }\n\n    return {\n      module: DecafModule,\n      imports: imports,\n    };\n  }\n}\n\nexport async function runMigrations(): Promise<void> {}\n","import {Model} from \"@decaf-ts/decorator-validation\";\nimport {InternalError} from \"@decaf-ts/db-decorators\";\nimport {Repository} from \"@decaf-ts/core\";\n\nexport function repoForModel(model: string) {\n\tconst m = Model.get(model);\n\tif (!m)\n\t\tthrow new InternalError(`Failed to find repository for ${model}`)\n\tconst repo = Repository.forModel(m);\n\treturn repo;\n}","/**\n * @module for-nest\n * @description This module serves as the main entry point for the ts-workspace library. It aggregates and exports\n * functionality from various submodules and utilities within the project.\n *\n * The module includes:\n * 1. Utility functions and types from the \"./utils\" directory:\n *    - These likely contain helper functions, common types, and shared functionality used throughout the project.\n *    - May include operations for data manipulation, type checking, or other general-purpose utilities.\n *\n * 2. A namespace and related types from the \"./namespace\" directory:\n *    - This could contain domain-specific code or a collection of related functionality.\n *    - Might include interfaces, types, or classes that represent core concepts in the library.\n *\n * 3. A VERSION constant:\n *    - Represents the current version of the module.\n *    - Useful for version checking and compatibility purposes.\n *\n * This structure provides a clean and organized export of the module's functionality, allowing consumers\n * to easily import and use specific parts of the library as needed.\n */\n\nimport { Metadata } from \"@decaf-ts/decoration\";\nimport \"./decoration\";\n\nexport * from \"./decoration\"; // on top on purpose\nexport * from \"./decaf-model\";\nexport * from \"./auth\";\nexport * from \"./factory\";\nexport * from \"./interceptors\";\nexport * from \"./overrides\";\nexport * from \"./request\";\nexport * from \"./constants\";\nexport * from \"./controllers\";\nexport * from \"./module\";\nexport * from \"./core-module\";\nexport * from \"./types\";\nexport * from \"./decorators\";\nexport * from \"./utils\";\nexport * from \"./events-module\";\n// export * from \"./webhooks\";\n\n/**\n * Represents the current version of the ts-workspace module.\n * The actual version number is replaced during the build process.\n * @constant\n * @type {string}\n */\nexport const VERSION = \"##VERSION##\";\n\n/**\n * @description Represents the current commit hash of the module build.\n * @summary Stores the current git commit hash for the package. The build replaces\n * the placeholder with the actual commit hash at publish time.\n * @const COMMIT\n */\nexport const COMMIT = \"##COMMIT##\";\n\n/**\n * @description Represents the full version string of the module.\n * @summary Stores the semver version and commit hash for the package.\n * The build replaces the placeholder with the actual `<version>-<commit>` value at publish time.\n * @const FULL_VERSION\n */\nexport const FULL_VERSION = \"##FULL_VERSION##\";\n\nexport const PACKAGE_NAME = \"##PACKAGE##\";\n\nMetadata.allowReregistration(true);\nMetadata.registerLibrary(PACKAGE_NAME, VERSION);\nMetadata.allowReregistration(false);\n"],"names":["DECORATORS_PREFIX","DECORATORS","API_OPERATION","API_RESPONSE","API_PRODUCES","API_CONSUMES","API_TAGS","API_CALLBACKS","API_PARAMETERS","API_HEADERS","API_MODEL_PROPERTIES","API_MODEL_PROPERTIES_ARRAY","API_SECURITY","API_EXCLUDE_ENDPOINT","API_EXCLUDE_CONTROLLER","API_EXTRA_MODELS","API_EXTENSION","API_SCHEMA","API_DEFAULT_GETTER","API_LINK","isConstructor","val","METADATA_FACTORY_NAME","METHOD_METADATA","createMethodDecorator","metakey","metadata","overrideExisting","target","key","descriptor","prevValue","Reflect","getMetadata","value","defineMetadata","createClassDecorator","createPropertyDecorator","propertyKey","properties","includes","existingMetadata","newMetadata","pickBy","negate","isUndefined","metadataToSave","type","constructor","createMixedDecorator","metadatas","Array","isArray","previousMetadata","Object","assign","createParamDecorator","initial","paramOptions","parameters","propertyKeys","getOwnPropertyNames","prototype","methodDescriptor","getOwnPropertyDescriptor","isApiMethod","hasMetadata","getTypeIsArrayTuple","input","isArrayFlag","isInputArray","obj","getEnumValues","enumType","numericValues","values","filter","map","toString","keys","getEnumType","hasString","isString","length","required","isEnumArray","opts","enum","undefined","ApiProperty","options","createApiPropertyDecorator","enumValues","items","ApiOperationFromModel","ModelConstructor","verb","path","httpToCrud","GET","OperationKeys","READ","Get","POST","CREATE","Post","PUT","UPDATE","Put","PATCH","Patch","DELETE","Delete","crudOp","HttpMethodDecorator","resolveBlockTarget","coreIsOperationBlocked","kind","apply","ApiExcludeEndpoint","BulkApiOperationFromModel","BulkCrudOperationKeys","READ_ALL","CREATE_ALL","UPDATE_ALL","DELETE_ALL","normalized","replace","statementTargets","PreparedStatementKeys","LIST_BY","PAGE_BY","FIND","PAGE","FIND_ONE_BY","FIND_BY","COUNT_OF","MAX_OF","MIN_OF","AVG_OF","SUM_OF","DISTINCT_OF","GROUP_OF","startsWith","statementValue","ApiParamsFromModel","props","decorators","p","ApiParamDec","name","description","String","applyDecorators","DecafBody","data","ctx","request","switchToHttp","getRequest","body","controller","getClass","ModelConstr","class","InternalServerErrorException","item","OrderedParams","order","req","original","params","orderList","ordered","k","raw","valuesInOrder","keysInOrder","DecafParams","DecafQuery","_","query","parsed","limit","n","Number","isNaN","offset","bookmark","DECAF_MODULE_OPTIONS","DECAF_ADAPTER_ID","DECAF_TASK_SERVICE_ID","DECAF_ROUTE","DECAF_HANDLERS","Symbol","DECAF_EXPOSE","DECAF_CONTROLLER_CONFIG","DECAF_CONTEXT_KEY","expose","flavours","Metadata","set","controllerConfig","config","controllerConfigDecorator","AUTH_HANDLER","AUTH_META_KEY","IS_PUBLIC_KEY","REQUIRED_ROLES_KEY","SKIP_MODEL_ROLES_KEY","DecafRequestContext","RequestContext","super","headersOf","headers","this","uuid","UUID","instance","generate","put","record","overrides","get","e","accumulate","__decorate","Injectable","scope","Scope","REQUEST","__param","Inject","AuthInterceptor","reflector","requestContext","authHandler","intercept","next","log","Logging","for","isPublic","getAllAndOverride","getHandler","modelName","requiredRoles","skipModelRoles","effectiveModel","verbose","debug","authorize","applyTransformers","user","getOrUndefined","organization","currentLog","childLog","logger","handle","Adapter","flavoursToTransform","flavour","transformer","transformerFor","from","Optional","Reflector","Auth","model","resource","decs","ApiBearerAuth","UseInterceptors","push","SetMetadata","Public","RequireRoles","roles","ApiSecurity","HttpVerbToDecorator","decorator","Error","extractPathParams","routePath","split","slice","apiParamSpec","getApiDecorators","methodName","httpVerb","includeQueryParams","NestHttpRouteDec","apiPathParams","swaggerQueryParams","ApiQuery","OrderDirection","method","ApiParam","ApiOperation","summary","ApiOkResponse","ApiNoContentResponse","Query","applyApiDecorators","proto","forEach","d","index","resolvePersistenceMethod","persistence","args","ModelService","statement","createRouteHandler","async","pathParams","queryParams","JSON","stringify","direction","error","defineRouteMethod","ControllerClass","handler","defineProperty","writable","DecafAuthHandler","AuthHandler","parseRequest","userRole","authorization","extractFromAuth","AuthorizationError","DecafRoleAuthHandler","toContextFlags","adapter","alias","bind","requestTransformers","meta","Context","toResponse","res","pending","header","ModelBuilder","decorateClass","_classDecorators","__hasClassDecoratorSupport","originalBuild","build","result","call","decorated","DecafRequestHandlerInterceptor","DecafRequestHandlerInterceptor_1","executor","contextualize","flags","ip","extractIp","DefaultAdapterFlags","timestamp","Date","operation","url","context","getResponse","exec","DecafHandlerExecutor","parseIpHeader","candidate","segment","trim","Boolean","DecafAuthModule","DecafAuthModule_1","forRoot","providers","provide","APP_INTERCEPTOR","useClass","global","useExisting","module","exports","Module","DecafHandlerExecutor_1","handlers","DecafResponseInterceptor","response","pipe","tap","DecafController","HttpDecafController","clientContext","_name","DecafModelController","_persistence","Service","getService","Repository","forModel","toOverrides","override","dtoCache","Map","DtoFor","op","stack","Set","TransactionOperationKeys","cache","getDtoCache","cached","isUpdateOp","DynamicDTO","toPascalCase","pkProp","Model","pk","pkPropsMetadata","pkProps","pkDesignType","pkTypeIsNumeric","BigInt","pkIsGenerated","generated","generatedBySequence","isPropertyGeneratedAcrossInheritance","allProps","relations","scalarProps","prop","has","validation","getValidationAcrossInheritance","isRequired","ValidationKeys","REQUIRED","typeHint","getTypeAcrossInheritance","apiOptions","designType","enumerable","configurable","relation","relationMeta","InternalError","relationType","validationFor","LIST","isCircular","pkTypeName","getPkOpenApiType","addRelationPkRef","relationDto","add","addRelationUpdate","addRelation","DtoClass","extraModels","dtoRef","oneOfItems","$ref","oneOf","pkType","current","Function","getPrototypeOf","WeakMap","FromModelController","getPersistence","ModelClazz","e2","createQueryRoutesFromRepository","prefix","PersistenceKeys","QUERY","repo","queryMethods","routeMethods","QueryController","entries","join","createComplexQueryHandler","defineMethod","httpDecorator","httpMethod","getQueryDecorators","objValues","fields","f","create","moduleConfigOverrides","globalDefaults","tableName","toKebabCase","modelClazzName","factoryPersistence","decoratorConfig","moduleOverride","mergedConfig","FactoryController","ModelControllerFactory","factoryRoutes","__routes__","getPK","apiProperties","pkPath","getRouteParametersFromModel","authConfig","auth","applyClassAuth","public","DynamicModelController","DynamicModelController_1","info","Controller","ApiTags","ApiExtraModels","sortedRoutes","sort","a","b","aSegments","bSegments","aParamCount","s","bParamCount","aLiteralCount","bLiteralCount","route","registration","matchRoute","paramDecorators","composed","DBKeys","COMPOSED","composedKeys","uniqueKeys","separator","methodDecorators","normalizedPath","createRegistration","createCreateHandler","createCreateDecorators","Response","passthrough","createBulkCreateHandler","bulkCreateDecorators","createBulkReadHandler","bulkReadDecorators","createBulkUpdateHandler","bulkUpdateDecorators","createBulkDeleteHandler","bulkDeleteDecorators","createReadHandler","readDecorators","createUpdateHandler","updateDecorators","createDeleteHandler","deleteDecorators","fallbackSegments","isAllParams","every","fallbackApiProps","suffix","createStatementHandler","statementDecorators","Param","statementRoutes","statementKey","statementMethodName","createStatementShortcutHandler","statementShortcutDecorators","statementShortcutParams","queryMethod","complexQueryParams","pathSegments","knownPrefixes","routeMetadata","matchedEntry","find","actualMethodName","paramSegments","createCustomRouteHandler","firstSegment","segments","seg","i","resp","logCtx","created","createAll","readAll","ids","normalizedIds","read","updateAll","updated","deleteAll","routeParams","id","ValidationError","readResult","update","payload","parse","remove","del","delete","details","STATEMENT","parseInt","pathDirection","resolvedDirection","statementShortcut","listBy","page","paginateBy","ASC","ref","findOneBy","findBy","field","complexQuery","spreadArgs","extractQueryArgs","customRoute","last","queryObj","pop","hasDirection","hasLimit","hasOffset","extras","ApiBody","ApiCreatedResponse","schema","getSchemaPath","ApiBadRequestResponse","ApiUnprocessableEntityResponse","ApiNotFoundResponse","base","getModuleFor","DecafModelModule","DecafModelModule_1","createModelServices","models","useFactory","isExposed","exposure","trackedModels","controllerExposure","modelServices","autoServices","aggregations","allowGroupingQueries","controllers","Decoration","InjectablesKeys","INJECTABLE","extend","nestInjectable","category","cfg","DefaultInjectablesConfig","singleton","DEFAULT","durable","INJECT","nestInject","innerNestInject","MAX","maxDec","max","maximum","MIN","minDec","min","minimum","MAX_LENGTH","maxLengthDec","maxLength","MIN_LENGTH","minLengthDec","minLength","TYPE","typeDec","DATE","dateDec","format","ENUM","optionDec","PATTERN","patternDec","pat","pattern","source","COLUMN","columnDec","DecorationKeys","DESCRIPTION","descriptionDec","AUTH","CorsError","ForbiddenError","msg","ToManyRequestsError","BaseError","DecafExceptionFilter","exception","host","isProduction","LoggedEnvironment","env","statusCode","NotFoundException","UnsupportedError","NotAcceptableException","message","getStatus","status","code","json","toISOString","Catch","UseDecafFilter","UseFilters","UseDecafHeaders","SWAGGER_UI_CONSTANTS","title","version","faviconFilePath","topbarIconFilePath","scheme","bearerFormat","in","persistAuthorization","topbarBgColor","SwaggerCustomUI","customCSS","css","topbarIconPath","img","b64","getCustomOptions","favicon","faviconPath","customSiteTitle","customCss","swaggerOptions","file","filePath","assetsPath","readFileSync","encoding","SwaggerBuilder","app","createDocument","openApiJsonPath","openApiYamlPath","DocumentBuilder","setTitle","setDescription","setVersion","addBearerAuth","SwaggerModule","registerOpenApiRoute","contentType","bodyFactory","httpAdapter","getHttpAdapter","_req","reply","setupSwagger","document","swaggerUI","setup","jsonDocumentUrl","yamlDocumentUrl","YAML","NestBootstraper","_logger","Logger","initialize","enableLogger","customLogger","useLogger","enableCors","origins","allowMethods","allowedOrigins","o","toLowerCase","corsOptions","origin","callback","credentials","methods","useHelmet","helmet","require","use","warn","swagger","useGlobalPipes","pipes","useGlobalFilters","filters","useGlobalInterceptors","interceptors","start","port","process","PORT","listen","then","getUrl","pendingProviders","getRegisteredDecafProviders","registerProvider","token","isModelConstructor","modelServiceToken","modelRepositoryToken","parameterIndex","resolved","paramTypes","asModel","injectableServiceKey","CoreService","CoreRepository","DecafCoreModule","DecafCoreModule_1","moduleRef","decafProviders","useValue","client","H","provider","bootPersistence","trimmed","conf","contr","possible","PersistenceService","boot","clients","c","possibleTransf","requestToContextTransformer","initialization","onApplicationShutdown","adapters","shutdown","Global","ModuleRef","LISTENING_ADAPTERS_FLAVOURS","normalizeEventResponse","modelConstr","serializedPayload","serialize","console","err","EventsController","EventsController_1","events$","Observable","observer","observerId","Math","random","toUpperCase","cb","refresh","Promise","resolve","adapterName","observe","unObserve","HEARTBEAT_INTERVAL_MS","heartbeat$","interval","ts","merge","listenForModel","Sse","DecafStreamModule","DecafStreamModule_1","forFlavours","imports","RouterModule","register","DecafModule","DecafModule_1","forRootAsync","autoControllers","observerOptions","enableObserverEvents","observerFlavours","runMigrations","repoForModel","m","VERSION","COMMIT","FULL_VERSION","PACKAGE_NAME","allowReregistration","registerLibrary"],"mappings":"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"}