@moostjs/swagger 0.5.21 → 0.5.23

package/dist/index.mjs

@@ -1,625 +1,517 @@
-import { getMoostMate, Controller, Const, useEventLogger, useControllerContext, Moost } from 'moost';
-import { Get, SetHeader, Url, HeaderHook, StatusHook } from '@moostjs/event-http';
-import { getZodType, z, getZodTypeForProp, ZodSkip } from '@moostjs/zod';
-import { useSetHeaders } from '@wooksjs/event-http';
-import { serveFile } from '@wooksjs/http-static';
-import Path from 'path';
-import { getAbsoluteFSPath } from 'swagger-ui-dist';
-import { parseZodType } from 'zod-parser';
+import { Const, Controller, Moost, getMoostMate, useControllerContext, useEventLogger } from "moost";
+import { Get, HeaderHook, SetHeader, StatusHook, Url } from "@moostjs/event-http";
+import { ZodSkip, getZodType, getZodTypeForProp, z } from "@moostjs/zod";
+import { THeaderHook, useSetHeaders } from "@wooksjs/event-http";
+import { serveFile } from "@wooksjs/http-static";
+import Path from "path";
+import { getAbsoluteFSPath } from "swagger-ui-dist";
+import { parseZodType } from "zod-parser";
 
+//#region packages/swagger/src/swagger.mate.ts
 function getSwaggerMate() {
-    return getMoostMate();
+	return getMoostMate();
 }
 
