nestjs-openapi-next 1.0.0

package/dist/swagger-explorer.js

@@ -0,0 +1,326 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwaggerExplorer = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("@nestjs/common/constants");
+const interfaces_1 = require("@nestjs/common/interfaces");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const core_1 = require("@nestjs/core");
+const legacy_route_converter_1 = require("@nestjs/core/router/legacy-route-converter");
+const route_path_factory_1 = require("@nestjs/core/router/route-path-factory");
+const lodash_1 = require("lodash");
+const path_to_regexp_1 = require("path-to-regexp");
+const constants_2 = require("./constants");
+const api_callbacks_explorer_1 = require("./explorers/api-callbacks.explorer");
+const api_exclude_controller_explorer_1 = require("./explorers/api-exclude-controller.explorer");
+const api_exclude_endpoint_explorer_1 = require("./explorers/api-exclude-endpoint.explorer");
+const api_extra_models_explorer_1 = require("./explorers/api-extra-models.explorer");
+const api_headers_explorer_1 = require("./explorers/api-headers.explorer");
+const api_operation_explorer_1 = require("./explorers/api-operation.explorer");
+const api_parameters_explorer_1 = require("./explorers/api-parameters.explorer");
+const api_response_explorer_1 = require("./explorers/api-response.explorer");
+const api_security_explorer_1 = require("./explorers/api-security.explorer");
+const api_use_tags_explorer_1 = require("./explorers/api-use-tags.explorer");
+const mimetype_content_wrapper_1 = require("./services/mimetype-content-wrapper");
+const is_body_parameter_util_1 = require("./utils/is-body-parameter.util");
+const merge_and_uniq_util_1 = require("./utils/merge-and-uniq.util");
+class SwaggerExplorer {
+    constructor(schemaObjectFactory, options = {}) {
+        this.schemaObjectFactory = schemaObjectFactory;
+        this.options = options;
+        this.mimetypeContentWrapper = new mimetype_content_wrapper_1.MimetypeContentWrapper();
+        this.metadataScanner = new core_1.MetadataScanner();
+        this.schemas = {};
+        this.operationIdFactory = (controllerKey, methodKey, version) => version
+            ? controllerKey
+                ? `${controllerKey}_${methodKey}_${version}`
+                : `${methodKey}_${version}`
+            : controllerKey
+                ? `${controllerKey}_${methodKey}`
+                : methodKey;
+        this.linkNameFactory = (controllerKey, methodKey, fieldKey) => controllerKey
+            ? `${controllerKey}_${methodKey}_from_${fieldKey}`
+            : `${methodKey}_from_${fieldKey}`;
+    }
+    exploreController(wrapper, applicationConfig, options) {
+        const { operationIdFactory, linkNameFactory } = options;
+        this.routePathFactory = new route_path_factory_1.RoutePathFactory(applicationConfig);
+        if (operationIdFactory) {
+            this.operationIdFactory = operationIdFactory;
+        }
+        if (linkNameFactory) {
+            this.linkNameFactory = linkNameFactory;
+        }
+        const { instance, metatype } = wrapper;
+        const prototype = Object.getPrototypeOf(instance);
+        const documentResolvers = {
+            root: [
+                this.exploreRoutePathAndMethod,
+                api_operation_explorer_1.exploreApiOperationMetadata,
+                api_parameters_explorer_1.exploreApiParametersMetadata.bind(null, this.schemas)
+            ],
+            security: [api_security_explorer_1.exploreApiSecurityMetadata],
+            tags: [api_use_tags_explorer_1.exploreApiTagsMetadata],
+            callbacks: [api_callbacks_explorer_1.exploreApiCallbacksMetadata],
+            responses: [
+                api_response_explorer_1.exploreApiResponseMetadata.bind(null, this.schemas, {
+                    operationId: this.operationIdFactory,
+                    linkName: this.linkNameFactory
+                })
+            ]
+        };
+        return this.generateDenormalizedDocument(metatype, prototype, instance, documentResolvers, applicationConfig, options);
+    }
+    getSchemas() {
+        return this.schemas;
+    }
+    generateDenormalizedDocument(metatype, prototype, instance, documentResolvers, applicationConfig, options) {
+        const self = this;
+        const excludeController = (0, api_exclude_controller_explorer_1.exploreApiExcludeControllerMetadata)(metatype);
+        if (excludeController) {
+            return [];
+        }
+        const globalMetadata = this.exploreGlobalMetadata(metatype, {
+            autoTagControllers: options.autoTagControllers
+        });
+        const ctrlExtraModels = (0, api_extra_models_explorer_1.exploreGlobalApiExtraModelsMetadata)(metatype);
+        this.registerExtraModels(ctrlExtraModels);
+        const denormalizedPaths = this.metadataScanner.scanFromPrototype(instance, prototype, (name) => {
+            const targetCallback = prototype[name];
+            const excludeEndpoint = (0, api_exclude_endpoint_explorer_1.exploreApiExcludeEndpointMetadata)(instance, prototype, targetCallback);
+            if (excludeEndpoint && excludeEndpoint.disable) {
+                return;
+            }
+            const ctrlExtraModels = (0, api_extra_models_explorer_1.exploreApiExtraModelsMetadata)(instance, prototype, targetCallback);
+            this.registerExtraModels(ctrlExtraModels);
+            const methodMetadata = (0, lodash_1.mapValues)(documentResolvers, (explorers) => explorers.reduce((metadata, fn) => {
+                const exploredMetadata = fn.call(self, instance, prototype, targetCallback, metatype, options.globalPrefix, options.modulePath, applicationConfig, options.autoTagControllers);
+                if (!exploredMetadata) {
+                    return metadata;
+                }
+                if (!(0, lodash_1.isArray)(exploredMetadata)) {
+                    if (Array.isArray(metadata)) {
+                        return metadata.map((item) => (Object.assign(Object.assign({}, item), exploredMetadata)));
+                    }
+                    return Object.assign(Object.assign({}, metadata), exploredMetadata);
+                }
+                return (0, lodash_1.isArray)(metadata)
+                    ? [...metadata, ...exploredMetadata]
+                    : exploredMetadata;
+            }, {}));
+            if (Array.isArray(methodMetadata.root)) {
+                return methodMetadata.root.map((endpointMetadata) => {
+                    endpointMetadata = (0, lodash_1.cloneDeep)(Object.assign(Object.assign({}, methodMetadata), { root: endpointMetadata }));
+                    const mergedMethodMetadata = this.mergeMetadata(globalMetadata, (0, lodash_1.omitBy)(endpointMetadata, lodash_1.isEmpty));
+                    return this.migrateOperationSchema(Object.assign(Object.assign({ responses: {} }, (0, lodash_1.omit)(globalMetadata, 'chunks')), mergedMethodMetadata), prototype, targetCallback);
+                });
+            }
+            const mergedMethodMetadata = this.mergeMetadata(globalMetadata, (0, lodash_1.omitBy)(methodMetadata, lodash_1.isEmpty));
+            return [
+                this.migrateOperationSchema(Object.assign(Object.assign({ responses: {} }, (0, lodash_1.omit)(globalMetadata, 'chunks')), mergedMethodMetadata), prototype, targetCallback)
+            ];
+        });
+        return (0, lodash_1.flatten)(denormalizedPaths).filter((path) => { var _a; return (_a = path.root) === null || _a === void 0 ? void 0 : _a.path; });
+    }
+    exploreGlobalMetadata(metatype, options) {
+        const globalExplorers = [
+            (0, api_use_tags_explorer_1.exploreGlobalApiTagsMetadata)(options.autoTagControllers),
+            api_security_explorer_1.exploreGlobalApiSecurityMetadata,
+            api_response_explorer_1.exploreGlobalApiResponseMetadata.bind(null, this.schemas),
+            api_headers_explorer_1.exploreGlobalApiHeaderMetadata
+        ];
+        const globalMetadata = globalExplorers
+            .map((explorer) => explorer.call(explorer, metatype))
+            .filter((val) => !(0, shared_utils_1.isUndefined)(val))
+            .reduce((curr, next) => {
+            if (next.depth) {
+                return Object.assign(Object.assign({}, curr), { chunks: (curr.chunks || []).concat(next) });
+            }
+            return Object.assign(Object.assign({}, curr), next);
+        }, {});
+        return globalMetadata;
+    }
+    exploreRoutePathAndMethod(instance, prototype, method, metatype, globalPrefix, modulePath, applicationConfig) {
+        const methodPath = Reflect.getMetadata(constants_1.PATH_METADATA, method);
+        if ((0, shared_utils_1.isUndefined)(methodPath)) {
+            return undefined;
+        }
+        const requestMethodMetadata = Reflect.getMetadata(constants_1.METHOD_METADATA, method);
+        const isQueryMethod = Reflect.getMetadata(constants_2.DECORATORS.API_QUERY_METHOD, method);
+        const requestMethodForPathFactory = typeof requestMethodMetadata === 'number'
+            ? requestMethodMetadata
+            :
+                common_1.RequestMethod.GET;
+        const methodVersion = Reflect.getMetadata(constants_1.VERSION_METADATA, method);
+        const versioningOptions = applicationConfig.getVersioning();
+        const controllerVersion = this.getVersionMetadata(metatype, versioningOptions);
+        const versionOrVersions = methodVersion !== null && methodVersion !== void 0 ? methodVersion : controllerVersion;
+        const versions = this.getRoutePathVersions(versionOrVersions, versioningOptions);
+        const allRoutePaths = this.routePathFactory.create({
+            methodPath,
+            methodVersion,
+            modulePath,
+            globalPrefix,
+            controllerVersion,
+            ctrlPath: this.reflectControllerPath(metatype),
+            versioningOptions: applicationConfig.getVersioning()
+        }, requestMethodForPathFactory);
+        return (0, lodash_1.flatten)(allRoutePaths.map((routePath, index) => {
+            const fullPath = this.validateRoutePath(routePath);
+            const apiExtension = Reflect.getMetadata(constants_2.DECORATORS.API_EXTENSION, method);
+            if (!isQueryMethod &&
+                typeof requestMethodMetadata === 'number' &&
+                requestMethodMetadata === common_1.RequestMethod.ALL) {
+                const validMethods = [
+                    'get',
+                    'post',
+                    'put',
+                    'delete',
+                    'patch',
+                    'options',
+                    'head',
+                    'search'
+                ];
+                return validMethods.map((requestMethod) => (Object.assign({ method: requestMethod, path: fullPath === '' ? '/' : fullPath, operationId: `${this.getOperationId(instance, method.name)}_${requestMethod.toLowerCase()}` }, apiExtension)));
+            }
+            const pathVersion = versions.find((v) => fullPath.includes(`/${v}/`) || fullPath.endsWith(`/${v}`));
+            const isAlias = allRoutePaths.length > 1 && allRoutePaths.length !== versions.length;
+            const methodKey = isAlias ? `${method.name}[${index}]` : method.name;
+            const httpMethodKey = isQueryMethod
+                ? 'query'
+                : typeof requestMethodMetadata === 'string'
+                    ? requestMethodMetadata.toLowerCase()
+                    : common_1.RequestMethod[requestMethodForPathFactory].toLowerCase();
+            return Object.assign({ method: httpMethodKey, path: fullPath === '' ? '/' : fullPath, operationId: this.getOperationId(instance, methodKey, pathVersion) }, apiExtension);
+        }));
+    }
+    getOperationId(instance, methodKey, version) {
+        var _a;
+        return this.operationIdFactory(((_a = instance.constructor) === null || _a === void 0 ? void 0 : _a.name) || '', methodKey, version);
+    }
+    getRoutePathVersions(versionValue, versioningOptions) {
+        let versions = [];
+        if (!versionValue || (versioningOptions === null || versioningOptions === void 0 ? void 0 : versioningOptions.type) !== common_1.VersioningType.URI) {
+            return versions;
+        }
+        if (Array.isArray(versionValue)) {
+            versions = versionValue.filter((v) => v !== interfaces_1.VERSION_NEUTRAL);
+        }
+        else if (versionValue !== interfaces_1.VERSION_NEUTRAL) {
+            versions = [versionValue];
+        }
+        const prefix = this.routePathFactory.getVersionPrefix(versioningOptions);
+        versions = versions.map((v) => `${prefix}${v}`);
+        return versions;
+    }
+    reflectControllerPath(metatype) {
+        return Reflect.getMetadata(constants_1.PATH_METADATA, metatype);
+    }
+    validateRoutePath(path) {
+        if ((0, shared_utils_1.isUndefined)(path)) {
+            return '';
+        }
+        if (Array.isArray(path)) {
+            path = (0, lodash_1.head)(path);
+        }
+        let pathWithParams = '';
+        try {
+            let normalizedPath = legacy_route_converter_1.LegacyRouteConverter.tryConvert(path, {
+                logs: this.options.httpAdapterType !== 'fastify'
+            });
+            normalizedPath = normalizedPath.replace(/::/g, '\\:');
+            normalizedPath = normalizedPath.replace(/\[:\]/g, '\\:');
+            normalizedPath = normalizedPath.replace(/\(\^([^)]+)\)/g, '');
+            const { tokens } = (0, path_to_regexp_1.parse)(normalizedPath);
+            for (const item of tokens) {
+                if (item.type === 'text') {
+                    pathWithParams += item.value;
+                }
+                else if (item.type === 'param') {
+                    pathWithParams += `{${item.name}}`;
+                }
+                else if (item.type === 'wildcard') {
+                    pathWithParams += `{${item.name}}`;
+                }
+                else if (item.type === 'group') {
+                    pathWithParams += item.tokens.reduce((acc, item) => acc +
+                        (item.type === 'text'
+                            ? item.value
+                            : `{${item.name}}`), '');
+                }
+            }
+        }
+        catch (err) {
+            if (err instanceof TypeError) {
+                legacy_route_converter_1.LegacyRouteConverter.printError(path);
+            }
+            throw err;
+        }
+        return pathWithParams === '/' ? '' : (0, shared_utils_1.addLeadingSlash)(pathWithParams);
+    }
+    mergeMetadata(globalMetadata, methodMetadata) {
+        if (methodMetadata.root && !methodMetadata.root.parameters) {
+            methodMetadata.root.parameters = [];
+        }
+        const deepMerge = (metadata) => (value, key) => {
+            if (!metadata[key]) {
+                return value;
+            }
+            const globalValue = metadata[key];
+            if (metadata.depth) {
+                return this.deepMergeMetadata(globalValue, value, metadata.depth);
+            }
+            return this.mergeValues(globalValue, value);
+        };
+        if (globalMetadata.chunks) {
+            const { chunks } = globalMetadata;
+            chunks.forEach((chunk) => {
+                methodMetadata = (0, lodash_1.mapValues)(methodMetadata, deepMerge(chunk));
+            });
+        }
+        return (0, lodash_1.mapValues)(methodMetadata, deepMerge(globalMetadata));
+    }
+    deepMergeMetadata(globalValue, methodValue, maxDepth, currentDepthLevel = 0) {
+        if (currentDepthLevel === maxDepth) {
+            return this.mergeValues(globalValue, methodValue);
+        }
+        return (0, lodash_1.mapValues)(methodValue, (value, key) => {
+            if (key in globalValue) {
+                return this.deepMergeMetadata(globalValue[key], methodValue[key], maxDepth, currentDepthLevel + 1);
+            }
+            return value;
+        });
+    }
+    mergeValues(globalValue, methodValue) {
+        if (!(0, lodash_1.isArray)(globalValue)) {
+            return Object.assign(Object.assign({}, globalValue), methodValue);
+        }
+        return [...globalValue, ...methodValue];
+    }
+    migrateOperationSchema(document, prototype, method) {
+        const parametersObject = (0, lodash_1.get)(document, 'root.parameters');
+        const requestBodyIndex = (parametersObject || []).findIndex(is_body_parameter_util_1.isBodyParameter);
+        if (requestBodyIndex < 0) {
+            return document;
+        }
+        const requestBody = parametersObject[requestBodyIndex];
+        parametersObject.splice(requestBodyIndex, 1);
+        const classConsumes = Reflect.getMetadata(constants_2.DECORATORS.API_CONSUMES, prototype);
+        const methodConsumes = Reflect.getMetadata(constants_2.DECORATORS.API_CONSUMES, method);
+        let consumes = (0, merge_and_uniq_util_1.mergeAndUniq)(classConsumes, methodConsumes);
+        consumes = (0, lodash_1.isEmpty)(consumes) ? ['application/json'] : consumes;
+        const keysToRemove = ['schema', 'in', 'name', 'examples'];
+        document.root.requestBody = Object.assign(Object.assign({}, (0, lodash_1.omit)(requestBody, keysToRemove)), this.mimetypeContentWrapper.wrap(consumes, (0, lodash_1.pick)(requestBody, ['schema', 'examples'])));
+        return document;
+    }
+    registerExtraModels(extraModels) {
+        extraModels.forEach((item) => this.schemaObjectFactory.exploreModelSchema(item, this.schemas));
+    }
+    getVersionMetadata(metatype, versioningOptions) {
+        var _a;
+        if ((versioningOptions === null || versioningOptions === void 0 ? void 0 : versioningOptions.type) === common_1.VersioningType.URI) {
+            return ((_a = Reflect.getMetadata(constants_1.VERSION_METADATA, metatype)) !== null && _a !== void 0 ? _a : versioningOptions.defaultVersion);
+        }
+    }
+}
+exports.SwaggerExplorer = SwaggerExplorer;

