@flusys/nestjs-core 7.0.2 → 8.0.0-beta.1

package/fesm/config/env-config.service.js

@@ -1,112 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-import * as dotenv from 'dotenv';
-dotenv.config();
-let EnvConfigService = class EnvConfigService {
-    getValue(key, throwOnMissing = true) {
-        const value = this.env[key];
-        if (!value && throwOnMissing) {
-            throw new Error(`Config error - missing env.${key}`);
-        }
-        return value ?? '';
-    }
-    tryGetValue(key, throwOnMissing = false) {
-        if (this.restrictedKeys[key]) {
-            throw new Error(`Access denied for env key "${key}". Use the method \`${this.restrictedKeys[key]}()\` instead.`);
-        }
-        return this.getValue(key, throwOnMissing);
-    }
-    getNumber(key, throwOnMissing = true) {
-        return Number(this.getValue(key, throwOnMissing));
-    }
-    getBoolean(key, throwOnMissing = true) {
-        return this.getValue(key, throwOnMissing).toLowerCase() === 'true';
-    }
-    getPort() {
-        return this.getNumber('PORT', false) || 3000;
-    }
-    isProduction() {
-        return this.getValue('MODE', false).toUpperCase() !== 'DEV';
-    }
-    getOrigins() {
-        const origins = this.getValue('ALLOW_ORIGINS');
-        return origins ? origins.split(',').map((o)=>o.trim()) : [];
-    }
-    getTypeOrmConfig() {
-        const type = this.getValue('DB_TYPE', false) || 'mysql';
-        const defaultPort = type === 'postgres' ? 5432 : 3306;
-        return {
-            type,
-            host: this.getValue('DB_HOST', false) || 'localhost',
-            port: this.getNumber('DB_PORT', false) || defaultPort,
-            username: this.getValue('DB_USER', false) || 'root',
-            password: this.getValue('DB_PASSWORD', false) || '',
-            database: this.getValue('DB_NAME', false) || 'flusys_main'
-        };
-    }
-    getJwtConfig() {
-        return {
-            secret: this.getValue('JWT_SECRET'),
-            expiration: this.getValue('JWT_EXPIRATION', false) || '1h',
-            refreshSecret: this.getValue('REFRESH_TOKEN_SECRET'),
-            refreshExpiration: this.getValue('REFRESH_TOKEN_EXPIRATION', false) || '7d'
-        };
-    }
-    getRedisUrl() {
-        return this.getValue('REDIS_URL', false) || 'redis://localhost:6379';
-    }
-    getMailConfig() {
-        return {
-            MAIL_FROM: this.getValue('MAIL_FROM', false) || '',
-            MAIL_APP_PASSWORD: this.getValue('MAIL_APP_PASSWORD', false) || ''
-        };
-    }
-    getTenantId() {
-        return this.getValue('TENANT_ID', false) || null;
-    }
-    useTenantMode() {
-        return this.getValue('USE_TENANT_MODE', false).toLowerCase() === 'true';
-    }
-    getLogConfig() {
-        return {
-            dir: this.getValue('LOG_DIR', false) || 'logs',
-            level: this.getValue('LOG_LEVEL', false) || (this.isProduction() ? 'info' : 'debug'),
-            maxSize: this.getValue('LOG_MAX_SIZE', false) || '20m',
-            maxFiles: this.getValue('LOG_MAX_FILES', false) || '14d',
-            disableHttpLogging: this.getValue('DISABLE_HTTP_LOGGING', false).toLowerCase() === 'true'
-        };
-    }
-    getEnv() {
-        return process.env;
-    }
-    constructor(env){
-        _define_property(this, "env", void 0);
-        _define_property(this, "restrictedKeys", void 0);
-        this.env = env;
-        this.restrictedKeys = {
-            FRONTEND_URL: 'getFrontendUrl',
-            ALLOW_ORIGINS: 'getOrigins',
-            PORT: 'getPort',
-            MODE: 'isProduction',
-            DB_TYPE: 'getTypeOrmConfig',
-            DB_HOST: 'getTypeOrmConfig',
-            DB_PORT: 'getTypeOrmConfig',
-            DB_USER: 'getTypeOrmConfig',
-            DB_PASSWORD: 'getTypeOrmConfig',
-            DB_NAME: 'getTypeOrmConfig'
-        };
-    }
-};
-const envConfig = new EnvConfigService(process.env);
-export { envConfig };

