@zenofolio/hyper-decor 0.0.3

package/dist/__internals/utils/object.util.js

@@ -0,0 +1,72 @@
+"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.$except_slash = exports.$each = exports.$constructor = exports.$get = exports.$array = void 0;
+/**
+ * Retrieves a value from an object using a path.
+ */
+const $get = (data, name, def) => {
+    if (!data || !name)
+        return def;
+    return name.split(".").reduce((data, key) => {
+        if (Object.prototype.hasOwnProperty.call(data, key)) {
+            return data[key];
+        }
+        return def;
+    }, data);
+};
+exports.$get = $get;
+////////////////////////////////////
+// Array utilities
+////////////////////////////////////
+/**
+ * Ensures the given value is returned as an array.
+ *
+ * @param {T | T[]} value - The value to ensure as an array.
+ * @returns {T[]} - The value as an array.
+ */
+const $array = (value) => {
+    if (!value)
+        return [];
+    return Array.isArray(value) ? value : [value];
+};
+exports.$array = $array;
+/**
+ * Extract constructor from value.
+ *
+ * @param value
+ */
+const $constructor = (value) => {
+    if (typeof value === "object") {
+        return value.constructor;
+    }
+    return value;
+};
+exports.$constructor = $constructor;
+const $each = (data, callback) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!data || !data.length)
+        return [];
+    return yield Promise.all(data.map(callback));
+});
+exports.$each = $each;
+const $except_slash = (message, length = 3, middle = true) => {
+    const parts = message.split("/");
+    if (parts.length === 1)
+        return message;
+    const middleLength = Math.floor(length / 2);
+    length = length - middleLength;
+    const start = parts.slice(0, length).join("/");
+    const end = parts.slice(-length).join("/");
+    if (!middle)
+        return `${start}/.../${end}`;
+    return `${start}/.../${parts.slice(-middleLength).join("/")}`;
+};
+exports.$except_slash = $except_slash;

package/dist/__internals/utils/path.util.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Joins all given paths, removing extra slashes.
+ */
+export declare const join: (...paths: (string | null | undefined)[]) => string;

package/dist/__internals/utils/path.util.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.join = void 0;
+/**
+ * Joins all given paths, removing extra slashes.
+ */
+const join = (...paths) => paths.filter(Boolean).join("/").replace(/\/+/g, "/");
+exports.join = join;

package/dist/__internals/utils/router.d.ts

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

package/dist/__internals/utils/router.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/common/bootstrap.d.ts

@@ -0,0 +1,3 @@
+import { IHyperApp, IHyperApplication } from "../type";
+export default function createApplication<T extends IHyperApplication>(app: new (...args: any[]) => T): Promise<IHyperApp<T>>;
+export { createApplication };

package/dist/common/bootstrap.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.default = createApplication;
+exports.createApplication = createApplication;
+const tsyringe_1 = require("tsyringe");
+function createApplication(app) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const instance = tsyringe_1.container.resolve(app);
+        if (instance.prepare) {
+            yield instance.prepare();
+        }
+        (_a = instance === null || instance === void 0 ? void 0 : instance.onPrepare) === null || _a === void 0 ? void 0 : _a.call(instance);
+        return instance;
+    });
+}

package/dist/common/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./role";
+export * from "./scopes";

package/dist/common/helpers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./role"), exports);
+__exportStar(require("./scopes"), exports);

package/dist/common/helpers/role.d.ts

@@ -0,0 +1,22 @@
+import type { Request } from "hyper-express";
+import { HyperRoleOptions } from "../../type";
+/**
+ * Set role to request object
+ *
+ * @param {Request} request
+ * @param {HyperRoleOptions} role
+ */
+export declare const setRole: (request: Request, role: HyperRoleOptions | null) => void;
+/**
+ * Get list of roles from request object
+ *
+ * @param {Request} request
+ */
+export declare const getRoles: (request: Request) => string[] | undefined;
+/**
+ * Check if user has role
+ *
+ * @param {Request} request
+ * @param {string | string[]} role
+ */
+export declare const hasRole: (request: Request, role: string | string[]) => boolean;

