@decaf-ts/for-nest 0.0.2 → 0.0.3

package/lib/esm/core-module.d.ts

@@ -2,11 +2,16 @@ import { DynamicModule, OnApplicationShutdown } from "@nestjs/common";
 import { ModuleRef } from "@nestjs/core";
 import type { DecafModuleOptions } from "./types";
 import { Adapter } from "@decaf-ts/core";
-import { LoggedClass } from "@decaf-ts/logging/lib/LoggedClass";
-export declare class DecafCoreModule<CONF, ADAPTER extends Adapter<CONF, any, any, any, any>> extends LoggedClass implements OnApplicationShutdown {
+import { Logger } from "@decaf-ts/logging";
+export declare class DecafCoreModule<CONF, ADAPTER extends Adapter<CONF, any, any, any, any>> implements OnApplicationShutdown {
     private readonly options;
     private readonly moduleRef;
+    private static _logger;
+    private static _adapterInstance;
+    protected static get log(): Logger;
     constructor(options: DecafModuleOptions<CONF, ADAPTER>, moduleRef: ModuleRef);
+    static createAdapter(options: DecafModuleOptions): Promise<Adapter<any, any, any, any, any>>;
+    static getAdapterInstance(): Adapter<any, any, any, any, any> | null;
     static forRoot(options: DecafModuleOptions): DynamicModule;
     onApplicationShutdown(): Promise<void>;
 }

package/lib/esm/core-module.js

@@ -14,13 +14,31 @@ var DecafCoreModule_1;
 import { Global, Inject, Module, Scope, } from "@nestjs/common";
 import { ModuleRef } from "@nestjs/core";
 import { DECAF_ADAPTER_ID, DECAF_MODULE_OPTIONS } from "./constants.js";
-import { LoggedClass } from "@decaf-ts/logging/lib/LoggedClass";
-let DecafCoreModule = DecafCoreModule_1 = class DecafCoreModule extends LoggedClass {
+import { Logging } from "@decaf-ts/logging";
+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,
@@ -28,7 +46,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,
@@ -44,15 +62,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);
         }
     }
 };
@@ -63,4 +83,4 @@ DecafCoreModule = DecafCoreModule_1 = __decorate([
     __metadata("design:paramtypes", [Object, ModuleRef])
 ], DecafCoreModule);
 export { DecafCoreModule };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/decoration.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/esm/decoration.js

@@ -0,0 +1,121 @@
+import { InjectablesKeys, } from "@decaf-ts/injectable-decorators";
+import { Inject, Injectable, Scope } from "@nestjs/common";
+import { Decoration, DecorationKeys } from "@decaf-ts/decoration";
+import { ValidationKeys } from "@decaf-ts/decorator-validation";
+import { ApiProperty } from "./decorators/ApiProperty.js";
+import { PersistenceKeys } from "@decaf-ts/core";
+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();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decoration.js","sourceRoot":"","sources":["../../src/decoration.ts"],"names":[],"mappings":"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","sourcesContent":["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"]}

package/lib/esm/decorators/ApiProperty.d.ts

@@ -0,0 +1,27 @@
+import { Type } from "@nestjs/common";
+import { SchemaObjectMetadata } from "@nestjs/swagger/dist/interfaces/schema-object-metadata.interface";
+import { EnumSchemaAttributes } from "@nestjs/swagger/dist/interfaces/enum-schema-attributes.interface";
+export type ApiPropertyCommonOptions = SchemaObjectMetadata & {
+    "x-enumNames"?: string[];
+    /**
+     * Lazy function returning the type for which the decorated property
+     * can be used as an id
+     *
+     * Use together with @ApiDefaultGetter on the getter route of the type
+     * to generate OpenAPI link objects
+     *
+     * @see [Swagger link objects](https://swagger.io/docs/specification/links/)
+     */
+    link?: () => Type<unknown> | Function;
+};
+export type ApiPropertyOptions = ApiPropertyCommonOptions | (ApiPropertyCommonOptions & {
+    enumName: string;
+    enumSchema?: EnumSchemaAttributes;
+});
+/**
+ * @publicApi
+ */
+export declare function ApiProperty(options?: ApiPropertyOptions): PropertyDecorator;
+export declare function createApiPropertyDecorator(options?: ApiPropertyOptions, overrideExisting?: boolean): PropertyDecorator;
+export declare function ApiPropertyOptional(options?: ApiPropertyOptions): PropertyDecorator;
+export declare function ApiResponseProperty(options?: Pick<ApiPropertyOptions, "type" | "example" | "format" | "deprecated" | "enum">): PropertyDecorator;

package/lib/esm/decorators/ApiProperty.js

