@zenofolio/hyper-decor 1.0.71 → 1.0.73

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

@@ -1,4 +1,13 @@
 "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());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -7,49 +16,158 @@ exports.default = createParamDecorator;
 require("reflect-metadata");
 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.
- *
- * @param {keyof Request | ByPassKeys} key - The key to extract from the request.
- * @param {IParamsResolver} resolver - Resolver function to handle the parameter.
- * @returns {ParameterDecorator} - The parameter decorator function.
- */
-function createParamDecorator(key, decoratorName, resolver, schema, isWholeSource) {
-    const _key = key;
+const object_util_1 = require("../utils/object.util");
+const transform_registry_1 = require("../transform/transform.registry");
+const identitySelector = (value) => value;
+const identityTransformer = (value) => value;
+function createParamDecorator(sourceKey, decoratorName, keyOrSchema, schemaOrTransform, isWholeSource = false) {
+    const _sourceKey = sourceKey;
     return (0, decorator_base_1.DecoratorHelper)({
         type: constants_1.KEY_TYPE_CONTROLLER,
         key: constants_1.KEY_PARAMS_PARAM,
         options: (options, Target, propertyKey, parameterIndex) => {
-            const { isProperty } = (0, who_helper_1.default)(Target, propertyKey, parameterIndex);
-            if (!isProperty)
-                throw new WrongPlaceException_1.default(decoratorName, "parameter", `${Target.constructor.name}.${propertyKey}`, Target);
+            const isProperty = typeof parameterIndex === "number";
+            if (!isProperty) {
+                throw new WrongPlaceException_1.default(decoratorName, "parameter", `${Target.constructor.name}.${String(propertyKey)}`, Target);
+            }
             const saved = options !== null && options !== void 0 ? options : { params: {} };
-            const names = (0, function_util_1.extractArgsNames)(Target[propertyKey]);
+            const method = Target[propertyKey];
+            const names = (0, function_util_1.extractArgsNames)(method);
             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];
+            let key = undefined;
+            let inputSchemaOrFn = undefined;
+            let wholeSource = isWholeSource;
+            if (typeof keyOrSchema === "string") {
+                key = keyOrSchema;
+                inputSchemaOrFn = schemaOrTransform;
+            }
+            else if (keyOrSchema !== undefined) {
+                inputSchemaOrFn = keyOrSchema;
+                wholeSource = true;
+            }
+            const hasKey = key !== undefined && key !== "";
+            const hasTransform = inputSchemaOrFn !== undefined;
+            const extractor = createExtractor(_sourceKey);
+            const selector = createSelector(key);
+            const transformer = createTransformer(inputSchemaOrFn, _sourceKey, wholeSource);
+            const resolver = composeResolver(extractor, selector, transformer, hasKey, hasTransform);
             if (name && saved) {
-                if (!saved.params[propertyKey]) {
-                    saved.params[propertyKey] = [];
+                let methodParams = saved.params[propertyKey];
+                if (!methodParams) {
+                    methodParams = saved.params[propertyKey] = [];
                 }
-                saved.params[propertyKey].push({
+                methodParams.push({
                     name,
                     type,
                     index: parameterIndex,
-                    key: _key,
+                    key: _sourceKey,
                     method: propertyKey.toString(),
                     resolver,
-                    schema,
-                    isWholeSource,
+                    schema: inputSchemaOrFn,
+                    isWholeSource: wholeSource,
                 });
-                // sort by index
-                saved.params[propertyKey].sort((a, b) => a.index - b.index);
-                Reflect.defineMetadata(constants_1.KEY_PARAMS_PARAM, saved, Target[propertyKey]);
+                if (methodParams.length > 1) {
+                    methodParams.sort((a, b) => a.index - b.index);
+                }
+                Reflect.defineMetadata(constants_1.KEY_PARAMS_PARAM, saved, method);
             }
             return saved;
         },
     });
 }
+//////////////////////////
+/// Functions
+/////////////////////////
+function createBodyExtractor() {
+    return (req) => __awaiter(this, void 0, void 0, function* () {
+        const request = req;
+        const cachedBody = request.body;
+        if (cachedBody !== undefined) {
+            return cachedBody;
+        }
+        const body = yield req.json();
+        request.body = body;
+        return body;
+    });
+}
+function createReqExtractor() {
+    return (req) => __awaiter(this, void 0, void 0, function* () { return req; });
+}
+function createResExtractor() {
+    return (_req, res) => __awaiter(this, void 0, void 0, function* () { return res; });
+}
+function createGenericExtractor(sourceKey) {
+    return (req) => __awaiter(this, void 0, void 0, function* () { return req[sourceKey]; });
+}
+function createExtractor(sourceKey) {
+    switch (sourceKey) {
+        case "body":
+            return createBodyExtractor();
+        case "req":
+            return createReqExtractor();
+        case "res":
+            return createResExtractor();
+        default:
+            return createGenericExtractor(sourceKey);
+    }
+}
+function createSelector(key) {
+    if (key === undefined || key === "") {
+        return identitySelector;
+    }
+    return (value) => (0, object_util_1.$get)(value, key, value);
+}
+function createDirectTransformer(fn) {
+    return (value) => fn(value);
+}
+function createRegistryTransformer(schema, sourceKey, isWholeSource) {
+    const options = { isWholeSource };
+    const from = sourceKey;
+    return (value, req, res) => transform_registry_1.transformRegistry.resolve({
+        data: value,
+        schema,
+        options,
+        req,
+        res,
+        from,
+    });
+}
+function createTransformer(inputSchemaOrFn, sourceKey, isWholeSource) {
+    if (inputSchemaOrFn === undefined) {
+        return identityTransformer;
+    }
+    if (typeof inputSchemaOrFn === "function" &&
+        inputSchemaOrFn.prototype === undefined) {
+        return createDirectTransformer(inputSchemaOrFn);
+    }
+    if (typeof inputSchemaOrFn === "function" ||
+        typeof inputSchemaOrFn === "string") {
+        return createRegistryTransformer(inputSchemaOrFn, sourceKey, isWholeSource);
+    }
+    return identityTransformer;
+}
+function composeResolver(extractor, selector, transformer, hasKey, hasTransform) {
+    if (!hasKey && !hasTransform) {
+        return extractor;
+    }
+    if (hasKey && !hasTransform) {
+        return (req, res) => __awaiter(this, void 0, void 0, function* () {
+            const value = yield extractor(req, res);
+            return selector(value);
+        });
+    }
+    if (!hasKey && hasTransform) {
+        return (req, res) => __awaiter(this, void 0, void 0, function* () {
+            const value = yield extractor(req, res);
+            return transformer(value, req, res);
+        });
+    }
+    return (req, res) => __awaiter(this, void 0, void 0, function* () {
+        const value = yield extractor(req, res);
+        return transformer(selector(value), req, res);
+    });
+}

package/dist/__internals/helpers/merge-metadata.d.ts

@@ -1,5 +1,4 @@
-import "reflect-metadata";
-type MetadataKey = string | symbol;
+import { HyperCommonMetadata } from "../types";
 type MergeOptions = {
     overwriteArrays?: boolean;
 };
@@ -10,5 +9,5 @@ type MergeOptions = {
  * @param keys Metadata keys to merge.
  * @param options Merge options (e.g., array handling).
  */
-export declare function mergeMetadata(target: any, source: any, keys: MetadataKey[], options?: MergeOptions): void;
+export declare function mergeMetadata(target: object, source: object, keys: (keyof HyperCommonMetadata)[], options?: MergeOptions): void;
 export {};

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

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeMetadata = mergeMetadata;
-require("reflect-metadata");
+const meta_store_1 = require("../stores/meta.store");
+/**
+ * Perform a clean merge of prefixes
+ */
+const HyperMeta = meta_store_1.Metadata.prefix('server');
 /**
  * Performs a deep merge of metadata from source to target using reflect-metadata.
  * @param target Object where the metadata will be merged.
@@ -10,13 +14,32 @@ require("reflect-metadata");
  * @param options Merge options (e.g., array handling).
  */
 function mergeMetadata(target, source, keys, options = {}) {
+    const sourceRoot = meta_store_1.Metadata.get(source);
+    const targetRoot = meta_store_1.Metadata.get(target);
+    const sourceServer = sourceRoot.server;
+    if (!sourceServer)
+        return;
+    const sourceCommon = sourceServer.common;
+    const targetServer = targetRoot.server || (targetRoot.server = { common: { type: 'controller' }, methods: {} });
+    const targetCommon = targetServer.common;
     for (let i = 0; i < keys.length; i++) {
         const key = keys[i];
-        const sourceMeta = Reflect.getMetadata(key, source);
-        if (sourceMeta === undefined)
+        const value = sourceCommon[key]; // Narrowing complex union access
+        if (value === undefined)
             continue;
-        const targetMeta = Reflect.getMetadata(key, target);
-        Reflect.defineMetadata(key, targetMeta === undefined ? sourceMeta : deepMerge(targetMeta, sourceMeta, options), target);
+        const current = targetCommon[key];
+        const merged = current === undefined
+            ? value
+            : deepMerge(current, value, options);
+        targetCommon[key] = merged;
+    }
+    // Also merge methods if they exist to preserve routes/params when extending
+    if (sourceServer.methods) {
+        const sourceMethods = sourceServer.methods;
+        const targetMethods = targetServer.methods || (targetServer.methods = {});
+        Object.keys(sourceMethods).forEach(methodKey => {
+            targetMethods[methodKey] = deepMerge(targetMethods[methodKey] || {}, sourceMethods[methodKey], options);
+        });
     }
 }
 function deepMerge(target, source, options) {
@@ -29,10 +52,11 @@ function deepMerge(target, source, options) {
     }
     if (source && typeof source === "object" && target && typeof target === "object") {
         const result = Object.assign({}, target);
-        const sourceKeys = Object.keys(source);
+        const sourceObj = source;
+        const sourceKeys = Object.keys(sourceObj);
         for (let i = 0; i < sourceKeys.length; i++) {
             const k = sourceKeys[i];
-            result[k] = deepMerge(result[k], source[k], options);
+            result[k] = deepMerge(result[k], sourceObj[k], options);
         }
         return result;
     }

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

@@ -1,11 +1,5 @@
+import "reflect-metadata";
 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>;
+import { Constructor, HyperAppMetadata, LogSpaces } from "../../lib/server/decorators/types";
+export declare function registerInstanceHandlers(instance: object, target: Constructor, namespace: string, log: (space: keyof LogSpaces, message: string) => void): Promise<void>;
+export declare function prepareApplication(options: HyperAppMetadata, Target: Constructor, log: (space: keyof LogSpaces, message: string) => void): Promise<Server>;