@moostjs/swagger 0.3.10 → 0.3.12

package/dist/index.mjs

@@ -20,7 +20,7 @@ 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 */
+/* global Reflect, Promise, SuppressedError, Symbol */
 
 
 function __decorate(decorators, target, key, desc) {
@@ -38,467 +38,455 @@ function __metadata(metadataKey, metadataValue) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
 }
 
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
 
-function getSwaggerMate() {
-    return getMoostMate();
+function getSwaggerMate() {
+    return getMoostMate();
 }
 
-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) {
-    return getSwaggerMate().decorate((meta) => {
-        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 description = typeof (opt as { description: string }).description === 'string' ? (opt as { description: string }).description : undefined
-        const response = (['object', 'function'].includes(typeof opt.response) ? opt.response : opt);
-        meta.swaggerResponses[keyCode] = meta.swaggerResponses[keyCode] || {};
-        meta.swaggerResponses[keyCode][contentType] = response;
-        // meta.swaggerResponses[keyCode].description = description
-        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;
-    });
+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) {
+    return getSwaggerMate().decorate((meta) => {
+        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;
+        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;
+    });
 }
 
-function mapToSwaggerSpec(metadata, options, logger) {
-    var _a;
-    const swaggerSpec = {
-        openapi: '3.0.0',
-        info: {
-            title: (options === null || options === void 0 ? void 0 : options.title) || 'API Documentation',
-            version: (options === null || options === void 0 ? void 0 : options.version) || '1.0.0',
-        },
-        paths: {},
-        tags: [],
-        components: {
-            schemas: globalSchemas,
-        },
-    };
-    for (const controller of metadata) {
-        const cmeta = controller.meta;
-        if (cmeta === null || cmeta === void 0 ? void 0 : cmeta.swaggerExclude)
-            continue;
-        const controllerTags = (cmeta === null || cmeta === void 0 ? void 0 : cmeta.swaggerTags) || [];
-        for (const handler of controller.handlers) {
-            const hmeta = handler.meta;
-            const hh = handler.handler;
-            if (hh.type !== 'HTTP' || (hmeta === null || hmeta === void 0 ? void 0 : hmeta.swaggerExclude) || !handler.registeredAs.length)
-                continue;
-            const handlerPath = handler.registeredAs[0].path;
-            const handlerMethod = ((_a = hh.method) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || 'get';
-            const handlerDescription = hmeta === null || hmeta === void 0 ? void 0 : hmeta.description;
-            const handlerTags = [...controllerTags, ...((hmeta === null || hmeta === void 0 ? void 0 : hmeta.swaggerTags) || [])];
-            if (!swaggerSpec.paths[handlerPath]) {
-                swaggerSpec.paths[handlerPath] = {};
-            }
-            let responses = undefined;
-            if (hmeta === null || hmeta === void 0 ? void 0 : hmeta.swaggerResponses) {
-                for (const [code, responseConfigs] of Object.entries(hmeta.swaggerResponses)) {
-                    const newCode = code === '0' ? getDefaultStatusCode(handlerMethod) : code;
-                    for (const [contentType, type] of Object.entries(responseConfigs)) {
-                        let schema = undefined;
-                        let zt = undefined;
-                        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);
-                            }
-                        }
-                        if (schema) {
-                            responses = responses || {};
-                            responses[newCode] = { content: { [contentType]: { schema } } };
-                        }
-                    }
-                }
-            }
-            else if (hmeta === null || hmeta === void 0 ? void 0 : 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 === null || hmeta === void 0 ? void 0 : hmeta.swaggerRequestBody) {
-                for (const [contentType, type] of Object.entries(hmeta === null || hmeta === void 0 ? void 0 : 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(/[^A-Za-z0-9]/g, '_'),
-                tags: handlerTags,
-                parameters: [],
-                responses,
-            };
-            const endpointSpec = swaggerSpec.paths[handlerPath][handlerMethod];
-            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);
-                }
-                endpointSpec.parameters.push({
-                    name: paramName,
-                    in: 'path',
-                    description: paramMeta ? paramMeta.description : undefined,
-                    required: !(paramMeta === null || paramMeta === void 0 ? void 0 : paramMeta.optional) && !(parsed === null || parsed === void 0 ? void 0 : 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 === null || paramMeta === void 0 ? void 0 : paramMeta.optional) && !(parsed === null || parsed === void 0 ? void 0 : parsed.$optional),
-                            schema: schema || { type: 'string' },
-                        });
-                    }
-                    else if (paramMeta.paramSource == 'QUERY') {
-                        if (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 === null || paramMeta === void 0 ? void 0 : 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).filter(e => !!e[1]).length > 0) {
-                swaggerSpec.paths[handlerPath][handlerMethod].requestBody = {
-                    content: bodyConfig,
-                    required: reqBodyRequired,
-                };
-            }
-        }
-    }
-    return swaggerSpec;
-}
-const globalSchemas = {};
-function getSwaggerSchema(parsed, forParam) {
-    var _a, _b;
-    const zodType = parsed.$ref;
-    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 (!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 'ZodAny':
-            case 'ZodArray':
-                schema.type = 'array';
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                schema.minItems = ((_a = parsed.$checks) === null || _a === void 0 ? void 0 : _a.minLength) || undefined;
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                schema.maxItems = ((_b = parsed.$checks) === null || _b === void 0 ? void 0 : _b.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);
-}
-function getDefaultStatusCode(httpMethod) {
-    const defaultStatusCodes = {
-        GET: 200,
-        PUT: 200,
-        POST: 201,
-        DELETE: 204,
-    };
-    return defaultStatusCodes[httpMethod.toUpperCase()] || 200;
+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)
+                continue;
+            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 = undefined;
+            if (hmeta?.swaggerResponses) {
+                for (const [code, responseConfigs] of Object.entries(hmeta.swaggerResponses)) {
+                    const newCode = code === '0' ? getDefaultStatusCode(handlerMethod) : code;
+                    for (const [contentType, type] of Object.entries(responseConfigs)) {
+                        let schema = undefined;
+                        let zt = undefined;
+                        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);
+                            }
+                        }
+                        if (schema) {
+                            responses = responses || {};
+                            responses[newCode] = { content: { [contentType]: { schema } } };
+                        }
+                    }
+                }
+            }
+            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(/[^A-Za-z0-9]/g, '_'),
+                tags: handlerTags,
+                parameters: [],
+                responses,
+            };
+            const endpointSpec = swaggerSpec.paths[handlerPath][handlerMethod];
+            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);
+                }
+                endpointSpec.parameters.push({
+                    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') {
+                        if (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 (bodyConfig && Object.entries(bodyConfig).filter(e => !!e[1]).length > 0) {
+                swaggerSpec.paths[handlerPath][handlerMethod].requestBody = {
+                    content: bodyConfig,
+                    required: reqBodyRequired,
+                };
+            }
+        }
+    }
+    return swaggerSpec;
+}
+const globalSchemas = {};
+function getSwaggerSchema(parsed, forParam) {
+    const zodType = parsed.$ref;
+    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 (!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);
+}
+function getDefaultStatusCode(httpMethod) {
+    const defaultStatusCodes = {
+        GET: 200,
+        PUT: 200,
+        POST: 201,
+        DELETE: 204,
+    };
+    return defaultStatusCodes[httpMethod.toUpperCase()] || 200;
 }
 