@@ -0,0 +1,57 @@
+import { getTypeIsArrayTuple } from "@nestjs/swagger/dist/decorators/helpers";
+import { getEnumType, getEnumValues, } from "@nestjs/swagger/dist/utils/enum.utils";
+import { DECORATORS } from "@nestjs/swagger/dist/constants";
+import { createPropertyDecorator } from "./helpers.js";
+const isEnumArray = (opts) => (opts.isArray && "enum" in opts && opts.enum !== undefined);
+/**
+ * @publicApi
+ */
+export function ApiProperty(options = {}) {
+    return createApiPropertyDecorator(options);
+}
+export function createApiPropertyDecorator(options = {}, overrideExisting = true) {
+    const [type, isArray] = getTypeIsArrayTuple(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);
+}
+export function ApiPropertyOptional(options = {}) {
+    return ApiProperty({
+        ...options,
+        required: false,
+    });
+}
+export function ApiResponseProperty(options = {}) {
+    return ApiProperty({
+        readOnly: true,
+        ...options,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/decorators/helpers.d.ts

@@ -0,0 +1,8 @@
+export declare function createMethodDecorator<T = any>(metakey: string, metadata: T, { overrideExisting }?: {
+    overrideExisting: boolean;
+}): MethodDecorator;
+export declare function createClassDecorator<T extends Array<any> = any>(metakey: string, metadata?: T): ClassDecorator;
+export declare function createPropertyDecorator<T extends Record<string, any> = any>(metakey: string, metadata: T, overrideExisting?: boolean): PropertyDecorator;
+export declare function createMixedDecorator<T = any>(metakey: string, metadata: T): MethodDecorator & ClassDecorator;
+export declare function createParamDecorator<T extends Record<string, any> = any>(metadata: T, initial: Partial<T>): MethodDecorator & ClassDecorator;
+export declare function getTypeIsArrayTuple(input: Function | [Function] | undefined | string | Record<string, any>, isArrayFlag: boolean): [Function | undefined, boolean];

package/lib/esm/decorators/helpers.js

@@ -0,0 +1,132 @@
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+import { METHOD_METADATA } from "@nestjs/common/constants";
+import { isConstructor } from "@nestjs/common/utils/shared.utils";
+import { isArray, isUndefined, negate, pickBy } from "lodash";
+import { METADATA_FACTORY_NAME } from "@nestjs/swagger/dist/plugin/plugin-constants";
+import { DECORATORS } from "@nestjs/swagger/dist/constants";
+export 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;
+    };
+}
+export function createClassDecorator(metakey, metadata = []) {
+    return (target) => {
+        const prevValue = Reflect.getMetadata(metakey, target) || [];
+        Reflect.defineMetadata(metakey, [...prevValue, ...metadata], target);
+        return target;
+    };
+}
+export 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);
+        }
+    };
+}
+export 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;
+    };
+}
+export 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);
+        }
+    };
+}
+export 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];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../../src/decorators/helpers.ts"],"names":[],"mappings":"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","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"]}

package/lib/esm/decorators/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ApiProperty";
+export * from "./helpers";

package/lib/esm/decorators/index.js

@@ -0,0 +1,3 @@
+export * from "./ApiProperty.js";
+export * from "./helpers.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZGVjb3JhdG9ycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxpQ0FBOEI7QUFDOUIsNkJBQTBCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vQXBpUHJvcGVydHlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2hlbHBlcnNcIjtcbiJdfQ==

package/lib/esm/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @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.
  *
@@ -19,14 +19,19 @@
  * This structure provides a clean and organized export of the module's functionality, allowing consumers
  * to easily import and use specific parts of the library as needed.
  */
+import "./decoration";
+export * from "./decorators";
 export * from "./constants";
+export * from "./decoration";
 export * from "./module";
+export * from "./RepoFactory";
 export * from "./types";
+export * from "./utils";
 /**
  * Represents the current version of the ts-workspace module.
  * The actual version number is replaced during the build process.
  * @constant
  * @type {string}
  */
-export declare const VERSION = "0.0.1";
+export declare const VERSION = "0.0.2";
 export declare const PACKAGE_NAME = "##PACKAGE_NAME##";

package/lib/esm/index.js

@@ -1,5 +1,5 @@
 /**
- * @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.
  *
@@ -20,16 +20,21 @@
  * to easily import and use specific parts of the library as needed.
  */
 import { Metadata } from "@decaf-ts/decoration";
+import "./decoration.js";
+export * from "./decorators/index.js";
 export * from "./constants.js";
+export * from "./decoration.js";
 export * from "./module.js";
+export * from "./RepoFactory.js";
 export * from "./types.js";
+export * from "./utils.js";
 /**
  * Represents the current version of the ts-workspace module.
  * The actual version number is replaced during the build process.
  * @constant
  * @type {string}
  */
-export const VERSION = "0.0.1";
+export const VERSION = "0.0.2";
 export const PACKAGE_NAME = "##PACKAGE_NAME##";
 Metadata.registerLibrary(PACKAGE_NAME, VERSION);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/model-module.d.ts

@@ -0,0 +1,8 @@
+import { Logger } from "@decaf-ts/logging";
+import { DynamicModule } from "@nestjs/common";
+export declare class DecafModelModule {
+    private static _logger;
+    protected static get log(): Logger;
+    private static toModelController;
+    static forRoot(flavour: string): DynamicModule;
+}