@zenofolio/hyper-decor 1.0.4 → 1.0.7

package/README.md

@@ -144,7 +144,7 @@ class TestController extends CRUD<string> {
 ```typescript
 @HyperModule({
     path: "users",
-    controllers: [HyperController]
+    controllers: [TestController]
 })
 class UserModule {}
 ```
@@ -185,7 +185,70 @@ As a result, we get:
  - [Middleware](./examples/middleware.ts)
  - [File](./examples//upload-file.ts)
 
+## Services & Dependency Injection
+You can use `@HyperService()` with `tsyringe` to inject dependencies into controllers or other services.
 
+```typescript
+import { injectable } from "tsyringe";
+
+@injectable()
+@HyperService()
+class UserService {
+  getUsers() { return ["User1", "User2"]; }
+}
+
+@HyperController("/users")
+class UserController {
+  constructor(private userService: UserService) {}
+
+  @Get("/")
+  getUsers(@Res() res: Response) {
+    res.json(this.userService.getUsers());
+  }
+}
+```
+
+## Agnostic Body Validation & Transformation (`@Transform`)
+You can use `@Transform` to validate and transform incoming requests agnostic of the validation library (like Zod) while seamlessly syncing with OpenAPI definitions.
+
+```typescript
+const ZodTransformer = {
+  transform: ({ data, schema }) => {
+    if (schema && schema._type === "zod") {
+      // Validate and return the parsed data
+      return { ...data, parsed: true };
+    }
+    return data;
+  },
+  getOpenApiSchema: (schema) => {
+    if (schema._type === "zod") {
+       return { type: "object", properties: { /* derived from schema */ } };
+    }
+  }
+};
+
+const app = await createApplication(Application);
+app.useTransform(ZodTransformer); // Register your custom transformer globally
+
+@HyperController("/users")
+class UserController {
+  @Post("/")
+  @Transform({ _type: "zod" /* pass your schema */ })
+  createUser(@Body() data: any, @Res() res: Response) {
+    res.json(data); // `data` is automatically intercepted and transformed!
+  }
+}
+```
+
+## OpenAPI Generation
+Generate a complete OpenAPI specification out-of-the-box leveraging your application tree and decorators footprint.
+
+```typescript
+import { getOpenAPI } from "@zenofolio/hyper-decor/lib/openapi";
+
+const openApiDoc = getOpenAPI(Application);
+console.log(openApiDoc.info.title, openApiDoc.paths);
+```
 
 # All for now
 More documentation will be added here late.

package/debug.txt

@@ -0,0 +1 @@
+State: class-before-dep-ok

package/dist/__internals/constants.d.ts

@@ -3,6 +3,7 @@ export declare const KEY_TYPE_CONTROLLER = "hyper:type:controller";
 export declare const KEY_TYPE_MODULE = "hyper:type:module";
 export declare const KEY_TYPE_ROUTE = "hyper:type:route";
 export declare const KEY_TYPE_SERVICE = "hyper:type:service";
+export declare const KEY_TYPE_GUARD = "hyper:type:guard";
 export type KeyTypes = typeof KEY_TYPE_APP | typeof KEY_TYPE_CONTROLLER | typeof KEY_TYPE_MODULE | typeof KEY_TYPE_SERVICE | typeof KEY_TYPE_ROUTE;
 export declare const KEY_PARAMS_APP = "hyper:type:app";
 export declare const KEY_PARAMS_CONTROLLER = "hyper:type:controller";
@@ -13,7 +14,8 @@ export declare const KEY_PARAMS_MIDDLEWARES = "hyper:type:middlewares";
 export declare const KEY_PARAMS_SCOPE = "hyper:type:scope";
 export declare const KEY_PARAMS_ROLE = "hyper:type:role";
 export declare const KEY_PARAMS_PASS = "hyper:type:pass";
-export type KeyParams = typeof KEY_PARAMS_APP | typeof KEY_PARAMS_CONTROLLER | typeof KEY_PARAMS_MODULE | typeof KEY_PARAMS_ROUTE | typeof KEY_PARAMS_PARAM | typeof KEY_PARAMS_MIDDLEWARES | typeof KEY_PARAMS_SCOPE | typeof KEY_PARAMS_ROLE | typeof KEY_PARAMS_PASS;
+export declare const KEY_OUTPUT_SCHEMA = "hyper:output:schema";
+export type KeyParams = typeof KEY_PARAMS_APP | typeof KEY_PARAMS_CONTROLLER | typeof KEY_PARAMS_MODULE | typeof KEY_PARAMS_ROUTE | typeof KEY_PARAMS_PARAM | typeof KEY_PARAMS_MIDDLEWARES | typeof KEY_PARAMS_SCOPE | typeof KEY_PARAMS_ROLE | typeof KEY_PARAMS_PASS | typeof KEY_OUTPUT_SCHEMA;
 export declare const KEY_STATE_UPDATED = "hyper:state:updated";
 export declare const KEY_STATE_CREATED = "hyper:state:created";
 export declare const KEY_STATE_PREPARED = "hyper:state:prepared";
@@ -40,6 +42,7 @@ export declare const METADATA_KEYS: {
     SCOPES: string;
     SCOPED: string;
     MIDDLEWARES: string;
+    ON_MESSAGE: string;
 };
 export declare const METADATA_STORE_KEYS: {
     PARAMS: string;
@@ -59,3 +62,4 @@ export declare const METADATA_STATE_KEYS: {
     CREATED: string;
     PREPARED: string;
 };
+export declare const FULL_ACCESS = "*";

package/dist/__internals/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.METADATA_STATE_KEYS = exports.METADATA_PARAMS_KEYS = exports.METADATA_METHOD_KEYS = exports.METADATA_STORE_KEYS = exports.METADATA_KEYS = exports.METADATA_HYPER_TYPE = exports.DESIGN_TYPE = exports.DESIGN_RETURNTYPE = exports.DESIGN_PARAMTYPES = exports.KEY_STATE_BY_PASS = exports.KEY_STATE_PREPARED = exports.KEY_STATE_CREATED = exports.KEY_STATE_UPDATED = exports.KEY_PARAMS_PASS = exports.KEY_PARAMS_ROLE = exports.KEY_PARAMS_SCOPE = exports.KEY_PARAMS_MIDDLEWARES = exports.KEY_PARAMS_PARAM = exports.KEY_PARAMS_ROUTE = exports.KEY_PARAMS_MODULE = exports.KEY_PARAMS_CONTROLLER = exports.KEY_PARAMS_APP = exports.KEY_TYPE_SERVICE = exports.KEY_TYPE_ROUTE = exports.KEY_TYPE_MODULE = exports.KEY_TYPE_CONTROLLER = exports.KEY_TYPE_APP = void 0;
+exports.FULL_ACCESS = exports.METADATA_STATE_KEYS = exports.METADATA_PARAMS_KEYS = exports.METADATA_METHOD_KEYS = exports.METADATA_STORE_KEYS = exports.METADATA_KEYS = exports.METADATA_HYPER_TYPE = exports.DESIGN_TYPE = exports.DESIGN_RETURNTYPE = exports.DESIGN_PARAMTYPES = exports.KEY_STATE_BY_PASS = exports.KEY_STATE_PREPARED = exports.KEY_STATE_CREATED = exports.KEY_STATE_UPDATED = exports.KEY_OUTPUT_SCHEMA = exports.KEY_PARAMS_PASS = exports.KEY_PARAMS_ROLE = exports.KEY_PARAMS_SCOPE = exports.KEY_PARAMS_MIDDLEWARES = exports.KEY_PARAMS_PARAM = exports.KEY_PARAMS_ROUTE = exports.KEY_PARAMS_MODULE = exports.KEY_PARAMS_CONTROLLER = exports.KEY_PARAMS_APP = exports.KEY_TYPE_GUARD = exports.KEY_TYPE_SERVICE = exports.KEY_TYPE_ROUTE = exports.KEY_TYPE_MODULE = exports.KEY_TYPE_CONTROLLER = exports.KEY_TYPE_APP = void 0;
 //////////////////////////////
 /// Types constants
 //////////////////////////////
@@ -9,6 +9,7 @@ exports.KEY_TYPE_CONTROLLER = "hyper:type:controller";
 exports.KEY_TYPE_MODULE = "hyper:type:module";
 exports.KEY_TYPE_ROUTE = "hyper:type:route";
 exports.KEY_TYPE_SERVICE = "hyper:type:service";
+exports.KEY_TYPE_GUARD = "hyper:type:guard";
 //////////////////////////////
 /// Params constants
 //////////////////////////////
@@ -21,6 +22,7 @@ exports.KEY_PARAMS_MIDDLEWARES = "hyper:type:middlewares";
 exports.KEY_PARAMS_SCOPE = "hyper:type:scope";
 exports.KEY_PARAMS_ROLE = "hyper:type:role";
 exports.KEY_PARAMS_PASS = "hyper:type:pass";
+exports.KEY_OUTPUT_SCHEMA = "hyper:output:schema";
 //////////////////////////////
 /// State constants
 //////////////////////////////
@@ -51,6 +53,7 @@ exports.METADATA_KEYS = {
     SCOPES: "hyper:scopes",
     SCOPED: "hyper:scoped",
     MIDDLEWARES: "hyper:middleware",
+    ON_MESSAGE: "hyper:on_message",
 };
 exports.METADATA_STORE_KEYS = {
     PARAMS: "hyper:store:params",
@@ -70,3 +73,4 @@ exports.METADATA_STATE_KEYS = {
     CREATED: "hyper:created",
     PREPARED: "hyper:prepared",
 };
+exports.FULL_ACCESS = "*";

package/dist/__internals/creators/request.creator.d.ts

@@ -1,6 +1,5 @@
 import "reflect-metadata";
-import { Request } from "hyper-express";
-import { ByPassKeys } from "../stores/params.store";
+import { Request } from "hyper-express/types";
 import { ParameterResolver } from "../../decorators";
 /**
  * Creates a parameter decorator for handling request data.
@@ -9,4 +8,4 @@ import { ParameterResolver } from "../../decorators";
  * @param {IParamsResolver} resolver - Resolver function to handle the parameter.
  * @returns {ParameterDecorator} - The parameter decorator function.
  */
-export default function createParamDecorator(key: keyof Request | ByPassKeys, decoratorName: string, resolver: ParameterResolver): ParameterDecorator;
+export default function createParamDecorator(key: keyof Request | "req" | "res", decoratorName: string, resolver: ParameterResolver, schema?: any, isWholeSource?: boolean): ParameterDecorator;

package/dist/__internals/creators/request.creator.js

@@ -5,11 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = createParamDecorator;
 require("reflect-metadata");
-const function_util_1 = require("../utils/function.util");
 const constants_1 = require("../constants");
 const decorator_base_1 = require("../decorator-base");
 const who_helper_1 = __importDefault(require("../helpers/who.helper"));
 const WrongPlaceException_1 = __importDefault(require("../../exeptions/WrongPlaceException"));
+const function_util_1 = require("../utils/function.util");
 /**
  * Creates a parameter decorator for handling request data.
  *
@@ -17,7 +17,7 @@ const WrongPlaceException_1 = __importDefault(require("../../exeptions/WrongPlac
  * @param {IParamsResolver} resolver - Resolver function to handle the parameter.
  * @returns {ParameterDecorator} - The parameter decorator function.
  */
-function createParamDecorator(key, decoratorName, resolver) {
+function createParamDecorator(key, decoratorName, resolver, schema, isWholeSource) {
     const _key = key;
     return (0, decorator_base_1.DecoratorHelper)({
         type: constants_1.KEY_TYPE_CONTROLLER,
@@ -27,7 +27,7 @@ function createParamDecorator(key, decoratorName, resolver) {
             if (!isProperty)
                 throw new WrongPlaceException_1.default(decoratorName, "parameter", `${Target.constructor.name}.${propertyKey}`, Target);
             const saved = options !== null && options !== void 0 ? options : { params: {} };
-            const names = (0, function_util_1.extreactArgsNames)(Target[propertyKey]);
+            const names = (0, function_util_1.extractArgsNames)(Target[propertyKey]);
             const types = Reflect.getMetadata(constants_1.DESIGN_PARAMTYPES, Target, propertyKey);
             const name = names === null || names === void 0 ? void 0 : names[parameterIndex];
             const type = types === null || types === void 0 ? void 0 : types[parameterIndex];
@@ -42,6 +42,8 @@ function createParamDecorator(key, decoratorName, resolver) {
                     key: _key,
                     method: propertyKey.toString(),
                     resolver,
+                    schema,
+                    isWholeSource,
                 });
                 // sort by index
                 saved.params[propertyKey].sort((a, b) => a.index - b.index);

package/dist/__internals/creators/routes.creator.d.ts

@@ -1,10 +1,9 @@
-import { Request, Response } from "hyper-express";
+import "reflect-metadata";
 /**
  * Helper function to create route decorators for HTTP methods.
  *
  * @param {string} method - The HTTP method (e.g., GET, POST).
- * @param {(req: Request, res: Response) => any} [resolver] - Optional resolver for the route.
  * @returns {(path?: string) => MethodDecorator} - A method decorator for defining routes.
  *
  */
-export default function createRouteDecorator(method: string, resolver?: (req: Request, res: Response) => any): (path?: string) => MethodDecorator & ClassDecorator;
+export default function createRouteDecorator<T extends any = undefined>(method: string): (path?: string, options?: T) => MethodDecorator & ClassDecorator;

package/dist/__internals/creators/routes.creator.js

@@ -1,22 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = createRouteDecorator;
+require("reflect-metadata");
 const constants_1 = require("../constants");
 const decorator_base_1 = require("../decorator-base");
 /**
  * Helper function to create route decorators for HTTP methods.
  *
  * @param {string} method - The HTTP method (e.g., GET, POST).
- * @param {(req: Request, res: Response) => any} [resolver] - Optional resolver for the route.
  * @returns {(path?: string) => MethodDecorator} - A method decorator for defining routes.
  *
  */
-function createRouteDecorator(method, resolver) {
-    return (path = "/") => (0, decorator_base_1.DecoratorHelper)({
+function createRouteDecorator(method) {
+    return (path = "/", options) => (0, decorator_base_1.DecoratorHelper)({
         type: constants_1.KEY_TYPE_CONTROLLER,
         key: constants_1.KEY_PARAMS_ROUTE,
         targetResolver: (target) => { var _a; return (_a = target.constructor) !== null && _a !== void 0 ? _a : target; },
         options: (data, Target, propertyKey, descriptor) => {
+            // add openAPI data here
             var _a;
             const handler = descriptor.value;
             if (typeof handler !== "function")
@@ -30,6 +31,7 @@ function createRouteDecorator(method, resolver) {
                 path,
                 propertyKey,
                 handler: handler,
+                options,
             });
             return saved;
         },

package/dist/__internals/decorator-base.js

@@ -48,15 +48,20 @@ function DecoratorHelper({ key, type, options, targetResolver, onDefineData }, .
             else {
                 (0, exports.defineDecorData)(key, Object.assign({ type }, options), Target);
                 value = Reflect.decorate(transforms, Target);
+                // If the class was wrapped/replaced, apply metadata to the new class too
+                if (value && value !== Target) {
+                    (0, exports.defineDecorData)(key, Object.assign({ type }, options), value);
+                }
             }
         }
         (0, tsyringe_1.injectable)()((0, object_util_1.$constructor)(target));
         return value;
     };
 }
+const METADATA_CACHE = new WeakMap();
 const defineDecorData = (key, options, target, property, descriptor) => {
     let value = options;
-    if (typeof options === "function") {
+    if (typeof options === "function" && !(options.prototype && options.prototype.constructor === options)) {
         const old = (0, exports.getDecorData)(key, target, property);
         value = Object.assign(Object.assign({}, old), options(old, target, property, descriptor));
     }
@@ -66,21 +71,52 @@ const defineDecorData = (key, options, target, property, descriptor) => {
     else {
         Reflect.defineMetadata(key, value, target);
     }
+    // Update Cache
+    let targetCache = METADATA_CACHE.get(target);
+    if (!targetCache) {
+        targetCache = new Map();
+        METADATA_CACHE.set(target, targetCache);
+    }
+    targetCache.set(property ? `${key}:${property}` : key, value);
 };
 exports.defineDecorData = defineDecorData;
-const getDecorData = (key, target, property) => property
-    ? Reflect.getMetadata(key, target, property)
-    : Reflect.getMetadata(key, target);
+const getDecorData = (key, target, property) => {
+    const cacheKey = property ? `${key}:${property}` : key;
+    const targetCache = METADATA_CACHE.get(target);
+    if (targetCache && targetCache.has(cacheKey)) {
+        return targetCache.get(cacheKey);
+    }
+    const value = property
+        ? Reflect.getMetadata(key, target, property)
+        : Reflect.getMetadata(key, target);
+    if (value !== undefined) {
+        let tc = METADATA_CACHE.get(target);
+        if (!tc) {
+            tc = new Map();
+            METADATA_CACHE.set(target, tc);
+        }
+        tc.set(cacheKey, value);
+    }
+    return value;
+};
 exports.getDecorData = getDecorData;
-const hasDecorData = (key, target, property) => property
-    ? Reflect.hasMetadata(key, target, property)
-    : Reflect.hasMetadata(key, target);
+const hasDecorData = (key, target, property) => {
+    const cacheKey = property ? `${key}:${property}` : key;
+    const targetCache = METADATA_CACHE.get(target);
+    if (targetCache && targetCache.has(cacheKey))
+        return true;
+    return property
+        ? Reflect.hasMetadata(key, target, property)
+        : Reflect.hasMetadata(key, target);
+};
 exports.hasDecorData = hasDecorData;
 const extractDecorData = (target) => {
     const keys = Reflect.getMetadataKeys(target);
-    return keys.reduce((acc, key) => {
-        acc[key] = Reflect.getMetadata(key, target);
-        return acc;
-    }, {});
+    const result = {};
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        result[key] = (0, exports.getDecorData)(key, target);
+    }
+    return result;
 };
 exports.extractDecorData = extractDecorData;

package/dist/__internals/helpers/imports.helper.d.ts

@@ -0,0 +1,8 @@
+import { IHyperHooks, ImportType } from "../../decorators/types";
+/**
+ * Prepare imports for the target class.
+ *
+ * @param target
+ * @param imports
+ */
+export declare function prepareImports(_target: any, imports: ImportType[], hooks?: IHyperHooks, context?: any): Promise<void>;

package/dist/__internals/helpers/imports.helper.js

@@ -0,0 +1,92 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareImports = prepareImports;
+const tsyringe_1 = require("tsyringe");
+const lifecycle_helper_1 = require("./lifecycle.helper");
+const decorator_base_1 = require("../decorator-base");
+const constants_1 = require("../constants");
+const message_bus_1 = require("../../common/message-bus");
+/**
+ * Prepare imports for the target class.
+ *
+ * @param target
+ * @param imports
+ */
+function prepareImports(_target, imports, hooks, context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const bus = tsyringe_1.container.resolve(message_bus_1.MessageBus);
+        yield Promise.all(imports.map((item) => __awaiter(this, void 0, void 0, function* () {
+            let token;
+            if (typeof item === "function" || typeof item === "string" || typeof item === "symbol") {
+                token = item;
+            }
+            else if (item && typeof item === "object" && "token" in item) {
+                token = item.token;
+                if (item.useClass) {
+                    tsyringe_1.container.register(token, { useClass: item.useClass }, item.options);
+                }
+                else if ("useValue" in item) {
+                    tsyringe_1.container.registerInstance(token, item.useValue);
+                    return;
+                }
+                else if (item.useFactory) {
+                    tsyringe_1.container.register(token, { useFactory: item.useFactory }, item.options);
+                    return;
+                }
+                else if (item.useToken) {
+                    tsyringe_1.container.register(token, { useToken: item.useToken }, item.options);
+                    return;
+                }
+            }
+            if (!token)
+                return;
+            try {
+                const instance = tsyringe_1.container.resolve(token);
+                if (!instance)
+                    return;
+                // Skip if already initialized to avoid double work/double subscription
+                const alreadyDone = (0, lifecycle_helper_1.isInitialized)(instance);
+                if (!alreadyDone) {
+                    if (hooks === null || hooks === void 0 ? void 0 : hooks.onBeforeInit) {
+                        yield hooks.onBeforeInit(instance, token, context);
+                    }
+                }
+                yield (0, lifecycle_helper_1.initializeInstance)(instance);
+                if (!alreadyDone) {
+                    if (hooks === null || hooks === void 0 ? void 0 : hooks.onAfterInit) {
+                        yield hooks.onAfterInit(instance, token, context);
+                    }
+                    // Handle singleton registration if it's a constructor and not registered
+                    if (typeof token === "function" && !tsyringe_1.container.isRegistered(token)) {
+                        const isSingleton = typeof instance.isSingleton === "function" ? instance.isSingleton() : true;
+                        if (isSingleton) {
+                            tsyringe_1.container.registerInstance(token, instance);
+                        }
+                    }
+                    // Discovery: Messaging (only on first init)
+                    const messaging = (0, decorator_base_1.getDecorData)(constants_1.METADATA_KEYS.ON_MESSAGE, typeof token === "function" ? token : instance.constructor);
+                    if (messaging === null || messaging === void 0 ? void 0 : messaging.length) {
+                        messaging.forEach((msg) => {
+                            bus.listen(msg.topic, instance[msg.propertyKey].bind(instance));
+                        });
+                    }
+                }
+            }
+            catch (e) {
+                // Skip dependencies that cannot be resolved automatically
+                // Log a warning to prevent silent failures in production
+                const name = typeof token === "function" ? token.name : String(token);
+                console.warn(`[HyperDecor] Warn: Could not resolve dependency for token "${name}". It might be missing injectable() or not exported correctly.`);
+            }
+        })));
+    });
+}

package/dist/__internals/helpers/lifecycle.helper.d.ts

@@ -0,0 +1,3 @@
+export declare const isInitialized: (target: any) => boolean;
+export declare const setInitialized: (target: any) => boolean;
+export declare function initializeInstance(instance: any): Promise<void>;

package/dist/__internals/helpers/lifecycle.helper.js

@@ -0,0 +1,25 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setInitialized = exports.isInitialized = void 0;
+exports.initializeInstance = initializeInstance;
+const isInitialized = (target) => Reflect.get(target, "____initialized") === true;
+exports.isInitialized = isInitialized;
+const setInitialized = (target) => Reflect.set(target, "____initialized", true);
+exports.setInitialized = setInitialized;
+function initializeInstance(instance) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (instance && typeof instance.onInit === "function" && !(0, exports.isInitialized)(instance)) {
+            yield instance.onInit();
+            (0, exports.setInitialized)(instance);
+        }
+    });
+}

package/dist/__internals/helpers/merge-metadata.js

@@ -10,35 +10,31 @@ require("reflect-metadata");
  * @param options Merge options (e.g., array handling).
  */
 function mergeMetadata(target, source, keys, options = {}) {
-    for (const key of keys) {
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
         const sourceMeta = Reflect.getMetadata(key, source);
-        const targetMeta = Reflect.getMetadata(key, target);
         if (sourceMeta === undefined)
             continue;
-        let mergedMeta = sourceMeta;
-        if (typeof sourceMeta === "object" && typeof targetMeta === "object") {
-            mergedMeta = deepMerge(targetMeta, sourceMeta, options);
-        }
-        Reflect.defineMetadata(key, mergedMeta, target);
+        const targetMeta = Reflect.getMetadata(key, target);
+        Reflect.defineMetadata(key, targetMeta === undefined ? sourceMeta : deepMerge(targetMeta, sourceMeta, options), target);
     }
 }
-/**
- * Performs a deep merge of two objects.
- * @param target Target object.
- * @param source Source object.
- * @param options Merge options.
- * @returns Merged object.
- */
 function deepMerge(target, source, options) {
     if (Array.isArray(target) && Array.isArray(source)) {
-        return (options.overwriteArrays ? source : Array.from(new Set([...target, ...source])));
+        if (options.overwriteArrays)
+            return source;
+        // Faster deduplication for primitive arrays
+        const combined = target.concat(source);
+        return Array.from(new Set(combined));
     }
-    if (typeof target === "object" && target !== null && typeof source === "object" && source !== null) {
-        const merged = Object.assign({}, target);
-        for (const key of Object.keys(source)) {
-            merged[key] = deepMerge(target[key], source[key], options);
+    if (source && typeof source === "object" && target && typeof target === "object") {
+        const result = Object.assign({}, target);
+        const sourceKeys = Object.keys(source);
+        for (let i = 0; i < sourceKeys.length; i++) {
+            const k = sourceKeys[i];
+            result[k] = deepMerge(result[k], source[k], options);
         }
-        return merged;
+        return result;
     }
     return source;
 }

package/dist/__internals/helpers/prepare.helper.d.ts

@@ -0,0 +1,11 @@
+import { Server } from "hyper-express";
+import { HyperAppMetadata, LogSpaces } from "../../decorators/types";
+/**
+ * Prepare the application with the given options.
+ *
+ * @param options
+ * @param Target
+ * @param app
+ * @param log
+ */
+export declare function prepareApplication(options: HyperAppMetadata, Target: any, app: Server, log: (space: keyof LogSpaces, message: string) => void): Promise<void>;