@zenofolio/hyper-decor 1.0.47 → 1.0.48

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

@@ -0,0 +1,19 @@
+"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);

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

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

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectMethodMetadata = collectMethodMetadata;
+require("reflect-metadata");
+const constants_1 = require("../constants");
+const param_collector_1 = require("./param.collector"); // Importamos el colector de parámetros
+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);
+    // 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),
+    };
+    // 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 (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,3 @@
+import "reflect-metadata";
+import { Parameter } from "../types";
+export declare function collectParameterMetadata(target: any, methodName: string): Parameter[];

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectParameterMetadata = collectParameterMetadata;
+require("reflect-metadata");
+const constants_1 = require("../constants");
+const function_util_1 = require("../../../__internals/utils/function.util");
+function collectParameterMetadata(target, methodName) {
+    const parameters = Reflect.getMetadata(constants_1.PARAMETERS, target, methodName) || [];
+    const methodParams = Reflect.getMetadata("design:paramtypes", target, methodName) || [];
+    // Intentamos obtener los nombres de los parámetros utilizando extractArgsNames
+    const paramNames = (0, function_util_1.extractArgsNames)(target[methodName]);
+    // Si no se encuentran parámetros en los metadatos y hay tipos de parámetros disponibles
+    if (parameters.length === 0 && methodParams.length > 0) {
+        methodParams.forEach((paramType, index) => {
+            const param = {
+                name: paramNames && paramNames[index] ? paramNames[index] : `param${index}`, // Asignamos nombre genérico o el nombre inferido
+                in: "query", // Definir el tipo de parámetro, se puede modificar según sea necesario
+                required: true,
+                schema: {
+                    type: paramType.name.toLowerCase(), // Inferimos el tipo del parámetro
+                },
+            };
+            parameters.push(param);
+        });
+    }
+    return parameters;
+}

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-method.decorator.d.ts

@@ -0,0 +1,3 @@
+import "reflect-metadata";
+import { Operation } from "../types";
+export declare function ApiMethod(options: Partial<Operation>): MethodDecorator;

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 { Parameter } from '../types';
+export declare function ApiParameter(options: Parameter): (target: any, propertyKey: string) => void;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiParameter = ApiParameter;
+require("reflect-metadata");
+const parameter_helper_1 = require("../helpers/parameter.helper");
+function ApiParameter(options) {
+    return (target, propertyKey) => {
+        (0, parameter_helper_1.apiParameter)(target, propertyKey, options);
+    };
+}

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

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

package/dist/lib/openapi/decorators/api-request-body.decorator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiRequestBody = ApiRequestBody;
+require("reflect-metadata");
+const request_body_helper_1 = require("../helpers/request-body.helper");
+function ApiRequestBody(options) {
+    return (target, propertyKey) => {
+        (0, request_body_helper_1.apiRequestBody)(target, propertyKey, options);
+    };
+}

package/dist/lib/openapi/decorators/api-response.decodator.d.ts

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

package/dist/lib/openapi/decorators/api-response.decodator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiResponse = ApiResponse;
+require("reflect-metadata");
+const response_helper_1 = require("../helpers/response.helper");
+function ApiResponse(options) {
+    return (target, propertyKey) => {
+        (0, response_helper_1.apiResponse)(target, propertyKey, options);
+    };
+}

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

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

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiSecurity = ApiSecurity;
+require("reflect-metadata");
+const security_helper_1 = require("../helpers/security.helper");
+function ApiSecurity(options) {
+    return (target) => {
+        (0, security_helper_1.apiSecurity)(target, options);
+    };
+}

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

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

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiTag = ApiTag;
+require("reflect-metadata");
+const tag_helper_1 = require("../helpers/tag.helper");
+function ApiTag(options) {
+    return (target) => {
+        (0, tag_helper_1.apiTag)(target, options);
+    };
+}

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

@@ -0,0 +1,6 @@
+export * from "./api-method.decorator";
+export * from "./api-parameter.decorator";
+export * from "./api-request-body.decorator";
+export * from "./api-response.decodator";
+export * from "./api-security.decorator";
+export * from "./api-tag.decorator";

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

