@decaf-ts/for-nest 0.0.2 → 0.0.4

package/dist/for-nest.esm.cjs

@@ -1,19 +1,344 @@
-import { Metadata } from '@decaf-ts/decoration';
+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 { 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';
+import { DECORATORS } from '@nestjs/swagger/dist/constants';
+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 { __decorate, __param, __metadata } from 'tslib';
-import { Global, Module, Inject, Scope } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
-import { LoggedClass } from '@decaf-ts/logging/lib/LoggedClass';
+import { Logging, toKebabCase, LoggedClass } from '@decaf-ts/logging';
+import { ApiOperation, ApiBody, ApiCreatedResponse, ApiBadRequestResponse, ApiUnprocessableEntityResponse, getSchemaPath, ApiParam, ApiOkResponse, ApiNotFoundResponse, ApiTags, ApiExtraModels } from '@nestjs/swagger';
+import { InternalError } from '@decaf-ts/db-decorators';
+
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+function createMethodDecorator(metakey, metadata, { overrideExisting } = { overrideExisting: true }) {
+    return (target, key, descriptor) => {
+        if (typeof metadata === "object") {
+            const prevValue = Reflect.getMetadata(metakey, descriptor.value);
+            if (prevValue && !overrideExisting) {
+                return descriptor;
+            }
+            Reflect.defineMetadata(metakey, { ...prevValue, ...metadata }, descriptor.value);
+            return descriptor;
+        }
+        Reflect.defineMetadata(metakey, metadata, descriptor.value);
+        return descriptor;
+    };
+}
+function createClassDecorator(metakey, metadata = []) {
+    return (target) => {
+        const prevValue = Reflect.getMetadata(metakey, target) || [];
+        Reflect.defineMetadata(metakey, [...prevValue, ...metadata], target);
+        return target;
+    };
+}
+function createPropertyDecorator(metakey, metadata, overrideExisting = true) {
+    return (target, propertyKey) => {
+        const properties = Reflect.getMetadata(DECORATORS.API_MODEL_PROPERTIES_ARRAY, target) || [];
+        const key = `:${propertyKey}`;
+        if (!properties.includes(key)) {
+            Reflect.defineMetadata(DECORATORS.API_MODEL_PROPERTIES_ARRAY, [...properties, `:${propertyKey}`], target);
+        }
+        const existingMetadata = Reflect.getMetadata(metakey, target, propertyKey);
+        if (existingMetadata) {
+            const newMetadata = pickBy(metadata, negate(isUndefined));
+            const metadataToSave = overrideExisting
+                ? {
+                    ...existingMetadata,
+                    ...newMetadata,
+                }
+                : {
+                    ...newMetadata,
+                    ...existingMetadata,
+                };
+            Reflect.defineMetadata(metakey, metadataToSave, target, propertyKey);
+        }
+        else {
+            const type = 
+            // @ts-expect-error nest js override
+            target?.constructor?.[METADATA_FACTORY_NAME]?.()[propertyKey]?.type ??
+                Reflect.getMetadata("design:type", target, propertyKey);
+            Reflect.defineMetadata(metakey, {
+                type,
+                ...pickBy(metadata, negate(isUndefined)),
+            }, target, propertyKey);
+        }
+    };
+}
+function createMixedDecorator(metakey, metadata) {
+    return (target, key, descriptor) => {
+        if (descriptor) {
+            let metadatas;
+            if (Array.isArray(metadata)) {
+                const previousMetadata = Reflect.getMetadata(metakey, descriptor.value) || [];
+                metadatas = [...previousMetadata, ...metadata];
+            }
+            else {
+                const previousMetadata = Reflect.getMetadata(metakey, descriptor.value) || {};
+                metadatas = { ...previousMetadata, ...metadata };
+            }
+            Reflect.defineMetadata(metakey, metadatas, descriptor.value);
+            return descriptor;
+        }
+        let metadatas;
+        if (Array.isArray(metadata)) {
+            const previousMetadata = Reflect.getMetadata(metakey, target) || [];
+            metadatas = [...previousMetadata, ...metadata];
+        }
+        else {
+            const previousMetadata = Reflect.getMetadata(metakey, target) || {};
+            metadatas = Object.assign(Object.assign({}, previousMetadata), metadata);
+        }
+        Reflect.defineMetadata(metakey, metadatas, target);
+        return target;
+    };
+}
+function createParamDecorator(metadata, initial) {
+    return (target, key, descriptor) => {
+        const paramOptions = {
+            ...initial,
+            ...pickBy(metadata, negate(isUndefined)),
+        };
+        if (descriptor) {
+            const parameters = Reflect.getMetadata(DECORATORS.API_PARAMETERS, descriptor.value) || [];
+            Reflect.defineMetadata(DECORATORS.API_PARAMETERS, [...parameters, paramOptions], descriptor.value);
+            return descriptor;
+        }
+        if (typeof target === "object") {
+            return target;
+        }
+        const propertyKeys = Object.getOwnPropertyNames(target.prototype);
+        for (const propertyKey of propertyKeys) {
+            if (isConstructor(propertyKey)) {
+                continue;
+            }
+            const methodDescriptor = Object.getOwnPropertyDescriptor(target.prototype, propertyKey);
+            if (!methodDescriptor) {
+                continue;
+            }
+            const isApiMethod = Reflect.hasMetadata(METHOD_METADATA, methodDescriptor.value);
+            if (!isApiMethod) {
+                continue;
+            }
+            const parameters = Reflect.getMetadata(DECORATORS.API_PARAMETERS, methodDescriptor.value) || [];
+            Reflect.defineMetadata(DECORATORS.API_PARAMETERS, [...parameters, paramOptions], methodDescriptor.value);
+        }
+    };
+}
+function getTypeIsArrayTuple(input, isArrayFlag) {
+    if (!input) {
+        return [input, isArrayFlag];
+    }
+    if (isArrayFlag) {
+        return [input, isArrayFlag];
+    }
+    const isInputArray = isArray(input);
+    const type = isInputArray ? input[0] : input;
+    return [type, isInputArray];
+}
+
+const isEnumArray = (opts) => (opts.isArray && "enum" in opts && opts.enum !== undefined);
+/**
+ * @publicApi
+ */
+function ApiProperty(options = {}) {
+    return createApiPropertyDecorator(options);
+}
+function createApiPropertyDecorator(options = {}, overrideExisting = true) {
+    const [type, isArray] = getTypeIsArrayTuple$1(options.type, options.isArray);
+    options = {
+        ...options,
+        type,
+        isArray,
+    };
+    if (isEnumArray(options)) {
+        options.type = "array";
+        const enumValues = getEnumValues(options.enum);
+        options.items = {
+            type: getEnumType(enumValues),
+            enum: enumValues,
+        };
+        // @ts-expect-error nest swagger override
+        delete options.enum;
+    }
+    else if ("enum" in options && options.enum !== undefined) {
+        const enumValues = getEnumValues(options.enum);
+        options.enum = enumValues;
+        options.type = getEnumType(enumValues);
+    }
+    if (Array.isArray(options.type)) {
+        options.type = "array";
+        options.items = {
+            type: "array",
+            items: {
+                type: options.type[0],
+            },
+        };
+    }
+    return createPropertyDecorator(DECORATORS.API_MODEL_PROPERTIES, options, overrideExisting);
+}
+function ApiPropertyOptional(options = {}) {
+    return ApiProperty({
+        ...options,
+        required: false,
+    });
+}
+function ApiResponseProperty(options = {}) {
+    return ApiProperty({
+        readOnly: true,
+        ...options,
+    });
+}
+
+Decoration.for(InjectablesKeys.INJECTABLE)
+    .extend({
+    decorator: function nestInjectable(category, cfg) {
+        return Injectable({
+            scope: cfg.singleton ? Scope.DEFAULT : Scope.REQUEST,
+            durable: cfg.singleton ? undefined : true,
+        });
+    },
+})
+    .apply();
+Decoration.for(InjectablesKeys.INJECT)
+    .extend({
+    decorator: function nestInject(category, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    cfg) {
+        return function innerNestInject(target, propertyKey, descriptor) {
+            return Inject(category || target)(target, propertyKey, descriptor);
+        };
+    },
+})
+    .apply();
+Decoration.for(ValidationKeys.REQUIRED)
+    .extend(ApiProperty({
+    required: true,
+}))
+    .apply();
+Decoration.for(ValidationKeys.MAX)
+    .extend({
+    decorator: function maxDec(max) {
+        return ApiProperty({ maximum: max });
+    },
+})
+    .apply();
+Decoration.for(ValidationKeys.MIN)
+    .extend({
+    decorator: function minDec(min) {
+        return ApiProperty({ minimum: min });
+    },
+})
+    .apply();
+Decoration.for(ValidationKeys.MAX_LENGTH)
+    .extend({
+    decorator: function maxLengthDec(max) {
+        return ApiProperty({ maxLength: max });
+    },
+})
+    .apply();
+Decoration.for(ValidationKeys.MIN_LENGTH)
+    .extend({
+    decorator: function minLengthDec(min) {
+        return ApiProperty({ minLength: min });
+    },
+})
+    .apply();
+//
+// Decoration.for(ValidationKeys.TYPE)
+//   .extend({
+//     decorator: function typeDec(type: (string | (() => string))[] | string | (() => string)) {
+//       return ApiProperty({ type: type as any });
+//     },
+//   })
+//   .apply();
+//
+// Decoration.for(ValidationKeys.DATE)
+//   .extend({
+//     decorator: function dateDec() {
+//       return ApiProperty({ type: Date });
+//     },
+//   })
+//   .apply();
+Decoration.for(ValidationKeys.LIST)
+    .extend({
+    decorator: function listDec(clazz) {
+        const c = Array.isArray(clazz) ? clazz[0] : clazz;
+        return ApiProperty({ type: [c] });
+    },
+})
+    .apply();
+//
+// Decoration.for(ValidationKeys.OPTION)
+//   .extend({
+//     decorator: function optionDec(options: string[] | Record<string, any>) {
+//       const opts = Array.isArray(options) ? options : Object.values(options);
+//       return ApiProperty({ enum: opts });
+//     },
+//   })
+//   .apply();
+Decoration.for(ValidationKeys.PATTERN)
+    .extend({
+    decorator: function patternDec(pat) {
+        return ApiProperty({
+            pattern: typeof pat === "string" ? pat : pat.source,
+        });
+    },
+})
+    .apply();
+Decoration.for(PersistenceKeys.COLUMN)
+    .extend({
+    decorator: function columnDec(name) {
+        return ApiProperty({
+            name: name,
+        });
+    },
+})
+    .apply();
+Decoration.for(DecorationKeys.DESCRIPTION)
+    .extend({
+    decorator: function descriptionDec(description) {
+        return ApiProperty({
+            description: description,
+        });
+    },
+})
+    .apply();
 
 const DECAF_MODULE_OPTIONS = "DecafModuleOptions";
 const DECAF_ADAPTER_ID = "DecafAdapter";
 
 var DecafCoreModule_1;
-let DecafCoreModule = DecafCoreModule_1 = class DecafCoreModule extends LoggedClass {
+let DecafCoreModule = class DecafCoreModule {
+    static { DecafCoreModule_1 = this; }
+    static { this._adapterInstance = null; }
+    static get log() {
+        if (!this._logger)
+            this._logger = Logging.for(DecafCoreModule_1);
+        return this._logger;
+    }
     constructor(options, moduleRef) {
-        super();
         this.options = options;
         this.moduleRef = moduleRef;
     }
+    static async createAdapter(options) {
+        if (!this._adapterInstance) {
+            const log = this.log.for(this.createAdapter);
+            log.info("Creating adapter instance...");
+            this._adapterInstance = new options.adapter(options.conf, options.alias);
+            log.info("Adapter instance created successfully!");
+        }
+        return this._adapterInstance;
+    }
+    static getAdapterInstance() {
+        return this._adapterInstance;
+    }
     static forRoot(options) {
         const typeOrmModuleOptions = {
             provide: DECAF_MODULE_OPTIONS,
@@ -21,7 +346,7 @@ let DecafCoreModule = DecafCoreModule_1 = class DecafCoreModule extends LoggedCl
         };
         const adapter = {
             useFactory: async (opts) => {
-                return new opts.adapter(opts.conf, opts.alias);
+                return DecafCoreModule_1.createAdapter(opts);
             },
             provide: DECAF_ADAPTER_ID,
             durable: true,
@@ -37,15 +362,17 @@ let DecafCoreModule = DecafCoreModule_1 = class DecafCoreModule extends LoggedCl
         };
     }
     async onApplicationShutdown() {
+        const log = DecafCoreModule_1.log.for(this.onApplicationShutdown);
         const adapter = this.moduleRef.get(DECAF_ADAPTER_ID);
         try {
             if (adapter) {
-                this.log.info("Shutting down");
+                log.info("Shutting down");
                 await adapter.shutdown();
+                DecafCoreModule_1._adapterInstance = null;
             }
         }
         catch (e) {
-            this.log.error(`Failed to shutdown application`, e);
+            log.error(`Failed to shutdown application`, e);
         }
     }
 };
@@ -56,15 +383,215 @@ DecafCoreModule = DecafCoreModule_1 = __decorate([
     __metadata("design:paramtypes", [Object, ModuleRef])
 ], DecafCoreModule);
 
+let RepoFactory = class RepoFactory {
+    for(model) {
+        model = typeof model === "string" ? Model.get(model) : model;
+        if (!model) {
+            throw new InternalError(`Failed to find repository for ${model}`);
+        }
+        return Repository.forModel(model);
+    }
+};
+RepoFactory = __decorate([
+    Injectable()
+], RepoFactory);
+
+var DecafModelModule_1;
+let DecafModelModule = class DecafModelModule {
+    static { DecafModelModule_1 = this; }
+    static get log() {
+        if (!this._logger)
+            this._logger = Logging.for(DecafModelModule_1);
+        return this._logger;
+    }
+    static toModelController(ModelClazz) {
+        const log = this.log.for(this.toModelController);
+        const tableName = Repository.table(ModelClazz);
+        const routePath = toKebabCase(tableName);
+        const modelClazzName = ModelClazz.name;
+        log.debug(`Creating controller for model: ${modelClazzName}`);
+        let DynamicModelController = class DynamicModelController extends LoggedClass {
+            constructor(repoFactory) {
+                super();
+                this.repoFactory = repoFactory;
+                log.info(`Registering dynamic controller for model: ${modelClazzName} route: /${routePath}`);
+                try {
+                    this.repo = this.repoFactory.for(ModelClazz.name);
+                    this.pk = this.repo.pk;
+                }
+                catch (e) {
+                    this.log.error(`Failed to initialize repository for model "${ModelClazz.name}".`, e);
+                }
+            }
+            async create(data) {
+                const log = this.log.for(this.create);
+                log.verbose(`creating new ${modelClazzName}`);
+                let created;
+                try {
+                    created = await this.repo.create(data);
+                }
+                catch (e) {
+                    log.error(`Failed to create new ${modelClazzName}`, e);
+                    throw e;
+                }
+                log.info(`created new ${modelClazzName} with id ${created[this.pk]}`);
+                return created;
+            }
+            async read(id) {
+                const log = this.log.for(this.read);
+                let read;
+                try {
+                    log.debug(`reading ${modelClazzName} with ${this.pk} ${id}`);
+                    read = await this.repo.read(id);
+                }
+                catch (e) {
+                    log.error(`Failed to read ${modelClazzName} with id ${id}`, e);
+                    throw e;
+                }
+                log.info(`read ${modelClazzName} with id ${read[this.pk]}`);
+                return read;
+            }
+            async update(data) {
+                const log = this.log.for(this.update);
+                let updated;
+                try {
+                    log.info(`updating ${modelClazzName} with ${this.pk} ${data[this.pk]}`);
+                    updated = await this.repo.create(data);
+                }
+                catch (e) {
+                    throw e;
+                }
+                return updated;
+            }
+            async delete(id) {
+                const log = this.log.for(this.delete);
+                let read;
+                try {
+                    log.debug(`deleting ${modelClazzName} with ${this.pk} ${id}`);
+                    read = await this.repo.read(id);
+                }
+                catch (e) {
+                    log.error(`Failed to delete ${modelClazzName} with id ${id}`, e);
+                    throw e;
+                }
+                log.info(`deleted ${modelClazzName} with id ${read[this.pk]}`);
+                return read;
+            }
+        };
+        __decorate([
+            Post(),
+            ApiOperation({ summary: `Create a new ${modelClazzName}.` }),
+            ApiBody({
+                description: `Payload for ${modelClazzName}`,
+                schema: { $ref: getSchemaPath(ModelClazz) },
+            }),
+            ApiCreatedResponse({
+                description: `${modelClazzName} created successfully.`,
+            }),
+            ApiBadRequestResponse({ description: "Payload validation failed." }),
+            ApiUnprocessableEntityResponse({
+                description: "Repository rejected the provided payload.",
+            }),
+            __param(0, Body()),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", Promise)
+        ], DynamicModelController.prototype, "create", null);
+        __decorate([
+            Get(":id"),
+            ApiOperation({ summary: `Retrieve a ${modelClazzName} record by id.` }),
+            ApiParam({ name: "id", description: "Primary key" }),
+            ApiOkResponse({
+                description: `${modelClazzName} retrieved successfully.`,
+            }),
+            ApiNotFoundResponse({
+                description: `No ${modelClazzName} record matches the provided identifier.`,
+            }),
+            __param(0, Param("id")),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [String]),
+            __metadata("design:returntype", Promise)
+        ], DynamicModelController.prototype, "read", null);
+        __decorate([
+            Put(":id"),
+            ApiOperation({
+                summary: `Replace an existing ${modelClazzName} record with a new payload.`,
+            }),
+            ApiBody({
+                description: `Payload for replace a existing record of ${modelClazzName}`,
+                schema: { $ref: getSchemaPath(ModelClazz) },
+            }),
+            ApiOkResponse({
+                description: `${ModelClazz} record replaced successfully.`,
+            }),
+            ApiNotFoundResponse({
+                description: `No ${modelClazzName} record matches the provided identifier.`,
+            }),
+            ApiBadRequestResponse({ description: "Payload validation failed." }),
+            __param(0, Body()),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Model]),
+            __metadata("design:returntype", Promise)
+        ], DynamicModelController.prototype, "update", null);
+        __decorate([
+            Delete(":id"),
+            ApiOperation({ summary: `Delete a ${modelClazzName} record by id.` }),
+            ApiParam({
+                name: "id",
+                description: `Primary key value of the ${modelClazzName} record to delete.`,
+            }),
+            ApiOkResponse({
+                description: `${modelClazzName} record deleted successfully.`,
+            }),
+            ApiNotFoundResponse({
+                description: `No ${modelClazzName} record matches the provided identifier.`,
+            }),
+            __param(0, Param("id")),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [String]),
+            __metadata("design:returntype", Promise)
+        ], DynamicModelController.prototype, "delete", null);
+        DynamicModelController = __decorate([
+            Controller(routePath),
+            ApiTags(modelClazzName),
+            ApiExtraModels(ModelClazz),
+            __metadata("design:paramtypes", [RepoFactory])
+        ], DynamicModelController);
+        return DynamicModelController;
+    }
+    static forRoot(flavour) {
+        const log = this.log.for(this.forRoot);
+        log.info(`Generating controllers for flavour...`);
+        const trackedModels = Adapter.models(flavour);
+        const controllers = trackedModels.map(this.toModelController.bind(this));
+        log.info(`Generated ${controllers.length} controllers`);
+        return {
+            module: DecafModelModule_1,
+            controllers,
+            providers: [RepoFactory],
+        };
+    }
+};
+DecafModelModule = DecafModelModule_1 = __decorate([
+    Module({})
+], DecafModelModule);
+
 var DecafModule_1;
 /**
  * @publicApi
  */
 let DecafModule = DecafModule_1 = class DecafModule {
-    static forRoot(options) {
+    static async forRootAsync(options) {
+        const { autoControllers } = options;
+        const adapter = await DecafCoreModule.createAdapter(options);
+        const flavour = adapter.flavour;
+        const imports = [DecafCoreModule.forRoot(options)];
+        if (autoControllers) {
+            imports.push(DecafModelModule.forRoot(flavour));
+        }
         return {
             module: DecafModule_1,
-            imports: [DecafCoreModule.forRoot(options)],
+            imports: imports,
         };
     }
 };
@@ -72,8 +599,16 @@ DecafModule = DecafModule_1 = __decorate([
     Module({})
 ], DecafModule);
 
+function repoForModel(model) {
+    const m = Model.get(model);
+    if (!m)
+        throw new InternalError(`Failed to find repository for ${model}`);
+    const repo = Repository.forModel(m);
+    return repo;
+}
+
 /**
- * @module ts-workspace
+ * @module for-nest
  * @description This module serves as the main entry point for the ts-workspace library. It aggregates and exports
  * functionality from various submodules and utilities within the project.
  *
@@ -99,9 +634,9 @@ DecafModule = DecafModule_1 = __decorate([
  * @constant
  * @type {string}
  */
-const VERSION = "0.0.1";
+const VERSION = "0.0.4";
 const PACKAGE_NAME = "##PACKAGE_NAME##";
 Metadata.registerLibrary(PACKAGE_NAME, VERSION);
 
-export { DECAF_ADAPTER_ID, DECAF_MODULE_OPTIONS, DecafModule, PACKAGE_NAME, VERSION };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+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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"}