@zenofolio/hyper-decor 0.0.3 → 1.0.7

package/dist/decorators/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./HyperApp"), exports);
 __exportStar(require("./HyperModule"), exports);
 __exportStar(require("./HyperController"), exports);
+__exportStar(require("./HyperService"), exports);
 __exportStar(require("./Middleware"), exports);
 __exportStar(require("./Scope"), exports);
 __exportStar(require("./Role"), exports);
@@ -25,3 +26,5 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./Http"), exports);
 __exportStar(require("./Pass"), exports);
 __exportStar(require("./File"), exports);
+__exportStar(require("./Messaging"), exports);
+__exportStar(require("./Output"), exports);

package/dist/decorators/types.d.ts

@@ -1,13 +1,35 @@
-import type { MiddlewareHandler, Request, Response, ServerConstructorOptions } from "hyper-express";
+import type { MiddlewareHandler, MiddlewareNext, Request, Response, ServerConstructorOptions } from "hyper-express";
+import { InjectionToken, RegistrationOptions } from "tsyringe";
+import { IMessageTransport } from "../common/transport";
+export interface OnInit {
+    onInit(): Promise<any>;
+}
+export interface IsSingleton {
+    isSingleton(): boolean;
+}
 export type Constructor<R extends any = any> = new (...args: any[]) => R;
+export type ImportObject = {
+    token: InjectionToken;
+    useClass?: Constructor;
+    useValue?: any;
+    useFactory?: (...args: any[]) => any;
+    useToken?: InjectionToken;
+    options?: RegistrationOptions;
+};
+export type ImportType = Constructor<Partial<OnInit> & Partial<IsSingleton>> | InjectionToken | ImportObject;
 export type ConstructorDecorator = (target: Constructor, kay?: any, descriptor?: PropertyDescriptor) => Constructor;
 export type HyperClassDecorator<T> = (options?: T) => ConstructorDecorator;
 export type HyperMethodDecorator<T> = (options?: T) => (target: any, key?: any, descriptor?: PropertyDescriptor) => void;
 export interface LogSpaces {
+    modules: boolean;
     controllers: boolean;
     middleware: boolean;
     routes: boolean;
 }
