@hazeljs/swagger 0.8.6 → 0.8.7

package/dist/index.js

@@ -4,12 +4,18 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getOperationMetadata = exports.getSwaggerMetadata = exports.ApiOperation = exports.Swagger = exports.SwaggerService = exports.SwaggerModule = void 0;
+exports.createOpenApiDocument = createOpenApiDocument;
+const swagger_service_1 = require("./swagger.service");
 var swagger_module_1 = require("./swagger.module");
 Object.defineProperty(exports, "SwaggerModule", { enumerable: true, get: function () { return swagger_module_1.SwaggerModule; } });
-var swagger_service_1 = require("./swagger.service");
-Object.defineProperty(exports, "SwaggerService", { enumerable: true, get: function () { return swagger_service_1.SwaggerService; } });
+var swagger_service_2 = require("./swagger.service");
+Object.defineProperty(exports, "SwaggerService", { enumerable: true, get: function () { return swagger_service_2.SwaggerService; } });
 var swagger_decorator_1 = require("./swagger.decorator");
 Object.defineProperty(exports, "Swagger", { enumerable: true, get: function () { return swagger_decorator_1.Swagger; } });
 Object.defineProperty(exports, "ApiOperation", { enumerable: true, get: function () { return swagger_decorator_1.ApiOperation; } });
 Object.defineProperty(exports, "getSwaggerMetadata", { enumerable: true, get: function () { return swagger_decorator_1.getSwaggerMetadata; } });
 Object.defineProperty(exports, "getOperationMetadata", { enumerable: true, get: function () { return swagger_decorator_1.getOperationMetadata; } });
+/** Build an OpenAPI document without serving HTTP (e.g. CI export). */
+function createOpenApiDocument(rootModule, options) {
+    return new swagger_service_1.SwaggerService().generateAutoSpec(rootModule, options);
+}

package/dist/openapi-document.test.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=openapi-document.test.d.ts.map

package/dist/openapi-document.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-document.test.d.ts","sourceRoot":"","sources":["../src/openapi-document.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/openapi-document.test.js

@@ -0,0 +1,42 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const index_1 = require("./index");
+const core_1 = require("@hazeljs/core");
+describe('createOpenApiDocument', () => {
+    it('returns a spec from the app module', () => {
+        let PingController = class PingController {
+            ping() {
+                return 'pong';
+            }
+        };
+        __decorate([
+            (0, core_1.Get)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", String)
+        ], PingController.prototype, "ping", null);
+        PingController = __decorate([
+            (0, core_1.Controller)({ path: '/ping' })
+        ], PingController);
+        Reflect.defineMetadata('hazel:controller', { path: '/ping' }, PingController);
+        Reflect.defineMetadata('hazel:routes', [{ propertyKey: 'ping', path: '', method: 'GET' }], PingController);
+        let AppModule = class AppModule {
+        };
+        AppModule = __decorate([
+            (0, core_1.HazelModule)({ controllers: [PingController], imports: [] })
+        ], AppModule);
+        const spec = (0, index_1.createOpenApiDocument)(AppModule, { title: 'CI', version: '0.0.1' });
+        expect(spec.info.title).toBe('CI');
+        expect(spec.paths['/ping']?.get).toBeDefined();
+    });
+});

package/dist/swagger-config.d.ts

@@ -0,0 +1,5 @@
+import type { SwaggerModuleOptions } from './swagger.types';
+export declare function mergeSwaggerModuleOptions(options: SwaggerModuleOptions): void;
+export declare function replaceSwaggerModuleOptions(options: SwaggerModuleOptions): void;
+export declare function getSwaggerModuleOptions(): SwaggerModuleOptions;
+//# sourceMappingURL=swagger-config.d.ts.map

package/dist/swagger-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swagger-config.d.ts","sourceRoot":"","sources":["../src/swagger-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAI5D,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI,CAE7E;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI,CAE/E;AAED,wBAAgB,uBAAuB,IAAI,oBAAoB,CAE9D"}

package/dist/swagger-config.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeSwaggerModuleOptions = mergeSwaggerModuleOptions;
+exports.replaceSwaggerModuleOptions = replaceSwaggerModuleOptions;
+exports.getSwaggerModuleOptions = getSwaggerModuleOptions;
+let swaggerModuleOptions = {};
+function mergeSwaggerModuleOptions(options) {
+    swaggerModuleOptions = { ...swaggerModuleOptions, ...options };
+}
+function replaceSwaggerModuleOptions(options) {
+    swaggerModuleOptions = { ...options };
+}
+function getSwaggerModuleOptions() {
+    return { ...swaggerModuleOptions };
+}