package/dist/common/helpers/role.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasRole = exports.getRoles = exports.setRole = void 0;
+const no_conflict_1 = require("reflect-metadata/no-conflict");
+const constants_1 = require("../../constants");
+const object_util_1 = require("../../__internals/utils/object.util");
+/**
+ * Set role to request object
+ *
+ * @param {Request} request
+ * @param {HyperRoleOptions} role
+ */
+const setRole = (request, role) => {
+    if (!role) {
+        (0, no_conflict_1.deleteMetadata)(constants_1.HYPER_ROLE_KEY, request);
+        return;
+    }
+    (0, no_conflict_1.defineMetadata)(constants_1.HYPER_ROLE_KEY, (0, object_util_1.$array)(role), request);
+};
+exports.setRole = setRole;
+/**
+ * Get list of roles from request object
+ *
+ * @param {Request} request
+ */
+const getRoles = (request) => {
+    return (0, no_conflict_1.getMetadata)(constants_1.HYPER_ROLE_KEY, request);
+};
+exports.getRoles = getRoles;
+/**
+ * Check if user has role
+ *
+ * @param {Request} request
+ * @param {string | string[]} role
+ */
+const hasRole = (request, role) => {
+    const roles = (0, exports.getRoles)(request);
+    if (!roles) {
+        return false;
+    }
+    return (0, object_util_1.$array)(role).every((r) => roles.includes(r));
+};
+exports.hasRole = hasRole;

package/dist/common/helpers/scopes.d.ts

@@ -0,0 +1,23 @@
+import type { Request } from "hyper-express";
+import { HyperScopeOptions } from "../../type";
+/**
+ * Set scopes to request object
+ *
+ * @param request
+ * @param scopes
+ */
+export declare const setScopes: (request: Request, scopes: HyperScopeOptions | null) => void;
+/**
+ * Get list of scopes from request object
+ *
+ * @param request
+ */
+export declare const getScopes: (request: Request) => string[] | undefined;
+/**
+ * Check if request has required scopes
+ *
+ * @param request
+ * @param scopes
+ * @returns
+ */
+export declare const hasScopes: (request: Request, scopes: HyperScopeOptions) => boolean;

package/dist/common/helpers/scopes.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasScopes = exports.getScopes = exports.setScopes = void 0;
+const no_conflict_1 = require("reflect-metadata/no-conflict");
+const constants_1 = require("../../constants");
+const object_util_1 = require("../../__internals/utils/object.util");
+/**
+ * Set scopes to request object
+ *
+ * @param request
+ * @param scopes
+ */
+const setScopes = (request, scopes) => {
+    if (!scopes) {
+        (0, no_conflict_1.deleteMetadata)(constants_1.HYPER_SCOPES_KEY, request);
+        return;
+    }
+    (0, no_conflict_1.defineMetadata)(constants_1.HYPER_SCOPES_KEY, (0, object_util_1.$array)(scopes), request);
+};
+exports.setScopes = setScopes;
+/**
+ * Get list of scopes from request object
+ *
+ * @param request
+ */
+const getScopes = (request) => {
+    if (!(0, no_conflict_1.hasOwnMetadata)(constants_1.HYPER_SCOPES_KEY, request)) {
+        return undefined;
+    }
+    return (0, no_conflict_1.getMetadata)(constants_1.HYPER_SCOPES_KEY, request);
+};
+exports.getScopes = getScopes;
+/**
+ * Check if request has required scopes
+ *
+ * @param request
+ * @param scopes
+ * @returns
+ */
+const hasScopes = (request, scopes) => {
+    const requestScopes = (0, exports.getScopes)(request);
+    if (!requestScopes) {
+        return false;
+    }
+    return (0, object_util_1.$array)(scopes).every((scope) => requestScopes.includes(scope));
+};
+exports.hasScopes = hasScopes;

package/dist/common/openapi/collect-class-data.d.ts

@@ -0,0 +1,21 @@
+import "reflect-metadata";
+/**
+ * Options to customize class metadata extraction.
+ */
+interface ClassDataOptions {
+    includePrivateMethods?: boolean;
+    methodOptions?: Record<string, any>;
+}
+/**
+ * Extracts metadata from a class, including methods and OpenAPI data.
+ *
+ * @param Target - The class constructor.
+ * @param options - Options for metadata extraction.
+ * @returns Object containing class metadata and method details.
+ */
+export declare function collectClassData(Target: new (...args: any[]) => any, options?: ClassDataOptions): {
+    className: string;
+    methods: Record<string, any>;
+    staticMethods: Record<string, any>;
+};
+export {};

