@decaf-ts/for-nest 0.0.4 → 0.0.5

package/dist/for-nest.esm.cjs

@@ -1,6 +1,6 @@
 import { Decoration, DecorationKeys, Metadata } from '@decaf-ts/decoration';
 import { InjectablesKeys } from '@decaf-ts/injectable-decorators';
-import { Injectable, Scope, Inject, Global, Module, Post, Body, Get, Param, Put, Delete, Controller } from '@nestjs/common';
+import { Injectable, Scope, Inject, Global, Module, Post, Body, Get, Param, Put, Delete, Controller, HttpStatus, Catch, HttpException, Logger } from '@nestjs/common';
 import { ValidationKeys, Model } from '@decaf-ts/decorator-validation';
 import { getTypeIsArrayTuple as getTypeIsArrayTuple$1 } from '@nestjs/swagger/dist/decorators/helpers';
 import { getEnumValues, getEnumType } from '@nestjs/swagger/dist/utils/enum.utils';
@@ -9,12 +9,14 @@ import { METHOD_METADATA } from '@nestjs/common/constants';
 import { isConstructor } from '@nestjs/common/utils/shared.utils';
 import { pickBy, negate, isUndefined, isArray } from 'lodash';
 import { METADATA_FACTORY_NAME } from '@nestjs/swagger/dist/plugin/plugin-constants';
-import { PersistenceKeys, Repository, Adapter } from '@decaf-ts/core';
+import { PersistenceKeys, Repository, Adapter, ForbiddenError } from '@decaf-ts/core';
 import { __decorate, __param, __metadata } from 'tslib';
 import { ModuleRef } from '@nestjs/core';
 import { Logging, toKebabCase, LoggedClass } from '@decaf-ts/logging';
