@moostjs/swagger 0.2.34

package/README.md

@@ -0,0 +1 @@
+# @moostjs/swagger

package/dist/index.cjs

@@ -0,0 +1,612 @@
+'use strict';
+
+var eventHttp = require('@moostjs/event-http');
+var moost = require('moost');
+var swaggerUiDist = require('swagger-ui-dist');
+var httpStatic = require('@wooksjs/http-static');
+var path = require('path');
+var zod = require('@moostjs/zod');
+var zodParser = require('zod-parser');
+
+/******************************************************************************
+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 */
+
+
+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);
+}
+
+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());
+    });
+}
+
+function getSwaggerMate() {
+    return moost.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;
+    });
+}
+
+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 zod.z.ZodType) {
+                            zt = type;
+                        }
+                        else if (typeof type === 'function') {
+                            zt = zod.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(zod.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 zod.z.ZodType) {
+                        zt = type;
+                    }
+                    else if (typeof type === 'function') {
+                        zt = zod.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 = zod.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 = zod.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 = zod.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 zodParser.parseZodType(schema);
+}
+function getDefaultStatusCode(httpMethod) {
+    const defaultStatusCodes = {
+        GET: 200,
+        PUT: 200,
+        POST: 201,
+        DELETE: 204,
+    };
+    return defaultStatusCodes[httpMethod.toUpperCase()] || 200;
+}
+
+exports.SwaggerController = class SwaggerController {
+    constructor(title = 'Moost API') {
+        this.title = title;
+        this.assetPath = swaggerUiDist.getAbsoluteFSPath();
+    }
+    serveIndex(url, location, status) {
+        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">
+    <title>${this.title}</title>
+    <link rel="stylesheet" type="text/css" href="./swagger-ui.css" />
+    <link rel="stylesheet" type="text/css" href="index.css" />
+    <link rel="icon" type="image/png" href="./favicon-32x32.png" sizes="32x32" />
+    <link rel="icon" type="image/png" href="./favicon-16x16.png" sizes="16x16" />
+  </head>
+
+  <body>
+    <div id="swagger-ui"></div>
+    <script src="./swagger-ui-bundle.js" charset="UTF-8"> </script>
+    <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'() {
+        return `window.onload = function() {
+  window.ui = SwaggerUIBundle({
+    url: "./spec.json",
+    dom_id: '#swagger-ui',
+    deepLinking: true,
+    presets: [
+      SwaggerUIBundle.presets.apis,
+      SwaggerUIStandalonePreset
+    ],
+    plugins: [
+      SwaggerUIBundle.plugins.DownloadUrl
+    ],
+    layout: "BaseLayout"
+  });
+};`;
+    }
+    'spec.json'() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const logger = moost.useEventLogger('@moostjs/zod');
+            if (!this.spec) {
+                const { instantiate } = moost.useControllerContext();
+                const moost$1 = yield instantiate(moost.Moost);
+                this.spec = mapToSwaggerSpec(moost$1.getControllersOverview(), { title: this.title }, logger);
+            }
+            return this.spec;
+        });
+    }
+    files(url) {
+        return this.serve(url.split('/').pop());
+    }
+    serve(path) {
+        return httpStatic.serveFile(path, {
+            baseDir: this.assetPath,
+            cacheControl: {
+                public: true,
+                maxAge: '1w',
+            },
+        });
+    }
+};
+__decorate([
+    eventHttp.Get(''),
+    eventHttp.Get('//'),
+    eventHttp.Get('index.html'),
+    eventHttp.SetHeader('content-type', 'text/html'),
+    __param(0, eventHttp.Url()),
+    __param(1, eventHttp.HeaderHook('location')),
+    __param(2, eventHttp.StatusHook()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", void 0)
+], exports.SwaggerController.prototype, "serveIndex", null);
+__decorate([
+    eventHttp.Get(),
+    eventHttp.SetHeader('content-type', 'application/javascript'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], exports.SwaggerController.prototype, "swagger-initializer.js", null);
+__decorate([
+    eventHttp.Get(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], exports.SwaggerController.prototype, "spec.json", null);
+__decorate([
+    eventHttp.Get('swagger-ui-bundle.*(js|js\\.map)'),
+    eventHttp.Get('swagger-ui-standalone-preset.*(js|js\\.map)'),
+    eventHttp.Get('swagger-ui.*(css|css\\.map)'),
+    eventHttp.Get('index.*(css|css\\.map)'),
+    __param(0, eventHttp.Url()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], exports.SwaggerController.prototype, "files", null);
+exports.SwaggerController = __decorate([
+    SwaggerExclude(),
+    zod.ZodSkip(),
+    moost.Controller('api-docs'),
+    __param(0, moost.Const('Moost API')),
+    __metadata("design:paramtypes", [Object])
+], exports.SwaggerController);
+
+exports.SwaggerDescription = SwaggerDescription;
+exports.SwaggerExclude = SwaggerExclude;
+exports.SwaggerRequestBody = SwaggerRequestBody;
+exports.SwaggerResponse = SwaggerResponse;
+exports.SwaggerTag = SwaggerTag;
+exports.getSwaggerMate = getSwaggerMate;

package/dist/index.d.ts

@@ -0,0 +1,94 @@
+import { Mate } from '@prostojs/mate';
+import { THeaderHook } from '@wooksjs/event-http';
+import { TMateParamMeta } from '@prostojs/mate';
+import { TMoostMetadata } from 'moost';
+import { TStatusHook } from '@wooksjs/event-http';
+import { z } from '@moostjs/zod';
+
+export declare function getSwaggerMate(): Mate<TMoostMetadata<TEmpty> & TSwaggerMate & {
+params: (TEmpty & TMateParamMeta)[];
+}, TMoostMetadata<TEmpty> & TSwaggerMate & {
+params: (TEmpty & TMateParamMeta)[];
+}>;
+
+export declare class SwaggerController {
+    protected title: string;
+    constructor(title?: string);
+    assetPath: string;
+    serveIndex(url: string, location: THeaderHook, status: TStatusHook): string;
+    'swagger-initializer.js'(): string;
+    spec?: Record<string, unknown>;
+    'spec.json'(): Promise<Record<string, unknown>>;
+    files(url: string): Promise<unknown>;
+    serve(path: string): Promise<unknown>;
+}
+
+export declare const SwaggerDescription: (descr: string) => MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
+
+export declare const SwaggerExclude: () => MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
+
+export declare function SwaggerRequestBody(opt: TSwaggerResponseOpts): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
+
+export declare function SwaggerResponse(opts: TSwaggerResponseOpts): MethodDecorator;
+
+export declare function SwaggerResponse(code: number, opts: TSwaggerResponseOpts): MethodDecorator;
+
+export declare const SwaggerTag: (tag: string) => MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
+
+declare interface TEmpty {
+}
+
+declare type TFunction = Function;
+
+export declare interface TSwaggerMate {
+    swaggerTags: string[];
+    swaggerExclude: boolean;
+    swaggerDescription: string;
+    swaggerResponses: Record<number, Record<string, TSwaggerResponseConfigValue>>;
+    swaggerRequestBody: Record<string, TSwaggerResponseConfigValue>;
+}
+
+declare interface TSwaggerResponseConfig {
+    contentType?: string;
+    description?: string;
+    response: TSwaggerResponseConfigValue;
+}
+
+export declare type TSwaggerResponseConfigValue = TFunction | z.ZodType | TSwaggerSchema;
+
+export declare type TSwaggerResponseOpts = TSwaggerResponseConfigValue | TSwaggerResponseConfig;
+
+declare interface TSwaggerSchema {
+    type?: string;
+    $ref?: string;
+    title?: string;
+    description?: string;
+    format?: string;
+    default?: unknown;
+    enum?: string[];
+    nullable?: boolean;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    example?: unknown;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    multipleOf?: number;
+    items?: TSwaggerSchema | TSwaggerSchema[];
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    properties?: Record<string, TSwaggerSchema>;
+    additionalProperties?: boolean | TSwaggerSchema;
+    required?: string[];
+    allOf?: TSwaggerSchema[];
+    anyOf?: TSwaggerSchema[];
+    oneOf?: TSwaggerSchema[];
+    not?: TSwaggerSchema;
+}
+
+export { }

package/dist/index.mjs

@@ -0,0 +1,605 @@
+import { Get, SetHeader, Url, HeaderHook, StatusHook } from '@moostjs/event-http';
+import { getMoostMate, Controller, Const, useEventLogger, useControllerContext, Moost } from 'moost';
+import { getAbsoluteFSPath } from 'swagger-ui-dist';
+import { serveFile } from '@wooksjs/http-static';
+import { join } from 'path';
+import { z, getZodType, getZodTypeForProp, ZodSkip } from '@moostjs/zod';
+import { parseZodType } from 'zod-parser';
+
+/******************************************************************************
+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 */
+
+
+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);
+}
+
+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());
+    });
+}
+
+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;
+    });
+}
+
+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;
+}
+
+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>
+    <meta charset="UTF-8">
+    <title>${this.title}</title>
+    <link rel="stylesheet" type="text/css" href="./swagger-ui.css" />
+    <link rel="stylesheet" type="text/css" href="index.css" />
+    <link rel="icon" type="image/png" href="./favicon-32x32.png" sizes="32x32" />
+    <link rel="icon" type="image/png" href="./favicon-16x16.png" sizes="16x16" />
+  </head>
+
+  <body>
+    <div id="swagger-ui"></div>
+    <script src="./swagger-ui-bundle.js" charset="UTF-8"> </script>
+    <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'() {
+        return `window.onload = function() {
+  window.ui = SwaggerUIBundle({
+    url: "./spec.json",
+    dom_id: '#swagger-ui',
+    deepLinking: true,
+    presets: [
+      SwaggerUIBundle.presets.apis,
+      SwaggerUIStandalonePreset
+    ],
+    plugins: [
+      SwaggerUIBundle.plugins.DownloadUrl
+    ],
+    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])
+], SwaggerController);
+
+export { SwaggerController, SwaggerDescription, SwaggerExclude, SwaggerRequestBody, SwaggerResponse, SwaggerTag, getSwaggerMate };

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@moostjs/swagger",
+  "version": "0.2.34",
+  "description": "@moostjs/swagger",
+  "sideEffects": false,
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moostjs/moostjs.git",
+    "directory": "packages/swagger"
+  },
+  "keywords": [
+    "moost",
+    "moostjs",
+    "composables",
+    "framework",
+    "wooksjs",
+    "prostojs"
+  ],
+  "author": "Artem Maltsev",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/moostjs/moostjs/issues"
+  },
+  "homepage": "https://github.com/moostjs/moostjs/tree/main/packages/swagger#readme",
+  "peerDependencies": {
+    "moost": "0.2.34",
+    "@moostjs/event-http": "0.2.34"
+  },
+  "dependencies": {
+    "swagger-ui-dist": "^4.19.0",
+    "zod-parser": "^0.0.3",
+    "@moostjs/zod": "0.2.34",
+    "@wooksjs/http-static": "^0.3.11"
+  },
+  "devDependencies": {
+    "@types/swagger-ui-dist": ""
+  }
+}