package/dist/swagger.controller.d.ts

@@ -1,11 +1,12 @@
 import { SwaggerService } from './swagger.service';
 import { RequestContext, Type } from '@hazeljs/core';
-import { SwaggerSpec } from './swagger.service';
+import type { SwaggerSpec } from './swagger.types';
 export declare class SwaggerController {
     private swaggerService;
     private static rootModule;
     constructor(swaggerService: SwaggerService);
     static setRootModule(module: Type<unknown>): void;
+    private static emptySpec;
     getSpec(_context: RequestContext): Promise<SwaggerSpec>;
     getDocs(_context: RequestContext): Promise<string>;
 }

package/dist/swagger.controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swagger.controller.d.ts","sourceRoot":"","sources":["../src/swagger.controller.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAIrD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,qBAca,iBAAiB;IAGhB,OAAO,CAAC,cAAc;IAFlC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAgB;gBAErB,cAAc,EAAE,cAAc;IAElD,MAAM,CAAC,aAAa,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI;IA6B3C,OAAO,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,WAAW,CAAC;IA6IvD,OAAO,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC;CA6DzD"}
+{"version":3,"file":"swagger.controller.d.ts","sourceRoot":"","sources":["../src/swagger.controller.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAGrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAGnD,qBAca,iBAAiB;IAGhB,OAAO,CAAC,cAAc;IAFlC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAgB;gBAErB,cAAc,EAAE,cAAc;IAElD,MAAM,CAAC,aAAa,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI;IAKjD,OAAO,CAAC,MAAM,CAAC,SAAS;IAuClB,OAAO,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,WAAW,CAAC;IAkDvD,OAAO,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC;CAqEzD"}

package/dist/swagger.controller.js

@@ -16,115 +16,75 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwaggerController = void 0;
 const core_1 = require("@hazeljs/core");
 const swagger_service_1 = require("./swagger.service");
-const core_2 = require("@hazeljs/core");
-const core_3 = __importDefault(require("@hazeljs/core"));
+const core_2 = __importDefault(require("@hazeljs/core"));
 const swagger_decorator_1 = require("./swagger.decorator");
+const swagger_config_1 = require("./swagger-config");
 let SwaggerController = SwaggerController_1 = class SwaggerController {
     constructor(swaggerService) {
         this.swaggerService = swaggerService;
     }
     static setRootModule(module) {
-        core_3.default.debug(`Setting root module for SwaggerController: ${module.name}`);
+        core_2.default.debug(`Setting root module for SwaggerController: ${module.name}`);
         SwaggerController_1.rootModule = module;
     }
+    static emptySpec(description) {
+        return {
+            openapi: '3.0.0',
+            info: {
+                title: 'API Documentation',
+                version: '1.0.0',
+                description,
+            },
+            paths: {},
+            components: {
+                schemas: {},
+            },
+        };
+    }
     async getSpec(_context) {
         try {
             if (!SwaggerController_1.rootModule) {
-                core_3.default.warn('No root module provided');
-                return {
-                    openapi: '3.0.0',
-                    info: {
-                        title: 'API Documentation',
-                        version: '1.0.0',
-                        description: 'No root module provided',
-                    },
-                    paths: {},
-                    components: {
-                        schemas: {},
-                    },
-                };
+                core_2.default.warn('No root module provided');
+                return SwaggerController_1.emptySpec('No root module provided');
             }
-            core_3.default.debug('Root module:', SwaggerController_1.rootModule.name);
-            // Get all controllers from the AppModule and its imported modules.
-            // Avoid JSON.stringify on full metadata because dynamic module objects can be circular.
-            const moduleMetadata = (0, core_2.getModuleMetadata)(SwaggerController_1.rootModule);
-            core_3.default.debug('Module metadata summary:', moduleMetadata
-                ? {
-                    controllers: moduleMetadata.controllers?.length || 0,
-                    imports: moduleMetadata.imports?.length || 0,
-                    providers: moduleMetadata.providers?.length || 0,
-                }
-                : null);
-            const controllers = new Set();
-            // Helper function to recursively collect controllers from modules
-            const collectControllers = (moduleRef) => {
-                const moduleName = typeof moduleRef === 'function'
-                    ? moduleRef.name
-                    : moduleRef.module?.name;
-                core_3.default.debug(`Collecting controllers from module: ${moduleName}`);
-                const metadata = (0, core_2.getModuleMetadata)(moduleRef);
-                if (!metadata) {
-                    core_3.default.warn(`No metadata found for module: ${moduleName}`);
-                    return;
-                }
-                // Add controllers from current module
-                if (metadata.controllers) {
-                    const validControllers = metadata.controllers.filter((c) => c && typeof c === 'function');
-                    core_3.default.debug(`${moduleName} controllers:`, validControllers.map((c) => typeof c === 'function' ? c.name : undefined));
-                    validControllers.forEach((controller) => controllers.add(controller));
-                }
-                else {
-                    core_3.default.debug(`No controllers found in module: ${moduleName}`);
-                }
-                // Recursively process imported modules (Type or DynamicModule)
-                if (metadata.imports) {
-                    const validModules = metadata.imports.filter((m) => m && (typeof m === 'function' || (typeof m === 'object' && 'module' in m)));
-                    core_3.default.debug(`${moduleName} imported modules:`, validModules.map((m) => typeof m === 'function' ? m.name : m.module?.name));
-                    validModules.forEach((moduleRef) => collectControllers(moduleRef));
-                }
-                else {
-                    core_3.default.debug(`No imports found in module: ${moduleName}`);
-                }
-            };
-            // Start collecting controllers from the root module
-            collectControllers(SwaggerController_1.rootModule);
-            const controllerArray = Array.from(controllers);
-            core_3.default.debug('Total controllers found:', controllerArray.length);
-            core_3.default.debug('Controller names:', controllerArray.map((c) => c.name));
-            if (controllerArray.length === 0) {
-                core_3.default.warn('No valid controllers found');
+            core_2.default.debug('Root module:', SwaggerController_1.rootModule.name);
+            const opts = (0, swagger_config_1.getSwaggerModuleOptions)();
+            const spec = this.swaggerService.generateAutoSpec(SwaggerController_1.rootModule, opts);
+            if (Object.keys(spec.paths).length === 0) {
+                core_2.default.warn('No routes found for OpenAPI document');
                 return {
-                    openapi: '3.0.0',
+                    ...spec,
                     info: {
-                        title: 'API Documentation',
-                        version: '1.0.0',
-                        description: 'No controllers found',
-                    },
-                    paths: {},
-                    components: {
-                        schemas: {},
+                        ...spec.info,
+                        description: spec.info.description || 'No routes found',
                     },
                 };
             }
-            const spec = this.swaggerService.generateSpec(controllerArray);
             return spec;
         }
         catch (error) {
             if (process.env.NODE_ENV !== 'test') {
-                core_3.default.error('Error generating Swagger spec:', error);
+                core_2.default.error('Error generating Swagger spec:', error);
             }
             throw error;
         }
     }
     async getDocs(_context) {
-        return `
-<!DOCTYPE html>
+        const opts = (0, swagger_config_1.getSwaggerModuleOptions)();
+        const cdn = opts.swaggerUiCdnBase?.replace(/\/$/, '') ?? 'https://unpkg.com/swagger-ui-dist@5.11.0';
+        let prefix = opts.globalPrefix?.trim() ?? '';
+        if (prefix && !prefix.startsWith('/')) {
+            prefix = `/${prefix}`;
+        }
+        prefix = prefix.replace(/\/$/, '');
+        const specPath = prefix ? `${prefix}/swagger/spec` : '/swagger/spec';
+        return `<!DOCTYPE html>
 <html>
 <head>
     <title>API Documentation</title>
     <meta charset="utf-8"/>
     <meta name="viewport" content="width=device-width, initial-scale=1">
-    <link rel="stylesheet" type="text/css" href="https://unpkg.com/swagger-ui-dist@4.18.3/swagger-ui.css" />
+    <link rel="stylesheet" type="text/css" href="${cdn}/swagger-ui.css" />
     <style>
         body {
             margin: 0;
@@ -146,19 +106,18 @@ let SwaggerController = SwaggerController_1 = class SwaggerController {
         <div class="loading">Loading API Documentation...</div>
     </div>
 
-    <script src="https://unpkg.com/swagger-ui-dist@4.18.3/swagger-ui-bundle.js"></script>
-    <script src="https://unpkg.com/swagger-ui-dist@4.18.3/swagger-ui-standalone-preset.js"></script>
+    <script src="${cdn}/swagger-ui-bundle.js"></script>
+    <script src="${cdn}/swagger-ui-standalone-preset.js"></script>
     <script>
-        // Basic error handling
         window.onerror = function(msg, url, line) {
-            document.getElementById('swagger-ui').innerHTML = 
+            document.getElementById('swagger-ui').innerHTML =
                 '<div style="color: red; padding: 20px;">Error: ' + msg + '<br>at line ' + line + '</div>';
             return false;
         };
 
-        // Simple initialization
+        const specPath = ${JSON.stringify(specPath)};
         const ui = SwaggerUIBundle({
-            url: window.location.origin + "/swagger/spec",
+            url: window.location.origin + specPath,
             dom_id: '#swagger-ui',
             deepLinking: true,
             presets: [
@@ -175,7 +134,7 @@ let SwaggerController = SwaggerController_1 = class SwaggerController {
     </script>
 </body>
 </html>
-    `;
+`;
     }
 };
 exports.SwaggerController = SwaggerController;

package/dist/swagger.controller.test.js

@@ -1,14 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const swagger_controller_1 = require("./swagger.controller");
-const core_1 = require("@hazeljs/core");
-// Mock the logger and getModuleMetadata
+const swagger_module_1 = require("./swagger.module");
 jest.mock('@hazeljs/core', () => {
     const actual = jest.requireActual('@hazeljs/core');
     return {
         ...actual,
         __esModule: true,
-        getModuleMetadata: jest.fn(),
         default: {
             error: jest.fn(),
             debug: jest.fn(),
@@ -23,89 +21,71 @@ describe('SwaggerController', () => {
     let controller;
     let swaggerService;
     beforeEach(() => {
+        swagger_module_1.SwaggerModule.configure({}, true);
         swaggerService = {
-            generateSpec: jest.fn(),
+            generateAutoSpec: jest.fn(),
         };
         controller = new swagger_controller_1.SwaggerController(swaggerService);
-        // Reset all mocks before each test
         jest.clearAllMocks();
+        swagger_controller_1.SwaggerController.rootModule = undefined;
     });
     it('should be defined', () => {
         expect(controller).toBeDefined();
     });
-    it('should return swagger spec', async () => {
+    it('should return swagger spec from generateAutoSpec', async () => {
+        class AppModule {
+        }
+        swagger_controller_1.SwaggerController.setRootModule(AppModule);
         const mockSpec = {
             openapi: '3.0.0',
             info: {
                 title: 'API Documentation',
                 version: '1.0.0',
-                description: 'No root module provided',
+                description: 'Test',
             },
-            paths: {},
+            paths: { '/x': { get: { summary: 'x' } } },
             components: {
                 schemas: {},
             },
         };
-        swaggerService.generateSpec.mockReturnValue(mockSpec);
+        swaggerService.generateAutoSpec.mockReturnValue(mockSpec);
         const spec = await controller.getSpec({});
         expect(spec).toEqual(mockSpec);
+        expect(swaggerService.generateAutoSpec).toHaveBeenCalledWith(AppModule, expect.any(Object));
     });
     describe('getSpec', () => {
-        it('should return Swagger specification', async () => {
+        it('should call generateAutoSpec with root module', async () => {
             const mockSpec = {
                 openapi: '3.0.0',
                 info: {
-                    title: 'API Documentation',
+                    title: 'API',
                     version: '1.0.0',
-                    description: 'No root module provided',
-                },
-                paths: {},
-                components: {
-                    schemas: {},
                 },
+                paths: { '/a': { get: { summary: 'a' } } },
+                components: { schemas: { Error: { type: 'object' } } },
             };
-            // Set up the root module
             class TestModule {
             }
             swagger_controller_1.SwaggerController.setRootModule(TestModule);
-            // Mock getModuleMetadata to return some controllers
-            core_1.getModuleMetadata.mockReturnValue({
-                controllers: [class TestController {
-                    }],
-                imports: [],
-            });
-            swaggerService.generateSpec.mockReturnValue(mockSpec);
-            const context = {};
-            const result = await controller.getSpec(context);
+            swaggerService.generateAutoSpec.mockReturnValue(mockSpec);
+            const result = await controller.getSpec({});
             expect(result).toEqual(mockSpec);
-            expect(swaggerService.generateSpec).toHaveBeenCalled();
+            expect(swaggerService.generateAutoSpec).toHaveBeenCalledWith(TestModule, expect.any(Object));
         });
         it('should handle errors', async () => {
             const error = new Error('Test error');
-            swaggerService.generateSpec.mockImplementation(() => {
+            swaggerService.generateAutoSpec.mockImplementation(() => {
                 throw error;
             });
-            // Set up the root module
             class TestModule {
             }
             swagger_controller_1.SwaggerController.setRootModule(TestModule);
-            // Mock getModuleMetadata to return some controllers
-            core_1.getModuleMetadata.mockReturnValue({
-                controllers: [class TestController {
-                    }],
-                imports: [],
-            });
-            const context = {};
-            await expect(controller.getSpec(context)).rejects.toThrow('Test error');
-            expect(swaggerService.generateSpec).toHaveBeenCalled();
+            await expect(controller.getSpec({})).rejects.toThrow('Test error');
         });
     });
     describe('getSpec edge cases', () => {
         it('should return default spec when no root module is set', async () => {
-            // Clear root module by setting it to undefined directly
-            swagger_controller_1.SwaggerController.rootModule = undefined;
-            const context = {};
-            const result = await controller.getSpec(context);
+            const result = await controller.getSpec({});
             expect(result).toEqual({
                 openapi: '3.0.0',
                 info: {
@@ -119,132 +99,37 @@ describe('SwaggerController', () => {
                 },
             });
         });
-        it('should handle module with no metadata', async () => {
-            class TestModule {
-            }
-            swagger_controller_1.SwaggerController.setRootModule(TestModule);
-            core_1.getModuleMetadata.mockReturnValue(null);
-            const context = {};
-            const result = await controller.getSpec(context);
-            expect(result).toEqual({
-                openapi: '3.0.0',
-                info: {
-                    title: 'API Documentation',
-                    version: '1.0.0',
-                    description: 'No controllers found',
-                },
-                paths: {},
-                components: {
-                    schemas: {},
-                },
-            });
-        });
-        it('should handle module with no controllers', async () => {
-            class TestModule {
-            }
-            swagger_controller_1.SwaggerController.setRootModule(TestModule);
-            core_1.getModuleMetadata.mockReturnValue({
-                controllers: [],
-                imports: [],
-            });
-            const context = {};
-            const result = await controller.getSpec(context);
-            expect(result).toEqual({
-                openapi: '3.0.0',
-                info: {
-                    title: 'API Documentation',
-                    version: '1.0.0',
-                    description: 'No controllers found',
-                },
-                paths: {},
-                components: {
-                    schemas: {},
-                },
-            });
-        });
-        it('should handle module with no imports', async () => {
+        it('should annotate description when spec has no paths', async () => {
             class TestModule {
             }
-            class TestController {
-            }
             swagger_controller_1.SwaggerController.setRootModule(TestModule);
-            core_1.getModuleMetadata.mockReturnValue({
-                controllers: [TestController],
-                imports: undefined,
-            });
-            swaggerService.generateSpec.mockReturnValue({
+            swaggerService.generateAutoSpec.mockReturnValue({
                 openapi: '3.0.0',
-                info: { title: 'Test API', version: '1.0.0' },
+                info: { title: 'T', version: '1' },
                 paths: {},
                 components: { schemas: {} },
             });
-            const context = {};
-            await controller.getSpec(context);
-            expect(swaggerService.generateSpec).toHaveBeenCalledWith([TestController]);
-        });
-        it('should recursively collect controllers from imported modules', async () => {
-            class RootModule {
-            }
-            class ImportedModule {
-            }
-            class RootController {
-            }
-            class ImportedController {
-            }
-            swagger_controller_1.SwaggerController.setRootModule(RootModule);
-            core_1.getModuleMetadata.mockImplementation((moduleType) => {
-                if (moduleType === RootModule) {
-                    return {
-                        controllers: [RootController],
-                        imports: [ImportedModule],
-                    };
-                }
-                if (moduleType === ImportedModule) {
-                    return {
-                        controllers: [ImportedController],
-                        imports: [],
-                    };
-                }
-                return null;
-            });
-            swaggerService.generateSpec.mockReturnValue({
-                openapi: '3.0.0',
-                info: { title: 'Test API', version: '1.0.0' },
-                paths: {},
-                components: { schemas: {} },
-            });
-            const context = {};
-            await controller.getSpec(context);
-            expect(swaggerService.generateSpec).toHaveBeenCalledWith(expect.arrayContaining([RootController, ImportedController]));
-        });
-        it('should filter out invalid controllers', async () => {
-            class TestModule {
-            }
-            class ValidController {
-            }
-            swagger_controller_1.SwaggerController.setRootModule(TestModule);
-            core_1.getModuleMetadata.mockReturnValue({
-                controllers: [ValidController, null, undefined, {}],
-                imports: [],
-            });
-            swaggerService.generateSpec.mockReturnValue({
-                openapi: '3.0.0',
-                info: { title: 'Test API', version: '1.0.0' },
-                paths: {},
-                components: { schemas: {} },
-            });
-            const context = {};
-            await controller.getSpec(context);
-            expect(swaggerService.generateSpec).toHaveBeenCalledWith([ValidController]);
+            const result = await controller.getSpec({});
+            expect(result.paths).toEqual({});
+            expect(result.info.description).toBe('No routes found');
         });
     });
     describe('getDocs', () => {
-        it('should return Swagger UI HTML', async () => {
-            const context = {};
-            const result = await controller.getDocs(context);
+        it('should return Swagger UI HTML with default CDN', async () => {
+            const result = await controller.getDocs({});
             expect(result).toContain('<!DOCTYPE html>');
             expect(result).toContain('API Documentation');
-            expect(result).toContain('Loading API Documentation...');
+            expect(result).toContain('https://unpkg.com/swagger-ui-dist@5.11.0/swagger-ui.css');
+            expect(result).toContain('"/swagger/spec"');
+        });
+        it('should use globalPrefix and custom CDN when configured', async () => {
+            swagger_module_1.SwaggerModule.configure({
+                globalPrefix: '/api',
+                swaggerUiCdnBase: 'https://cdn.example.com/ui',
+            }, true);
+            const result = await controller.getDocs({});
+            expect(result).toContain('https://cdn.example.com/ui/swagger-ui.css');
+            expect(result).toContain('"/api/swagger/spec"');
         });
     });
 });

package/dist/swagger.module.d.ts

@@ -1,5 +1,12 @@
 import { Type } from '@hazeljs/core';
+import type { SwaggerModuleOptions } from './swagger.types';
 export declare class SwaggerModule {
+    /**
+     * Document + UI options.
+     * @param replaceAll When true, replaces all options (use to reset). Default merges shallowly with previous `configure` calls.
+     */
+    static configure(options: SwaggerModuleOptions, replaceAll?: boolean): void;
+    static getOptions(): SwaggerModuleOptions;
     static setRootModule(rootModule: Type<unknown>): void;
 }
 //# sourceMappingURL=swagger.module.d.ts.map

package/dist/swagger.module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swagger.module.d.ts","sourceRoot":"","sources":["../src/swagger.module.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAGrC,qBAKa,aAAa;IACxB,MAAM,CAAC,aAAa,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI;CAItD"}
+{"version":3,"file":"swagger.module.d.ts","sourceRoot":"","sources":["../src/swagger.module.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAErC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAO5D,qBAKa,aAAa;IACxB;;;OAGG;IACH,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,oBAAoB,EAAE,UAAU,UAAQ,GAAG,IAAI;IAQzE,MAAM,CAAC,UAAU,IAAI,oBAAoB;IAIzC,MAAM,CAAC,aAAa,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI;CAItD"}

package/dist/swagger.module.js

@@ -14,7 +14,23 @@ const core_1 = require("@hazeljs/core");
 const swagger_service_1 = require("./swagger.service");
 const swagger_controller_1 = require("./swagger.controller");
 const core_2 = __importDefault(require("@hazeljs/core"));
+const swagger_config_1 = require("./swagger-config");
 let SwaggerModule = class SwaggerModule {
+    /**
+     * Document + UI options.
+     * @param replaceAll When true, replaces all options (use to reset). Default merges shallowly with previous `configure` calls.
+     */
+    static configure(options, replaceAll = false) {
+        if (replaceAll) {
+            (0, swagger_config_1.replaceSwaggerModuleOptions)(options);
+        }
+        else {
+            (0, swagger_config_1.mergeSwaggerModuleOptions)(options);
+        }
+    }
+    static getOptions() {
+        return (0, swagger_config_1.getSwaggerModuleOptions)();
+    }
     static setRootModule(rootModule) {
         core_2.default.debug('SwaggerModule: Setting root module:', rootModule.name);
         swagger_controller_1.SwaggerController.setRootModule(rootModule);