package/dist/swagger-module.d.ts

@@ -0,0 +1,27 @@
+import { INestApplication } from '@nestjs/common';
+import { HttpServer } from '@nestjs/common/interfaces/http/http-server.interface';
+import { OpenAPIObject, SwaggerCustomOptions, SwaggerDocumentOptions } from './interfaces';
+export declare class SwaggerModule {
+    private static readonly metadataLoader;
+    private static mergeTags;
+    static createDocument(app: INestApplication, config: Omit<OpenAPIObject, 'paths'>, options?: SwaggerDocumentOptions): OpenAPIObject;
+    static loadPluginMetadata(metadataFn: () => Promise<Record<string, any>>): Promise<void>;
+    protected static serveStatic(finalPath: string, app: INestApplication, customStaticPath?: string): void;
+    protected static serveDocuments(finalPath: string, urlLastSubdirectory: string, httpAdapter: HttpServer, documentOrFactory: OpenAPIObject | (() => OpenAPIObject), options: {
+        ui: boolean;
+        raw: boolean | Array<'json' | 'yaml'>;
+        jsonDocumentUrl: string;
+        yamlDocumentUrl: string;
+        swaggerOptions: SwaggerCustomOptions;
+    }): void;
+    protected static serveSwaggerUi(finalPath: string, urlLastSubdirectory: string, httpAdapter: HttpServer, getBuiltDocument: () => OpenAPIObject, swaggerOptions: SwaggerCustomOptions): void;
+    protected static serveDefinitions(httpAdapter: HttpServer, getBuiltDocument: () => OpenAPIObject, options: {
+        jsonDocumentUrl: string;
+        yamlDocumentUrl: string;
+        swaggerOptions: SwaggerCustomOptions;
+    }, serveOptions: {
+        serveJson: boolean;
+        serveYaml: boolean;
+    }): void;
+    static setup(path: string, app: INestApplication, documentOrFactory: OpenAPIObject | (() => OpenAPIObject), options?: SwaggerCustomOptions): void;
+}

