@hazeljs/swagger 0.2.0-alpha.1

package/dist/swagger.controller.js

@@ -0,0 +1,243 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var SwaggerController_1;
+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 swagger_decorator_1 = require("./swagger.decorator");
+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}`);
+        SwaggerController_1.rootModule = module;
+    }
+    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_3.default.debug('Root module:', SwaggerController_1.rootModule.name);
+            // Get all controllers from the AppModule and its imported modules
+            const moduleMetadata = (0, core_2.getModuleMetadata)(SwaggerController_1.rootModule);
+            core_3.default.debug('Module metadata:', JSON.stringify(moduleMetadata, null, 2));
+            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');
+                return {
+                    openapi: '3.0.0',
+                    info: {
+                        title: 'API Documentation',
+                        version: '1.0.0',
+                        description: 'No controllers found',
+                    },
+                    paths: {},
+                    components: {
+                        schemas: {},
+                    },
+                };
+            }
+            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);
+            }
+            throw error;
+        }
+    }
+    async getDocs(_context) {
+        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" />
+    <style>
+        body {
+            margin: 0;
+            padding: 20px;
+        }
+        #swagger-ui {
+            max-width: 1460px;
+            margin: 0 auto;
+        }
+        .loading {
+            text-align: center;
+            padding: 20px;
+            font-family: Arial, sans-serif;
+        }
+    </style>
+</head>
+<body>
+    <div id="swagger-ui">
+        <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>
+        // Basic error handling
+        window.onerror = function(msg, url, line) {
+            document.getElementById('swagger-ui').innerHTML = 
+                '<div style="color: red; padding: 20px;">Error: ' + msg + '<br>at line ' + line + '</div>';
+            return false;
+        };
+
+        // Simple initialization
+        const ui = SwaggerUIBundle({
+            url: window.location.origin + "/swagger/spec",
+            dom_id: '#swagger-ui',
+            deepLinking: true,
+            presets: [
+                SwaggerUIBundle.presets.apis,
+                SwaggerUIStandalonePreset
+            ],
+            plugins: [
+                SwaggerUIBundle.plugins.DownloadUrl
+            ],
+            layout: "BaseLayout"
+        });
+
+        window.ui = ui;
+    </script>
+</body>
+</html>
+    `;
+    }
+};
+exports.SwaggerController = SwaggerController;
+__decorate([
+    (0, core_1.Get)('/spec'),
+    (0, swagger_decorator_1.ApiOperation)({
+        summary: 'Get OpenAPI specification',
+        description: 'Retrieves the OpenAPI specification for the API',
+        tags: ['swagger'],
+        responses: {
+            '200': {
+                description: 'OpenAPI specification retrieved successfully',
+                content: {
+                    'application/json': {
+                        schema: {
+                            type: 'object',
+                            properties: {
+                                openapi: { type: 'string' },
+                                info: { type: 'object' },
+                                paths: { type: 'object' },
+                                components: { type: 'object' },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SwaggerController.prototype, "getSpec", null);
+__decorate([
+    (0, core_1.Get)('/'),
+    (0, swagger_decorator_1.ApiOperation)({
+        summary: 'Get Swagger UI',
+        description: 'Serves the Swagger UI interface',
+        tags: ['swagger'],
+        responses: {
+            '200': {
+                description: 'Swagger UI HTML page',
+                content: {
+                    'text/html': {
+                        schema: {
+                            type: 'string',
+                        },
+                    },
+                },
+            },
+        },
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SwaggerController.prototype, "getDocs", null);
+exports.SwaggerController = SwaggerController = SwaggerController_1 = __decorate([
+    (0, swagger_decorator_1.Swagger)({
+        title: 'Swagger Documentation',
+        description: 'API documentation using Swagger/OpenAPI',
+        version: '1.0.0',
+        tags: [
+            {
+                name: 'swagger',
+                description: 'Swagger documentation endpoints',
+            },
+        ],
+    }),
+    (0, core_1.Controller)({
+        path: 'swagger',
+    }),
+    __metadata("design:paramtypes", [swagger_service_1.SwaggerService])
+], SwaggerController);

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=swagger.controller.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"swagger.controller.test.d.ts","sourceRoot":"","sources":["../src/swagger.controller.test.ts"],"names":[],"mappings":""}

package/dist/swagger.controller.test.js

@@ -0,0 +1,250 @@
+"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
+jest.mock('@hazeljs/core', () => {
+    const actual = jest.requireActual('@hazeljs/core');
+    return {
+        ...actual,
+        __esModule: true,
+        getModuleMetadata: jest.fn(),
+        default: {
+            error: jest.fn(),
+            debug: jest.fn(),
+            warn: jest.fn(),
+            info: jest.fn(),
+            http: jest.fn(),
+            silly: jest.fn(),
+        },
+    };
+});
+describe('SwaggerController', () => {
+    let controller;
+    let swaggerService;
+    beforeEach(() => {
+        swaggerService = {
+            generateSpec: jest.fn(),
+        };
+        controller = new swagger_controller_1.SwaggerController(swaggerService);
+        // Reset all mocks before each test
+        jest.clearAllMocks();
+    });
+    it('should be defined', () => {
+        expect(controller).toBeDefined();
+    });
+    it('should return swagger spec', async () => {
+        const mockSpec = {
+            openapi: '3.0.0',
+            info: {
+                title: 'API Documentation',
+                version: '1.0.0',
+                description: 'No root module provided',
+            },
+            paths: {},
+            components: {
+                schemas: {},
+            },
+        };
+        swaggerService.generateSpec.mockReturnValue(mockSpec);
+        const spec = await controller.getSpec({});
+        expect(spec).toEqual(mockSpec);
+    });
+    describe('getSpec', () => {
+        it('should return Swagger specification', async () => {
+            const mockSpec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'API Documentation',
+                    version: '1.0.0',
+                    description: 'No root module provided',
+                },
+                paths: {},
+                components: {
+                    schemas: {},
+                },
+            };
+            // 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);
+            expect(result).toEqual(mockSpec);
+            expect(swaggerService.generateSpec).toHaveBeenCalled();
+        });
+        it('should handle errors', async () => {
+            const error = new Error('Test error');
+            swaggerService.generateSpec.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();
+        });
+    });
+    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);
+            expect(result).toEqual({
+                openapi: '3.0.0',
+                info: {
+                    title: 'API Documentation',
+                    version: '1.0.0',
+                    description: 'No root module provided',
+                },
+                paths: {},
+                components: {
+                    schemas: {},
+                },
+            });
+        });
+        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 () => {
+            class TestModule {
+            }
+            class TestController {
+            }
+            swagger_controller_1.SwaggerController.setRootModule(TestModule);
+            core_1.getModuleMetadata.mockReturnValue({
+                controllers: [TestController],
+                imports: undefined,
+            });
+            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([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]);
+        });
+    });
+    describe('getDocs', () => {
+        it('should return Swagger UI HTML', async () => {
+            const context = {};
+            const result = await controller.getDocs(context);
+            expect(result).toContain('<!DOCTYPE html>');
+            expect(result).toContain('API Documentation');
+            expect(result).toContain('Loading API Documentation...');
+        });
+    });
+});

package/dist/swagger.decorator.d.ts

@@ -0,0 +1,7 @@
+import 'reflect-metadata';
+import { SwaggerOptions, SwaggerOperation } from './swagger.types';
+export declare function Swagger(options: SwaggerOptions): ClassDecorator;
+export declare function ApiOperation(operation: SwaggerOperation): MethodDecorator;
+export declare function getSwaggerMetadata(target: object): SwaggerOptions | undefined;
+export declare function getOperationMetadata(target: object, propertyKey: string | symbol): SwaggerOperation | undefined;
+//# sourceMappingURL=swagger.decorator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"swagger.decorator.d.ts","sourceRoot":"","sources":["../src/swagger.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAKnE,wBAAgB,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,CAM/D;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,gBAAgB,GAAG,eAAe,CAIzE;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAE7E;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAAG,MAAM,GAC3B,gBAAgB,GAAG,SAAS,CAE9B"}

package/dist/swagger.decorator.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Swagger = Swagger;
+exports.ApiOperation = ApiOperation;
+exports.getSwaggerMetadata = getSwaggerMetadata;
+exports.getOperationMetadata = getOperationMetadata;
+require("reflect-metadata");
+const SWAGGER_METADATA_KEY = 'swagger:options';
+const SWAGGER_OPERATION_METADATA_KEY = 'swagger:operation';
+function Swagger(options) {
+    return (target) => {
+        const metaTarget = typeof target === 'function' ? target.prototype : target;
+        Reflect.defineMetadata(SWAGGER_METADATA_KEY, options, metaTarget);
+    };
+}
+function ApiOperation(operation) {
+    return (target, propertyKey) => {
+        Reflect.defineMetadata(SWAGGER_OPERATION_METADATA_KEY, operation, target, propertyKey);
+    };
+}
+function getSwaggerMetadata(target) {
+    return Reflect.getMetadata(SWAGGER_METADATA_KEY, target);
+}
+function getOperationMetadata(target, propertyKey) {
+    return Reflect.getMetadata(SWAGGER_OPERATION_METADATA_KEY, target, propertyKey);
+}

package/dist/swagger.decorator.test.d.ts

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

package/dist/swagger.decorator.test.d.ts.map

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

package/dist/swagger.decorator.test.js

@@ -0,0 +1,72 @@
+"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 swagger_decorator_1 = require("./swagger.decorator");
+describe('Swagger Decorators', () => {
+    describe('@Swagger', () => {
+        it('should store metadata on the prototype', () => {
+            const options = {
+                title: 'Test API',
+                description: 'Test API description',
+                version: '1.0.0',
+                tags: [{ name: 'test', description: 'Test operations' }],
+            };
+            let TestController = class TestController {
+            };
+            TestController = __decorate([
+                (0, swagger_decorator_1.Swagger)(options)
+            ], TestController);
+            const metadata = (0, swagger_decorator_1.getSwaggerMetadata)(TestController.prototype);
+            expect(metadata).toBeDefined();
+            expect(metadata).toEqual(options);
+        });
+        it('should handle undefined metadata', () => {
+            class TestController {
+            }
+            const metadata = (0, swagger_decorator_1.getSwaggerMetadata)(TestController.prototype);
+            expect(metadata).toBeUndefined();
+        });
+    });
+    describe('@ApiOperation', () => {
+        it('should store operation metadata on the prototype', () => {
+            const operation = {
+                summary: 'Test operation',
+                description: 'Test operation description',
+                tags: ['test'],
+                responses: {
+                    '200': {
+                        description: 'Success',
+                    },
+                },
+            };
+            class TestController {
+                testMethod() { }
+            }
+            __decorate([
+                (0, swagger_decorator_1.ApiOperation)(operation),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "testMethod", null);
+            const metadata = (0, swagger_decorator_1.getOperationMetadata)(TestController.prototype, 'testMethod');
+            expect(metadata).toBeDefined();
+            expect(metadata).toEqual(operation);
+        });
+        it('should handle undefined operation metadata', () => {
+            class TestController {
+                testMethod() { }
+            }
+            const metadata = (0, swagger_decorator_1.getOperationMetadata)(TestController.prototype, 'testMethod');
+            expect(metadata).toBeUndefined();
+        });
+    });
+});

package/dist/swagger.module.d.ts

@@ -0,0 +1,5 @@
+import { Type } from '@hazeljs/core';
+export declare class SwaggerModule {
+    static setRootModule(rootModule: Type<unknown>): void;
+}
+//# sourceMappingURL=swagger.module.d.ts.map

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

@@ -0,0 +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"}

package/dist/swagger.module.js

@@ -0,0 +1,30 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwaggerModule = void 0;
+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"));
+let SwaggerModule = class SwaggerModule {
+    static setRootModule(rootModule) {
+        core_2.default.debug('SwaggerModule: Setting root module:', rootModule.name);
+        swagger_controller_1.SwaggerController.setRootModule(rootModule);
+    }
+};
+exports.SwaggerModule = SwaggerModule;
+exports.SwaggerModule = SwaggerModule = __decorate([
+    (0, core_1.HazelModule)({
+        providers: [swagger_service_1.SwaggerService],
+        controllers: [swagger_controller_1.SwaggerController],
+        exports: [swagger_service_1.SwaggerService],
+    })
+], SwaggerModule);