-import { ApiOperation, ApiBody, ApiCreatedResponse, ApiBadRequestResponse, ApiUnprocessableEntityResponse, getSchemaPath, ApiParam, ApiOkResponse, ApiNotFoundResponse, ApiTags, ApiExtraModels } from '@nestjs/swagger';
+import { ApiOperation, ApiBody, ApiCreatedResponse, ApiBadRequestResponse, ApiUnprocessableEntityResponse, getSchemaPath, ApiParam, ApiOkResponse, ApiNotFoundResponse, ApiTags, ApiExtraModels, DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
 import { InternalError } from '@decaf-ts/db-decorators';
+import { readFileSync } from 'fs';
+import * as path from 'path';
 
 /* eslint-disable @typescript-eslint/no-unsafe-function-type */
 function createMethodDecorator(metakey, metadata, { overrideExisting } = { overrideExisting: true }) {
@@ -607,6 +609,547 @@ function repoForModel(model) {
     return repo;
 }
 
+class CorsError extends ForbiddenError {
+    constructor(msg) {
+        super(msg, CorsError.name);
+    }
+}
+
+class HttpResponseError {
+    constructor(request, responseError) {
+        const status = responseError?.status ?? HttpStatus.INTERNAL_SERVER_ERROR;
+        const message = responseError?.message ?? "Internal Server Error";
+        const error = (responseError?.error ?? HttpStatus[status] ?? "HTTP_EXCEPTION")
+            .toString()
+            .toUpperCase();
+        Object.assign(this, {
+            status,
+            message,
+            error,
+            timestamp: new Date().toISOString(),
+            path: request.url,
+            method: request.method,
+        });
+    }
+}
+
+class AuthorizationError extends Error {
+    constructor(message = "Unauthorized") {
+        super(message);
+        this.name = "AuthorizationError";
+        this.status = 401;
+        this.code = "UNAUTHORIZED";
+        Object.setPrototypeOf(this, AuthorizationError.prototype);
+    }
+}
+let AuthorizationExceptionFilter = class AuthorizationExceptionFilter {
+    catch(exception, host) {
+        const ctx = host.switchToHttp();
+        const request = ctx.getRequest();
+        const response = ctx.getResponse();
+        const httpResponseError = new HttpResponseError(request, {
+            error: "UNAUTHORIZED",
+            status: HttpStatus.UNAUTHORIZED,
+            message: exception.message,
+        });
+        response.status(HttpStatus.UNAUTHORIZED).json(httpResponseError);
+    }
+};
+AuthorizationExceptionFilter = __decorate([
+    Catch(AuthorizationError)
+], AuthorizationExceptionFilter);
+
+class ConflictError extends Error {
+    constructor(message = "Conflict") {
+        super(message);
+        this.name = "ConflictError";
+        this.status = 409;
+        this.code = "CONFLICT";
+        Object.setPrototypeOf(this, ConflictError.prototype);
+    }
+}
+let ConflictExceptionFilter = class ConflictExceptionFilter {
+    catch(exception, host) {
+        const ctx = host.switchToHttp();
+        const response = ctx.getResponse();
+        const request = ctx.getRequest();
+        const httpResponseError = new HttpResponseError(request, {
+            status: HttpStatus.CONFLICT,
+            message: exception.message,
+            error: "CONFLICT"
+        });
+        response.status(httpResponseError.status).json(httpResponseError);
+    }
+};
+ConflictExceptionFilter = __decorate([
+    Catch(ConflictError)
+], ConflictExceptionFilter);
+
+let GlobalExceptionFilter = class GlobalExceptionFilter {
+    catch(exception, host) {
+        const ctx = host.switchToHttp();
+        const request = ctx.getRequest();
+        const response = ctx.getResponse();
+        let status = HttpStatus.INTERNAL_SERVER_ERROR;
+        let message = "Internal Server Error";
+        let error;
+        if (exception instanceof HttpException) {
+            const res = exception.getResponse();
+            status = exception.getStatus();
+            message = (res?.message || exception.message) ?? message;
+            error = res?.error ?? exception.name;
+        }
+        else if (exception instanceof Error) {
+            message = exception.message;
+            error = exception.name;
+        }
+        const httpResponseError = new HttpResponseError(request, { status, message, error });
+        response.status(httpResponseError.status).json(httpResponseError);
+    }
+};
+GlobalExceptionFilter = __decorate([
+    Catch()
+], GlobalExceptionFilter);
+
+let HttpExceptionFilter = class HttpExceptionFilter {
+    catch(exception, host) {
+        const ctx = host.switchToHttp();
+        const response = ctx.getResponse();
+        const request = ctx.getRequest();
+        const status = exception.getStatus();
+        const httpResponseError = new HttpResponseError(request, {
+            status,
+            message: exception.message,
+            error: exception.name
+        });
+        response.status(httpResponseError.status).json(httpResponseError);
+    }
+};
+HttpExceptionFilter = __decorate([
+    Catch(HttpException)
+], HttpExceptionFilter);
+
+class NotFoundError extends Error {
+    constructor(message = "Resource not found") {
+        super(message);
+        this.name = "NotFoundError";
+        this.status = 404;
+        this.code = "NOT_FOUND";
+        Object.setPrototypeOf(this, NotFoundError.prototype);
+    }
+}
+let NotFoundExceptionFilter = class NotFoundExceptionFilter {
+    catch(exception, host) {
+        const ctx = host.switchToHttp();
+        const response = ctx.getResponse();
+        const request = ctx.getRequest();
+        const httpResponseError = new HttpResponseError(request, {
+            status: HttpStatus.NOT_FOUND,
+            message: exception.message,
+            error: "NOT_FOUND",
+        });
+        response.status(httpResponseError.status).json(httpResponseError);
+    }
+};
+NotFoundExceptionFilter = __decorate([
+    Catch(NotFoundError)
+], NotFoundExceptionFilter);
+
+class ValidationError extends Error {
+    constructor(message = "Validation failed") {
+        super(message);
+        this.name = "ValidationError";
+        this.status = 422;
+        this.code = "VALIDATION_ERROR";
+        Object.setPrototypeOf(this, ValidationError.prototype);
+    }
+}
+let ValidationExceptionFilter = class ValidationExceptionFilter {
+    catch(exception, host) {
+        const ctx = host.switchToHttp();
+        const response = ctx.getResponse();
+        const request = ctx.getRequest();
+        const httpResponseError = new HttpResponseError(request, {
+            status: HttpStatus.UNPROCESSABLE_ENTITY,
+            message: exception.message,
+            error: "VALIDATION_ERROR"
+        });
+        response.status(httpResponseError.status).json(httpResponseError);
+    }
+};
+ValidationExceptionFilter = __decorate([
+    Catch(ValidationError)
+], ValidationExceptionFilter);
+
+const SWAGGER_UI_CONSTANTS = {
+    path: "docs",
+    auth: {
+        type: "http",
+        scheme: "bearer",
+        bearerFormat: "JWT",
+        name: "Authorization",
+        description: "Enter JWT token",
+        in: "header",
+    },
+    topbarBgColor: "#000000",
+};
+
+class SwaggerCustomUI {
+    // private readonly assetsPath: string = path.join(
+    //   __dirname,
+    //   "..",
+    //   "..",
+    //   "workdocs",
+    //   "assets"
+    // );
+    constructor(options) {
+        this.options = {
+            ...options,
+        };
+    }
+    customCSS() {
+        let css = "";
+        if (this.options.topbarIconPath) {
+            const img = this.b64(this.options.topbarIconPath);
+            css += `.topbar-wrapper { content: url('data:image/png;base64,${img}'); width: 200px; height: auto; }\n`;
+        }
+        return (css +
+            `
+        .topbar-wrapper svg { visibility: hidden; }
+        .swagger-ui .topbar { background-color: ${this.options.topbarBgColor || SWAGGER_UI_CONSTANTS.topbarBgColor}; }
+      `);
+    }
+    getCustomOptions() {
+        const favicon = {};
+        if (this.options.faviconPath) {
+            favicon["customfavIcon"] = this.b64(this.options.faviconPath, true);
+        }
+        return {
+            customSiteTitle: this.options.title,
+            ...favicon,
+            customCss: this.customCSS(),
+            swaggerOptions: {
+                persistAuthorization: this.options.persistAuthorization,
+            },
+            jsonDocumentUrl: this.options.path
+                ? `${this.options.path}/spec.json`
+                : undefined,
+            yamlDocumentUrl: this.options.path
+                ? `${this.options.path}/spec.yaml`
+                : undefined,
+        };
+    }
+    b64(file, img = false) {
+        const filePath = path.join(this.options.assetsPath || "", file);
+        const b64 = readFileSync(filePath, { encoding: "base64" });
+        return img ? "data:image/png;base64," + b64 : b64;
+    }
+}
+
+class SwaggerBuilder {
+    constructor(app, options) {
+        this.app = app;
+        this.options = options;
+    }
+    createDocument() {
+        const description = this.options.path
+            ? this.options.description +
+                "" +
+                `<br><br><a href="${this.options.path}/spec.json">OpenAPI JSON Spec</a> | ` +
+                `<a href="${this.options.path}/spec.yaml">OpenAPI YAML Spec</a>`
+            : this.options.description;
+        const config = new DocumentBuilder()
+            .setTitle(this.options.title)
+            .setDescription(description)
+            .setVersion(this.options.version || "0.0.1")
+            .addBearerAuth(this.options.auth || SWAGGER_UI_CONSTANTS.auth)
+            .build();
+        return SwaggerModule.createDocument(this.app, config, {
+            extraModels: this.options.extraModels || [],
+        });
+    }
+    setupSwagger() {
+        const document = this.createDocument();
+        const swaggerUI = new SwaggerCustomUI({
+            title: this.options.title,
+            path: this.options.path || SWAGGER_UI_CONSTANTS.path,
+            persistAuthorization: this.options.persistAuthorization ?? true,
+            assetsPath: this.options.assetsPath,
+            faviconPath: this.options.faviconFilePath,
+            topbarIconPath: this.options.topbarIconFilePath,
+            topbarBgColor: this.options.topbarBgColor,
+        });
+        SwaggerModule.setup(this.options.path || SWAGGER_UI_CONSTANTS.path, this.app, document, {
+            ...swaggerUI.getCustomOptions(),
+        });
+    }
+}
+
+/**
+ * @description
+ * A fluent, static bootstrap class for initializing and configuring a NestJS application.
+ *
+ * @summary
+ * The `NestBootstraper` class provides a chainable API for configuring
+ * a NestJS application instance. It includes built-in methods for enabling
+ * CORS, Helmet security, Swagger documentation, global pipes, filters,
+ * interceptors, and starting the server.
+ *
+ * This class promotes consistency and reduces repetitive setup code
+ * across multiple NestJS projects.
+ *
+ * @example
+ * ```ts
+ * import { NestFactory } from "@nestjs/core";
+ * import { AppModule } from "./app.module";
+ * import { MyLogger } from "./MyLogger";
+ * import { NestBootstraper } from "@decaf-ts/for-nest";
+ *
+ * async function bootstrap() {
+ *   const app = await NestFactory.create(AppModule);
+ *
+ *   await NestBootstraper
+ *     .initialize(app)
+ *     .enableLogger(new MyLogger())
+ *     .enableCors(["http://localhost:4200"])
+ *     .useHelmet()
+ *     .setupSwagger({
+ *       title: "OpenAPI by TradeMark™",
+ *       description: "TradeMark™ API documentation",
+ *       version: "1.0.0",
+ *       path: "api",
+ *       persistAuthorization: true,
+ *       topbarBgColor: "#2C3E50",
+ *       topbarIconPath: "/assets/logo.svg",
+ *       faviconPath: "/assets/favicon.ico"
+ *     })
+ *     .useGlobalFilters()
+ *     .useGlobalPipes(...)
+ *     .useGlobalInterceptors(...)
+ *     .start(3000);
+ * }
+ *
+ * bootstrap();
+ * ```
+ * @class
+ */
+class NestBootstraper {
+    /**
+     * @description
+     * Returns the current logger instance, creating a default one if not set.
+     *
+     * @summary
+     * Ensures that a valid `Logger` instance is always available
+     * for logging bootstrap-related messages.
+     *
+     * @return {Logger} The active logger instance.
+     */
+    static get logger() {
+        if (!this._logger) {
+            // fallback
+            this._logger = new Logger("NestBootstrap");
+        }
+        return this._logger;
+    }
+    /**
+     * @description
+     * Initializes the bootstrapper with a given NestJS application.
+     *
+     * @summary
+     * Binds the provided NestJS app instance to the bootstrapper, enabling
+     * chained configuration methods.
+     *
+     * @param {INestApplication} app - The NestJS application instance to initialize.
+     * @return {typeof NestBootstraper} Returns the class for chaining configuration methods.
+     */
+    static initialize(app) {
+        this.app = app;
+        return this;
+    }
+    /**
+     * @description
+     * Enables or replaces the global logger for the NestJS application.
+     *
+     * @summary
+     * If a custom logger is provided, it replaces the default logger. Otherwise,
+     * a new logger named `"NestBootstrap"` is used. This logger is also registered
+     * with the NestJS application.
+     *
+     * @param {Logger} [customLogger] - Optional custom logger instance.
+     * @return {typeof NestBootstraper} Returns the class for chaining.
+     */
+    static enableLogger(customLogger) {
+        this._logger = customLogger || new Logger("NestBootstrap");
+        this.app.useLogger(this._logger);
+        return this;
+    }
+    /**
+     * @description
+     * Enables Cross-Origin Resource Sharing (CORS) for the application.
+     *
+     * @summary
+     * Allows defining either a wildcard origin (`"*"`) or a list of allowed origins.
+     * Automatically accepts local development requests and those without origin headers.
+     * Throws a `CorsError` for unauthorized origins.
+     *
+     * @param {'*' | string[]} [origins=[]] - List of allowed origins or `"*"` to allow all.
+     * @param {string[]} [allowMethods=['GET', 'POST', 'PUT', 'DELETE']] - Allowed HTTP methods.
+     * @return {typeof NestBootstraper} Returns the class for chaining configuration.
+     *
+     */
+    static enableCors(origins = [], allowMethods = ["GET", "POST", "PUT", "DELETE"]) {
+        const allowedOrigins = origins === "*" ? "*" : origins.map((o) => o.trim().toLowerCase());
+        const corsOptions = {
+            origin: (origin, callback) => {
+                // Allow request without origin...
+                if (!origin)
+                    return callback(null, true);
+                if (allowedOrigins === "*" ||
+                    (Array.isArray(allowedOrigins) &&
+                        allowedOrigins.includes(origin.toLowerCase()))) {
+                    return callback(null, true);
+                }
+                callback(new CorsError(`Origin ${origin} not allowed`));
+            },
+            credentials: true,
+            methods: allowMethods.join(","),
+        };
+        this.app.enableCors(corsOptions);
+        return this;
+    }
+    /**
+     * @description
+     * Applies the Helmet middleware for enhanced security.
+     *
+     * @summary
+     * Dynamically loads the `helmet` package if available and registers it
+     * as middleware to improve HTTP header security. If not installed, logs a warning
+     * and continues execution without throwing errors.
+     *
+     * @param {Record<string, any>} [options] - Optional configuration passed to Helmet.
+     * @return {typeof NestBootstraper} Returns the class for chaining configuration.
+     */
+    static useHelmet(options) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const helmet = require("helmet"); // Dynamic import to avoid hard dependency
+            this.app.use(helmet(options));
+            this.logger.log("Helmet middleware enabled successfully.");
+        }
+        catch (e) {
+            this.logger.warn("Helmet not installed. Skipping middleware.");
+        }
+        return this;
+    }
+    /**
+     * @description
+     * Configures and initializes Swagger UI for API documentation.
+     *
+     * @summary
+     * Uses the `SwaggerBuilder` utility to configure API documentation
+     * with detailed customization for title, version, paths, and colors.
+     * Swagger is automatically exposed at the configured path.
+     *
+     * @param {SwaggerSetupOptions} options - Swagger configuration options.
+     * @return {typeof NestBootstraper} Returns the class for chaining configuration.
+     */
+    static setupSwagger(options) {
+        const swagger = new SwaggerBuilder(this.app, {
+            title: options.title,
+            description: options.description,
+            version: options.version,
+            path: options.path || "api",
+            persistAuthorization: options.persistAuthorization ?? true,
+            assetsPath: options.assetsPath,
+            faviconFilePath: options.faviconPath,
+            topbarIconFilePath: options.topbarIconPath,
+            topbarBgColor: options.topbarBgColor,
+        });
+        swagger.setupSwagger();
+        return this;
+    }
+    /**
+     * @description
+     * Registers one or more global validation pipes.
+     *
+     * @summary
+     * Enables request payload validation and transformation globally across
+     * the entire NestJS application. Multiple pipes can be chained together
+     * for modular input validation.
+     *
+     * @param {...PipeTransform[]} pipes - Pipe instances to register globally.
+     * @return {typeof NestBootstraper} Returns the class for chaining.
+     */
+    static useGlobalPipes(...pipes) {
+        if (pipes.length > 0)
+            this.app.useGlobalPipes(...pipes);
+        return this;
+    }
+    /**
+     * @description
+     * Registers one or more global exception filters.
+     *
+     * @summary
+     * If no filters are provided, it automatically registers a default
+     * set of standard exception filters for common error types like
+     * `HttpException`, `ValidationException`, `ConflictException`, and others.
+     *
+     * @param {...ExceptionFilter[]} filters - Optional filters to apply globally.
+     * @return {typeof NestBootstraper} Returns the class for chaining configuration.
+     */
+    static useGlobalFilters(...filters) {
+        const defaultFilters = [
+            new HttpExceptionFilter(),
+            new ValidationExceptionFilter(),
+            new NotFoundExceptionFilter(),
+            new ConflictExceptionFilter(),
+            new AuthorizationExceptionFilter(),
+            new GlobalExceptionFilter(),
+        ];
+        this.app.useGlobalFilters(...(filters.length > 0 ? filters : defaultFilters));
+        return this;
+    }
+    /**
+     * @description
+     * Registers global interceptors for request and response transformation.
+     *
+     * @summary
+     * Interceptors allow advanced request/response manipulation such as
+     * serialization, logging, or transformation. Multiple interceptors
+     * can be added for modular configuration.
+     *
+     * @param {...NestInterceptor[]} interceptors - Interceptor instances to register.
+     * @return {typeof NestBootstraper} Returns the class for chaining configuration.
+     */
+    static useGlobalInterceptors(...interceptors) {
+        if (interceptors.length > 0)
+            this.app.useGlobalInterceptors(...interceptors);
+        return this;
+    }
+    /**
+     * @description
+     * Starts the NestJS application and binds it to the given port and host.
+     *
+     * @summary
+     * Listens on the specified port and optionally a host. Once started,
+     * logs the application URL for easy access. The startup process resolves
+     * once the application is successfully running.
+     *
+     * @param {number} [port=3000] - Port number to listen on.
+     * @param {string} [host] - Optional host or IP address to bind to.
+     * @param {boolean} [log=true] - Whether to log the application URL upon startup.
+     * @return {Promise<void>} Resolves once the application starts successfully.
+     */
+    static async start(port = Number(process.env.PORT) || 3000, host = undefined, log = true) {
+        this.app.listen(port, host).then(async () => {
+            if (log) {
+                const url = await this.app.getUrl();
+                this.logger.log(`🚀 Application is running at: ${url}`);
+            }
+        });
+    }
+}
+
 /**
  * @module for-nest
  * @description This module serves as the main entry point for the ts-workspace library. It aggregates and exports
@@ -634,9 +1177,9 @@ function repoForModel(model) {
  * @constant
  * @type {string}
  */