-const SwaggerTag = (tag) => getSwaggerMate().decorate('swaggerTags', tag, true);
-const SwaggerExclude = () => getSwaggerMate().decorate('swaggerExclude', true);
-const SwaggerDescription = (descr) => getSwaggerMate().decorate('swaggerDescription', descr);
+//#endregion
+//#region packages/swagger/src/decorators.ts
+const SwaggerTag = (tag) => getSwaggerMate().decorate("swaggerTags", tag, true);
+const SwaggerExclude = () => getSwaggerMate().decorate("swaggerExclude", true);
+const SwaggerDescription = (descr) => getSwaggerMate().decorate("swaggerDescription", descr);
 function SwaggerResponse(code, opts, example) {
-    return getSwaggerMate().decorate(meta => {
-        let ex;
-        if (example) {
-            ex = example;
-        }
-        if (typeof code !== 'number' && opts) {
-            ex = opts;
-        }
-        meta.swaggerResponses = meta.swaggerResponses || {};
-        const keyCode = typeof code === 'number' ? code : 0;
-        const opt = typeof code === 'number' ? opts : code;
-        const contentType = typeof opt.contentType === 'string'
-            ? opt.contentType
-            : '*/*';
-        const response = (['object', 'function'].includes(typeof opt.response)
-            ? opt.response
-            : opt);
-        meta.swaggerResponses[keyCode] = meta.swaggerResponses[keyCode] || {};
-        meta.swaggerResponses[keyCode][contentType] = { response, example: ex };
-        return meta;
-    });
+	return getSwaggerMate().decorate((meta) => {
+		let ex;
+		if (example) ex = example;
+		if (typeof code !== "number" && opts) ex = opts;
+		meta.swaggerResponses = meta.swaggerResponses || {};
+		const keyCode = typeof code === "number" ? code : 0;
+		const opt = typeof code === "number" ? opts : code;
+		const contentType = typeof opt.contentType === "string" ? opt.contentType : "*/*";
+		const response = ["object", "function"].includes(typeof opt.response) ? opt.response : opt;
+		meta.swaggerResponses[keyCode] = meta.swaggerResponses[keyCode] || {};
+		meta.swaggerResponses[keyCode][contentType] = {
+			response,
+			example: ex
+		};
+		return meta;
+	});
 }
 function SwaggerRequestBody(opt) {
-    return getSwaggerMate().decorate(meta => {
-        meta.swaggerRequestBody = meta.swaggerRequestBody || {};
-        const contentType = typeof opt.contentType === 'string'
-            ? opt.contentType
-            : 'application/json';
-        const response = (typeof opt.contentType === 'string'
-            ? opt.response
-            : opt);
-        meta.swaggerRequestBody[contentType] = response;
-        return meta;
-    });
+	return getSwaggerMate().decorate((meta) => {
+		meta.swaggerRequestBody = meta.swaggerRequestBody || {};
+		const contentType = typeof opt.contentType === "string" ? opt.contentType : "application/json";
+		const response = typeof opt.contentType === "string" ? opt.response : opt;
+		meta.swaggerRequestBody[contentType] = response;
+		return meta;
+	});
 }
 function SwaggerParam(opts) {
-    return getSwaggerMate().decorate('swaggerParams', opts, true);
+	return getSwaggerMate().decorate("swaggerParams", opts, true);
 }
 function SwaggerExample(example) {
-    return getSwaggerMate().decorate('swaggerExample', example);
+	return getSwaggerMate().decorate("swaggerExample", example);
 }
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
-
-
-function __decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
-function __param(paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-}
-
-function __metadata(metadataKey, metadataValue) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
+//#endregion
+//#region packages/swagger/src/mapping.ts
 function mapToSwaggerSpec(metadata, options, logger) {
-    const swaggerSpec = {
-        openapi: '3.0.0',
-        info: {
-            title: options?.title || 'API Documentation',
-            version: options?.version || '1.0.0',
-        },
-        paths: {},
-        tags: [],
-        components: {
-            schemas: globalSchemas,
-        },
-    };
-    for (const controller of metadata) {
-        const cmeta = controller.meta;
-        if (cmeta?.swaggerExclude) {
-            continue;
-        }
-        const controllerTags = cmeta?.swaggerTags || [];
-        for (const handler of controller.handlers) {
-            const hmeta = handler.meta;
-            const hh = handler.handler;
-            if (hh.type !== 'HTTP' || hmeta?.swaggerExclude || handler.registeredAs.length === 0) {
-                continue;
-            }
-            const uniqueParams = {};
-            const handlerPath = handler.registeredAs[0].path;
-            const handlerMethod = hh.method?.toLowerCase() || 'get';
-            const handlerDescription = hmeta?.description;
-            const handlerTags = [...controllerTags, ...(hmeta?.swaggerTags || [])];
-            if (!swaggerSpec.paths[handlerPath]) {
-                swaggerSpec.paths[handlerPath] = {};
-            }
-            let responses;
-            if (hmeta?.swaggerResponses) {
-                for (const [code, responseConfigs] of Object.entries(hmeta.swaggerResponses)) {
-                    const newCode = code === '0' ? getDefaultStatusCode(handlerMethod) : code;
-                    for (const [contentType, conf] of Object.entries(responseConfigs)) {
-                        const { response, example } = conf;
-                        const schema = getSwaggerSchemaFromSwaggerConfigType(response);
-                        if (schema) {
-                            responses = responses || {};
-                            responses[newCode] = {
-                                content: {
-                                    [contentType]: { schema: { ...schema, example: example || schema.example } },
-                                },
-                            };
-                        }
-                    }
-                }
-            }
-            else if (hmeta?.returnType) {
-                const parsed = myParseZod(getZodType({
-                    type: hmeta.returnType,
-                }));
-                if (['ZodString', 'ZodNumber', 'ZodObject', 'ZodArray', 'ZodBoolean'].includes(parsed.$type)) {
-                    const schema = getSwaggerSchema(parsed);
-                    if (schema) {
-                        responses = responses || {};
-                        responses[getDefaultStatusCode(handlerMethod)] = {
-                            content: {
-                                '*/*': {
-                                    schema,
-                                },
-                            },
-                        };
-                    }
-                }
-            }
-            let reqBodyRequired = true;
-            const bodyConfig = {};
-            if (hmeta?.swaggerRequestBody) {
-                for (const [contentType, type] of Object.entries(hmeta.swaggerRequestBody)) {
-                    let zt;
-                    let schema;
-                    if (type instanceof z.ZodType) {
-                        zt = type;
-                    }
-                    else if (typeof type === 'function') {
-                        zt = getZodType({
-                            type,
-                        });
-                    }
-                    if (zt) {
-                        const parsed = myParseZod(zt);
-                        if (['ZodString', 'ZodNumber', 'ZodObject', 'ZodArray', 'ZodBoolean'].includes(parsed.$type)) {
-                            schema = getSwaggerSchema(parsed);
-                        }
-                    }
-                    bodyConfig[contentType] = { schema };
-                }
-            }
-            swaggerSpec.paths[handlerPath][handlerMethod] = {
-                summary: handlerDescription,
-                operationId: `${handlerMethod.toUpperCase()}_${handlerPath
-                    .replace(/\//g, '_')
-                    .replace(/[{}]/g, '__')
-                    .replace(/[^\dA-Za-z]/g, '_')}`,
-                tags: handlerTags,
-                parameters: [],
-                responses,
-            };
-            const endpointSpec = swaggerSpec.paths[handlerPath][handlerMethod];
-            function addParam(param) {
-                const key = `${param.in}//${param.name}`;
-                if (uniqueParams[key]) {
-                    uniqueParams[key].description = param.description ?? uniqueParams[key].description;
-                    uniqueParams[key].required = param.required;
-                    uniqueParams[key].schema = param.schema ?? uniqueParams[key].schema;
-                }
-                else {
-                    uniqueParams[key] = param;
-                    endpointSpec.parameters.push(param);
-                }
-            }
-            for (const param of cmeta?.swaggerParams || []) {
-                addParam({
-                    name: param.name,
-                    in: param.in,
-                    description: param.description,
-                    required: !!param.required,
-                    schema: getSwaggerSchemaFromSwaggerConfigType(param.type) || { type: 'string' },
-                });
-            }
-            for (const param of hmeta?.swaggerParams || []) {
-                addParam({
-                    name: param.name,
-                    in: param.in,
-                    description: param.description,
-                    required: !!param.required,
-                    schema: getSwaggerSchemaFromSwaggerConfigType(param.type) || { type: 'string' },
-                });
-            }
-            for (const paramName of handler.registeredAs[0].args) {
-                const paramIndex = handler.meta.params.findIndex(param => param.paramSource === 'ROUTE' && param.paramName === paramName);
-                const paramMeta = handler.meta.params[paramIndex];
-                let schema;
-                let parsed;
-                if (paramMeta) {
-                    const zodType = getZodTypeForProp({
-                        type: controller.type,
-                        key: handler.method,
-                        index: paramIndex,
-                    }, {
-                        type: paramMeta.type,
-                        additionalMeta: paramMeta,
-                    }, undefined, logger);
-                    parsed = myParseZod(zodType);
-                    schema = getSwaggerSchema(parsed, true);
-                }
-                addParam({
-                    name: paramName,
-                    in: 'path',
-                    description: paramMeta ? paramMeta.description : undefined,
-                    required: !paramMeta.optional && !parsed?.$optional,
-                    schema: schema || { type: 'string' },
-                });
-            }
-            for (let i = 0; i < handler.meta.params.length; i++) {
-                const paramMeta = handler.meta.params[i];
-                if (paramMeta.paramSource && ['QUERY_ITEM', 'QUERY'].includes(paramMeta.paramSource)) {
-                    const zodType = getZodTypeForProp({
-                        type: controller.type,
-                        key: handler.method,
-                        index: i,
-                    }, {
-                        type: paramMeta.type,
-                        additionalMeta: paramMeta,
-                    }, undefined, logger);
-                    const parsed = myParseZod(zodType);
-                    const schema = getSwaggerSchema(parsed, true);
-                    if (paramMeta.paramSource === 'QUERY_ITEM') {
-                        endpointSpec.parameters.push({
-                            name: paramMeta.paramName || '',
-                            in: 'query',
-                            description: paramMeta.description,
-                            required: !paramMeta.optional && !parsed.$optional,
-                            schema: schema || { type: 'string' },
-                        });
-                    }
-                    else if (paramMeta.paramSource === 'QUERY' && parsed.$type === 'ZodObject') {
-                        for (const [key, value] of Object.entries(parsed.$inner)) {
-                            const schema = getSwaggerSchema(value, true);
-                            if (schema) {
-                                const swaggerSchema = {
-                                    name: key,
-                                    in: 'query',
-                                    description: value.description,
-                                    required: !parsed.$optional && !value.$optional,
-                                    schema,
-                                };
-                                endpointSpec.parameters.push(swaggerSchema);
-                            }
-                        }
-                    }
-                }
-                if (paramMeta.paramSource === 'BODY') {
-                    const zodType = getZodTypeForProp({
-                        type: controller.type,
-                        key: handler.method,
-                        index: i,
-                    }, {
-                        type: paramMeta.type,
-                        additionalMeta: paramMeta,
-                    }, undefined, logger);
-                    const parsed = myParseZod(zodType);
-                    let contentType = '';
-                    switch (parsed.$type) {
-                        case 'ZodString':
-                        case 'ZodNumber':
-                        case 'ZodBigInt':
-                        case 'ZodBoolean':
-                        case 'ZodDate':
-                        case 'ZodEnum':
-                        case 'ZodNativeEnum':
-                        case 'ZodLiteral': {
-                            contentType = 'text/plan';
-                            break;
-                        }
-                        default: {
-                            contentType = 'application/json';
-                        }
-                    }
-                    if (!bodyConfig[contentType]) {
-                        bodyConfig[contentType] = { schema: getSwaggerSchema(parsed) };
-                    }
-                    reqBodyRequired = !zodType.isOptional() && !paramMeta.optional;
-                }
-            }
-            if (Object.entries(bodyConfig).some(e => !!e[1])) {
-                swaggerSpec.paths[handlerPath][handlerMethod].requestBody = {
-                    content: bodyConfig,
-                    required: reqBodyRequired,
-                };
-            }
-        }
-    }
-    return swaggerSpec;
+	const swaggerSpec = {
+		openapi: "3.0.0",
+		info: {
+			title: options?.title || "API Documentation",
+			version: options?.version || "1.0.0"
+		},
+		paths: {},
+		tags: [],
+		components: { schemas: globalSchemas }
+	};
+	for (const controller of metadata) {
+		const cmeta = controller.meta;
+		if (cmeta?.swaggerExclude) continue;
+		const controllerTags = cmeta?.swaggerTags || [];
+		for (const handler of controller.handlers) {
+			const hmeta = handler.meta;
+			const hh = handler.handler;
+			if (hh.type !== "HTTP" || hmeta?.swaggerExclude || handler.registeredAs.length === 0) continue;
+			const uniqueParams = {};
+			const handlerPath = handler.registeredAs[0].path;
+			const handlerMethod = hh.method?.toLowerCase() || "get";
+			const handlerDescription = hmeta?.description;
+			const handlerTags = [...controllerTags, ...hmeta?.swaggerTags || []];
+			if (!swaggerSpec.paths[handlerPath]) swaggerSpec.paths[handlerPath] = {};
+			let responses;
+			if (hmeta?.swaggerResponses) for (const [code, responseConfigs] of Object.entries(hmeta.swaggerResponses)) {
+				const newCode = code === "0" ? getDefaultStatusCode(handlerMethod) : code;
+				for (const [contentType, conf] of Object.entries(responseConfigs)) {
+					const { response, example } = conf;
+					const schema = getSwaggerSchemaFromSwaggerConfigType(response);
+					if (schema) {
+						responses = responses || {};
+						responses[newCode] = { content: { [contentType]: { schema: {
+							...schema,
+							example: example || schema.example
+						} } } };
+					}
+				}
+			}
+			else if (hmeta?.returnType) {
+				const parsed = myParseZod(getZodType({ type: hmeta.returnType }));
+				if ([
+					"ZodString",
+					"ZodNumber",
+					"ZodObject",
+					"ZodArray",
+					"ZodBoolean"
+				].includes(parsed.$type)) {
+					const schema = getSwaggerSchema(parsed);
+					if (schema) {
+						responses = responses || {};
+						responses[getDefaultStatusCode(handlerMethod)] = { content: { "*/*": { schema } } };
+					}
+				}
+			}
+			let reqBodyRequired = true;
+			const bodyConfig = {};
+			if (hmeta?.swaggerRequestBody) for (const [contentType, type] of Object.entries(hmeta.swaggerRequestBody)) {
+				let zt;
+				let schema;
+				if (type instanceof z.ZodType) zt = type;
+				else if (typeof type === "function") zt = getZodType({ type });
+				if (zt) {
+					const parsed = myParseZod(zt);
+					if ([
+						"ZodString",
+						"ZodNumber",
+						"ZodObject",
+						"ZodArray",
+						"ZodBoolean"
+					].includes(parsed.$type)) schema = getSwaggerSchema(parsed);
+				}
+				bodyConfig[contentType] = { schema };
+			}
+			swaggerSpec.paths[handlerPath][handlerMethod] = {
+				summary: handlerDescription,
+				operationId: `${handlerMethod.toUpperCase()}_${handlerPath.replace(/\//g, "_").replace(/[{}]/g, "__").replace(/[^\dA-Za-z]/g, "_")}`,
+				tags: handlerTags,
+				parameters: [],
+				responses
+			};
+			const endpointSpec = swaggerSpec.paths[handlerPath][handlerMethod];
+			function addParam(param) {
+				const key = `${param.in}//${param.name}`;
+				if (uniqueParams[key]) {
+					uniqueParams[key].description = param.description ?? uniqueParams[key].description;
+					uniqueParams[key].required = param.required;
+					uniqueParams[key].schema = param.schema ?? uniqueParams[key].schema;
+				} else {
+					uniqueParams[key] = param;
+					endpointSpec.parameters.push(param);
+				}
+			}
+			for (const param of cmeta?.swaggerParams || []) addParam({
+				name: param.name,
+				in: param.in,
+				description: param.description,
+				required: !!param.required,
+				schema: getSwaggerSchemaFromSwaggerConfigType(param.type) || { type: "string" }
+			});
+			for (const param of hmeta?.swaggerParams || []) addParam({
+				name: param.name,
+				in: param.in,
+				description: param.description,
+				required: !!param.required,
+				schema: getSwaggerSchemaFromSwaggerConfigType(param.type) || { type: "string" }
+			});
+			for (const paramName of handler.registeredAs[0].args) {
+				const paramIndex = handler.meta.params.findIndex((param) => param.paramSource === "ROUTE" && param.paramName === paramName);
+				const paramMeta = handler.meta.params[paramIndex];
+				let schema;
+				let parsed;
+				if (paramMeta) {
+					const zodType = getZodTypeForProp({
+						type: controller.type,
+						key: handler.method,
+						index: paramIndex
+					}, {
+						type: paramMeta.type,
+						additionalMeta: paramMeta
+					}, undefined, logger);
+					parsed = myParseZod(zodType);
+					schema = getSwaggerSchema(parsed, true);
+				}
+				addParam({
+					name: paramName,
+					in: "path",
+					description: paramMeta ? paramMeta.description : undefined,
+					required: !paramMeta.optional && !parsed?.$optional,
+					schema: schema || { type: "string" }
+				});
+			}
+			for (let i = 0; i < handler.meta.params.length; i++) {
+				const paramMeta = handler.meta.params[i];
+				if (paramMeta.paramSource && ["QUERY_ITEM", "QUERY"].includes(paramMeta.paramSource)) {
+					const zodType = getZodTypeForProp({
+						type: controller.type,
+						key: handler.method,
+						index: i
+					}, {
+						type: paramMeta.type,
+						additionalMeta: paramMeta
+					}, undefined, logger);
+					const parsed = myParseZod(zodType);
+					const schema = getSwaggerSchema(parsed, true);
+					if (paramMeta.paramSource === "QUERY_ITEM") endpointSpec.parameters.push({
+						name: paramMeta.paramName || "",
+						in: "query",
+						description: paramMeta.description,
+						required: !paramMeta.optional && !parsed.$optional,
+						schema: schema || { type: "string" }
+					});
+					else if (paramMeta.paramSource === "QUERY" && parsed.$type === "ZodObject") for (const [key, value] of Object.entries(parsed.$inner)) {
+						const schema$1 = getSwaggerSchema(value, true);
+						if (schema$1) {
+							const swaggerSchema = {
+								name: key,
+								in: "query",
+								description: value.description,
+								required: !parsed.$optional && !value.$optional,
+								schema: schema$1
+							};
+							endpointSpec.parameters.push(swaggerSchema);
+						}
+					}
+				}
+				if (paramMeta.paramSource === "BODY") {
+					const zodType = getZodTypeForProp({
+						type: controller.type,
+						key: handler.method,
+						index: i
+					}, {
+						type: paramMeta.type,
+						additionalMeta: paramMeta
+					}, undefined, logger);
+					const parsed = myParseZod(zodType);
+					let contentType = "";
+					switch (parsed.$type) {
+						case "ZodString":
+						case "ZodNumber":
+						case "ZodBigInt":
+						case "ZodBoolean":
+						case "ZodDate":
+						case "ZodEnum":
+						case "ZodNativeEnum":
+						case "ZodLiteral": {
+							contentType = "text/plan";
+							break;
+						}
+						default: contentType = "application/json";
+					}
+					if (!bodyConfig[contentType]) bodyConfig[contentType] = { schema: getSwaggerSchema(parsed) };
+					reqBodyRequired = !zodType.isOptional() && !paramMeta.optional;
+				}
+			}
+			if (bodyConfig && Object.entries(bodyConfig).some((e) => !!e[1])) swaggerSpec.paths[handlerPath][handlerMethod].requestBody = {
+				content: bodyConfig,
+				required: reqBodyRequired
+			};
+		}
+	}
+	return swaggerSpec;
 }
 const globalSchemas = {};
 function getSwaggerSchema(parsed, forParam) {
-    const zodType = parsed.$ref;
-    const meta = zodType.__type_ref ? getSwaggerMate().read(zodType.__type_ref) : undefined;
-    if (!forParam && zodType.__type_ref && globalSchemas[zodType.__type_ref.name]) {
-        return { $ref: `#/components/schemas/${zodType.__type_ref.name}` };
-    }
-    if (forParam && zodType.__type_ref && globalSchemas[zodType.__type_ref.name]) {
-        return globalSchemas[zodType.__type_ref.name];
-    }
-    const schema = {};
-    if (meta) {
-        if (meta.swaggerExample) {
-            schema.example = meta.swaggerExample;
-        }
-        if (meta.label || meta.id) {
-            schema.title = meta.label || meta.id;
-        }
-        if (meta.description) {
-            schema.description = meta.description;
-        }
-    }
-    if (!forParam && zodType.__type_ref) {
-        globalSchemas[zodType.__type_ref.name] = schema;
-    }
-    function asString() {
-        schema.type = 'string';
-        if (parsed.$checks) {
-            const { regex } = parsed.$checks;
-            if (regex) {
-                schema.pattern = regex.source;
-            }
-        }
-    }
-    function asLiteral() {
-        if (parsed.$type === 'ZodLiteral') {
-            schema.type = 'string';
-            schema.enum = [parsed.$value];
-        }
-    }
-    function asEnum() {
-        if (parsed.$type === 'ZodEnum') {
-            schema.type = 'string';
-            schema.enum = parsed.$value;
-        }
-    }
-    function asNativeEnum() {
-        if (parsed.$type === 'ZodNativeEnum') {
-            schema.type = 'string';
-            schema.enum = Object.keys(parsed.$value);
-        }
-    }
-    if (forParam) {
-        switch (parsed.$type) {
-            case 'ZodAny':
-            case 'ZodUnknown':
-            case 'ZodString': {
-                asString();
-                break;
-            }
-            case 'ZodNumber': {
-                schema.type = 'number';
-                break;
-            }
-            case 'ZodBigInt': {
-                schema.type = 'integer';
-                break;
-            }
-            case 'ZodBoolean': {
-                schema.type = 'boolean';
-                break;
-            }
-            case 'ZodLiteral': {
-                asLiteral();
-                break;
-            }
-            case 'ZodEnum': {
-                asEnum();
-                break;
-            }
-            case 'ZodNativeEnum': {
-                asNativeEnum();
-                break;
-            }
-            case 'ZodDate': {
-                schema.type = 'string';
-                break;
-            }
-            case 'ZodNull': {
-                schema.type = 'null';
-                break;
-            }
-            default: {
-                return undefined;
-            }
-        }
-    }
-    else {
-        switch (parsed.$type) {
-            case 'ZodString': {
-                asString();
-                break;
-            }
-            case 'ZodNumber': {
-                schema.type = 'number';
-                break;
-            }
-            case 'ZodBigInt': {
-                schema.type = 'integer';
-                break;
-            }
-            case 'ZodBoolean': {
-                schema.type = 'boolean';
-                break;
-            }
-            case 'ZodLiteral': {
-                asLiteral();
-                break;
-            }
-            case 'ZodEnum': {
-                asEnum();
-                break;
-            }
-            case 'ZodNativeEnum': {
-                asNativeEnum();
-                break;
-            }
-            case 'ZodDate': {
-                schema.type = 'string';
-                break;
-            }
-            case 'ZodNull': {
-                schema.type = 'null';
-                break;
-            }
-            case 'ZodFunction':
-            case 'ZodSymbol':
-            case 'ZodUndefined':
-            case 'ZodUnknown':
-            case 'ZodNever':
-            case 'ZodVoid':
-            case 'ZodNaN': {
-                return undefined;
-            }
-            case 'ZodArray': {
-                schema.type = 'array';
-                schema.minItems = parsed.$checks?.minLength || undefined;
-                schema.maxItems = parsed.$checks?.maxLength || undefined;
-                schema.items = getSwaggerSchema(parsed.$inner);
-                break;
-            }
-            case 'ZodTuple': {
-                schema.type = 'array';
-                schema.items = parsed.$inner
-                    .map(t => getSwaggerSchema(t))
-                    .filter(t => !!t);
-                break;
-            }
-            case 'ZodObject': {
-                schema.type = 'object';
-                schema.properties = {};
-                schema.required = [];
-                if (zodType._def.unknownKeys === 'passthrough') {
-                    schema.additionalProperties = {};
-                }
-                for (const [key, val] of Object.entries(parsed.$inner)) {
-                    const prop = getSwaggerSchema(val);
-                    if (prop) {
-                        schema.properties[key] = prop;
-                        if (!val.$optional) {
-                            schema.required.push(key);
-                        }
-                    }
-                }
-                break;
-            }
-            case 'ZodPromise':
-            case 'ZodRecord':
-            case 'ZodMap':
-            case 'ZodSet': {
-                schema.type = 'object';
-                schema.properties = {};
-                schema.additionalProperties = parsed.$type === 'ZodRecord' ? {} : undefined;
-                break;
-            }
-            case 'ZodUnion':
-            case 'ZodDiscriminatedUnion': {
-                schema.oneOf = parsed.$inner
-                    .map(t => getSwaggerSchema(t))
-                    .filter(t => !!t);
-                break;
-            }
-            case 'ZodIntersection': {
-                schema.allOf = parsed.$inner
-                    .map(t => getSwaggerSchema(t))
-                    .filter(t => !!t);
-                break;
-            }
-            case 'ZodLazy': {
-                return getSwaggerSchema(parsed.$get());
-            }
-        }
-    }
-    if (parsed.$nullable) {
-        schema.nullable = parsed.$nullable;
-    }
-    if (parsed.$ref._def.description) {
-        schema.description = parsed.$ref._def.description;
-    }
-    if (parsed.$checks) {
-        const checks = parsed.$checks;
-        if (parsed.$type === 'ZodString') {
-            if (typeof checks.min === 'number') {
-                schema.minLength = checks.min;
-            }
-            if (typeof checks.max === 'number') {
-                schema.maxLength = checks.max;
-            }
-        }
-        else {
-            if (typeof checks.min === 'number') {
-                schema.minimum = checks.min;
-            }
-            if (typeof checks.max === 'number') {
-                schema.maximum = checks.max;
-            }
-        }
-    }
-    if (!forParam && zodType.__type_ref) {
-        return { $ref: `#/components/schemas/${zodType.__type_ref.name}` };
-    }
-    return schema;
+	const zodType = parsed.$ref;
+	const meta = zodType.__type_ref ? getSwaggerMate().read(zodType.__type_ref) : undefined;
+	if (!forParam && zodType.__type_ref && globalSchemas[zodType.__type_ref.name]) return { $ref: `#/components/schemas/${zodType.__type_ref.name}` };
+	if (forParam && zodType.__type_ref && globalSchemas[zodType.__type_ref.name]) return globalSchemas[zodType.__type_ref.name];
+	const schema = {};
+	if (meta) {
+		if (meta.swaggerExample) schema.example = meta.swaggerExample;
+		if (meta.label || meta.id) schema.title = meta.label || meta.id;
+		if (meta.description) schema.description = meta.description;
+	}
+	if (!forParam && zodType.__type_ref) globalSchemas[zodType.__type_ref.name] = schema;
+	function asString() {
+		schema.type = "string";
+		if (parsed.$checks) {
+			const { regex } = parsed.$checks;
+			if (regex) schema.pattern = regex.source;
+		}
+	}
+	function asLiteral() {
+		if (parsed.$type === "ZodLiteral") {
+			schema.type = "string";
+			schema.enum = [parsed.$value];
+		}
+	}
+	function asEnum() {
+		if (parsed.$type === "ZodEnum") {
+			schema.type = "string";
+			schema.enum = parsed.$value;
+		}
+	}
+	function asNativeEnum() {
+		if (parsed.$type === "ZodNativeEnum") {
+			schema.type = "string";
+			schema.enum = Object.keys(parsed.$value);
+		}
+	}
+	if (forParam) switch (parsed.$type) {
+		case "ZodAny":
+		case "ZodUnknown":
+		case "ZodString": {
+			asString();
+			break;
+		}
+		case "ZodNumber": {
+			schema.type = "number";
+			break;
+		}
+		case "ZodBigInt": {
+			schema.type = "integer";
+			break;
+		}
+		case "ZodBoolean": {
+			schema.type = "boolean";
+			break;
+		}
+		case "ZodLiteral": {
+			asLiteral();
+			break;
+		}
+		case "ZodEnum": {
+			asEnum();
+			break;
+		}
+		case "ZodNativeEnum": {
+			asNativeEnum();
+			break;
+		}
+		case "ZodDate": {
+			schema.type = "string";
+			break;
+		}
+		case "ZodNull": {
+			schema.type = "null";
+			break;
+		}
+		default: return undefined;
+	}
+	else switch (parsed.$type) {
+		case "ZodString": {
+			asString();
+			break;
+		}
+		case "ZodNumber": {
+			schema.type = "number";
+			break;
+		}
+		case "ZodBigInt": {
+			schema.type = "integer";
+			break;
+		}
+		case "ZodBoolean": {
+			schema.type = "boolean";
+			break;
+		}
+		case "ZodLiteral": {
+			asLiteral();
+			break;
+		}
+		case "ZodEnum": {
+			asEnum();
+			break;
+		}
+		case "ZodNativeEnum": {
+			asNativeEnum();
+			break;
+		}
+		case "ZodDate": {
+			schema.type = "string";
+			break;
+		}
+		case "ZodNull": {
+			schema.type = "null";
+			break;
+		}
+		case "ZodFunction":
+		case "ZodSymbol":
+		case "ZodUndefined":
+		case "ZodUnknown":
+		case "ZodNever":
+		case "ZodVoid":
+		case "ZodNaN": return undefined;
+		case "ZodArray": {
+			schema.type = "array";
+			schema.minItems = parsed.$checks?.minLength || undefined;
+			schema.maxItems = parsed.$checks?.maxLength || undefined;
+			schema.items = getSwaggerSchema(parsed.$inner);
+			break;
+		}
+		case "ZodTuple": {
+			schema.type = "array";
+			schema.items = parsed.$inner.map((t) => getSwaggerSchema(t)).filter((t) => !!t);
+			break;
+		}
+		case "ZodObject": {
+			schema.type = "object";
+			schema.properties = {};
+			schema.required = [];
+			if (zodType._def.unknownKeys === "passthrough") schema.additionalProperties = {};
+			for (const [key, val] of Object.entries(parsed.$inner)) {
+				const prop = getSwaggerSchema(val);
+				if (prop) {
+					schema.properties[key] = prop;
+					if (!val.$optional) schema.required.push(key);
+				}
+			}
+			break;
+		}
+		case "ZodPromise":
+		case "ZodRecord":
+		case "ZodMap":
+		case "ZodSet": {
+			schema.type = "object";
+			schema.properties = {};
+			schema.additionalProperties = parsed.$type === "ZodRecord" ? {} : undefined;
+			break;
+		}
+		case "ZodUnion":
+		case "ZodDiscriminatedUnion": {
+			schema.oneOf = parsed.$inner.map((t) => getSwaggerSchema(t)).filter((t) => !!t);
+			break;
+		}
+		case "ZodIntersection": {
+			schema.allOf = parsed.$inner.map((t) => getSwaggerSchema(t)).filter((t) => !!t);
+			break;
+		}
+		case "ZodLazy": return getSwaggerSchema(parsed.$get());
+	}
+	if (parsed.$nullable) schema.nullable = parsed.$nullable;
+	if (parsed.$ref._def.description) schema.description = parsed.$ref._def.description;
+	if (parsed.$checks) {
+		const checks = parsed.$checks;
+		if (parsed.$type === "ZodString") {
+			if (typeof checks.min === "number") schema.minLength = checks.min;
+			if (typeof checks.max === "number") schema.maxLength = checks.max;
+		} else {
+			if (typeof checks.min === "number") schema.minimum = checks.min;
+			if (typeof checks.max === "number") schema.maximum = checks.max;
+		}
+	}
+	if (!forParam && zodType.__type_ref) return { $ref: `#/components/schemas/${zodType.__type_ref.name}` };
+	return schema;
 }
 function myParseZod(schema) {
-    return parseZodType(schema);
+	return parseZodType(schema);
 }
 function getDefaultStatusCode(httpMethod) {
-    const defaultStatusCodes = {
-        GET: 200,
-        PUT: 200,
-        POST: 201,
-        DELETE: 204,
-    };
-    return defaultStatusCodes[httpMethod.toUpperCase()] || 200;
+	const defaultStatusCodes = {
+		GET: 200,
+		PUT: 200,
+		POST: 201,
+		DELETE: 204
+	};
+	return defaultStatusCodes[httpMethod.toUpperCase()] || 200;
 }
 function getSwaggerSchemaFromSwaggerConfigType(type) {
-    let schema;
-    let zt;
-    if (type instanceof z.ZodType) {
-        zt = type;
-    }
-    else if (typeof type === 'function') {
-        zt = getZodType({
-            type,
-        });
-    }
-    if (zt) {
-        const parsed = myParseZod(zt);
-        if (['ZodString', 'ZodNumber', 'ZodObject', 'ZodArray', 'ZodBoolean'].includes(parsed.$type)) {
-            schema = getSwaggerSchema(parsed);
-        }
-    }
-    else if (type.type || type.$ref) {
-        schema = type;
-    }
-    return schema;
+	let schema;
+	let zt;
+	if (type instanceof z.ZodType) zt = type;
+	else if (typeof type === "function") zt = getZodType({ type });
+	if (zt) {
+		const parsed = myParseZod(zt);
+		if ([
+			"ZodString",
+			"ZodNumber",
+			"ZodObject",
+			"ZodArray",
+			"ZodBoolean"
+		].includes(parsed.$type)) schema = getSwaggerSchema(parsed);
+	} else if (type.type || type.$ref) schema = type;
+	return schema;
 }
 