package/dist/swagger-module.js

@@ -0,0 +1,223 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwaggerModule = void 0;
+const common_1 = require("@nestjs/common");
+const jsyaml = require("js-yaml");
+const metadata_loader_1 = require("./plugin/metadata-loader");
+const swagger_scanner_1 = require("./swagger-scanner");
+const swagger_ui_1 = require("./swagger-ui");
+const assign_two_levels_deep_1 = require("./utils/assign-two-levels-deep");
+const get_global_prefix_1 = require("./utils/get-global-prefix");
+const normalize_rel_path_1 = require("./utils/normalize-rel-path");
+const resolve_path_util_1 = require("./utils/resolve-path.util");
+const validate_global_prefix_util_1 = require("./utils/validate-global-prefix.util");
+const validate_path_util_1 = require("./utils/validate-path.util");
+class SwaggerModule {
+    static mergeTags(configTags, scannedTags) {
+        var _a, _b, _c, _d, _e;
+        const byName = new Map();
+        for (const tag of configTags || []) {
+            if (!(tag === null || tag === void 0 ? void 0 : tag.name)) {
+                continue;
+            }
+            byName.set(tag.name, Object.assign({}, tag));
+        }
+        for (const tag of scannedTags || []) {
+            if (!(tag === null || tag === void 0 ? void 0 : tag.name)) {
+                continue;
+            }
+            const existing = byName.get(tag.name) || { name: tag.name };
+            const merged = { name: tag.name };
+            merged.summary = (_a = existing.summary) !== null && _a !== void 0 ? _a : tag.summary;
+            merged.description = (_b = existing.description) !== null && _b !== void 0 ? _b : tag.description;
+            merged.externalDocs = (_c = existing.externalDocs) !== null && _c !== void 0 ? _c : tag.externalDocs;
+            merged.parent = (_d = existing.parent) !== null && _d !== void 0 ? _d : tag.parent;
+            merged.kind = (_e = existing.kind) !== null && _e !== void 0 ? _e : tag.kind;
+            byName.set(tag.name, merged);
+        }
+        const merged = [...byName.values()];
+        return merged.length > 0 ? merged : undefined;
+    }
+    static createDocument(app, config, options = {}) {
+        const swaggerScanner = new swagger_scanner_1.SwaggerScanner();
+        const document = swaggerScanner.scanApplication(app, options);
+        document.components = (0, assign_two_levels_deep_1.assignTwoLevelsDeep)({}, config.components, document.components);
+        const mergedTags = SwaggerModule.mergeTags(config.tags, document.tags);
+        const mergedDocument = Object.assign(Object.assign(Object.assign({ openapi: '3.0.0', paths: {} }, config), document), (mergedTags ? { tags: mergedTags } : {}));
+        return mergedDocument;
+    }
+    static loadPluginMetadata(metadataFn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const metadata = yield metadataFn();
+            return this.metadataLoader.load(metadata);
+        });
+    }
+    static serveStatic(finalPath, app, customStaticPath) {
+        const httpAdapter = app.getHttpAdapter();
+        const swaggerAssetsPath = customStaticPath
+            ? (0, resolve_path_util_1.resolvePath)(customStaticPath)
+            : (0, swagger_ui_1.getSwaggerAssetsAbsoluteFSPath)();
+        if (httpAdapter && httpAdapter.getType() === 'fastify') {
+            app.useStaticAssets({
+                root: swaggerAssetsPath,
+                prefix: finalPath,
+                decorateReply: false
+            });
+        }
+        else {
+            app.useStaticAssets(swaggerAssetsPath, {
+                prefix: finalPath
+            });
+        }
+    }
+    static serveDocuments(finalPath, urlLastSubdirectory, httpAdapter, documentOrFactory, options) {
+        let document;
+        const getBuiltDocument = () => {
+            if (!document) {
+                document =
+                    typeof documentOrFactory === 'function'
+                        ? documentOrFactory()
+                        : documentOrFactory;
+            }
+            return document;
+        };
+        if (options.ui) {
+            this.serveSwaggerUi(finalPath, urlLastSubdirectory, httpAdapter, getBuiltDocument, options.swaggerOptions);
+        }
+        if (options.raw === true ||
+            (Array.isArray(options.raw) && options.raw.length > 0)) {
+            const serveJson = options.raw === true || options.raw.includes('json');
+            const serveYaml = options.raw === true || options.raw.includes('yaml');
+            this.serveDefinitions(httpAdapter, getBuiltDocument, options, {
+                serveJson,
+                serveYaml
+            });
+        }
+    }
+    static serveSwaggerUi(finalPath, urlLastSubdirectory, httpAdapter, getBuiltDocument, swaggerOptions) {
+        const baseUrlForSwaggerUI = (0, normalize_rel_path_1.normalizeRelPath)(`./${urlLastSubdirectory}/`);
+        let swaggerUiHtml;
+        let swaggerUiInitJS;
+        httpAdapter.get((0, normalize_rel_path_1.normalizeRelPath)(`${finalPath}/swagger-ui-init.js`), (req, res) => {
+            res.type('application/javascript');
+            const document = getBuiltDocument();
+            if (swaggerOptions.patchDocumentOnRequest) {
+                const documentToSerialize = swaggerOptions.patchDocumentOnRequest(req, res, document);
+                const swaggerInitJsPerRequest = (0, swagger_ui_1.buildSwaggerInitJS)(documentToSerialize, swaggerOptions);
+                return res.send(swaggerInitJsPerRequest);
+            }
+            if (!swaggerUiInitJS) {
+                swaggerUiInitJS = (0, swagger_ui_1.buildSwaggerInitJS)(document, swaggerOptions);
+            }
+            res.send(swaggerUiInitJS);
+        });
+        try {
+            httpAdapter.get((0, normalize_rel_path_1.normalizeRelPath)(`${finalPath}/${urlLastSubdirectory}/swagger-ui-init.js`), (req, res) => {
+                res.type('application/javascript');
+                const document = getBuiltDocument();
+                if (swaggerOptions.patchDocumentOnRequest) {
+                    const documentToSerialize = swaggerOptions.patchDocumentOnRequest(req, res, document);
+                    const swaggerInitJsPerRequest = (0, swagger_ui_1.buildSwaggerInitJS)(documentToSerialize, swaggerOptions);
+                    return res.send(swaggerInitJsPerRequest);
+                }
+                if (!swaggerUiInitJS) {
+                    swaggerUiInitJS = (0, swagger_ui_1.buildSwaggerInitJS)(document, swaggerOptions);
+                }
+                res.send(swaggerUiInitJS);
+            });
+        }
+        catch (_a) {
+        }
+        function serveSwaggerHtml(_, res) {
+            res.type('text/html');
+            if (!swaggerUiHtml) {
+                swaggerUiHtml = (0, swagger_ui_1.buildSwaggerHTML)(baseUrlForSwaggerUI, swaggerOptions);
+            }
+            res.send(swaggerUiHtml);
+        }
+        httpAdapter.get(finalPath, serveSwaggerHtml);
+        httpAdapter.get(`${finalPath}/index.html`, serveSwaggerHtml);
+        httpAdapter.get(`${finalPath}/LICENSE`, () => {
+            throw new common_1.NotFoundException();
+        });
+        try {
+            httpAdapter.get((0, normalize_rel_path_1.normalizeRelPath)(`${finalPath}/`), serveSwaggerHtml);
+        }
+        catch (_b) {
+        }
+    }
+    static serveDefinitions(httpAdapter, getBuiltDocument, options, serveOptions) {
+        if (serveOptions.serveJson) {
+            httpAdapter.get((0, normalize_rel_path_1.normalizeRelPath)(options.jsonDocumentUrl), (req, res) => {
+                res.type('application/json');
+                const document = getBuiltDocument();
+                const documentToSerialize = options.swaggerOptions
+                    .patchDocumentOnRequest
+                    ? options.swaggerOptions.patchDocumentOnRequest(req, res, document)
+                    : document;
+                res.send(JSON.stringify(documentToSerialize));
+            });
+        }
+        if (serveOptions.serveYaml) {
+            httpAdapter.get((0, normalize_rel_path_1.normalizeRelPath)(options.yamlDocumentUrl), (req, res) => {
+                res.type('text/yaml');
+                const document = getBuiltDocument();
+                const documentToSerialize = options.swaggerOptions
+                    .patchDocumentOnRequest
+                    ? options.swaggerOptions.patchDocumentOnRequest(req, res, document)
+                    : document;
+                const yamlDocument = jsyaml.dump(documentToSerialize, {
+                    skipInvalid: true,
+                    noRefs: true
+                });
+                res.send(yamlDocument);
+            });
+        }
+    }
+    static setup(path, app, documentOrFactory, options) {
+        var _a, _b, _c;
+        const globalPrefix = (0, get_global_prefix_1.getGlobalPrefix)(app);
+        const finalPath = (0, validate_path_util_1.validatePath)((options === null || options === void 0 ? void 0 : options.useGlobalPrefix) && (0, validate_global_prefix_util_1.validateGlobalPrefix)(globalPrefix)
+            ? `${globalPrefix}${(0, validate_path_util_1.validatePath)(path)}`
+            : path);
+        const urlLastSubdirectory = finalPath.split('/').slice(-1).pop() || '';
+        const validatedGlobalPrefix = (options === null || options === void 0 ? void 0 : options.useGlobalPrefix) && (0, validate_global_prefix_util_1.validateGlobalPrefix)(globalPrefix)
+            ? (0, validate_path_util_1.validatePath)(globalPrefix)
+            : '';
+        const finalJSONDocumentPath = (options === null || options === void 0 ? void 0 : options.jsonDocumentUrl)
+            ? `${validatedGlobalPrefix}${(0, validate_path_util_1.validatePath)(options.jsonDocumentUrl)}`
+            : `${finalPath}-json`;
+        const finalYAMLDocumentPath = (options === null || options === void 0 ? void 0 : options.yamlDocumentUrl)
+            ? `${validatedGlobalPrefix}${(0, validate_path_util_1.validatePath)(options.yamlDocumentUrl)}`
+            : `${finalPath}-yaml`;
+        const ui = (_b = (_a = options === null || options === void 0 ? void 0 : options.ui) !== null && _a !== void 0 ? _a : options === null || options === void 0 ? void 0 : options.swaggerUiEnabled) !== null && _b !== void 0 ? _b : true;
+        const raw = (_c = options === null || options === void 0 ? void 0 : options.raw) !== null && _c !== void 0 ? _c : true;
+        const httpAdapter = app.getHttpAdapter();
+        SwaggerModule.serveDocuments(finalPath, urlLastSubdirectory, httpAdapter, documentOrFactory, {
+            ui,
+            raw,
+            jsonDocumentUrl: finalJSONDocumentPath,
+            yamlDocumentUrl: finalYAMLDocumentPath,
+            swaggerOptions: options || {}
+        });
+        if (ui) {
+            SwaggerModule.serveStatic(finalPath, app, options === null || options === void 0 ? void 0 : options.customSwaggerUiPath);
+            if (finalPath === `/${urlLastSubdirectory}`) {
+                return;
+            }
+            const serveStaticSlashEndingPath = `${finalPath}/${urlLastSubdirectory}`;
+            SwaggerModule.serveStatic(serveStaticSlashEndingPath, app);
+        }
+    }
+}
+exports.SwaggerModule = SwaggerModule;
+SwaggerModule.metadataLoader = new metadata_loader_1.MetadataLoader();