@@ -0,0 +1,22 @@
+"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("./api-method.decorator"), exports);
+__exportStar(require("./api-parameter.decorator"), exports);
+__exportStar(require("./api-request-body.decorator"), exports);
+__exportStar(require("./api-response.decodator"), exports);
+__exportStar(require("./api-security.decorator"), exports);
+__exportStar(require("./api-tag.decorator"), exports);

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

@@ -0,0 +1,6 @@
+export * from "./method.helper";
+export * from "./parameter.helper";
+export * from "./request-body.helper";
+export * from "./response.helper";
+export * from "./security.helper";
+export * from "./tag.helper";

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

@@ -0,0 +1,22 @@
+"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("./method.helper"), exports);
+__exportStar(require("./parameter.helper"), exports);
+__exportStar(require("./request-body.helper"), exports);
+__exportStar(require("./response.helper"), exports);
+__exportStar(require("./security.helper"), exports);
+__exportStar(require("./tag.helper"), exports);

package/dist/lib/openapi/helpers/method.helper.d.ts

@@ -0,0 +1,3 @@
+import "reflect-metadata";
+import { Operation } from "../types";
+export declare function apimethod(target: any, propertyKey: string | symbol, options: Partial<Operation>): void;

package/dist/lib/openapi/helpers/method.helper.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apimethod = apimethod;
+require("reflect-metadata");
+const constants_1 = require("../constants");
+const response_helper_1 = require("./response.helper");
+function apimethod(target, propertyKey, options) {
+    if (options.summary) {
+        Reflect.defineMetadata(constants_1.METHOD_SUMMARY, options.summary, target, propertyKey);
+    }
+    if (options.operationId) {
+        Reflect.defineMetadata(constants_1.METHOD_OPERATION_ID, options.operationId, target, propertyKey);
+    }
+    if (options.tags) {
+        Reflect.defineMetadata(constants_1.METHOD_TAGS, options.tags, target, propertyKey);
+    }
+    if (options.responses) {
+        (0, response_helper_1.apiResponse)(target, propertyKey, options.responses);
+    }
+}

package/dist/lib/openapi/helpers/parameter.helper.d.ts

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

package/dist/lib/openapi/helpers/parameter.helper.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiParameter = apiParameter;
+require("reflect-metadata");
+const constants_1 = require("../constants");
+function apiParameter(target, propertyKey, options) {
+    const existingParameters = Reflect.getMetadata(constants_1.PARAMETERS, target, propertyKey) || [];
+    existingParameters.push({
+        name: options.name,
+        in: options.in,
+        required: options.required || false,
+        description: options.description,
+        schema: options.schema,
+    });
+    Reflect.defineMetadata(constants_1.PARAMETERS, existingParameters, target, propertyKey);
+}

package/dist/lib/openapi/helpers/request-body.helper.d.ts

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

package/dist/lib/openapi/helpers/request-body.helper.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiRequestBody = apiRequestBody;
+require("reflect-metadata");
+const constants_1 = require("../constants");
+function apiRequestBody(target, propertyKey, options) {
+    Reflect.defineMetadata(constants_1.REQUEST_BODY_DESCRIPTION, options.description, target, propertyKey);
+    Reflect.defineMetadata(constants_1.REQUEST_BODY_CONTENT, options.content, target, propertyKey);
+}

package/dist/lib/openapi/helpers/response.helper.d.ts

@@ -0,0 +1,3 @@
+import "reflect-metadata";
+import { Responses } from "../types";
+export declare function apiResponse(target: any, propertyKey: string | symbol, options: Responses): void;

package/dist/lib/openapi/helpers/response.helper.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiResponse = apiResponse;
+require("reflect-metadata");
+const constants_1 = require("../constants");
+function apiResponse(target, propertyKey, options) {
+    const existingResponses = Reflect.getMetadata(constants_1.RESPONSES, target, propertyKey) || {};
+    for (const key in options) {
+        if (options.hasOwnProperty(key)) {
+            const response = options[key];
+            existingResponses[key] = {
+                description: response.description,
+                content: response.content,
+            };
+        }
+    }
+    Reflect.defineMetadata(constants_1.RESPONSES, existingResponses, target, propertyKey);
+}