-let SwaggerController = class SwaggerController {
-    constructor(title = 'Moost API') {
-        this.title = title;
-        this.assetPath = getAbsoluteFSPath();
-    }
-    serveIndex(url, location, status) {
-        if (!url.endsWith('index.html') && !url.endsWith('/')) {
-            status.value = 302;
-            location.value = join(url, '/');
-            return '';
-        }
+let SwaggerController = class SwaggerController {
+    constructor(title = 'Moost API') {
+        this.title = title;
+        this.assetPath = getAbsoluteFSPath();
+    }
+    serveIndex(url, location, status) {
+        if (!url.endsWith('index.html') && !url.endsWith('/')) {
+            status.value = 302;
+            location.value = join(url, '/');
+            return '';
+        }
         return `<!DOCTYPE html>
 <html lang="en">
   <head>
@@ -516,9 +504,9 @@ let SwaggerController = class SwaggerController {
     <script src="./swagger-ui-standalone-preset.js" charset="UTF-8"> </script>
     <script src="./swagger-initializer.js" charset="UTF-8"> </script>
   </body>
-</html>`;
-    }
-    'swagger-initializer.js'() {
+</html>`;
+    }
+    'swagger-initializer.js'() {
         return `window.onload = function() {
   window.ui = SwaggerUIBundle({
     url: "./spec.json",
@@ -533,73 +521,71 @@ let SwaggerController = class SwaggerController {
     ],
     layout: "BaseLayout"
   });
-};`;
-    }
-    'spec.json'() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const logger = useEventLogger('@moostjs/zod');
-            if (!this.spec) {
-                const { instantiate } = useControllerContext();
-                const moost = yield instantiate(Moost);
-                this.spec = mapToSwaggerSpec(moost.getControllersOverview(), { title: this.title }, logger);
-            }
-            return this.spec;
-        });
-    }
-    files(url) {
-        return this.serve(url.split('/').pop());
-    }
-    serve(path) {
-        return serveFile(path, {
-            baseDir: this.assetPath,
-            cacheControl: {
-                public: true,
-                maxAge: '1w',
-            },
-        });
-    }
-};
-__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)
-], SwaggerController.prototype, "serveIndex", null);
-__decorate([
-    Get(),
-    SetHeader('content-type', 'application/javascript'),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
-], SwaggerController.prototype, "swagger-initializer.js", null);
-__decorate([
-    Get(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __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)
-], SwaggerController.prototype, "files", null);
-SwaggerController = __decorate([
-    SwaggerExclude(),
-    ZodSkip(),
-    Controller('api-docs'),
-    __param(0, Const('Moost API')),
-    __metadata("design:paramtypes", [Object])
+};`;
+    }
+    async 'spec.json'() {
+        const logger = useEventLogger('@moostjs/zod');
+        if (!this.spec) {
+            const { instantiate } = useControllerContext();
+            const moost = await instantiate(Moost);
+            this.spec = mapToSwaggerSpec(moost.getControllersOverview(), { title: this.title }, logger);
+        }
+        return this.spec;
+    }
+    files(url) {
+        return this.serve(url.split('/').pop());
+    }
+    serve(path) {
+        return serveFile(path, {
+            baseDir: this.assetPath,
+            cacheControl: {
+                public: true,
+                maxAge: '1w',
+            },
+        });
+    }
+};
+__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)
+], SwaggerController.prototype, "serveIndex", null);
+__decorate([
+    Get(),
+    SetHeader('content-type', 'application/javascript'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], SwaggerController.prototype, "swagger-initializer.js", null);
+__decorate([
+    Get(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __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)
+], SwaggerController.prototype, "files", null);
+SwaggerController = __decorate([
+    SwaggerExclude(),
+    ZodSkip(),
+    Controller('api-docs'),
+    __param(0, Const('Moost API')),
+    __metadata("design:paramtypes", [Object])
 ], SwaggerController);
 
 export { SwaggerController, SwaggerDescription, SwaggerExclude, SwaggerRequestBody, SwaggerResponse, SwaggerTag, getSwaggerMate };