package/dist/swagger-scanner.d.ts

@@ -0,0 +1,25 @@
+import { INestApplication, InjectionToken } from '@nestjs/common';
+import { ApplicationConfig } from '@nestjs/core';
+import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
+import { Module } from '@nestjs/core/injector/module';
+import { OpenAPIObject, OperationIdFactory, SwaggerDocumentOptions } from './interfaces';
+import { ModuleRoute } from './interfaces/module-route.interface';
+import { SchemaObject } from './interfaces/open-api-spec.interface';
+export declare class SwaggerScanner {
+    private readonly transformer;
+    private readonly schemaObjectFactory;
+    private explorer;
+    scanApplication(app: INestApplication, options: SwaggerDocumentOptions): Omit<OpenAPIObject, 'openapi' | 'info'>;
+    scanModuleControllers(controller: Map<InjectionToken, InstanceWrapper>, applicationConfig: ApplicationConfig, options: {
+        modulePath: string | undefined;
+        globalPrefix: string | undefined;
+        operationIdFactory?: OperationIdFactory;
+        linkNameFactory?: (controllerKey: string, methodKey: string, fieldKey: string) => string;
+        autoTagControllers?: boolean;
+    }): ModuleRoute[];
+    getModules(modulesContainer: Map<string, Module>, include: Function[]): Module[];
+    addExtraModels(schemas: Record<string, SchemaObject>, extraModels: Function[]): void;
+    private getModulePathMetadata;
+    private initializeSwaggerExplorer;
+    private exploreTagGroups;
+}