package/dist/lib/openapi/helpers/security.helper.d.ts

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

package/dist/lib/openapi/helpers/security.helper.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiSecurity = apiSecurity;
+require("reflect-metadata");
+const constants_1 = require("../constants");
+function apiSecurity(target, options) {
+    const existingSecurity = Reflect.getMetadata(constants_1.SECURITY, target) || [];
+    existingSecurity.push(options);
+    Reflect.defineMetadata(constants_1.SECURITY, existingSecurity, target);
+}

package/dist/lib/openapi/helpers/tag.helper.d.ts

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

package/dist/lib/openapi/helpers/tag.helper.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiTag = apiTag;
+require("reflect-metadata");
+const constants_1 = require("../constants");
+function apiTag(target, options) {
+    const existingTags = Reflect.getMetadata(constants_1.TAGS, target) || [];
+    existingTags.push({ name: options.name, description: options.description });
+    Reflect.defineMetadata(constants_1.TAGS, existingTags, target);
+}

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

@@ -0,0 +1 @@
+export * from "./collectors";

package/dist/lib/openapi/index.js

@@ -0,0 +1,17 @@
+"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("./collectors"), exports);

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

@@ -0,0 +1,131 @@
+export interface OpenAPIDocument {
+    openapi: string;
+    info: Info;
+    paths: Paths;
+    components?: Components;
+    security?: SecurityRequirement[];
+    tags?: Tag[];
+}
+export interface Info {
+    title: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: Contact;
+    license?: License;
+    version: string;
+}
+export interface Contact {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+export interface License {
+    name: string;
+    url?: string;
+}
+export interface Paths {
+    [path: string]: PathItem;
+}
+export interface PathItem {
+    get?: Operation;
+    post?: Operation;
+    put?: Operation;
+    delete?: Operation;
+    patch?: Operation;
+    head?: Operation;
+    options?: Operation;
+    trace?: Operation;
+}
+export interface Operation {
+    summary?: string;
+    description?: string;
+    operationId?: string;
+    tags?: Tag[];
+    parameters?: Parameter[];
+    requestBody?: RequestBody;
+    responses: Responses;
+    security?: SecurityRequirement[];
+}
+export interface Parameter {
+    name: string;
+    in: "query" | "header" | "path" | "cookie";
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    schema: Schema;
+}
+export interface RequestBody {
+    description?: string;
+    content: {
+        [mediaType: string]: MediaType;
+    };
+}
+export interface MediaType {
+    schema: Schema;
+}
+export interface Responses {
+    [statusCode: string]: Response;
+}
+export interface Response {
+    description: string;
+    content?: {
+        [mediaType: string]: MediaType;
+    };
+    headers?: {
+        [name: string]: Header;
+    };
+}
+export interface Header {
+    description?: string;
+    required?: boolean;
+    schema: Schema;
+}
+export interface Schema {
+    type: string;
+    format?: string;
+    items?: Schema;
+    properties?: {
+        [key: string]: Schema;
+    };
+    additionalProperties?: boolean;
+    example?: any;
+}
+export interface SecurityRequirement {
+    [securityScheme: string]: string[];
+}
+export interface Tag {
+    name: string;
+    description?: string;
+}
+export interface Components {
+    schemas?: {
+        [schemaName: string]: Schema;
+    };
+    responses?: {
+        [responseName: string]: Response;
+    };
+    parameters?: {
+        [parameterName: string]: Parameter;
+    };
+    securitySchemes?: {
+        [schemeName: string]: SecurityScheme;
+    };
+}
+export interface SecurityScheme {
+    type: "apiKey" | "http" | "oauth2" | "openIdConnect";
+    in?: "header" | "query" | "cookie";
+    name?: string;
+    scheme?: string;
+    bearerFormat?: string;
+    openIdConnectUrl?: string;
+    oauth2?: OAuth2Scheme;
+}
+export interface OAuth2Scheme {
+    authorizationUrl: string;
+    tokenUrl: string;
+    refreshUrl?: string;
+    scopes: {
+        [scope: string]: string;
+    };
+}