-const VERSION = "0.0.4";
+const VERSION = "0.0.5";
 const PACKAGE_NAME = "##PACKAGE_NAME##";
 Metadata.registerLibrary(PACKAGE_NAME, VERSION);
 
-export { ApiProperty, ApiPropertyOptional, ApiResponseProperty, DECAF_ADAPTER_ID, DECAF_MODULE_OPTIONS, DecafModule, PACKAGE_NAME, RepoFactory, VERSION, createApiPropertyDecorator, createClassDecorator, createMethodDecorator, createMixedDecorator, createParamDecorator, createPropertyDecorator, getTypeIsArrayTuple, repoForModel };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"for-nest.esm.cjs","sources":["../src/decorators/helpers.ts","../src/decorators/ApiProperty.ts","../src/decoration.ts","../src/constants.ts","../src/core-module.ts","../src/RepoFactory.ts","../src/model-module.ts","../src/module.ts","../src/utils.ts","../src/index.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unsafe-function-type */\n\nimport { METHOD_METADATA } from \"@nestjs/common/constants\";\nimport { isConstructor } from \"@nestjs/common/utils/shared.utils\";\nimport { isArray, isUndefined, negate, pickBy } from \"lodash\";\nimport { METADATA_FACTORY_NAME } from \"@nestjs/swagger/dist/plugin/plugin-constants\";\nimport { DECORATORS } from \"@nestjs/swagger/dist/constants\";\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 unknown as T\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?: any) => {\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 override\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          ...pickBy(metadata, negate(isUndefined)),\n        },\n        target,\n        propertyKey\n      );\n    }\n  };\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    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  input: Function | [Function] | undefined | string | Record<string, any>,\n  isArrayFlag: boolean\n): [Function | undefined, boolean] {\n  if (!input) {\n    return [input as undefined, isArrayFlag];\n  }\n  if (isArrayFlag) {\n    return [input as Function, isArrayFlag];\n  }\n  const isInputArray = isArray(input);\n  const type = isInputArray ? input[0] : input;\n  return [type as Function, isInputArray];\n}\n","import { Type } from \"@nestjs/common\";\nimport {\n  EnumAllowedTypes,\n  SchemaObjectMetadata,\n} from \"@nestjs/swagger/dist/interfaces/schema-object-metadata.interface\";\nimport { EnumSchemaAttributes } from \"@nestjs/swagger/dist/interfaces/enum-schema-attributes.interface\";\nimport { getTypeIsArrayTuple } from \"@nestjs/swagger/dist/decorators/helpers\";\nimport {\n  getEnumType,\n  getEnumValues,\n} from \"@nestjs/swagger/dist/utils/enum.utils\";\nimport { DECORATORS } from \"@nestjs/swagger/dist/constants\";\nimport { createPropertyDecorator } from \"./helpers\";\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 boolean\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 swagger override\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\nexport function ApiPropertyOptional(\n  options: ApiPropertyOptions = {}\n): PropertyDecorator {\n  return ApiProperty({\n    ...options,\n    required: false,\n  } as ApiPropertyOptions);\n}\n\nexport function ApiResponseProperty(\n  options: Pick<\n    ApiPropertyOptions,\n    \"type\" | \"example\" | \"format\" | \"deprecated\" | \"enum\"\n  > = {}\n): PropertyDecorator {\n  return ApiProperty({\n    readOnly: true,\n    ...options,\n  } as ApiPropertyOptions);\n}\n","import {\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 { ApiProperty } from \"./decorators/ApiProperty\";\nimport { PersistenceKeys } from \"@decaf-ts/core\";\n\nDecoration.for(InjectablesKeys.INJECTABLE)\n  .extend({\n    decorator: function nestInjectable(\n      category: string | Constructor,\n      cfg: InjectableConfig\n    ) {\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 });\n    },\n  })\n  .apply();\n\nDecoration.for(ValidationKeys.MIN)\n  .extend({\n    decorator: function minDec(min: number) {\n      return ApiProperty({ minimum: min });\n    },\n  })\n  .apply();\n\nDecoration.for(ValidationKeys.MAX_LENGTH)\n  .extend({\n    decorator: function maxLengthDec(max: number) {\n      return ApiProperty({ maxLength: max });\n    },\n  })\n  .apply();\n\nDecoration.for(ValidationKeys.MIN_LENGTH)\n  .extend({\n    decorator: function minLengthDec(min: number) {\n      return ApiProperty({ minLength: min });\n    },\n  })\n  .apply();\n//\n// Decoration.for(ValidationKeys.TYPE)\n//   .extend({\n//     decorator: function typeDec(type: (string | (() => string))[] | string | (() => string)) {\n//       return ApiProperty({ type: type as any });\n//     },\n//   })\n//   .apply();\n//\n// Decoration.for(ValidationKeys.DATE)\n//   .extend({\n//     decorator: function dateDec() {\n//       return ApiProperty({ type: Date });\n//     },\n//   })\n//   .apply();\n\nDecoration.for(ValidationKeys.LIST)\n  .extend({\n    decorator: function listDec(\n      clazz:\n        | Constructor<any>\n        | (() => Constructor<any>)\n        | (Constructor<any> | (() => Constructor<any>))[]\n    ) {\n      const c = Array.isArray(clazz) ? clazz[0] : clazz;\n      return ApiProperty({ type: [c] });\n    },\n  })\n  .apply();\n\n//\n// Decoration.for(ValidationKeys.OPTION)\n//   .extend({\n//     decorator: function optionDec(options: string[] | Record<string, any>) {\n//       const opts = Array.isArray(options) ? options : Object.values(options);\n//       return ApiProperty({ enum: opts });\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      });\n    },\n  })\n  .apply();\n\nDecoration.for(PersistenceKeys.COLUMN)\n  .extend({\n    decorator: function columnDec(name: string) {\n      return ApiProperty({\n        name: name,\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      });\n    },\n  })\n  .apply();\n","export const DECAF_MODULE_OPTIONS = \"DecafModuleOptions\";\nexport const DECAF_ADAPTER_ID = \"DecafAdapter\";\n","import {\n  DynamicModule,\n  Global,\n  Inject,\n  Module,\n  OnApplicationShutdown,\n  Scope,\n} from \"@nestjs/common\";\nimport { ModuleRef } from \"@nestjs/core\";\nimport type { DecafModuleOptions } from \"./types\";\nimport { DECAF_ADAPTER_ID, DECAF_MODULE_OPTIONS } from \"./constants\";\nimport { FactoryProvider } from \"@nestjs/common/interfaces/modules/provider.interface\";\nimport { Adapter } from \"@decaf-ts/core\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\n\n@Global()\n@Module({})\nexport class DecafCoreModule<\n  CONF,\n  ADAPTER extends Adapter<CONF, any, any, any, any>,\n> implements OnApplicationShutdown\n{\n  private static _logger: Logger;\n  private static _adapterInstance: Adapter<any, any, any, any, any> | null =\n    null;\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 async createAdapter(\n    options: DecafModuleOptions\n  ): Promise<Adapter<any, any, any, any, any>> {\n    if (!this._adapterInstance) {\n      const log = this.log.for(this.createAdapter);\n      log.info(\"Creating adapter instance...\");\n      this._adapterInstance = new options.adapter(options.conf, options.alias);\n      log.info(\"Adapter instance created successfully!\");\n    }\n    return this._adapterInstance;\n  }\n\n  static getAdapterInstance(): Adapter<any, any, any, any, any> | null {\n    return this._adapterInstance;\n  }\n\n  static forRoot(options: DecafModuleOptions): DynamicModule {\n    const typeOrmModuleOptions = {\n      provide: DECAF_MODULE_OPTIONS,\n      useValue: options,\n    };\n\n    const adapter: FactoryProvider<any> = {\n      useFactory: async (opts: DecafModuleOptions) => {\n        return DecafCoreModule.createAdapter(opts);\n      },\n      provide: DECAF_ADAPTER_ID,\n      durable: true,\n      scope: Scope.DEFAULT,\n      inject: [DECAF_MODULE_OPTIONS],\n    };\n\n    const providers = [adapter, typeOrmModuleOptions];\n    const exports = [adapter];\n\n    return {\n      module: DecafCoreModule,\n      providers,\n      exports,\n    };\n  }\n\n  async onApplicationShutdown(): Promise<void> {\n    const log = DecafCoreModule.log.for(this.onApplicationShutdown);\n    const adapter = this.moduleRef.get<ADAPTER>(DECAF_ADAPTER_ID);\n    try {\n      if (adapter) {\n        log.info(\"Shutting down\");\n        await adapter.shutdown();\n        DecafCoreModule._adapterInstance = null;\n      }\n    } catch (e: unknown) {\n      log.error(`Failed to shutdown application`, e as Error);\n    }\n  }\n}\n","import { Model } from \"@decaf-ts/decorator-validation\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport { Repo, Repository } from \"@decaf-ts/core\";\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport { Injectable } from \"@nestjs/common\";\n\n@Injectable()\nexport class RepoFactory {\n  for<M extends Model>(model: string | Constructor<M>): Repo<M> {\n    model = typeof model === \"string\" ? (Model.get(model) as any) : model;\n    if (!model) {\n      throw new InternalError(`Failed to find repository for ${model}`);\n    }\n    return Repository.forModel(model as Constructor<M>);\n  }\n}\n","import {\n  Body,\n  Controller,\n  Delete,\n  DynamicModule,\n  Get,\n  Module,\n  Param,\n  Post,\n  Put,\n} from \"@nestjs/common\";\nimport {\n  ApiBadRequestResponse,\n  ApiBody,\n  ApiCreatedResponse,\n  ApiExtraModels,\n  ApiNotFoundResponse,\n  ApiOkResponse,\n  ApiOperation,\n  ApiParam,\n  ApiTags,\n  ApiUnprocessableEntityResponse,\n  getSchemaPath,\n} from \"@nestjs/swagger\";\nimport { Adapter, Repo, Repository } from \"@decaf-ts/core\";\nimport { Model, ModelConstructor } from \"@decaf-ts/decorator-validation\";\nimport { LoggedClass, Logger, Logging, toKebabCase } from \"@decaf-ts/logging\";\nimport { RepoFactory } from \"./RepoFactory\";\n\n@Module({})\nexport class DecafModelModule {\n  private static _logger: Logger;\n\n  protected static get log(): Logger {\n    if (!this._logger) this._logger = Logging.for(DecafModelModule);\n    return this._logger;\n  }\n\n  private static toModelController<T extends Model<any>>(\n    ModelClazz: ModelConstructor<any>\n  ) {\n    const log = this.log.for(this.toModelController);\n    const tableName = Repository.table(ModelClazz);\n    const routePath = toKebabCase(tableName);\n    const modelClazzName = ModelClazz.name;\n\n    log.debug(`Creating controller for model: ${modelClazzName}`);\n\n    @Controller(routePath)\n    @ApiTags(modelClazzName)\n    @ApiExtraModels(ModelClazz)\n    class DynamicModelController extends LoggedClass {\n      // private readonly repo = this.repoFactory.for(ModelClazz);\n      private readonly pk!: string;\n      private readonly repo!: Repo<T>; //Repository<Model<any>, any, any, any, any>;\n\n      constructor(private readonly repoFactory: RepoFactory) {\n        super();\n        log.info(\n          `Registering dynamic controller for model: ${modelClazzName} route: /${routePath}`\n        );\n\n        try {\n          this.repo = this.repoFactory.for(ModelClazz.name);\n          this.pk = this.repo.pk as string;\n        } catch (e: any) {\n          this.log.error(\n            `Failed to initialize repository for model \"${ModelClazz.name}\".`,\n            e\n          );\n        }\n      }\n\n      @Post()\n      @ApiOperation({ summary: `Create a new ${modelClazzName}.` })\n      @ApiBody({\n        description: `Payload for ${modelClazzName}`,\n        schema: { $ref: getSchemaPath(ModelClazz) },\n      })\n      @ApiCreatedResponse({\n        description: `${modelClazzName} created successfully.`,\n      })\n      @ApiBadRequestResponse({ description: \"Payload validation failed.\" })\n      @ApiUnprocessableEntityResponse({\n        description: \"Repository rejected the provided payload.\",\n      })\n      async create(@Body() data: T): Promise<Model<any>> {\n        const log = this.log.for(this.create);\n        log.verbose(`creating new ${modelClazzName}`);\n        let created: Model;\n        try {\n          created = await this.repo.create(data);\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[this.pk]}`);\n        return created;\n      }\n\n      @Get(\":id\")\n      @ApiOperation({ summary: `Retrieve a ${modelClazzName} record by id.` })\n      @ApiParam({ name: \"id\", description: \"Primary key\" })\n      @ApiOkResponse({\n        description: `${modelClazzName} retrieved successfully.`,\n      })\n      @ApiNotFoundResponse({\n        description: `No ${modelClazzName} record matches the provided identifier.`,\n      })\n      async read(@Param(\"id\") id: string) {\n        const log = this.log.for(this.read);\n        let read: Model;\n        try {\n          log.debug(`reading ${modelClazzName} with ${this.pk} ${id}`);\n          read = await this.repo.read(id);\n        } catch (e: unknown) {\n          log.error(\n            `Failed to read ${modelClazzName} with id ${id}`,\n            e as Error\n          );\n          throw e;\n        }\n\n        log.info(`read ${modelClazzName} with id ${read[this.pk]}`);\n        return read;\n      }\n\n      @Put(\":id\")\n      @ApiOperation({\n        summary: `Replace an existing ${modelClazzName} record with a new payload.`,\n      })\n      @ApiBody({\n        description: `Payload for replace a existing record of ${modelClazzName}`,\n        schema: { $ref: getSchemaPath(ModelClazz) },\n      })\n      @ApiOkResponse({\n        description: `${ModelClazz} record replaced successfully.`,\n      })\n      @ApiNotFoundResponse({\n        description: `No ${modelClazzName} record matches the provided identifier.`,\n      })\n      @ApiBadRequestResponse({ description: \"Payload validation failed.\" })\n      async update(@Body() data: Model<any>) {\n        const log = this.log.for(this.update);\n        let updated: Model;\n        try {\n          log.info(\n            `updating ${modelClazzName} with ${this.pk} ${data[this.pk]}`\n          );\n          updated = await this.repo.create(data);\n        } catch (e: unknown) {\n          throw e;\n        }\n        return updated;\n      }\n\n      @Delete(\":id\")\n      @ApiOperation({ summary: `Delete a ${modelClazzName} record by id.` })\n      @ApiParam({\n        name: \"id\",\n        description: `Primary key value of the ${modelClazzName} record to delete.`,\n      })\n      @ApiOkResponse({\n        description: `${modelClazzName} record deleted successfully.`,\n      })\n      @ApiNotFoundResponse({\n        description: `No ${modelClazzName} record matches the provided identifier.`,\n      })\n      async delete(@Param(\"id\") id: string) {\n        const log = this.log.for(this.delete);\n        let read: Model;\n        try {\n          log.debug(\n            `deleting ${modelClazzName} with ${this.pk as string} ${id}`\n          );\n          read = await this.repo.read(id);\n        } catch (e: unknown) {\n          log.error(\n            `Failed to delete ${modelClazzName} with id ${id}`,\n            e as Error\n          );\n          throw e;\n        }\n        log.info(`deleted ${modelClazzName} with id ${read[this.pk]}`);\n        return read;\n      }\n    }\n\n    return DynamicModelController;\n  }\n\n  static forRoot(flavour: string): DynamicModule {\n    const log = this.log.for(this.forRoot);\n    log.info(`Generating controllers for flavour...`);\n\n    const trackedModels = Adapter.models(flavour);\n    const controllers = trackedModels.map(this.toModelController.bind(this));\n\n    log.info(`Generated ${controllers.length} controllers`);\n\n    return {\n      module: DecafModelModule,\n      controllers,\n      providers: [RepoFactory],\n    };\n  }\n}\n","import { DynamicModule, ForwardReference, Module, Type } from \"@nestjs/common\";\nimport { DecafModuleOptions } from \"./types\";\nimport { DecafCoreModule } from \"./core-module\";\nimport { DecafModelModule } from \"./model-module\";\n\n/**\n * @publicApi\n */\n@Module({})\nexport class DecafModule {\n  static async forRootAsync(\n    options: DecafModuleOptions\n  ): Promise<DynamicModule> {\n    const { autoControllers } = options;\n\n    const adapter = await DecafCoreModule.createAdapter(options);\n    const flavour = 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      imports.push(DecafModelModule.forRoot(flavour));\n    }\n\n    return {\n      module: DecafModule,\n      imports: imports,\n    };\n  }\n}\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 \"./decorators\";\nexport * from \"./constants\";\nexport * from \"./decoration\";\nexport * from \"./module\";\nexport * from \"./RepoFactory\";\nexport * from \"./types\";\nexport * from \"./utils\";\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##\";\nexport const PACKAGE_NAME = \"##PACKAGE_NAME##\";\n\nMetadata.registerLibrary(PACKAGE_NAME, VERSION);\n"],"names":["getTypeIsArrayTuple"],"mappings":"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"}
+export { ApiProperty, ApiPropertyOptional, ApiResponseProperty, AuthorizationError, AuthorizationExceptionFilter, ConflictError, ConflictExceptionFilter, CorsError, DECAF_ADAPTER_ID, DECAF_MODULE_OPTIONS, DecafModule, GlobalExceptionFilter, HttpExceptionFilter, NestBootstraper, NotFoundError, NotFoundExceptionFilter, PACKAGE_NAME, RepoFactory, SwaggerBuilder, VERSION, ValidationError, ValidationExceptionFilter, createApiPropertyDecorator, createClassDecorator, createMethodDecorator, createMixedDecorator, createParamDecorator, createPropertyDecorator, getTypeIsArrayTuple, repoForModel };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"for-nest.esm.cjs","sources":["../src/decorators/helpers.ts","../src/decorators/ApiProperty.ts","../src/decoration.ts","../src/constants.ts","../src/core-module.ts","../src/RepoFactory.ts","../src/model-module.ts","../src/module.ts","../src/utils.ts","../src/factory/errors/cors.ts","../src/factory/exceptions/HttpResponseError.ts","../src/factory/exceptions/AuthorizationExceptionFilter.ts","../src/factory/exceptions/ConflictExceptionFilter.ts","../src/factory/exceptions/GlobalExceptionFilter.ts","../src/factory/exceptions/HttpExceptionFilter.ts","../src/factory/exceptions/NotFoundExceptionFilter.ts","../src/factory/exceptions/ValidationExceptionFilter.ts","../src/factory/openapi/constants.ts","../src/factory/openapi/SwaggerCustomUI.ts","../src/factory/openapi/SwaggerBuilder.ts","../src/factory/NestBootstraper.ts","../src/index.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unsafe-function-type */\n\nimport { METHOD_METADATA } from \"@nestjs/common/constants\";\nimport { isConstructor } from \"@nestjs/common/utils/shared.utils\";\nimport { isArray, isUndefined, negate, pickBy } from \"lodash\";\nimport { METADATA_FACTORY_NAME } from \"@nestjs/swagger/dist/plugin/plugin-constants\";\nimport { DECORATORS } from \"@nestjs/swagger/dist/constants\";\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 unknown as T\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?: any) => {\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 override\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          ...pickBy(metadata, negate(isUndefined)),\n        },\n        target,\n        propertyKey\n      );\n    }\n  };\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    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  input: Function | [Function] | undefined | string | Record<string, any>,\n  isArrayFlag: boolean\n): [Function | undefined, boolean] {\n  if (!input) {\n    return [input as undefined, isArrayFlag];\n  }\n  if (isArrayFlag) {\n    return [input as Function, isArrayFlag];\n  }\n  const isInputArray = isArray(input);\n  const type = isInputArray ? input[0] : input;\n  return [type as Function, isInputArray];\n}\n","import { Type } from \"@nestjs/common\";\nimport {\n  EnumAllowedTypes,\n  SchemaObjectMetadata,\n} from \"@nestjs/swagger/dist/interfaces/schema-object-metadata.interface\";\nimport { EnumSchemaAttributes } from \"@nestjs/swagger/dist/interfaces/enum-schema-attributes.interface\";\nimport { getTypeIsArrayTuple } from \"@nestjs/swagger/dist/decorators/helpers\";\nimport {\n  getEnumType,\n  getEnumValues,\n} from \"@nestjs/swagger/dist/utils/enum.utils\";\nimport { DECORATORS } from \"@nestjs/swagger/dist/constants\";\nimport { createPropertyDecorator } from \"./helpers\";\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 boolean\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 swagger override\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\nexport function ApiPropertyOptional(\n  options: ApiPropertyOptions = {}\n): PropertyDecorator {\n  return ApiProperty({\n    ...options,\n    required: false,\n  } as ApiPropertyOptions);\n}\n\nexport function ApiResponseProperty(\n  options: Pick<\n    ApiPropertyOptions,\n    \"type\" | \"example\" | \"format\" | \"deprecated\" | \"enum\"\n  > = {}\n): PropertyDecorator {\n  return ApiProperty({\n    readOnly: true,\n    ...options,\n  } as ApiPropertyOptions);\n}\n","import {\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 { ApiProperty } from \"./decorators/ApiProperty\";\nimport { PersistenceKeys } from \"@decaf-ts/core\";\n\nDecoration.for(InjectablesKeys.INJECTABLE)\n  .extend({\n    decorator: function nestInjectable(\n      category: string | Constructor,\n      cfg: InjectableConfig\n    ) {\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 });\n    },\n  })\n  .apply();\n\nDecoration.for(ValidationKeys.MIN)\n  .extend({\n    decorator: function minDec(min: number) {\n      return ApiProperty({ minimum: min });\n    },\n  })\n  .apply();\n\nDecoration.for(ValidationKeys.MAX_LENGTH)\n  .extend({\n    decorator: function maxLengthDec(max: number) {\n      return ApiProperty({ maxLength: max });\n    },\n  })\n  .apply();\n\nDecoration.for(ValidationKeys.MIN_LENGTH)\n  .extend({\n    decorator: function minLengthDec(min: number) {\n      return ApiProperty({ minLength: min });\n    },\n  })\n  .apply();\n//\n// Decoration.for(ValidationKeys.TYPE)\n//   .extend({\n//     decorator: function typeDec(type: (string | (() => string))[] | string | (() => string)) {\n//       return ApiProperty({ type: type as any });\n//     },\n//   })\n//   .apply();\n//\n// Decoration.for(ValidationKeys.DATE)\n//   .extend({\n//     decorator: function dateDec() {\n//       return ApiProperty({ type: Date });\n//     },\n//   })\n//   .apply();\n\nDecoration.for(ValidationKeys.LIST)\n  .extend({\n    decorator: function listDec(\n      clazz:\n        | Constructor<any>\n        | (() => Constructor<any>)\n        | (Constructor<any> | (() => Constructor<any>))[]\n    ) {\n      const c = Array.isArray(clazz) ? clazz[0] : clazz;\n      return ApiProperty({ type: [c] });\n    },\n  })\n  .apply();\n\n//\n// Decoration.for(ValidationKeys.OPTION)\n//   .extend({\n//     decorator: function optionDec(options: string[] | Record<string, any>) {\n//       const opts = Array.isArray(options) ? options : Object.values(options);\n//       return ApiProperty({ enum: opts });\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      });\n    },\n  })\n  .apply();\n\nDecoration.for(PersistenceKeys.COLUMN)\n  .extend({\n    decorator: function columnDec(name: string) {\n      return ApiProperty({\n        name: name,\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      });\n    },\n  })\n  .apply();\n","export const DECAF_MODULE_OPTIONS = \"DecafModuleOptions\";\nexport const DECAF_ADAPTER_ID = \"DecafAdapter\";\n","import {\n  DynamicModule,\n  Global,\n  Inject,\n  Module,\n  OnApplicationShutdown,\n  Scope,\n} from \"@nestjs/common\";\nimport { ModuleRef } from \"@nestjs/core\";\nimport type { DecafModuleOptions } from \"./types\";\nimport { DECAF_ADAPTER_ID, DECAF_MODULE_OPTIONS } from \"./constants\";\nimport { FactoryProvider } from \"@nestjs/common/interfaces/modules/provider.interface\";\nimport { Adapter } from \"@decaf-ts/core\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\n\n@Global()\n@Module({})\nexport class DecafCoreModule<\n  CONF,\n  ADAPTER extends Adapter<CONF, any, any, any, any>,\n> implements OnApplicationShutdown\n{\n  private static _logger: Logger;\n  private static _adapterInstance: Adapter<any, any, any, any, any> | null =\n    null;\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 async createAdapter(\n    options: DecafModuleOptions\n  ): Promise<Adapter<any, any, any, any, any>> {\n    if (!this._adapterInstance) {\n      const log = this.log.for(this.createAdapter);\n      log.info(\"Creating adapter instance...\");\n      this._adapterInstance = new options.adapter(options.conf, options.alias);\n      log.info(\"Adapter instance created successfully!\");\n    }\n    return this._adapterInstance;\n  }\n\n  static getAdapterInstance(): Adapter<any, any, any, any, any> | null {\n    return this._adapterInstance;\n  }\n\n  static forRoot(options: DecafModuleOptions): DynamicModule {\n    const typeOrmModuleOptions = {\n      provide: DECAF_MODULE_OPTIONS,\n      useValue: options,\n    };\n\n    const adapter: FactoryProvider<any> = {\n      useFactory: async (opts: DecafModuleOptions) => {\n        return DecafCoreModule.createAdapter(opts);\n      },\n      provide: DECAF_ADAPTER_ID,\n      durable: true,\n      scope: Scope.DEFAULT,\n      inject: [DECAF_MODULE_OPTIONS],\n    };\n\n    const providers = [adapter, typeOrmModuleOptions];\n    const exports = [adapter];\n\n    return {\n      module: DecafCoreModule,\n      providers,\n      exports,\n    };\n  }\n\n  async onApplicationShutdown(): Promise<void> {\n    const log = DecafCoreModule.log.for(this.onApplicationShutdown);\n    const adapter = this.moduleRef.get<ADAPTER>(DECAF_ADAPTER_ID);\n    try {\n      if (adapter) {\n        log.info(\"Shutting down\");\n        await adapter.shutdown();\n        DecafCoreModule._adapterInstance = null;\n      }\n    } catch (e: unknown) {\n      log.error(`Failed to shutdown application`, e as Error);\n    }\n  }\n}\n","import { Model } from \"@decaf-ts/decorator-validation\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport { Repo, Repository } from \"@decaf-ts/core\";\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport { Injectable } from \"@nestjs/common\";\n\n@Injectable()\nexport class RepoFactory {\n  for<M extends Model>(model: string | Constructor<M>): Repo<M> {\n    model = typeof model === \"string\" ? (Model.get(model) as any) : model;\n    if (!model) {\n      throw new InternalError(`Failed to find repository for ${model}`);\n    }\n    return Repository.forModel(model as Constructor<M>);\n  }\n}\n","import {\n  Body,\n  Controller,\n  Delete,\n  DynamicModule,\n  Get,\n  Module,\n  Param,\n  Post,\n  Put,\n} from \"@nestjs/common\";\nimport {\n  ApiBadRequestResponse,\n  ApiBody,\n  ApiCreatedResponse,\n  ApiExtraModels,\n  ApiNotFoundResponse,\n  ApiOkResponse,\n  ApiOperation,\n  ApiParam,\n  ApiTags,\n  ApiUnprocessableEntityResponse,\n  getSchemaPath,\n} from \"@nestjs/swagger\";\nimport { Adapter, Repo, Repository } from \"@decaf-ts/core\";\nimport { Model, ModelConstructor } from \"@decaf-ts/decorator-validation\";\nimport { LoggedClass, Logger, Logging, toKebabCase } from \"@decaf-ts/logging\";\nimport { RepoFactory } from \"./RepoFactory\";\n\n@Module({})\nexport class DecafModelModule {\n  private static _logger: Logger;\n\n  protected static get log(): Logger {\n    if (!this._logger) this._logger = Logging.for(DecafModelModule);\n    return this._logger;\n  }\n\n  private static toModelController<T extends Model<any>>(\n    ModelClazz: ModelConstructor<any>\n  ) {\n    const log = this.log.for(this.toModelController);\n    const tableName = Repository.table(ModelClazz);\n    const routePath = toKebabCase(tableName);\n    const modelClazzName = ModelClazz.name;\n\n    log.debug(`Creating controller for model: ${modelClazzName}`);\n\n    @Controller(routePath)\n    @ApiTags(modelClazzName)\n    @ApiExtraModels(ModelClazz)\n    class DynamicModelController extends LoggedClass {\n      // private readonly repo = this.repoFactory.for(ModelClazz);\n      private readonly pk!: string;\n      private readonly repo!: Repo<T>; //Repository<Model<any>, any, any, any, any>;\n\n      constructor(private readonly repoFactory: RepoFactory) {\n        super();\n        log.info(\n          `Registering dynamic controller for model: ${modelClazzName} route: /${routePath}`\n        );\n\n        try {\n          this.repo = this.repoFactory.for(ModelClazz.name);\n          this.pk = this.repo.pk as string;\n        } catch (e: any) {\n          this.log.error(\n            `Failed to initialize repository for model \"${ModelClazz.name}\".`,\n            e\n          );\n        }\n      }\n\n      @Post()\n      @ApiOperation({ summary: `Create a new ${modelClazzName}.` })\n      @ApiBody({\n        description: `Payload for ${modelClazzName}`,\n        schema: { $ref: getSchemaPath(ModelClazz) },\n      })\n      @ApiCreatedResponse({\n        description: `${modelClazzName} created successfully.`,\n      })\n      @ApiBadRequestResponse({ description: \"Payload validation failed.\" })\n      @ApiUnprocessableEntityResponse({\n        description: \"Repository rejected the provided payload.\",\n      })\n      async create(@Body() data: T): Promise<Model<any>> {\n        const log = this.log.for(this.create);\n        log.verbose(`creating new ${modelClazzName}`);\n        let created: Model;\n        try {\n          created = await this.repo.create(data);\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[this.pk]}`);\n        return created;\n      }\n\n      @Get(\":id\")\n      @ApiOperation({ summary: `Retrieve a ${modelClazzName} record by id.` })\n      @ApiParam({ name: \"id\", description: \"Primary key\" })\n      @ApiOkResponse({\n        description: `${modelClazzName} retrieved successfully.`,\n      })\n      @ApiNotFoundResponse({\n        description: `No ${modelClazzName} record matches the provided identifier.`,\n      })\n      async read(@Param(\"id\") id: string) {\n        const log = this.log.for(this.read);\n        let read: Model;\n        try {\n          log.debug(`reading ${modelClazzName} with ${this.pk} ${id}`);\n          read = await this.repo.read(id);\n        } catch (e: unknown) {\n          log.error(\n            `Failed to read ${modelClazzName} with id ${id}`,\n            e as Error\n          );\n          throw e;\n        }\n\n        log.info(`read ${modelClazzName} with id ${read[this.pk]}`);\n        return read;\n      }\n\n      @Put(\":id\")\n      @ApiOperation({\n        summary: `Replace an existing ${modelClazzName} record with a new payload.`,\n      })\n      @ApiBody({\n        description: `Payload for replace a existing record of ${modelClazzName}`,\n        schema: { $ref: getSchemaPath(ModelClazz) },\n      })\n      @ApiOkResponse({\n        description: `${ModelClazz} record replaced successfully.`,\n      })\n      @ApiNotFoundResponse({\n        description: `No ${modelClazzName} record matches the provided identifier.`,\n      })\n      @ApiBadRequestResponse({ description: \"Payload validation failed.\" })\n      async update(@Body() data: Model<any>) {\n        const log = this.log.for(this.update);\n        let updated: Model;\n        try {\n          log.info(\n            `updating ${modelClazzName} with ${this.pk} ${data[this.pk]}`\n          );\n          updated = await this.repo.create(data);\n        } catch (e: unknown) {\n          throw e;\n        }\n        return updated;\n      }\n\n      @Delete(\":id\")\n      @ApiOperation({ summary: `Delete a ${modelClazzName} record by id.` })\n      @ApiParam({\n        name: \"id\",\n        description: `Primary key value of the ${modelClazzName} record to delete.`,\n      })\n      @ApiOkResponse({\n        description: `${modelClazzName} record deleted successfully.`,\n      })\n      @ApiNotFoundResponse({\n        description: `No ${modelClazzName} record matches the provided identifier.`,\n      })\n      async delete(@Param(\"id\") id: string) {\n        const log = this.log.for(this.delete);\n        let read: Model;\n        try {\n          log.debug(\n            `deleting ${modelClazzName} with ${this.pk as string} ${id}`\n          );\n          read = await this.repo.read(id);\n        } catch (e: unknown) {\n          log.error(\n            `Failed to delete ${modelClazzName} with id ${id}`,\n            e as Error\n          );\n          throw e;\n        }\n        log.info(`deleted ${modelClazzName} with id ${read[this.pk]}`);\n        return read;\n      }\n    }\n\n    return DynamicModelController;\n  }\n\n  static forRoot(flavour: string): DynamicModule {\n    const log = this.log.for(this.forRoot);\n    log.info(`Generating controllers for flavour...`);\n\n    const trackedModels = Adapter.models(flavour);\n    const controllers = trackedModels.map(this.toModelController.bind(this));\n\n    log.info(`Generated ${controllers.length} controllers`);\n\n    return {\n      module: DecafModelModule,\n      controllers,\n      providers: [RepoFactory],\n    };\n  }\n}\n","import { DynamicModule, ForwardReference, Module, Type } from \"@nestjs/common\";\nimport { DecafModuleOptions } from \"./types\";\nimport { DecafCoreModule } from \"./core-module\";\nimport { DecafModelModule } from \"./model-module\";\n\n/**\n * @publicApi\n */\n@Module({})\nexport class DecafModule {\n  static async forRootAsync(\n    options: DecafModuleOptions\n  ): Promise<DynamicModule> {\n    const { autoControllers } = options;\n\n    const adapter = await DecafCoreModule.createAdapter(options);\n    const flavour = 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      imports.push(DecafModelModule.forRoot(flavour));\n    }\n\n    return {\n      module: DecafModule,\n      imports: imports,\n    };\n  }\n}\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}","import {ConnectionError, ForbiddenError} from \"@decaf-ts/core\";\n\nexport class CorsError extends ForbiddenError {\n\tconstructor(msg: string | Error) {\n\t\tsuper(msg, CorsError.name);\n\t}\n}","import { Request } from \"express\";\nimport { HttpStatus } from \"@nestjs/common\";\n\nexport class HttpResponseError {\n\tstatus!: number;\n\terror!: string;\n\tmessage!: string;\n\ttimestamp!: string;\n\tpath!: string;\n\tmethod!: string;\n\n\tconstructor(\n\t\trequest: Request,\n\t\tresponseError?: { status?: number; message?: string; error?: string }\n\t) {\n\t\tconst status = responseError?.status ?? HttpStatus.INTERNAL_SERVER_ERROR;\n\t\tconst message = responseError?.message ?? \"Internal Server Error\";\n\t\tconst error = (responseError?.error ?? HttpStatus[status] ?? \"HTTP_EXCEPTION\")\n\t\t\t.toString()\n\t\t\t.toUpperCase();\n\n\t\tObject.assign(this, {\n\t\t\tstatus,\n\t\t\tmessage,\n\t\t\terror,\n\t\t\ttimestamp: new Date().toISOString(),\n\t\t\tpath: request.url,\n\t\t\tmethod: request.method,\n\t\t});\n\t}\n}\n","import {ArgumentsHost, Catch, ExceptionFilter, HttpStatus} from \"@nestjs/common\";\nimport {Request, Response} from \"express\";\nimport {HttpResponseError} from \"./HttpResponseError\";\n\nexport class AuthorizationError extends Error {\n    readonly status: number;\n    readonly code: string;\n\n    constructor(message = \"Unauthorized\") {\n        super(message);\n        this.name = \"AuthorizationError\";\n        this.status = 401;\n        this.code = \"UNAUTHORIZED\";\n        Object.setPrototypeOf(this, AuthorizationError.prototype);\n    }\n}\n\n@Catch(AuthorizationError)\nexport class AuthorizationExceptionFilter implements ExceptionFilter {\n    catch(exception: AuthorizationError, host: ArgumentsHost) {\n        const ctx = host.switchToHttp();\n        const request = ctx.getRequest<Request>();\n        const response = ctx.getResponse<Response>();\n\n        const httpResponseError = new HttpResponseError(request, {\n            error: \"UNAUTHORIZED\",\n            status: HttpStatus.UNAUTHORIZED,\n            message: exception.message,\n        });\n\n        response.status(HttpStatus.UNAUTHORIZED).json(httpResponseError);\n    }\n}\n","import {ArgumentsHost, Catch, ExceptionFilter, HttpStatus} from \"@nestjs/common\";\nimport {Request, Response} from \"express\";\nimport {HttpResponseError} from \"./HttpResponseError\";\n\nexport class ConflictError extends Error {\n    readonly status: number;\n    readonly code: string;\n\n    constructor(message = \"Conflict\") {\n        super(message);\n        this.name = \"ConflictError\";\n        this.status = 409;\n        this.code = \"CONFLICT\";\n\n        Object.setPrototypeOf(this, ConflictError.prototype);\n    }\n}\n\n@Catch(ConflictError)\nexport class ConflictExceptionFilter implements ExceptionFilter {\n    catch(exception: ConflictError, host: ArgumentsHost) {\n        const ctx = host.switchToHttp();\n        const response = ctx.getResponse<Response>();\n        const request = ctx.getRequest<Request>();\n\n        const httpResponseError = new HttpResponseError(request, {\n            status: HttpStatus.CONFLICT,\n            message: exception.message,\n            error: \"CONFLICT\"\n        });\n\n        response.status(httpResponseError.status).json(httpResponseError);\n    }\n}\n","import {ArgumentsHost, Catch, ExceptionFilter, HttpException, HttpStatus} from \"@nestjs/common\";\nimport {Request, Response} from \"express\";\nimport {HttpResponseError} from \"./HttpResponseError\";\n\n@Catch()\nexport class GlobalExceptionFilter implements ExceptionFilter {\n    catch(exception: unknown, host: ArgumentsHost) {\n        const ctx = host.switchToHttp();\n        const request = ctx.getRequest<Request>();\n        const response = ctx.getResponse<Response>();\n\n        let status = HttpStatus.INTERNAL_SERVER_ERROR;\n        let message = \"Internal Server Error\";\n        let error: string | undefined;\n\n        if (exception instanceof HttpException) {\n            const res: any = exception.getResponse();\n            status = exception.getStatus();\n            message = (res?.message || exception.message) ?? message;\n            error = res?.error ?? exception.name;\n        } else if (exception instanceof Error) {\n            message = exception.message;\n            error = exception.name;\n        }\n\n        const httpResponseError = new HttpResponseError(request, {status, message, error});\n        response.status(httpResponseError.status).json(httpResponseError);\n    }\n}\n","import {ArgumentsHost, Catch, ExceptionFilter, HttpException} from \"@nestjs/common\";\nimport {Request, Response} from \"express\";\nimport {HttpResponseError} from \"./HttpResponseError\";\n\n@Catch(HttpException)\nexport class HttpExceptionFilter implements ExceptionFilter {\n    catch(exception: HttpException, host: ArgumentsHost) {\n        const ctx = host.switchToHttp();\n        const response = ctx.getResponse<Response>();\n        const request = ctx.getRequest<Request>();\n        const status = exception.getStatus();\n\n        const httpResponseError = new HttpResponseError(request, {\n            status,\n            message: exception.message,\n            error: exception.name\n        });\n\n        response.status(httpResponseError.status).json(httpResponseError);\n    }\n}\n","import { ArgumentsHost, Catch, ExceptionFilter, HttpStatus } from \"@nestjs/common\";\nimport { Request, Response } from \"express\";\nimport { HttpResponseError } from \"./HttpResponseError\";\n\nexport class NotFoundError extends Error {\n\treadonly status: number;\n\treadonly code: string;\n\n\tconstructor(message = \"Resource not found\") {\n\t\tsuper(message);\n\t\tthis.name = \"NotFoundError\";\n\t\tthis.status = 404;\n\t\tthis.code = \"NOT_FOUND\";\n\n\t\tObject.setPrototypeOf(this, NotFoundError.prototype);\n\t}\n}\n\n@Catch(NotFoundError)\nexport class NotFoundExceptionFilter implements ExceptionFilter {\n\tcatch(exception: NotFoundError, host: ArgumentsHost) {\n\t\tconst ctx = host.switchToHttp();\n\t\tconst response = ctx.getResponse<Response>();\n\t\tconst request = ctx.getRequest<Request>();\n\n\t\tconst httpResponseError = new HttpResponseError(request, {\n\t\t\tstatus: HttpStatus.NOT_FOUND,\n\t\t\tmessage: exception.message,\n\t\t\terror: \"NOT_FOUND\",\n\t\t});\n\n\t\tresponse.status(httpResponseError.status).json(httpResponseError);\n\t}\n}\n","import {ArgumentsHost, Catch, ExceptionFilter, HttpStatus} from \"@nestjs/common\";\nimport {Request, Response} from \"express\";\nimport {HttpResponseError} from \"./HttpResponseError\";\n\nexport class ValidationError extends Error {\n    readonly status: number;\n    readonly code: string;\n\n    constructor(message = \"Validation failed\") {\n        super(message);\n        this.name = \"ValidationError\";\n        this.status = 422;\n        this.code = \"VALIDATION_ERROR\";\n\n        Object.setPrototypeOf(this, ValidationError.prototype);\n    }\n}\n\n@Catch(ValidationError)\nexport class ValidationExceptionFilter implements ExceptionFilter {\n    catch(exception: ValidationError, host: ArgumentsHost) {\n        const ctx = host.switchToHttp();\n        const response = ctx.getResponse<Response>();\n        const request = ctx.getRequest<Request>();\n\n        const httpResponseError = new HttpResponseError(request, {\n            status: HttpStatus.UNPROCESSABLE_ENTITY,\n            message: exception.message,\n            error: \"VALIDATION_ERROR\"\n        });\n\n        response.status(httpResponseError.status).json(httpResponseError);\n    }\n}\n","import { SecuritySchemeObject } from \"@nestjs/swagger/dist/interfaces/open-api-spec.interface\";\nimport { Constructor } from \"@decaf-ts/decoration\";\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\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      jsonDocumentUrl: this.options.path\n        ? `${this.options.path}/spec.json`\n        : undefined,\n      yamlDocumentUrl: this.options.path\n        ? `${this.options.path}/spec.yaml`\n        : undefined,\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\";\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.path}/spec.json\">OpenAPI JSON Spec</a> | ` +\n        `<a href=\"${this.options.path}/spec.yaml\">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  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      }\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  ExceptionFilter,\n  INestApplication,\n  Logger,\n  NestInterceptor,\n  PipeTransform,\n} from \"@nestjs/common\";\nimport {\n  AuthorizationExceptionFilter,\n  ConflictExceptionFilter,\n  GlobalExceptionFilter,\n  HttpExceptionFilter,\n  NotFoundExceptionFilter,\n  ValidationExceptionFilter,\n} 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\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 {typeof 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 {typeof 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 {typeof 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 {typeof 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    } 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 {typeof 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    });\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 {typeof 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   * @return {typeof NestBootstraper} Returns the class for chaining configuration.\n   */\n  static useGlobalFilters(...filters: any[]) {\n    const defaultFilters = [\n      new HttpExceptionFilter(),\n      new ValidationExceptionFilter(),\n      new NotFoundExceptionFilter(),\n      new ConflictExceptionFilter(),\n      new AuthorizationExceptionFilter(),\n      new GlobalExceptionFilter(),\n    ];\n\n    this.app.useGlobalFilters(\n      ...(filters.length > 0 ? filters : defaultFilters)\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 {typeof 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","/**\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 \"./decorators\";\nexport * from \"./constants\";\nexport * from \"./decoration\";\nexport * from \"./module\";\nexport * from \"./RepoFactory\";\nexport * from \"./types\";\nexport * from \"./utils\";\nexport * from \"./factory\";\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##\";\nexport const PACKAGE_NAME = \"##PACKAGE_NAME##\";\n\nMetadata.registerLibrary(PACKAGE_NAME, VERSION);\n"],"names":["getTypeIsArrayTuple"],"mappings":"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"}