package/fesm/config/env-config.service.spec.js

@@ -1,321 +0,0 @@
-import { envConfig } from './env-config.service';
-describe('EnvConfigService', ()=>{
-    const ORIGINAL_ENV = {
-        ...process.env
-    };
-    afterEach(()=>{
-        for (const key of Object.keys(process.env)){
-            if (!(key in ORIGINAL_ENV)) delete process.env[key];
-        }
-        Object.assign(process.env, ORIGINAL_ENV);
-    });
-    describe('tryGetValue', ()=>{
-        it('should return env value for an unrestricted key', ()=>{
-            process.env.CUSTOM_KEY = 'custom-value';
-            expect(envConfig.tryGetValue('CUSTOM_KEY')).toBe('custom-value');
-        });
-        it('should return empty string when missing and throwOnMissing is false', ()=>{
-            delete process.env.MISSING_KEY;
-            expect(envConfig.tryGetValue('MISSING_KEY', false)).toBe('');
-        });
-        it('should throw when missing and throwOnMissing is true', ()=>{
-            delete process.env.MISSING_KEY;
-            expect(()=>envConfig.tryGetValue('MISSING_KEY', true)).toThrow('Config error - missing env.MISSING_KEY');
-        });
-        it.each([
-            [
-                'FRONTEND_URL',
-                'getFrontendUrl'
-            ],
-            [
-                'ALLOW_ORIGINS',
-                'getOrigins'
-            ],
-            [
-                'PORT',
-                'getPort'
-            ],
-            [
-                'MODE',
-                'isProduction'
-            ],
-            [
-                'DB_TYPE',
-                'getTypeOrmConfig'
-            ],
-            [
-                'DB_HOST',
-                'getTypeOrmConfig'
-            ],
-            [
-                'DB_PORT',
-                'getTypeOrmConfig'
-            ],
-            [
-                'DB_USER',
-                'getTypeOrmConfig'
-            ],
-            [
-                'DB_PASSWORD',
-                'getTypeOrmConfig'
-            ],
-            [
-                'DB_NAME',
-                'getTypeOrmConfig'
-            ]
-        ])('should deny direct access to restricted key %s and point to %s()', (key, method)=>{
-            expect(()=>envConfig.tryGetValue(key)).toThrow(`Access denied for env key "${key}". Use the method \`${method}()\` instead.`);
-        });
-    });
-    describe('getNumber', ()=>{
-        it('should coerce a numeric env value', ()=>{
-            process.env.SOME_NUMBER = '42';
-            expect(envConfig.getNumber('SOME_NUMBER')).toBe(42);
-        });
-        it('should return NaN for a non-numeric value', ()=>{
-            process.env.SOME_NUMBER = 'not-a-number';
-            expect(envConfig.getNumber('SOME_NUMBER')).toBeNaN();
-        });
-    });
-    describe('getBoolean', ()=>{
-        it.each([
-            [
-                'true',
-                true
-            ],
-            [
-                'TRUE',
-                true
-            ],
-            [
-                'True',
-                true
-            ],
-            [
-                'false',
-                false
-            ],
-            [
-                'yes',
-                false
-            ],
-            [
-                '',
-                false
-            ]
-        ])('should parse %s as %s', (value, expected)=>{
-            process.env.SOME_BOOL = value;
-            expect(envConfig.getBoolean('SOME_BOOL', false)).toBe(expected);
-        });
-    });
-    describe('getPort', ()=>{
-        it('should default to 3000 when PORT is unset', ()=>{
-            delete process.env.PORT;
-            expect(envConfig.getPort()).toBe(3000);
-        });
-        it('should return the configured PORT', ()=>{
-            process.env.PORT = '2002';
-            expect(envConfig.getPort()).toBe(2002);
-        });
-    });
-    describe('isProduction', ()=>{
-        it('should be true when MODE is unset', ()=>{
-            delete process.env.MODE;
-            expect(envConfig.isProduction()).toBe(true);
-        });
-        it('should be false when MODE is "dev" (case-insensitive)', ()=>{
-            process.env.MODE = 'dev';
-            expect(envConfig.isProduction()).toBe(false);
-            process.env.MODE = 'DEV';
-            expect(envConfig.isProduction()).toBe(false);
-        });
-        it('should be true for any non-DEV mode', ()=>{
-            process.env.MODE = 'production';
-            expect(envConfig.isProduction()).toBe(true);
-        });
-    });
-    describe('getOrigins', ()=>{
-        it('should split and trim a comma-separated origin list', ()=>{
-            process.env.ALLOW_ORIGINS = 'http://localhost:2001, http://localhost:3000 ,http://example.com';
-            expect(envConfig.getOrigins()).toEqual([
-                'http://localhost:2001',
-                'http://localhost:3000',
-                'http://example.com'
-            ]);
-        });
-        it('should throw when unset since getOrigins requires the value', ()=>{
-            delete process.env.ALLOW_ORIGINS;
-            expect(()=>envConfig.getOrigins()).toThrow('Config error - missing env.ALLOW_ORIGINS');
-        });
-    });
-    describe('getTypeOrmConfig', ()=>{
-        it('should apply mysql defaults when DB_TYPE is unset', ()=>{
-            delete process.env.DB_TYPE;
-            delete process.env.DB_HOST;
-            delete process.env.DB_PORT;
-            delete process.env.DB_USER;
-            delete process.env.DB_PASSWORD;
-            delete process.env.DB_NAME;
-            expect(envConfig.getTypeOrmConfig()).toEqual({
-                type: 'mysql',
-                host: 'localhost',
-                port: 3306,
-                username: 'root',
-                password: '',
-                database: 'flusys_main'
-            });
-        });
-        it('should default the postgres port to 5432', ()=>{
-            process.env.DB_TYPE = 'postgres';
-            delete process.env.DB_PORT;
-            expect(envConfig.getTypeOrmConfig().port).toBe(5432);
-        });
-        it('should use explicit connection values when provided', ()=>{
-            process.env.DB_TYPE = 'postgres';
-            process.env.DB_HOST = 'db.internal';
-            process.env.DB_PORT = '5555';
-            process.env.DB_USER = 'flusys';
-            process.env.DB_PASSWORD = 'secret';
-            process.env.DB_NAME = 'flusys_prod';
-            expect(envConfig.getTypeOrmConfig()).toEqual({
-                type: 'postgres',
-                host: 'db.internal',
-                port: 5555,
-                username: 'flusys',
-                password: 'secret',
-                database: 'flusys_prod'
-            });
-        });
-    });
-    describe('getJwtConfig', ()=>{
-        it('should throw when JWT_SECRET is missing', ()=>{
-            delete process.env.JWT_SECRET;
-            process.env.REFRESH_TOKEN_SECRET = 'refresh';
-            expect(()=>envConfig.getJwtConfig()).toThrow('Config error - missing env.JWT_SECRET');
-        });
-        it('should throw when REFRESH_TOKEN_SECRET is missing', ()=>{
-            process.env.JWT_SECRET = 'secret';
-            delete process.env.REFRESH_TOKEN_SECRET;
-            expect(()=>envConfig.getJwtConfig()).toThrow('Config error - missing env.REFRESH_TOKEN_SECRET');
-        });
-        it('should apply default expirations when unset', ()=>{
-            process.env.JWT_SECRET = 'secret';
-            process.env.REFRESH_TOKEN_SECRET = 'refresh-secret';
-            delete process.env.JWT_EXPIRATION;
-            delete process.env.REFRESH_TOKEN_EXPIRATION;
-            expect(envConfig.getJwtConfig()).toEqual({
-                secret: 'secret',
-                expiration: '1h',
-                refreshSecret: 'refresh-secret',
-                refreshExpiration: '7d'
-            });
-        });
-        it('should use explicit expirations when set', ()=>{
-            process.env.JWT_SECRET = 'secret';
-            process.env.JWT_EXPIRATION = '15m';
-            process.env.REFRESH_TOKEN_SECRET = 'refresh-secret';
-            process.env.REFRESH_TOKEN_EXPIRATION = '30d';
-            expect(envConfig.getJwtConfig()).toEqual({
-                secret: 'secret',
-                expiration: '15m',
-                refreshSecret: 'refresh-secret',
-                refreshExpiration: '30d'
-            });
-        });
-    });
-    describe('getRedisUrl', ()=>{
-        it('should default to localhost redis', ()=>{
-            delete process.env.REDIS_URL;
-            expect(envConfig.getRedisUrl()).toBe('redis://localhost:6379');
-        });
-        it('should return the configured redis url', ()=>{
-            process.env.REDIS_URL = 'redis://redis-host:6380';
-            expect(envConfig.getRedisUrl()).toBe('redis://redis-host:6380');
-        });
-    });
-    describe('getMailConfig', ()=>{
-        it('should default to empty strings when unset', ()=>{
-            delete process.env.MAIL_FROM;
-            delete process.env.MAIL_APP_PASSWORD;
-            expect(envConfig.getMailConfig()).toEqual({
-                MAIL_FROM: '',
-                MAIL_APP_PASSWORD: ''
-            });
-        });
-        it('should return configured mail settings', ()=>{
-            process.env.MAIL_FROM = 'noreply@flusys.io';
-            process.env.MAIL_APP_PASSWORD = 'app-pass';
-            expect(envConfig.getMailConfig()).toEqual({
-                MAIL_FROM: 'noreply@flusys.io',
-                MAIL_APP_PASSWORD: 'app-pass'
-            });
-        });
-    });
-    describe('getTenantId', ()=>{
-        it('should return null when unset', ()=>{
-            delete process.env.TENANT_ID;
-            expect(envConfig.getTenantId()).toBeNull();
-        });
-        it('should return the configured tenant id', ()=>{
-            process.env.TENANT_ID = 'tenant-a';
-            expect(envConfig.getTenantId()).toBe('tenant-a');
-        });
-    });
-    describe('useTenantMode', ()=>{
-        it('should be false by default', ()=>{
-            delete process.env.USE_TENANT_MODE;
-            expect(envConfig.useTenantMode()).toBe(false);
-        });
-        it('should be true when explicitly set', ()=>{
-            process.env.USE_TENANT_MODE = 'true';
-            expect(envConfig.useTenantMode()).toBe(true);
-        });
-    });
-    describe('getLogConfig', ()=>{
-        it('should default log level to info in production', ()=>{
-            delete process.env.MODE;
-            delete process.env.LOG_LEVEL;
-            expect(envConfig.getLogConfig().level).toBe('info');
-        });
-        it('should default log level to debug outside production', ()=>{
-            process.env.MODE = 'dev';
-            delete process.env.LOG_LEVEL;
-            expect(envConfig.getLogConfig().level).toBe('debug');
-        });
-        it('should apply all defaults when unset', ()=>{
-            process.env.MODE = 'dev';
-            delete process.env.LOG_DIR;
-            delete process.env.LOG_LEVEL;
-            delete process.env.LOG_MAX_SIZE;
-            delete process.env.LOG_MAX_FILES;
-            delete process.env.DISABLE_HTTP_LOGGING;
-            expect(envConfig.getLogConfig()).toEqual({
-                dir: 'logs',
-                level: 'debug',
-                maxSize: '20m',
-                maxFiles: '14d',
-                disableHttpLogging: false
-            });
-        });
-        it('should honor explicit overrides', ()=>{
-            process.env.LOG_DIR = '/var/log/flusys';
-            process.env.LOG_LEVEL = 'warn';
-            process.env.LOG_MAX_SIZE = '50m';
-            process.env.LOG_MAX_FILES = '30d';
-            process.env.DISABLE_HTTP_LOGGING = 'true';
-            expect(envConfig.getLogConfig()).toEqual({
-                dir: '/var/log/flusys',
-                level: 'warn',
-                maxSize: '50m',
-                maxFiles: '30d',
-                disableHttpLogging: true
-            });
-        });
-    });
-    describe('getEnv', ()=>{
-        it('should return the full process.env map', ()=>{
-            process.env.SOME_FLAG = 'x';
-            expect(envConfig.getEnv()).toBe(process.env);
-        });
-    });
-});