package/dist/common/openapi/collect-class-data.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectClassData = collectClassData;
+require("reflect-metadata");
+const collect_function_data_1 = require("./collect-function-data");
+/**
+ * Extracts metadata from a class, including methods and OpenAPI data.
+ *
+ * @param Target - The class constructor.
+ * @param options - Options for metadata extraction.
+ * @returns Object containing class metadata and method details.
+ */
+function collectClassData(Target, options = {}) {
+    if (typeof Target !== "function") {
+        throw new Error("Target must be a class constructor.");
+    }
+    const prototype = Target.prototype;
+    const className = Target.name;
+    // Get method names
+    const allMethods = Object.getOwnPropertyNames(prototype).filter((name) => typeof prototype[name] === "function" && name !== "constructor");
+    // Get static methods
+    const staticMethods = Object.getOwnPropertyNames(Target).filter((name) => typeof Target[name] === "function");
+    // Filter private methods (if not included)
+    const isPrivate = (name) => name.startsWith("_");
+    const methods = options.includePrivateMethods
+        ? allMethods
+        : allMethods.filter((m) => !isPrivate(m));
+    // Extract metadata for each method
+    const methodsData = methods.reduce((acc, methodName) => {
+        var _a;
+        acc[methodName] = (0, collect_function_data_1.collectFunctionData)(prototype[methodName], ((_a = options.methodOptions) === null || _a === void 0 ? void 0 : _a[methodName]) || {});
+        return acc;
+    }, {});
+    // Extract metadata for static methods
+    const staticMethodsData = staticMethods.reduce((acc, methodName) => {
+        var _a;
+        acc[methodName] = (0, collect_function_data_1.collectFunctionData)(Target[methodName], ((_a = options.methodOptions) === null || _a === void 0 ? void 0 : _a[methodName]) || {});
+        return acc;
+    }, {});
+    return {
+        className,
+        methods: methodsData,
+        staticMethods: staticMethodsData,
+    };
+}

package/dist/common/openapi/collect-function-data.d.ts

@@ -0,0 +1,32 @@
+type OpenAPIParamLocation = "query" | "path" | "body";
+type OpenAPIType = "string" | "number" | "boolean" | "object" | "array" | "any";
+/**
+ * Options to customize OpenAPI metadata extraction.
+ */
+interface FunctionDataOptions {
+    paramLocation?: OpenAPIParamLocation;
+    paramDescriptions?: Record<string, string>;
+    responseDescriptions?: Record<number, string>;
+    responseSchemas?: Record<number, any>;
+}
+/**
+ * Extracts function metadata and adapts it for OpenAPI documentation.
+ *
+ * @param Target - The function to analyze.
+ * @param options - Customization options for OpenAPI extraction.
+ * @returns An object formatted for OpenAPI documentation.
+ */
+export declare function collectFunctionData(Target: (...args: any[]) => any, options?: FunctionDataOptions): {
+    operationId: string;
+    parameters: {
+        name: string;
+        in: OpenAPIParamLocation;
+        required: boolean;
+        description: string;
+        schema: {
+            type: OpenAPIType;
+        };
+    }[];
+    responses: Record<number, any>;
+};
+export {};

