@avleon/core 0.0.7 → 0.0.10

package/dist/icore.d.ts

@@ -1,9 +1,20 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
 import { FastifyInstance, FastifyReply, FastifyRequest, HookHandlerDoneFunction } from "fastify";
+import { Constructable } from "typedi";
 import { Constructor } from "./helpers";
 import { PathLike } from "fs";
 import { DataSourceOptions } from "typeorm";
 import { AppMiddleware } from "./middleware";
 import { OpenApiOptions, OpenApiUiOptions } from "./openapi";
+import { IConfig } from "./config";
+import { FastifyCorsOptions } from "@fastify/cors";
+import { FastifyMultipartOptions } from "@fastify/multipart";
+import { MultipartFile } from "./multipart";
 export type FuncRoute = {
     handler: any;
     middlewares?: any[];
@@ -28,7 +39,7 @@ export interface ParamMetaOptions {
     validate: boolean;
     dataType: any;
     validatorClass: boolean;
-    type: "route:param" | "route:query" | "route:body" | "route:header" | "route:user";
+    type: "route:param" | "route:query" | "route:body" | "route:header" | "route:user" | "route:file" | "route:files";
 }
 export interface MethodParamMeta {
     params: ParamMetaOptions[];
@@ -37,12 +48,44 @@ export interface MethodParamMeta {
     headers: ParamMetaOptions[];
     currentUser: ParamMetaOptions[];
     swagger?: OpenApiUiOptions;
+    file?: any[];
+    files?: MultipartFile[];
 }
 type StaticFileOptions = {
     path?: PathLike;
     prefix?: string;
 };
-declare class AvleonApplication {
+type MultipartOptions = {
+    destination: PathLike;
+} & FastifyMultipartOptions;
+type AvleonApp = FastifyInstance;
+export type TestAppOptions = {
+    controllers: Constructor[];
+};
+export interface AvleonTestAppliction {
+    addDataSource: (dataSourceOptions: DataSourceOptions) => void;
+    getApp: (options?: TestAppOptions) => any;
+    getController: <T>(controller: Constructor<T>) => T;
+}
+export interface IAvleonApplication {
+    isDevelopment(): boolean;
+    useCors(corsOptions?: FastifyCorsOptions): void;
+    useOpenApi<T extends IConfig<R>, R = ReturnType<InstanceType<Constructable<T>>["config"]>>(ConfigClass: Constructable<T>, modifyConfig?: (config: R) => R): void;
+    useSwagger(options: OpenApiUiOptions): Promise<void>;
+    useMultipart(options: MultipartOptions): IAvleonApplication;
+    useMiddlewares<T extends AppMiddleware>(mclasses: Constructor<T>[]): void;
+    useAuthoriztion<T extends any>(middleware: Constructor<T>): void;
+    mapRoute<T extends (...args: any[]) => any>(method: "get" | "post" | "put" | "delete", path: string, fn: T): Promise<void>;
+    mapGet<T extends (...args: any[]) => any>(path: string, fn: T): any;
+    mapPost<T extends (...args: any[]) => any>(path: string, fn: T): any;
+    mapPut<T extends (...args: any[]) => any>(path: string, fn: T): any;
+    mapDelete<T extends (...args: any[]) => any>(path: string, fn: T): any;
+    mapControllers(controllers: any[]): any;
+    useStaticFiles(options?: StaticFileOptions): void;
+    run(port?: number): Promise<void>;
+    getTestApp(): any;
+}
+declare class AvleonApplication implements IAvleonApplication {
     private static instance;
     private static buildOptions;
     private app;
@@ -53,18 +96,46 @@ declare class AvleonApplication {
     private rMap;
     private hasSwagger;
     private globalSwaggerOptions;
+    private dataSourceOptions?;
     private controllers;
     private authorizeMiddleware?;
+    private appConfig;
+    private dataSource?;
+    private metaCache;
+    private multipartOptions;
     private constructor();
     static getInternalApp(buildOptions: any): AvleonApplication;
     isDevelopment(): boolean;
     private initSwagger;
+    useCors(corsOptions?: FastifyCorsOptions): void;
+    useOpenApi<T extends IConfig<R>, R = ReturnType<InstanceType<Constructable<T>>["config"]>>(ConfigClass: Constructable<T>, modifyConfig?: (config: R) => R): void;
+    /**
+     * @deprecated
+     * Will remove in next major version
+     */
     useSwagger(options: OpenApiUiOptions): Promise<void>;
+    useMultipart(options: MultipartOptions): this;
     private handleMiddlewares;
     private executeMiddlewares;
+    /**
+     * build controller
+     * @param controller
+     * @returns void
+     */
     private buildController;
+    /**
+     * map all request parameters
+     * @param req
+     * @param meta
+     * @returns
+     */
     private _mapArgs;
-    private metaCache;
+    /**
+     * Process Meta for controlelr class methods
+     * @param prototype
+     * @param method
+     * @returns
+     */
     private _processMeta;
     autoControllers(): Promise<void>;
     mapControllers(controllers: Function[]): void;
@@ -94,19 +165,48 @@ declare class AvleonApplication {
         useSwagger: (options: OpenApiOptions) => /*elided*/ any;
     };
     useStaticFiles(options?: StaticFileOptions): void;
+    initializeDatabase(): Promise<void>;
     run(port?: number): Promise<void>;
-    getTestApp(app: AvleonApplication): FastifyInstance<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>;
+    getTestApp(buildOptions?: any): Promise<any>;
+}
+export type Application = typeof AvleonApplication;
+export interface ITestBuilder {
+    getTestApplication(): AvleonTestAppliction;
+    createTestApplication(options: any): AvleonTestAppliction;
+}
+export interface IAppBuilder {
+    registerPlugin<T extends Function, S extends {}>(plugin: T, options: S): Promise<void>;
+    addDataSource<T extends IConfig<R>, R = ReturnType<InstanceType<Constructable<T>>["config"]>>(ConfigClass: Constructable<T>, modifyConfig?: (config: R) => R): void;
+    build<T extends IAvleonApplication>(): T;
+}
+export declare class TestBuilder {
+    private static instance;
+    private app;
+    private dataSourceOptions?;
+    private constructor();
+    static createBuilder(): TestBuilder;
+    getController<T>(controller: Constructor<T>): T;
+    getService<T>(service: Constructor<T>): T;
+    getTestApplication(options: TestAppOptions): Promise<AvleonApp>;
+    build(app: IAvleonApplication): any;
+    fromApplication(app: IAvleonApplication): any;
 }
-export declare class Builder {
+export declare class Builder implements ITestBuilder, IAppBuilder {
     private static instance;
     private alreadyBuilt;
     private database;
     private dataSource?;
+    private multipartOptions;
+    private dataSourceOptions?;
+    private testBuilder;
+    private appConfig;
     private constructor();
+    getTestApplication(): AvleonTestAppliction;
     static createAppBuilder(): Builder;
-    static creatTestAppBilder(): Builder;
+    static creatTestAppBuilder(): ITestBuilder;
     registerPlugin<T extends Function, S extends {}>(plugin: T, options: S): Promise<void>;
-    addDataSource(config: DataSourceOptions): Promise<void>;
-    build(): AvleonApplication;
+    addDataSource<T extends IConfig<R>, R = ReturnType<InstanceType<Constructable<T>>["config"]>>(ConfigClass: Constructable<T>, modifyConfig?: (config: R) => R): void;
+    createTestApplication<T extends AvleonTestAppliction>(buildOptions?: any): any;
+    build<T extends IAvleonApplication>(): T;
 }
 export {};

package/dist/icore.js

@@ -54,7 +54,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Builder = void 0;
+exports.Builder = exports.TestBuilder = void 0;
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
 const fastify_1 = __importDefault(require("fastify"));
 const typedi_1 = __importDefault(require("typedi"));
 const promises_1 = __importDefault(require("fs/promises"));
@@ -65,7 +71,10 @@ const system_exception_1 = require("./exceptions/system-exception");
 const fs_1 = require("fs");
 const exceptions_1 = require("./exceptions");
 const swagger_1 = __importDefault(require("@fastify/swagger"));
+const config_1 = require("./config");
 const environment_variables_1 = require("./environment-variables");
+const cors_1 = __importDefault(require("@fastify/cors"));
+const multipart_1 = __importDefault(require("@fastify/multipart"));
 const isTsNode = process.env.TS_NODE_DEV ||
     process.env.TS_NODE_PROJECT ||
     process[Symbol.for("ts-node.register.instance")];
@@ -80,10 +89,13 @@ class AvleonApplication {
         this.rMap = new Map();
         this.hasSwagger = false;
         this.globalSwaggerOptions = {};
+        this.dataSourceOptions = undefined;
         this.controllers = [];
         this.authorizeMiddleware = undefined;
+        this.dataSource = undefined;
         this.metaCache = new Map();
         this.app = (0, fastify_1.default)();
+        this.appConfig = new config_1.AppConfig();
         // this.app.setValidatorCompiler(() => () => true);
     }
     static getInternalApp(buildOptions) {
@@ -93,10 +105,19 @@ class AvleonApplication {
         AvleonApplication.buildOptions = buildOptions;
         if (buildOptions.controllers) {
         }
+        if (buildOptions.dataSourceOptions) {
+            AvleonApplication.instance.dataSourceOptions =
+                buildOptions.dataSourceOptions;
+            const typeorm = require("typeorm");
+            const datasource = new typeorm.DataSource(buildOptions.dataSourceOptions);
+            typedi_1.default.set("idatasource", datasource);
+            AvleonApplication.instance.dataSource = datasource;
+        }
         return AvleonApplication.instance;
     }
     isDevelopment() {
-        return environment_variables_1.env["NODE_ENV"] == "development";
+        const env = container_1.default.get(environment_variables_1.Environment);
+        return env.get("NODE_ENV") == "development";
     }
     async initSwagger(options) {
         const { routePrefix, logo, theme } = options, restOptions = __rest(options, ["routePrefix", "logo", "theme"]);
@@ -104,8 +125,6 @@ class AvleonApplication {
             openapi: Object.assign({ openapi: "3.0.0" }, restOptions),
         });
         const rPrefix = routePrefix ? routePrefix : "/docs";
-        //import fastifyApiReference from "@scalar/fastify-api-reference";
-        //const fastifyApiReference = await require("@scalar/fastify-api-reference");
         await this.app.register(require("@fastify/swagger-ui"), {
             logo: logo ? logo : null,
             theme: theme ? theme : {},
@@ -120,10 +139,33 @@ class AvleonApplication {
             },
         });
     }
+    useCors(corsOptions = {}) {
+        this.app.register(cors_1.default, corsOptions);
+    }
+    useOpenApi(ConfigClass, modifyConfig) {
+        const openApiConfig = this.appConfig.get(ConfigClass);
+        if (modifyConfig) {
+            const modifiedConfig = modifyConfig(openApiConfig);
+            this.globalSwaggerOptions = modifiedConfig;
+        }
+        else {
+            this.globalSwaggerOptions = openApiConfig;
+        }
+        this.hasSwagger = true;
+    }
+    /**
+     * @deprecated
+     * Will remove in next major version
+     */
     async useSwagger(options) {
         this.hasSwagger = true;
         this.globalSwaggerOptions = options;
     }
+    useMultipart(options) {
+        this.multipartOptions = options;
+        this.app.register(multipart_1.default, options);
+        return this;
+    }
     handleMiddlewares(mclasses) {
         for (const mclass of mclasses) {
             const cls = typedi_1.default.get(mclass.constructor);
@@ -138,6 +180,11 @@ class AvleonApplication {
             : [];
         return [...classMiddlewares, ...methodMiddlewares];
     }
+    /**
+     * build controller
+     * @param controller
+     * @returns void
+     */
     async buildController(controller) {
         var _a, e_1, _b, _c;
         const ctrl = typedi_1.default.get(controller);
@@ -155,7 +202,6 @@ class AvleonApplication {
                 return this.authorizeMiddleware.authorize(req);
             });
         }
-        console.log("ClassMiddlware:", tag + ":", authClsMeata);
         try {
             for (var _d = true, methods_1 = __asyncValues(methods), methods_1_1; methods_1_1 = await methods_1.next(), _a = methods_1_1.done, !_a; _d = true) {
                 _c = methods_1_1.value;
@@ -226,7 +272,14 @@ class AvleonApplication {
             finally { if (e_1) throw e_1.error; }
         }
     }
+    /**
+     * map all request parameters
+     * @param req
+     * @param meta
+     * @returns
+     */
     async _mapArgs(req, meta) {
+        var _a, e_2, _b, _c;
         if (!req.hasOwnProperty("_argsCache")) {
             Object.defineProperty(req, "_argsCache", {
                 value: new Map(),
@@ -244,9 +297,32 @@ class AvleonApplication {
         meta.currentUser.forEach((user) => (args[user.index] = req.user));
         meta.headers.forEach((header) => (args[header.index] =
             header.key === "all" ? req.headers : req.headers[header.key]));
+        if (meta.file) {
+            try {
+                for (var _d = true, _e = __asyncValues(meta.file), _f; _f = await _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    let f = _c;
+                    args[f.index] = await req.file();
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
         cache.set(cacheKey, args);
         return args;
     }
+    /**
+     * Process Meta for controlelr class methods
+     * @param prototype
+     * @param method
+     * @returns
+     */
     _processMeta(prototype, method) {
         const cacheKey = `${prototype.constructor.name}_${method}`;
         if (this.metaCache.has(cacheKey)) {
@@ -256,6 +332,8 @@ class AvleonApplication {
             params: Reflect.getMetadata(container_1.PARAM_META_KEY, prototype, method) || [],
             query: Reflect.getMetadata(container_1.QUERY_META_KEY, prototype, method) || [],
             body: Reflect.getMetadata(container_1.REQUEST_BODY_META_KEY, prototype, method) || [],
+            file: Reflect.getMetadata(container_1.REQUEST_BODY_FILE_KEY, prototype, method) || [],
+            files: Reflect.getMetadata(container_1.REQUEST_BODY_FILES_KEY, prototype, method) || [],
             headers: Reflect.getMetadata(container_1.REQUEST_HEADER_META_KEY, prototype, method) || [],
             currentUser: Reflect.getMetadata(container_1.REQUEST_USER_META_KEY, prototype, method) || [],
             // swagger: Reflect.getMetadata("route:openapi", prototype, method) || {}
@@ -297,14 +375,10 @@ class AvleonApplication {
             this.autoControllers();
         }
     }
-    async handleRoute(args) {
-        console.log(args);
-    }
+    async handleRoute(args) { }
     async mapFn(fn) {
         const original = fn;
-        fn = function () {
-            console.log(arguments);
-        };
+        fn = function () { };
         return fn;
     }
     useMiddlewares(mclasses) {
@@ -329,7 +403,7 @@ class AvleonApplication {
         }
         return {
             code: 500,
-            error: "INTERNALERROR",
+            error: "INTERNAL_ERROR",
             message: error.message ? error.message : "Something going wrong.",
         };
     }
@@ -367,20 +441,20 @@ class AvleonApplication {
                 const ms = midds.map((mclass) => {
                     const cls = typedi_1.default.get(mclass);
                     this.middlewares.set(mclass.name, cls);
-                    return cls.invoke; // Ensure `invoke` runs in the correct context
+                    return cls.invoke;
                 });
                 const r = this.rMap.get(routeKey);
                 if (r) {
-                    r.middlewares = ms; // Update middlewares array
+                    r.middlewares = ms;
                 }
-                return route; // Ensure chaining by returning the same route object
+                return route;
             },
             useSwagger: (options) => {
                 const r = this.rMap.get(routeKey);
                 if (r) {
-                    r.schema = options; // Update schema
+                    r.schema = options;
                 }
-                return route; // Ensure chaining
+                return route;
             },
         };
         return route;
@@ -403,20 +477,19 @@ class AvleonApplication {
             prefix: options.prefix ? options.prefix : "/static/",
         });
     }
+    async initializeDatabase() {
+        if (this.dataSourceOptions && this.dataSource) {
+            await this.dataSource.initialize();
+        }
+    }
     async run(port = 4000) {
         if (this.alreadyRun)
             throw new system_exception_1.SystemUseError("App already running");
         this.alreadyRun = true;
-        if (AvleonApplication.buildOptions.database) {
-        }
-        //this.app.swagger();
         if (this.hasSwagger) {
             await this.initSwagger(this.globalSwaggerOptions);
         }
         await this._mapControllers();
-        // this.controllers.forEach(controller => {
-        //   this.buildController(controller)
-        // })
         this.rMap.forEach((value, key) => {
             const [m, r] = key.split(":");
             this.app.route({
@@ -443,18 +516,91 @@ class AvleonApplication {
         });
         await this.app.ready();
         await this.app.listen({ port });
-        console.log(`Application running on port: 0.0.0.0:${port}`);
+        console.log(`Application running on http://127.0.0.1:${port}`);
     }
-    getTestApp(app) {
-        return this.app;
+    async getTestApp(buildOptions) {
+        try {
+            if (buildOptions && buildOptions.addDataSource) {
+                const typeorm = await Promise.resolve().then(() => __importStar(require("typeorm")));
+                if (!typeorm) {
+                    throw new system_exception_1.SystemUseError("TypeOrm not installed");
+                }
+                const datasource = new typeorm.DataSource(buildOptions.addDataSource);
+                typedi_1.default.set("idatasource", datasource);
+                await datasource.initialize();
+            }
+            this._mapControllers();
+            this.rMap.forEach((value, key) => {
+                const [m, r] = key.split(":");
+                this.app.route({
+                    method: m,
+                    url: r,
+                    schema: value.schema || {},
+                    preHandler: value.middlewares ? value.middlewares : [],
+                    handler: async (req, res) => {
+                        const result = await value.handler.apply(this, [req, res]);
+                        return result;
+                    },
+                });
+            });
+            this.app.setErrorHandler(async (error, req, res) => {
+                const handledErr = this._handleError(error);
+                if (error instanceof exceptions_1.ValidationErrorException) {
+                    return res.status(handledErr.code).send({
+                        code: handledErr.code,
+                        error: handledErr.error,
+                        errors: handledErr.message,
+                    });
+                }
+                return res.status(handledErr.code).send(handledErr);
+            });
+            return this.app;
+        }
+        catch (error) {
+            throw new system_exception_1.SystemUseError("Can't get test appliction");
+        }
     }
 }
 AvleonApplication.buildOptions = {};
-// Applciation Builder
+class TestBuilder {
+    constructor() { }
+    static createBuilder() {
+        if (!TestBuilder.instance) {
+            TestBuilder.instance = new TestBuilder();
+        }
+        return TestBuilder.instance;
+    }
+    getController(controller) {
+        return typedi_1.default.get(controller);
+    }
+    getService(service) {
+        return typedi_1.default.get(service);
+    }
+    async getTestApplication(options) {
+        const app = AvleonApplication.getInternalApp({
+            dataSourceOptions: this.dataSourceOptions
+        });
+        app.mapControllers([...options.controllers]);
+        const fa = await app.getTestApp();
+        return fa;
+    }
+    build(app) {
+        return app.getTestApp();
+    }
+    fromApplication(app) {
+        return app.getTestApp();
+    }
+}
+exports.TestBuilder = TestBuilder;
 class Builder {
     constructor() {
         this.alreadyBuilt = false;
         this.database = false;
+        this.testBuilder = false;
+        this.appConfig = new config_1.AppConfig();
+    }
+    getTestApplication() {
+        throw new Error("Method not implemented.");
     }
     static createAppBuilder() {
         if (!Builder.instance) {
@@ -462,41 +608,57 @@ class Builder {
         }
         return Builder.instance;
     }
-    static creatTestAppBilder() {
+    static creatTestAppBuilder() {
         if (!Builder.instance) {
             Builder.instance = new Builder();
+            Builder.instance.testBuilder = true;
         }
         return Builder.instance;
     }
     async registerPlugin(plugin, options) {
         container_1.default.set(plugin, plugin.prototype);
     }
-    async addDataSource(config) {
-        if (this.database) {
-            throw new system_exception_1.SystemUseError("Datasource already added.");
+    addDataSource(ConfigClass, modifyConfig) {
+        const openApiConfig = this.appConfig.get(ConfigClass);
+        if (modifyConfig) {
+            const modifiedConfig = modifyConfig(openApiConfig);
+            this.dataSourceOptions = modifiedConfig;
         }
-        this.database = true;
-        try {
-            const typeorm = await Promise.resolve().then(() => __importStar(require("typeorm")));
-            if (!typeorm) {
-                throw new system_exception_1.SystemUseError("TypeOrm not installed");
-            }
-            const datasource = new typeorm.DataSource(config);
-            typedi_1.default.set("idatasource", datasource);
-            this.dataSource = datasource;
-            await datasource.initialize();
-        }
-        catch (error) {
-            console.log(error);
-            console.error("Database Initialize Error:", error.message);
+        else {
+            this.dataSourceOptions = openApiConfig;
         }
     }
+    createTestApplication(buildOptions) {
+        return {
+            addDataSource: (dataSourceOptions) => (this.dataSourceOptions = dataSourceOptions),
+            getApp: async (options) => {
+                const app = AvleonApplication.getInternalApp({
+                    database: this.database,
+                    dataSourceOptions: buildOptions.datSource,
+                });
+                app.mapControllers([...options.controllers]);
+                const _tapp = await app.getTestApp();
+                return {
+                    async get(url, options) {
+                        const res = await _tapp.inject(Object.assign({ url, method: "GET" }, options));
+                        return res;
+                    },
+                };
+            },
+            getController(controller) {
+                return typedi_1.default.get(controller);
+            },
+        };
+    }
     build() {
-        if (this.alreadyBuilt)
+        if (this.alreadyBuilt) {
             throw new Error("Already built");
+        }
         this.alreadyBuilt = true;
         const app = AvleonApplication.getInternalApp({
             database: this.database,
+            multipartOptions: this.multipartOptions,
+            dataSourceOptions: this.dataSourceOptions,
         });
         return app;
     }

package/dist/index.d.ts

@@ -1,3 +1,9 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
 export * from "./icore";
 export { inject, validateRequestBody } from "./helpers";
 export * from "./decorators";
@@ -12,4 +18,7 @@ export * from "./validation";
 export * from "./environment-variables";
 export * from "./collection";
 export * from "./queue";
+export * from "./security";
+export * from "./multipart";
+export * from "./file-storage";
 export { default as Container } from "./container";

package/dist/index.js

@@ -1,4 +1,10 @@
 "use strict";
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -18,7 +24,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Container = exports.validateRequestBody = exports.inject = void 0;
-//export * from "./iqra-core";
 __exportStar(require("./icore"), exports);
 var helpers_1 = require("./helpers");
 Object.defineProperty(exports, "inject", { enumerable: true, get: function () { return helpers_1.inject; } });
@@ -35,5 +40,8 @@ __exportStar(require("./validation"), exports);
 __exportStar(require("./environment-variables"), exports);
 __exportStar(require("./collection"), exports);
 __exportStar(require("./queue"), exports);
+__exportStar(require("./security"), exports);
+__exportStar(require("./multipart"), exports);
+__exportStar(require("./file-storage"), exports);
 var container_1 = require("./container");
 Object.defineProperty(exports, "Container", { enumerable: true, get: function () { return __importDefault(container_1).default; } });

package/dist/map-types.d.ts

@@ -1,4 +1,9 @@
-import "reflect-metadata";
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
 type Constructor<T = any> = new (...args: any[]) => T;
 export declare function PartialType<T>(BaseClass: Constructor<T>): Constructor<Partial<T>>;
 /**

package/dist/map-types.js

@@ -1,9 +1,14 @@
 "use strict";
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PartialType = PartialType;
 exports.PickType = PickType;
 exports.OmitType = OmitType;
-require("reflect-metadata");
 function PartialType(BaseClass) {
     const baseProperties = [];
     let currentPrototype = BaseClass.prototype;