-let SwaggerController = class SwaggerController {
-    constructor(opts = { title: 'Moost API' }) {
-        this.opts = opts;
-        this['assetPath'] = getAbsoluteFSPath();
-    }
-    'processCors'() {
-        if (this.opts.cors) {
-            const { enableCors } = useSetHeaders();
-            enableCors(this.opts.cors === true ? undefined : this.opts.cors);
-        }
-    }
-    'serveIndex'(url, location, status) {
-        this.processCors();
-        if (!url.endsWith('index.html') && !url.endsWith('/')) {
-            status.value = 302;
-            location.value = Path.join(url, '/');
-            return '';
-        }
-        return `<!DOCTYPE html>
+//#endregion
+//#region packages/swagger/src/swagger.controller.ts
+function _define_property(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+	else obj[key] = value;
+	return obj;
+}
+function _ts_decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+var SwaggerController = class {
+	"processCors"() {
+		if (this.opts.cors) {
+			const { enableCors } = useSetHeaders();
+			enableCors(this.opts.cors === true ? undefined : this.opts.cors);
+		}
+	}
+	"serveIndex"(url, location, status) {
+		this.processCors();
+		if (!url.endsWith("index.html") && !url.endsWith("/")) {
+			status.value = 302;
+			location.value = Path.join(url, "/");
+			return "";
+		}
+		return `<!DOCTYPE html>
 <html lang="en">
   <head>
     <meta charset="UTF-8">
@@ -637,10 +529,10 @@ let SwaggerController = class SwaggerController {
     <script src="./swagger-initializer.js" charset="UTF-8"> </script>
   </body>
 </html>`;
-    }
-    'swagger-initializer.js'() {
-        this.processCors();
-        return `window.onload = function() {
+	}
+	"swagger-initializer.js"() {
+		this.processCors();
+		return `window.onload = function() {
   window.ui = SwaggerUIBundle({
     url: "./spec.json",
     dom_id: '#swagger-ui',
@@ -655,72 +547,85 @@ let SwaggerController = class SwaggerController {
     layout: "BaseLayout"
   });
 };`;
-    }
-    async 'spec.json'() {
-        this.processCors();
-        const logger = useEventLogger('@moostjs/zod');
-        if (!this.spec) {
-            const { instantiate } = useControllerContext();
-            const moost = await instantiate(Moost);
-            this.spec = mapToSwaggerSpec(moost.getControllersOverview(), this.opts, logger);
-        }
-        return this.spec;
-    }
-    'files'(url) {
-        this.processCors();
-        return this.serve(url.split('/').pop());
-    }
-    'serve'(path) {
-        return serveFile(path, {
-            baseDir: this.assetPath,
-            cacheControl: {
-                public: true,
-                maxAge: '1w',
-            },
-        });
-    }
+	}
+	async "spec.json"() {
+		this.processCors();
+		const logger = useEventLogger("@moostjs/zod");
+		if (!this.spec) {
+			const { instantiate } = useControllerContext();
+			const moost = await instantiate(Moost);
+			this.spec = mapToSwaggerSpec(moost.getControllersOverview(), this.opts, logger);
+		}
+		return this.spec;
+	}
+	"files"(url) {
+		this.processCors();
+		return this.serve(url.split("/").pop());
+	}
+	"serve"(path) {
+		return serveFile(path, {
+			baseDir: this.assetPath,
+			cacheControl: {
+				public: true,
+				maxAge: "1w"
+			}
+		});
+	}
+	constructor(opts = { title: "Moost API" }) {
+		_define_property(this, "opts", void 0);
+		_define_property(this, "assetPath", void 0);
+		_define_property(this, "spec", void 0);
+		this.opts = opts;
+		this["assetPath"] = getAbsoluteFSPath();
+	}
 };
-__decorate([
-    Get(''),
-    Get('//'),
-    Get('index.html'),
-    SetHeader('content-type', 'text/html'),
-    __param(0, Url()),
-    __param(1, HeaderHook('location')),
-    __param(2, StatusHook()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Object, Object]),
-    __metadata("design:returntype", void 0)
+_ts_decorate([
+	Get(""),
+	Get("//"),
+	Get("index.html"),
+	SetHeader("content-type", "text/html"),
+	_ts_param(0, Url()),
+	_ts_param(1, HeaderHook("location")),
+	_ts_param(2, StatusHook()),
+	_ts_metadata("design:type", Function),
+	_ts_metadata("design:paramtypes", [
+		String,
+		typeof THeaderHook === "undefined" ? Object : THeaderHook,
+		typeof TStatusHook === "undefined" ? Object : TStatusHook
+	]),
+	_ts_metadata("design:returntype", void 0)
 ], SwaggerController.prototype, "serveIndex", null);
-__decorate([
-    Get(),
-    SetHeader('content-type', 'application/javascript'),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
+_ts_decorate([
+	Get(),
+	SetHeader("content-type", "application/javascript"),
+	_ts_metadata("design:type", Function),
+	_ts_metadata("design:paramtypes", []),
+	_ts_metadata("design:returntype", void 0)
 ], SwaggerController.prototype, "swagger-initializer.js", null);
-__decorate([
-    Get(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
+_ts_decorate([
+	Get(),
+	_ts_metadata("design:type", Function),
+	_ts_metadata("design:paramtypes", []),
+	_ts_metadata("design:returntype", Promise)
 ], SwaggerController.prototype, "spec.json", null);
-__decorate([
-    Get('swagger-ui-bundle.*(js|js\\.map)'),
-    Get('swagger-ui-standalone-preset.*(js|js\\.map)'),
-    Get('swagger-ui.*(css|css\\.map)'),
-    Get('index.*(css|css\\.map)'),
-    __param(0, Url()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", void 0)
+_ts_decorate([
+	Get("swagger-ui-bundle.*(js|js\\.map)"),
+	Get("swagger-ui-standalone-preset.*(js|js\\.map)"),
+	Get("swagger-ui.*(css|css\\.map)"),
+	Get("index.*(css|css\\.map)"),
+	_ts_param(0, Url()),
+	_ts_metadata("design:type", Function),
+	_ts_metadata("design:paramtypes", [String]),
+	_ts_metadata("design:returntype", void 0)
 ], SwaggerController.prototype, "files", null);
-SwaggerController = __decorate([
-    SwaggerExclude(),
-    ZodSkip(),
-    Controller('api-docs'),
-    __param(0, Const({ title: 'Moost API' })),
-    __metadata("design:paramtypes", [Object])
+SwaggerController = _ts_decorate([
+	SwaggerExclude(),
+	ZodSkip(),
+	Controller("api-docs"),
+	_ts_param(0, Const({ title: "Moost API" })),
+	_ts_metadata("design:type", Function),
+	_ts_metadata("design:paramtypes", [typeof TSwaggerOptions === "undefined" ? Object : TSwaggerOptions])
 ], SwaggerController);
 
-export { SwaggerController, SwaggerDescription, SwaggerExample, SwaggerExclude, SwaggerParam, SwaggerRequestBody, SwaggerResponse, SwaggerTag, getSwaggerMate };
+//#endregion
+export { SwaggerController, SwaggerDescription, SwaggerExample, SwaggerExclude, SwaggerParam, SwaggerRequestBody, SwaggerResponse, SwaggerTag, getSwaggerMate };