package/dist/common/openapi/collect-function-data.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectFunctionData = collectFunctionData;
+const constants_1 = require("../../__internals/constants");
+const function_util_1 = require("../../__internals/utils/function.util");
+/**
+ * Maps TypeScript types to OpenAPI-compatible types.
+ */
+const mapTypeToOpenAPI = (type) => {
+    if (!type)
+        return "any";
+    const typeMap = {
+        String: "string",
+        Number: "number",
+        Boolean: "boolean",
+        Object: "object",
+        Array: "array",
+    };
+    return type.name === "Array" ? "array" : typeMap[type.name] || "any";
+};
+/**
+ * Formats the response schema for OpenAPI.
+ */
+const formatResponseSchema = (type, description = "Successful response") => ({
+    description,
+    content: {
+        "application/json": {
+            schema: { type: mapTypeToOpenAPI(type) },
+        },
+    },
+});
+/**
+ * Extracts function metadata and adapts it for OpenAPI documentation.
+ *
+ * @param Target - The function to analyze.
+ * @param options - Customization options for OpenAPI extraction.
+ * @returns An object formatted for OpenAPI documentation.
+ */
+function collectFunctionData(Target, options = {}) {
+    var _a;
+    if (typeof Target !== "function") {
+        throw new Error("Target must be a function.");
+    }
+    // Extract metadata
+    const paramTypes = Reflect.getMetadata(constants_1.DESIGN_PARAMTYPES, Target) || [];
+    const paramNames = (_a = (0, function_util_1.extreactArgsNames)(Target)) !== null && _a !== void 0 ? _a : [];
+    const returnType = Reflect.getMetadata(constants_1.DESIGN_RETURNTYPE, Target);
+    // Default locations and descriptions
+    const { paramLocation = "query", paramDescriptions = {}, responseDescriptions = { 200: "Successful response" }, responseSchemas = {}, } = options;
+    // Build OpenAPI parameters
+    const parameters = paramNames.map((name, index) => ({
+        name,
+        in: paramLocation,
+        required: true,
+        description: paramDescriptions[name] || `Parameter ${name}`,
+        schema: { type: mapTypeToOpenAPI(paramTypes[index]) },
+    }));
+    // Build OpenAPI responses
+    const responses = {};
+    Object.entries(responseDescriptions).forEach(([statusCode, description]) => {
+        const code = Number(statusCode);
+        responses[code] =
+            responseSchemas[code] || formatResponseSchema(returnType, description);
+    });
+    return {
+        operationId: Target.name || "anonymous",
+        parameters,
+        responses,
+    };
+}

package/dist/common/openapi/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./collect-class-data";
+export * from "./collect-function-data";

package/dist/common/openapi/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./collect-class-data"), exports);
+__exportStar(require("./collect-function-data"), exports);

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const HYPER_SCOPES_KEY = "__HYPER_SCOPES_KEY";
+export declare const HYPER_ROLE_KEY = "__HYPER_ROLE_KEY";
+export declare const HYPER_PASS_KEY = "__HYPER_PASS_KEY";

package/dist/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HYPER_PASS_KEY = exports.HYPER_ROLE_KEY = exports.HYPER_SCOPES_KEY = void 0;
+exports.HYPER_SCOPES_KEY = "__HYPER_SCOPES_KEY";
+exports.HYPER_ROLE_KEY = "__HYPER_ROLE_KEY";
+exports.HYPER_PASS_KEY = "__HYPER_PASS_KEY";

package/dist/decorators/File.d.ts

@@ -0,0 +1,65 @@
+import { Request } from "hyper-express";
+/**
+ * File upload restrictions
+ *
+ * @param allowedMimeTypes Allowed MIME types
+ * @param maxFileSize Maximum file size in bytes
+ *
+ */
+export interface FileUplopadRestrictions {
+    allowedMimeTypes: string[];
+    maxFileSize: number;
+}
+/**
+ * File restrictions resolver
+ *
+ * @param request Request object
+ * @returns File restrictions
+ *
+ */
+export type FileRestrictions = FileUplopadRestrictions | ((request: Request) => FileUplopadRestrictions | Promise<FileUplopadRestrictions>);
+/**
+ * File decorator options
+ *
+ * @param fieldName Field name to extract from the request
+ * @param restrictions File restrictions
+ * @param required If the file is required
+ *
+ *
+ */
+export interface FileOptions {
+    fieldName: string | string[];
+    restrictions?: FileRestrictions;
+    required?: boolean;
+}
+export interface UploadedFile {
+    name: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+    ext: string;
+    buffer: Buffer;
+}
+/**
+ * Decorator to extract file from the request
+ *
+ * @param param0
+ */
+export declare const File: {
+    (options: FileOptions | string): ParameterDecorator;
+    /**
+     *
+     * Helper function to create a file decorator with options
+     *
+     * @param options
+     * @returns
+     */
+    options(options: FileOptions, required?: boolean): (fieldName: string | string[]) => ParameterDecorator;
+    /**
+     * Helper function to create a file decorator with restrictions
+     *
+     * @param restrictions
+     * @returns
+     */
+    restrictions(restrictions: FileRestrictions): (fieldName: string | string[], required?: boolean) => ParameterDecorator;
+};