package/fesm/constants/database.constants.js

@@ -1,2 +0,0 @@
-export const MODULE_OPTIONS = Symbol('MODULE_OPTIONS');
-export const DEFAULT_TENANT_HEADER = 'x-tenant-id';

package/fesm/docs/docs.config.js

@@ -1,258 +0,0 @@
-import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
-function filterSchemaProperties(document, exclusions) {
-    if (!exclusions?.length || !document.components?.schemas) {
-        return document;
-    }
-    const schemas = {
-        ...document.components.schemas
-    };
-    for (const exclusion of exclusions){
-        const schema = schemas[exclusion.schemaName];
-        if (schema && typeof schema === 'object' && 'properties' in schema) {
-            const filteredProperties = {
-                ...schema.properties
-            };
-            for (const prop of exclusion.properties){
-                delete filteredProperties[prop];
-            }
-            // Also remove from required array if present
-            const filteredRequired = schema.required?.filter((r)=>!exclusion.properties.includes(r));
-            schemas[exclusion.schemaName] = {
-                ...schema,
-                properties: filteredProperties,
-                ...filteredRequired?.length ? {
-                    required: filteredRequired
-                } : {}
-            };
-        }
-    }
-    return {
-        ...document,
-        components: {
-            ...document.components,
-            schemas
-        }
-    };
-}
-function filterQueryParameters(document, exclusions) {
-    if (!exclusions?.length || !document.paths) {
-        return document;
-    }
-    const filteredPaths = {};
-    for (const [path, pathItem] of Object.entries(document.paths)){
-        const filteredPathItem = {};
-        for (const [method, operation] of Object.entries(pathItem)){
-            // Skip non-operation properties
-            if (!operation || typeof operation !== 'object') {
-                filteredPathItem[method] = operation;
-                continue;
-            }
-            // Check if this endpoint matches any exclusion pattern
-            const matchingExclusions = exclusions.filter((exclusion)=>{
-                const pathMatches = pathMatchesPattern(path, exclusion.pathPattern);
-                const methodMatches = !exclusion.method || exclusion.method === method;
-                return pathMatches && methodMatches;
-            });
-            if (matchingExclusions.length > 0) {
-                // Collect all parameters to exclude
-                const paramsToExclude = new Set();
-                matchingExclusions.forEach((exclusion)=>{
-                    exclusion.parameters.forEach((param)=>paramsToExclude.add(param));
-                });
-                // Filter out excluded query parameters
-                const filteredOperation = {
-                    ...operation
-                };
-                if (Array.isArray(filteredOperation.parameters)) {
-                    filteredOperation.parameters = filteredOperation.parameters.filter((param)=>{
-                        return !(param.in === 'query' && paramsToExclude.has(param.name));
-                    });
-                }
-                filteredPathItem[method] = filteredOperation;
-            } else {
-                filteredPathItem[method] = operation;
-            }
-        }
-        filteredPaths[path] = filteredPathItem;
-    }
-    return {
-        ...document,
-        paths: filteredPaths
-    };
-}
-function filterExamples(document, exclusions) {
-    if (!exclusions?.length || !document.paths) {
-        return document;
-    }
-    const filteredPaths = {};
-    for (const [path, pathItem] of Object.entries(document.paths)){
-        const filteredPathItem = {};
-        for (const [method, operation] of Object.entries(pathItem)){
-            // Skip non-operation properties
-            if (!operation || typeof operation !== 'object') {
-                filteredPathItem[method] = operation;
-                continue;
-            }
-            // Check if this endpoint matches any exclusion pattern
-            const matchingExclusions = exclusions.filter((exclusion)=>{
-                const pathMatches = pathMatchesPattern(path, exclusion.pathPattern);
-                const methodMatches = !exclusion.method || exclusion.method === method;
-                return pathMatches && methodMatches;
-            });
-            if (matchingExclusions.length > 0) {
-                // Collect all examples to exclude
-                const examplesToExclude = new Set();
-                matchingExclusions.forEach((exclusion)=>{
-                    exclusion.examples.forEach((example)=>examplesToExclude.add(example));
-                });
-                // Deep clone the operation to avoid mutating original
-                const filteredOperation = JSON.parse(JSON.stringify(operation));
-                // Filter examples from responses
-                if (filteredOperation.responses) {
-                    for (const [statusCode, response] of Object.entries(filteredOperation.responses)){
-                        const responseObj = response;
-                        if (responseObj?.content) {
-                            const content = responseObj.content;
-                            for (const [mediaType, mediaTypeObj] of Object.entries(content)){
-                                const media = mediaTypeObj;
-                                if (media?.examples && typeof media.examples === 'object') {
-                                    const examples = media.examples;
-                                    for (const exampleName of examplesToExclude){
-                                        delete examples[exampleName];
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                filteredPathItem[method] = filteredOperation;
-            } else {
-                filteredPathItem[method] = operation;
-            }
-        }
-        filteredPaths[path] = filteredPathItem;
-    }
-    return {
-        ...document,
-        paths: filteredPaths
-    };
-}
-function pathMatchesPattern(path, pattern) {
-    // Convert wildcard pattern to regex
-    const regexPattern = pattern.replace(/\*/g, '[^/]+') // * matches any characters except /
-    .replace(/\*\*/g, '.*'); // ** matches any characters including /
-    const regex = new RegExp(`^${regexPattern}$`);
-    return regex.test(path);
-}
-function filterPaths(document, excludePaths) {
-    if (!excludePaths?.length || !document.paths) {
-        return document;
-    }
-    const filteredPaths = {};
-    for (const [path, pathItem] of Object.entries(document.paths)){
-        const isExcluded = excludePaths.some((pattern)=>pathMatchesPattern(path, pattern));
-        if (!isExcluded) {
-            filteredPaths[path] = pathItem;
-        }
-    }
-    return {
-        ...document,
-        paths: filteredPaths
-    };
-}
-function filterDocumentByTags(document, excludeTags) {
-    if (!excludeTags?.length) {
-        return document;
-    }
-    const excludeTagsSet = new Set(excludeTags.map((tag)=>tag.toLowerCase()));
-    // Filter out paths that have any of the excluded tags
-    const filteredPaths = {};
-    for (const [path, pathItem] of Object.entries(document.paths)){
-        const filteredPathItem = {};
-        for (const [method, operation] of Object.entries(pathItem)){
-            // Skip non-operation properties like 'parameters'
-            if (!operation || typeof operation !== 'object' || !('tags' in operation)) {
-                filteredPathItem[method] = operation;
-                continue;
-            }
-            const operationTags = operation.tags || [];
-            const hasExcludedTag = operationTags.some((tag)=>excludeTagsSet.has(tag.toLowerCase()));
-            if (!hasExcludedTag) {
-                filteredPathItem[method] = operation;
-            }
-        }
-        // Only include path if it has at least one operation
-        const hasOperations = Object.keys(filteredPathItem).some((key)=>[
-                'get',
-                'post',
-                'put',
-                'patch',
-                'delete',
-                'options',
-                'head'
-            ].includes(key));
-        if (hasOperations) {
-            filteredPaths[path] = filteredPathItem;
-        }
-    }
-    // Filter out excluded tags from the tags array
-    const filteredTags = document.tags?.filter((tag)=>!excludeTagsSet.has(tag.name.toLowerCase()));
-    return {
-        ...document,
-        paths: filteredPaths,
-        tags: filteredTags
-    };
-}
-export function setupModuleSwaggerDocs(app, configs) {
-    configs.forEach((config)=>{
-        const builder = new DocumentBuilder().setTitle(config.title).setDescription(config.description).setVersion(config.version || '1.0');
-        // Add bearer auth
-        if (config.bearerAuth) {
-            builder.addBearerAuth();
-        }
-        // Add custom global headers
-        if (config.globalHeaders?.length) {
-            config.globalHeaders.forEach((header)=>{
-                builder.addGlobalParameters({
-                    name: header.name,
-                    in: 'header',
-                    description: header.description,
-                    required: header.required ?? false,
-                    schema: {
-                        type: 'string',
-                        example: header.example || ''
-                    }
-                });
-            });
-        }
-        // Only filter by modules if specified
-        const createDocOptions = config.modules?.length ? {
-            include: config.modules
-        } : {};
-        let document = SwaggerModule.createDocument(app, builder.build(), createDocOptions);
-        // Filter out excluded paths
-        if (config.excludePaths?.length) {
-            document = filterPaths(document, config.excludePaths);
-        }
-        // Filter out excluded tags
-        if (config.excludeTags?.length) {
-            document = filterDocumentByTags(document, config.excludeTags);
-        }
-        // Filter out excluded schema properties
-        if (config.excludeSchemaProperties?.length) {
-            document = filterSchemaProperties(document, config.excludeSchemaProperties);
-        }
-        // Filter out excluded query parameters
-        if (config.excludeQueryParameters?.length) {
-            document = filterQueryParameters(document, config.excludeQueryParameters);
-        }
-        // Filter out excluded examples
-        if (config.excludeExamples?.length) {
-            document = filterExamples(document, config.excludeExamples);
-        }
-        SwaggerModule.setup(config.path, app, document);
-    });
-}
-export function setupSwaggerDocs(app, ...modules) {
-    setupModuleSwaggerDocs(app, modules);
-}