+export interface IHyperHooks {
+    onBeforeInit?(instance: any, token: any, context: any): void | Promise<void>;
+    onAfterInit?(instance: any, token: any, context: any): void | Promise<void>;
+}
 export interface HyperAppMetadata {
     name?: string;
     version?: string;
@@ -16,31 +38,35 @@ export interface HyperAppMetadata {
     license?: string;
     prefix?: string;
     logger?: (...args: any[]) => void;
-    logs?: LogSpaces;
+    logs?: Partial<LogSpaces>;
     modules: Constructor[];
-    imports?: Constructor[];
+    imports?: ImportType[];
     options?: ServerConstructorOptions;
+    transports?: IMessageTransport[];
+    hooks?: IHyperHooks | Constructor<IHyperHooks>;
+}
+export interface HyperAppDecorator {
+    (options?: HyperAppMetadata): (target: Constructor) => Constructor;
 }
-export type HyperAppDecorator = (options?: HyperAppMetadata) => (target: Constructor) => Constructor;
 export type HyperModuleMetadata = {
-    path: string;
+    path?: string;
     name?: string;
     roles?: string[];
     scopes?: string[];
     modules?: Constructor[];
     controllers?: Constructor[];
-    imports?: Constructor[];
+    imports?: ImportType[];
 };
 export type HyperModuleDecorator = HyperClassDecorator<HyperModuleMetadata>;
 export type HyperControllerMetadata = {
     path?: string;
     roles?: string[];
     scopes?: string[];
-    imports?: Constructor[];
+    imports?: ImportType[];
 };
 export type HyperControllerDecorator = HyperClassDecorator<HyperControllerMetadata | string>;
 export type ParameterResolver = (req: Request, res: Response) => any | Promise<any>;
-export type HyperParamerMetadata = {
+export type HyperParameterMetadata = {
     params: Record<string, {
         index: number;
         type: any;
@@ -48,6 +74,8 @@ export type HyperParamerMetadata = {
         name: string;
         method: string;
         resolver: ParameterResolver;
+        schema?: any;
+        isWholeSource?: boolean;
     }[]>;
 };
 export type HyperParamDecorator = (key: string) => (target: any, key: string, index: number) => void;
@@ -61,7 +89,7 @@ export type RoleMap<T> = {
  * It can accept a single role, an array of roles, or a function that evaluates roles dynamically.
  */
 export type RoleType<T extends string = string> = T | T[] | RoleMap<T> | RoleMap<T>[];
-export type ScopeMap<T> = {
+export type ScopeMap<T extends string = string> = {
     scope: T;
     description: string;
     message?: string;
@@ -80,10 +108,17 @@ export interface RouteMetadata {
     method: string;
     path: string;
     propertyKey: string;
+    options?: any;
     handler: (...args: any[]) => any;
 }
+export declare abstract class MiddlewareClass {
+    abstract handle(req: Request, res: Response, next: MiddlewareNext): void;
+}
+export interface MiddlewareClassConstructor {
+    new (...args: any[]): MiddlewareClass;
+}
 /**
  * Type definition for Middleware.
  * Middleware can be a single handler or an array of handlers.
  */
-export type MiddlewareType = MiddlewareHandler | MiddlewareHandler[];
+export type MiddlewareType = MiddlewareHandler | MiddlewareClassConstructor;

package/dist/decorators/types.js

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

package/dist/extension.js

@@ -18,6 +18,9 @@ const requestMethods = {
     setScopes(scopes) {
         (0, helpers_1.setScopes)(this, scopes);
     },
+    setFullScopes() {
+        (0, helpers_1.setScopes)(this, ["*"]);
+    },
     hasScopes(scopes) {
         return (0, helpers_1.hasScopes)(this, scopes);
     },
@@ -25,8 +28,14 @@ const requestMethods = {
         return (0, helpers_1.getScopes)(this);
     },
     setRoleScopes(role, scopes) {
-        this.setRole(role);
-        this.setScopes(scopes);
+        (0, helpers_1.setRole)(this, role);
+        (0, helpers_1.setScopes)(this, scopes);
+    },
+    setValue(key, value) {
+        (0, helpers_1.setValue)(this, key, value);
+    },
+    getValue(key, defaultValue) {
+        return (0, helpers_1.getValue)(this, key, defaultValue);
     },
 };
 /////////////////////////////

package/dist/index.d.ts

@@ -3,7 +3,13 @@ export * from "./constants";
 export * from "./extension";
 export * from "./decorators";
 export * from "./common/helpers";
+export * from "./__internals/helpers/tree.helper";
 export * from "./common/bootstrap";
 export * from "hyper-express";
 export * from "tsyringe";
+export * from "./stores";
 export * from "./type";
+export * from "./common/transport";
+export * from "./common/message-bus";
+export * from "./__internals/transform/transform.registry";
+export * from "./lib/openapi";

package/dist/index.js

@@ -19,7 +19,13 @@ __exportStar(require("./constants"), exports);
 __exportStar(require("./extension"), exports);
 __exportStar(require("./decorators"), exports);
 __exportStar(require("./common/helpers"), exports);
+__exportStar(require("./__internals/helpers/tree.helper"), exports);
 __exportStar(require("./common/bootstrap"), exports);
 __exportStar(require("hyper-express"), exports);
 __exportStar(require("tsyringe"), exports);
+__exportStar(require("./stores"), exports);
 __exportStar(require("./type"), exports);
+__exportStar(require("./common/transport"), exports);
+__exportStar(require("./common/message-bus"), exports);
+__exportStar(require("./__internals/transform/transform.registry"), exports);
+__exportStar(require("./lib/openapi"), exports);

package/dist/lib/openapi/collectors/class.collector.d.ts

@@ -0,0 +1,9 @@
+import "reflect-metadata";
+import { Tag, SecurityRequirement, Operation } from "../types";
+export declare function collectClassMetadata(target: any): {
+    tags: Tag[];
+    security: SecurityRequirement[];
+    methods: {
+        [methodName: string]: Operation;
+    };
+};

package/dist/lib/openapi/collectors/class.collector.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectClassMetadata = collectClassMetadata;
+require("reflect-metadata");
+const constants_1 = require("../constants");
+const method_collector_1 = require("./method.collector");
+const function_util_1 = require("../../../__internals/utils/function.util");
+const metadata_registry_1 = require("../metadata.registry");
+function collectClassMetadata(target) {
+    var _a;
+    const prototype = Reflect.getPrototypeOf(target);
+    const constructor = prototype === null || prototype === void 0 ? void 0 : prototype.constructor;
+    const name = target.name || (constructor === null || constructor === void 0 ? void 0 : constructor.name) || ((_a = target === null || target === void 0 ? void 0 : target.constructor) === null || _a === void 0 ? void 0 : _a.name);
+    // Extraemos las metadata de la clase
+    let tags = Reflect.getMetadata(constants_1.TAGS, target) || [];
+    let security = Reflect.getMetadata(constants_1.SECURITY, target) || [];
+    // Invoke custom class collectors
+    metadata_registry_1.openApiRegistry.getCollectors("class").forEach(collector => {
+        const data = collector(target);
+        if (data === null || data === void 0 ? void 0 : data.tags)
+            tags = [...tags, ...data.tags];
+        if (data === null || data === void 0 ? void 0 : data.security)
+            security = [...security, ...data.security];
+    });
+    // Si no tenemos tags, intentamos inferirlos
+    if (tags.length === 0) {
+        tags.push({ name });
+    }
+    // Si no tenemos seguridad, intentamos asignar un valor predeterminado
+    if (security.length === 0) {
+        security.push({ bearerAuth: [] });
+    }
+    // Obtenemos todos los métodos de la clase
+    const methodNames = Object.getOwnPropertyNames(target.prototype || {}).filter((method) => method !== "constructor");
+    // Creamos una lista con la metadata de cada uno de los métodos
+    const methods = {};
+    methodNames.forEach((methodName) => {
+        let methodMetadata = (0, method_collector_1.collectMethodMetadata)(target.prototype, methodName);
+        // Invoke custom method collectors
+        metadata_registry_1.openApiRegistry.getCollectors("method").forEach(collector => {
+            const data = collector(target.prototype, methodName);
+            methodMetadata = Object.assign(Object.assign({}, methodMetadata), data);
+        });
+        // Si el método no tiene parámetros definidos, intentamos inferirlos
+        if (!methodMetadata.parameters || methodMetadata.parameters.length === 0) {
+            const methodParams = (0, function_util_1.extractArgsNames)(target.prototype[methodName]);
+            methodParams === null || methodParams === void 0 ? void 0 : methodParams.forEach((paramName, index) => {
+                const inferredParam = {
+                    name: paramName || `param${index}`,
+                    in: "query",
+                    required: true,
+                    schema: {
+                        type: "string",
+                    },
+                };
+                methodMetadata.parameters || (methodMetadata.parameters = []);
+                methodMetadata.parameters.push(inferredParam);
+            });
+        }
+        methods[methodName] = methodMetadata;
+    });
+    return {
+        tags,
+        security,
+        methods,
+    };
+}

package/dist/lib/openapi/collectors/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./class.collector";
+export * from "./method.collector";
+export * from "./param.collector";
+export * from "./schema.collector";

package/dist/lib/openapi/collectors/index.js

@@ -0,0 +1,20 @@
+"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("./class.collector"), exports);
+__exportStar(require("./method.collector"), exports);
+__exportStar(require("./param.collector"), exports);
+__exportStar(require("./schema.collector"), exports);

package/dist/lib/openapi/collectors/method.collector.d.ts

@@ -0,0 +1,2 @@
+import { Operation } from '../types';
+export declare function collectMethodMetadata(target: any, methodName: string): Operation;

package/dist/lib/openapi/collectors/method.collector.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectMethodMetadata = collectMethodMetadata;
+const constants_1 = require("../constants");
+const param_collector_1 = require("./param.collector");
+const constants_2 = require("../../../__internals/constants");
+const transform_registry_1 = require("../../../__internals/transform/transform.registry");
+function collectMethodMetadata(target, methodName) {
+    const methodMetadata = {};
+    // Extraemos la metadata del método
+    const summary = Reflect.getMetadata(constants_1.METHOD_SUMMARY, target, methodName);
+    const operationId = Reflect.getMetadata(constants_1.METHOD_OPERATION_ID, target, methodName);
+    const tags = Reflect.getMetadata(constants_1.METHOD_TAGS, target, methodName);
+    const security = Reflect.getMetadata(constants_1.SECURITY, target, methodName);
+    // Extraemos las respuestas del método
+    const responses = Reflect.getMetadata(constants_1.RESPONSES, target, methodName) || {};
+    // Extraemos los parámetros del método
+    const parameters = (0, param_collector_1.collectParameterMetadata)(target, methodName);
+    // Extraemos la información del cuerpo de la solicitud
+    const requestBody = {
+        description: Reflect.getMetadata(constants_1.REQUEST_BODY_DESCRIPTION, target, methodName),
+        content: Reflect.getMetadata(constants_1.REQUEST_BODY_CONTENT, target, methodName),
+    };
+    // Bridge @Body to OpenAPI
+    const hyperParams = Reflect.getMetadata(constants_2.KEY_PARAMS_PARAM, target[methodName]);
+    if (hyperParams && hyperParams.params[methodName]) {
+        const bodyParam = hyperParams.params[methodName].find(p => ['body', 'BODY', 'req'].includes(p.key));
+        if (bodyParam) {
+            const targetSchema = bodyParam.schema;
+            if (targetSchema) {
+                const bodySchema = transform_registry_1.transformRegistry.getOpenApiSchema(targetSchema);
+                if (bodySchema) {
+                    requestBody.content = requestBody.content || {};
+                    requestBody.content['application/json'] = {
+                        schema: bodySchema
+                    };
+                }
+            }
+        }
+    }
+    // Bridging @Output / return type to OpenAPI
+    const outputSchema = Reflect.getMetadata(constants_2.KEY_OUTPUT_SCHEMA, target, methodName)
+        || Reflect.getMetadata(constants_2.DESIGN_RETURNTYPE, target, methodName);
+    if (outputSchema && outputSchema !== Object && outputSchema !== Promise) {
+        const schema = transform_registry_1.transformRegistry.getOpenApiSchema(outputSchema);
+        if (schema) {
+            responses['200'] = responses['200'] || { description: 'Success' };
+            responses['200'].content = responses['200'].content || {};
+            responses['200'].content['application/json'] = { schema };
+        }
+    }
+    // Asignamos las propiedades al objeto de metadata solo si existen
+    if (summary)
+        methodMetadata.summary = summary;
+    if (operationId)
+        methodMetadata.operationId = operationId;
+    if (tags)
+        methodMetadata.tags = tags;
+    if (security)
+        methodMetadata.security = security;
+    if (responses && Object.keys(responses).length > 0)
+        methodMetadata.responses = responses;
+    if (parameters.length > 0)
+        methodMetadata.parameters = parameters;
+    if (requestBody.content)
+        methodMetadata.requestBody = requestBody;
+    return methodMetadata;
+}

package/dist/lib/openapi/collectors/param.collector.d.ts

@@ -0,0 +1,2 @@
+import { OpenApiParameter } from "../types";
+export declare function collectParameterMetadata(target: any, methodName: string): OpenApiParameter[];

package/dist/lib/openapi/collectors/param.collector.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectParameterMetadata = collectParameterMetadata;
+const constants_1 = require("../constants");
+const constants_2 = require("../../../__internals/constants");
+const transform_registry_1 = require("../../../__internals/transform/transform.registry");
+const function_util_1 = require("../../../__internals/utils/function.util");
+function collectParameterMetadata(target, methodName) {
+    const parameters = Reflect.getMetadata(constants_1.PARAMETERS, target, methodName) || [];
+    const hyperParams = Reflect.getMetadata(constants_2.KEY_PARAMS_PARAM, target[methodName]);
+    if (hyperParams && hyperParams.params[methodName]) {
+        hyperParams.params[methodName].forEach((p) => {
+            // Ignore body, req, res as they are not standard "parameters" in OpenAPI terms (body is separate)
+            if (['req', 'res', 'body', 'BODY'].includes(p.key))
+                return;
+            const locationMap = {
+                'query': 'query',
+                'params': 'path',
+                'headers': 'header',
+                'cookie': 'cookie'
+            };
+            const location = locationMap[p.key] || 'query';
+            if (p.isWholeSource && p.schema) {
+                const schema = transform_registry_1.transformRegistry.getOpenApiSchema(p.schema);
+                if (schema && schema.properties) {
+                    Object.keys(schema.properties).forEach((propKey) => {
+                        parameters.push({
+                            name: propKey,
+                            in: location,
+                            required: (schema.required || []).includes(propKey),
+                            schema: schema.properties[propKey]
+                        });
+                    });
+                }
+            }
+            else {
+                parameters.push({
+                    name: p.name,
+                    in: location,
+                    required: true, // TODO: detect optionality from design:paramtypes or metadata
+                    schema: p.schema ? transform_registry_1.transformRegistry.getOpenApiSchema(p.schema) : { type: 'string' }
+                });
+            }
+        });
+    }
+    // Fallback to design:paramtypes if no hyper-decor metadata found
+    if (parameters.length === 0) {
+        const methodParams = Reflect.getMetadata("design:paramtypes", target, methodName) || [];
+        const paramNames = (0, function_util_1.extractArgsNames)(target[methodName]);
+        methodParams.forEach((paramType, index) => {
+            var _a;
+            const name = paramNames && paramNames[index] ? paramNames[index] : `param${index}`;
+            parameters.push({
+                name,
+                in: "query",
+                required: true,
+                schema: {
+                    type: ((_a = paramType === null || paramType === void 0 ? void 0 : paramType.name) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'number' ? 'number' : 'string',
+                },
+            });
+        });
+    }
+    return parameters;
+}

package/dist/lib/openapi/collectors/schema.collector.d.ts

@@ -0,0 +1,11 @@
+import "reflect-metadata";
+import { Schema } from "../types";
+/**
+ * Collector responsible for transforming DTO classes into OpenAPI Schema objects.
+ * Uses design:type and property inspection.
+ */
+export declare function collectSchema(Target: any): Schema;
+/**
+ * Infer OpenAPI type from JavaScript constructor names.
+ */
+export declare function inferType(constructorName: string): string;

package/dist/lib/openapi/collectors/schema.collector.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectSchema = collectSchema;
+exports.inferType = inferType;
+require("reflect-metadata");
+/**
+ * Collector responsible for transforming DTO classes into OpenAPI Schema objects.
+ * Uses design:type and property inspection.
+ */
+function collectSchema(Target) {
+    if (!Target || typeof Target !== "function") {
+        return { type: "object" };
+    }
+    const schema = {
+        type: "object",
+        properties: {},
+    };
+    // Note: Standard reflect-metadata has limitations for property enumeration.
+    // In a full implementation, we might use a custom decorator or 
+    // class-transformer/class-validator if available.
+    // For now, we provide the structure to be extended.
+    return schema;
+}
+/**
+ * Infer OpenAPI type from JavaScript constructor names.
+ */
+function inferType(constructorName) {
+    const map = {
+        String: "string",
+        Number: "number",
+        Boolean: "boolean",
+        Array: "array",
+        Object: "object",
+        Date: "string", // Dates are strings in OpenAPI
+    };
+    return map[constructorName] || "string";
+}

package/dist/lib/openapi/constants.d.ts

@@ -0,0 +1,46 @@
+export declare const OPENAPI_VERSION = "3.0.0";
+export declare const INFO_TITLE = "openapi:info:title";
+export declare const INFO_DESCRIPTION = "openapi:info:description";
+export declare const INFO_VERSION = "openapi:info:version";
+export declare const INFO_TERMS_OF_SERVICE = "openapi:info:termsOfService";
+export declare const INFO_CONTACT = "openapi:info:contact";
+export declare const INFO_LICENSE = "openapi:info:license";
+export declare const PATHS = "openapi:paths";
+export declare const METHOD_GET = "openapi:method:get";
+export declare const METHOD_POST = "openapi:method:post";
+export declare const METHOD_PUT = "openapi:method:put";
+export declare const METHOD_DELETE = "openapi:method:delete";
+export declare const METHOD_PATCH = "openapi:method:patch";
+export declare const METHOD_HEAD = "openapi:method:head";
+export declare const METHOD_OPTIONS = "openapi:method:options";
+export declare const METHOD_TRACE = "openapi:method:trace";
+export declare const PARAMETERS = "openapi:parameters";
+export declare const PARAM_NAME = "openapi:parameter:name";
+export declare const PARAM_IN = "openapi:parameter:in";
+export declare const PARAM_REQUIRED = "openapi:parameter:required";
+export declare const PARAM_DESCRIPTION = "openapi:parameter:description";
+export declare const PARAM_SCHEMA = "openapi:parameter:schema";
+export declare const REQUEST_BODY = "openapi:requestBody";
+export declare const REQUEST_BODY_DESCRIPTION = "openapi:requestBody:description";
+export declare const REQUEST_BODY_CONTENT = "openapi:requestBody:content";
+export declare const RESPONSES = "openapi:responses";
+export declare const RESPONSE_DESCRIPTION = "openapi:response:description";
+export declare const RESPONSE_CONTENT = "openapi:response:content";
+export declare const RESPONSE_SCHEMA = "openapi:response:schema";
+export declare const SECURITY = "openapi:security";
+export declare const SECURITY_SCHEME = "openapi:security:scheme";
+export declare const TAGS = "openapi:tags";
+export declare const TAG_NAME = "openapi:tag:name";
+export declare const TAG_DESCRIPTION = "openapi:tag:description";
+export declare const METHOD_METADATA = "openapi:method:metadata";
+export declare const METHOD_SUMMARY = "openapi:method:summary";
+export declare const METHOD_OPERATION_ID = "openapi:method:operationId";
+export declare const METHOD_TAGS = "openapi:method:tags";
+export declare const COMPONENTS = "openapi:components";
+export declare const COMPONENTS_SCHEMAS = "openapi:components:schemas";
+export declare const COMPONENTS_RESPONSES = "openapi:components:responses";
+export declare const COMPONENTS_PARAMETERS = "openapi:components:parameters";
+export declare const COMPONENTS_SECURITY_SCHEMES = "openapi:components:securitySchemes";
+export declare const SECURITY_API_KEY = "openapi:security:apiKey";
+export declare const SECURITY_OAUTH2 = "openapi:security:oauth2";
+export declare const SECURITY_OIDC = "openapi:security:oidc";

package/dist/lib/openapi/constants.js

@@ -0,0 +1,61 @@
+"use strict";
+// constants.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SECURITY_OIDC = exports.SECURITY_OAUTH2 = exports.SECURITY_API_KEY = exports.COMPONENTS_SECURITY_SCHEMES = exports.COMPONENTS_PARAMETERS = exports.COMPONENTS_RESPONSES = exports.COMPONENTS_SCHEMAS = exports.COMPONENTS = exports.METHOD_TAGS = exports.METHOD_OPERATION_ID = exports.METHOD_SUMMARY = exports.METHOD_METADATA = exports.TAG_DESCRIPTION = exports.TAG_NAME = exports.TAGS = exports.SECURITY_SCHEME = exports.SECURITY = exports.RESPONSE_SCHEMA = exports.RESPONSE_CONTENT = exports.RESPONSE_DESCRIPTION = exports.RESPONSES = exports.REQUEST_BODY_CONTENT = exports.REQUEST_BODY_DESCRIPTION = exports.REQUEST_BODY = exports.PARAM_SCHEMA = exports.PARAM_DESCRIPTION = exports.PARAM_REQUIRED = exports.PARAM_IN = exports.PARAM_NAME = exports.PARAMETERS = exports.METHOD_TRACE = exports.METHOD_OPTIONS = exports.METHOD_HEAD = exports.METHOD_PATCH = exports.METHOD_DELETE = exports.METHOD_PUT = exports.METHOD_POST = exports.METHOD_GET = exports.PATHS = exports.INFO_LICENSE = exports.INFO_CONTACT = exports.INFO_TERMS_OF_SERVICE = exports.INFO_VERSION = exports.INFO_DESCRIPTION = exports.INFO_TITLE = exports.OPENAPI_VERSION = void 0;
+// OpenAPI Version
+exports.OPENAPI_VERSION = "3.0.0";
+// Info Metadata (Información general sobre la API)
+exports.INFO_TITLE = "openapi:info:title";
+exports.INFO_DESCRIPTION = "openapi:info:description";
+exports.INFO_VERSION = "openapi:info:version";
+exports.INFO_TERMS_OF_SERVICE = "openapi:info:termsOfService";
+exports.INFO_CONTACT = "openapi:info:contact";
+exports.INFO_LICENSE = "openapi:info:license";
+// Paths (Rutas de la API)
+exports.PATHS = "openapi:paths";
+exports.METHOD_GET = "openapi:method:get";
+exports.METHOD_POST = "openapi:method:post";
+exports.METHOD_PUT = "openapi:method:put";
+exports.METHOD_DELETE = "openapi:method:delete";
+exports.METHOD_PATCH = "openapi:method:patch";
+exports.METHOD_HEAD = "openapi:method:head";
+exports.METHOD_OPTIONS = "openapi:method:options";
+exports.METHOD_TRACE = "openapi:method:trace";
+// Parameters (Parámetros de los métodos)
+exports.PARAMETERS = "openapi:parameters";
+exports.PARAM_NAME = "openapi:parameter:name";
+exports.PARAM_IN = "openapi:parameter:in"; // query, header, path, cookie
+exports.PARAM_REQUIRED = "openapi:parameter:required";
+exports.PARAM_DESCRIPTION = "openapi:parameter:description";
+exports.PARAM_SCHEMA = "openapi:parameter:schema";
+// RequestBody (Cuerpo de la solicitud)
+exports.REQUEST_BODY = "openapi:requestBody";
+exports.REQUEST_BODY_DESCRIPTION = "openapi:requestBody:description";
+exports.REQUEST_BODY_CONTENT = "openapi:requestBody:content";
+// Responses (Respuestas de los métodos)
+exports.RESPONSES = "openapi:responses";
+exports.RESPONSE_DESCRIPTION = "openapi:response:description";
+exports.RESPONSE_CONTENT = "openapi:response:content";
+exports.RESPONSE_SCHEMA = "openapi:response:schema";
+// Security (Esquemas de seguridad)
+exports.SECURITY = "openapi:security";
+exports.SECURITY_SCHEME = "openapi:security:scheme"; // Esquemas de seguridad como apiKey, oauth2, etc.
+// Tags (Etiquetas de los métodos)
+exports.TAGS = "openapi:tags";
+exports.TAG_NAME = "openapi:tag:name";
+exports.TAG_DESCRIPTION = "openapi:tag:description";
+// Method Metadata (Metadatos adicionales de los métodos)
+exports.METHOD_METADATA = "openapi:method:metadata";
+exports.METHOD_SUMMARY = "openapi:method:summary";
+exports.METHOD_OPERATION_ID = "openapi:method:operationId";
+exports.METHOD_TAGS = "openapi:method:tags";
+// Components (Componentes reutilizables)
+exports.COMPONENTS = "openapi:components";
+exports.COMPONENTS_SCHEMAS = "openapi:components:schemas"; // Esquemas reutilizables de parámetros y respuestas
+exports.COMPONENTS_RESPONSES = "openapi:components:responses"; // Respuestas reutilizables
+exports.COMPONENTS_PARAMETERS = "openapi:components:parameters"; // Parámetros reutilizables
+exports.COMPONENTS_SECURITY_SCHEMES = "openapi:components:securitySchemes"; // Esquemas de seguridad reutilizables
+// Security Schemes (Esquemas de seguridad)
+exports.SECURITY_API_KEY = "openapi:security:apiKey";
+exports.SECURITY_OAUTH2 = "openapi:security:oauth2";
+exports.SECURITY_OIDC = "openapi:security:oidc"; // OpenID Connect

package/dist/lib/openapi/decorators/api-bearer-auth.decorator.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+export declare function ApiBearerAuth(name?: string): (target: any, propertyKey?: any, descriptor?: any) => void;

package/dist/lib/openapi/decorators/api-bearer-auth.decorator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiBearerAuth = ApiBearerAuth;
+require("reflect-metadata");
+const security_helper_1 = require("../helpers/security.helper");
+function ApiBearerAuth(name = 'bearerAuth') {
+    return (target, propertyKey, descriptor) => {
+        (0, security_helper_1.apiSecurity)(target, { [name]: [] }, propertyKey);
+    };
+}

package/dist/lib/openapi/decorators/api-method.decorator.d.ts

@@ -0,0 +1,3 @@
+import "reflect-metadata";
+import { Operation } from "../types";
+export declare function ApiMethod(options: Partial<Operation>): <T>(target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<T>) => any;

package/dist/lib/openapi/decorators/api-method.decorator.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiMethod = ApiMethod;
+require("reflect-metadata");
+const method_helper_1 = require("../helpers/method.helper");
+function ApiMethod(options) {
+    return (target, propertyKey, descriptor) => {
+        (0, method_helper_1.apimethod)(target, propertyKey, options);
+        return descriptor;
+    };
+}

package/dist/lib/openapi/decorators/api-parameter.decorator.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+import { OpenApiParameter } from '../types';
+export declare function ApiParameter(options: OpenApiParameter): (target: any, propertyKey: any) => void;