@hazeljs/swagger 0.2.0-alpha.1

package/dist/swagger.service.d.ts

@@ -0,0 +1,24 @@
+import { SwaggerOperation, SwaggerSchema } from './swagger.types';
+import { Type } from '@hazeljs/core';
+export interface SwaggerSpec {
+    openapi: string;
+    info: {
+        title?: string;
+        description?: string;
+        version?: string;
+    };
+    paths: Record<string, Record<string, SwaggerOperation>>;
+    components: {
+        schemas: Record<string, SwaggerSchema>;
+    };
+    tags?: Array<{
+        name: string;
+        description: string;
+    }>;
+}
+export declare class SwaggerService {
+    private spec;
+    generateSpec(controllers: Type<unknown>[]): SwaggerSpec;
+    private normalizePath;
+}
+//# sourceMappingURL=swagger.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"swagger.service.d.ts","sourceRoot":"","sources":["../src/swagger.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGlE,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAErC,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE;QACJ,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC;IACxD,UAAU,EAAE;QACV,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;KACxC,CAAC;IACF,IAAI,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACrD;AAQD,qBACa,cAAc;IACzB,OAAO,CAAC,IAAI,CAOV;IAEF,YAAY,CAAC,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE,GAAG,WAAW;IAsGvD,OAAO,CAAC,aAAa;CAStB"}

package/dist/swagger.service.js

@@ -0,0 +1,121 @@
+"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.SwaggerService = void 0;
+const core_1 = require("@hazeljs/core");
+const swagger_decorator_1 = require("./swagger.decorator");
+const core_2 = __importDefault(require("@hazeljs/core"));
+let SwaggerService = class SwaggerService {
+    constructor() {
+        this.spec = {
+            openapi: '3.0.0',
+            info: {},
+            paths: {},
+            components: {
+                schemas: {},
+            },
+        };
+    }
+    generateSpec(controllers) {
+        try {
+            if (!Array.isArray(controllers)) {
+                throw new Error('Controllers must be an array');
+            }
+            core_2.default.debug('Generating spec for controllers:', controllers.map((c) => c?.name || 'undefined'));
+            // Reset spec
+            this.spec = {
+                openapi: '3.0.0',
+                info: {},
+                paths: {},
+                components: {
+                    schemas: {},
+                },
+            };
+            // Process each controller
+            controllers.forEach((controller) => {
+                if (!controller || typeof controller !== 'function') {
+                    if (process.env.NODE_ENV !== 'test') {
+                        core_2.default.warn('Invalid controller found:', controller);
+                    }
+                    return;
+                }
+                // Get Swagger metadata from the controller prototype
+                const swaggerOptions = (0, swagger_decorator_1.getSwaggerMetadata)(controller.prototype);
+                if (!swaggerOptions) {
+                    core_2.default.debug(`No Swagger metadata found for controller: ${controller.name}`);
+                    return;
+                }
+                core_2.default.debug(`Processing controller: ${controller.name}`, swaggerOptions);
+                // Update info if not already set
+                if (!this.spec.info.title) {
+                    this.spec.info = {
+                        title: swaggerOptions.title,
+                        description: swaggerOptions.description,
+                        version: swaggerOptions.version,
+                    };
+                }
+                // Add tags if not already set
+                if (swaggerOptions.tags && !this.spec.tags) {
+                    this.spec.tags = swaggerOptions.tags;
+                }
+                // Get controller path from metadata
+                const controllerMetadata = Reflect.getMetadata('hazel:controller', controller) || {};
+                const basePath = controllerMetadata.path || '';
+                // Get route metadata
+                const routes = Reflect.getMetadata('hazel:routes', controller);
+                if (!routes) {
+                    core_2.default.debug(`No routes found for controller: ${controller.name}`);
+                    return;
+                }
+                core_2.default.debug(`Found routes for ${controller.name}:`, routes);
+                // Process each route
+                routes.forEach((route) => {
+                    const { path, method, propertyKey } = route;
+                    const fullPath = this.normalizePath(`${basePath}${path}`);
+                    const operation = (0, swagger_decorator_1.getOperationMetadata)(controller.prototype, propertyKey);
+                    if (!operation) {
+                        core_2.default.debug(`No operation metadata found for method: ${String(propertyKey)}`);
+                        return;
+                    }
+                    core_2.default.debug(`Adding operation for ${method} ${fullPath}`);
+                    // Add operation to paths
+                    const pathItem = this.spec.paths[fullPath] || {};
+                    pathItem[method.toLowerCase()] = {
+                        ...operation,
+                        tags: operation.tags || [controller.name],
+                    };
+                    this.spec.paths[fullPath] = pathItem;
+                });
+            });
+            core_2.default.debug('Generated Swagger specification:', this.spec);
+            return this.spec;
+        }
+        catch (error) {
+            if (process.env.NODE_ENV !== 'test') {
+                core_2.default.error('Failed to generate Swagger specification:', error);
+            }
+            throw error;
+        }
+    }
+    normalizePath(path) {
+        // Remove trailing slash
+        let normalized = path.replace(/\/$/, '');
+        // Ensure path starts with slash
+        if (!normalized.startsWith('/')) {
+            normalized = '/' + normalized;
+        }
+        return normalized;
+    }
+};
+exports.SwaggerService = SwaggerService;
+exports.SwaggerService = SwaggerService = __decorate([
+    (0, core_1.Service)()
+], SwaggerService);

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

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

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

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

package/dist/swagger.service.test.js

@@ -0,0 +1,364 @@
+"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_service_1 = require("./swagger.service");
+const swagger_decorator_1 = require("./swagger.decorator");
+const core_1 = require("@hazeljs/core");
+describe('SwaggerService', () => {
+    let swaggerService;
+    beforeEach(() => {
+        swaggerService = new swagger_service_1.SwaggerService();
+    });
+    describe('generateSpec', () => {
+        it('should generate spec for a controller with Swagger metadata', () => {
+            const swaggerOptions = {
+                title: 'Test API',
+                description: 'Test API description',
+                version: '1.0.0',
+                tags: [{ name: 'test', description: 'Test operations' }],
+            };
+            const getOperation = {
+                summary: 'Get test',
+                description: 'Get test description',
+                tags: ['test'],
+                responses: {
+                    '200': {
+                        description: 'Success',
+                    },
+                },
+            };
+            const postOperation = {
+                summary: 'Create test',
+                description: 'Create test description',
+                tags: ['test'],
+                responses: {
+                    '201': {
+                        description: 'Created',
+                    },
+                },
+            };
+            let TestController = class TestController {
+                getTest() { }
+                createTest() { }
+            };
+            __decorate([
+                (0, core_1.Get)(),
+                (0, swagger_decorator_1.ApiOperation)(getOperation),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "getTest", null);
+            __decorate([
+                (0, core_1.Post)(),
+                (0, swagger_decorator_1.ApiOperation)(postOperation),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "createTest", null);
+            TestController = __decorate([
+                (0, swagger_decorator_1.Swagger)(swaggerOptions),
+                (0, core_1.Controller)({ path: '/test' })
+            ], TestController);
+            // Mock controller metadata
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            // Mock route metadata
+            Reflect.defineMetadata('hazel:routes', [
+                { propertyKey: 'getTest', path: '', method: 'GET' },
+                { propertyKey: 'createTest', path: '', method: 'POST' },
+            ], TestController);
+            const spec = swaggerService.generateSpec([TestController]);
+            expect(spec).toBeDefined();
+            expect(spec.openapi).toBe('3.0.0');
+            expect(spec.info).toEqual({
+                title: swaggerOptions.title,
+                description: swaggerOptions.description,
+                version: swaggerOptions.version,
+            });
+            expect(spec.tags).toEqual(swaggerOptions.tags);
+            expect(spec.paths['/test']).toBeDefined();
+            expect(spec.paths['/test'].get).toEqual({
+                summary: getOperation.summary,
+                description: getOperation.description,
+                tags: getOperation.tags,
+                responses: getOperation.responses,
+            });
+            expect(spec.paths['/test'].post).toEqual({
+                summary: postOperation.summary,
+                description: postOperation.description,
+                tags: postOperation.tags,
+                responses: postOperation.responses,
+            });
+        });
+        it('should handle controller without Swagger metadata', () => {
+            let TestController = class TestController {
+                getTest() { }
+            };
+            __decorate([
+                (0, core_1.Get)(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "getTest", null);
+            TestController = __decorate([
+                (0, core_1.Controller)({ path: '/test' })
+            ], TestController);
+            // Mock route metadata
+            Reflect.defineMetadata('hazel:routes', [{ propertyKey: 'getTest', path: '/test', method: 'GET' }], TestController);
+            const spec = swaggerService.generateSpec([TestController]);
+            expect(spec).toBeDefined();
+            expect(spec.paths).toEqual({});
+        });
+        it('should handle invalid controllers', () => {
+            class InvalidController {
+            }
+            const spec = swaggerService.generateSpec([InvalidController]);
+            expect(spec).toBeDefined();
+            expect(spec.paths).toEqual({});
+        });
+        it('should handle controller without route metadata', () => {
+            let TestController = class TestController {
+                getTest() { }
+            };
+            __decorate([
+                (0, core_1.Get)(),
+                (0, swagger_decorator_1.ApiOperation)({
+                    summary: 'Get test',
+                    description: 'Get test description',
+                    tags: ['test'],
+                    responses: { '200': { description: 'Success' } },
+                }),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "getTest", null);
+            TestController = __decorate([
+                (0, swagger_decorator_1.Swagger)({
+                    title: 'Test API',
+                    description: 'Test API description',
+                    version: '1.0.0',
+                    tags: [{ name: 'test', description: 'Test operations' }],
+                }),
+                (0, core_1.Controller)({ path: '/test' })
+            ], TestController);
+            // Explicitly remove route metadata
+            Reflect.deleteMetadata('hazel:routes', TestController);
+            const spec = swaggerService.generateSpec([TestController]);
+            expect(spec).toBeDefined();
+            expect(spec.paths).toEqual({});
+        });
+        it('should handle controller with method without operation metadata', () => {
+            let TestController = class TestController {
+                getTest() { }
+            };
+            __decorate([
+                (0, core_1.Get)(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "getTest", null);
+            TestController = __decorate([
+                (0, swagger_decorator_1.Swagger)({
+                    title: 'Test API',
+                    description: 'Test API description',
+                    version: '1.0.0',
+                    tags: [{ name: 'test', description: 'Test operations' }],
+                }),
+                (0, core_1.Controller)({ path: '/test' })
+            ], TestController);
+            // Mock route metadata
+            Reflect.defineMetadata('hazel:routes', [{ propertyKey: 'getTest', path: '/test', method: 'GET' }], TestController);
+            const spec = swaggerService.generateSpec([TestController]);
+            expect(spec).toBeDefined();
+            expect(spec.paths).toEqual({});
+        });
+        it('should throw error when controllers is not an array', () => {
+            expect(() => {
+                swaggerService.generateSpec(null);
+            }).toThrow('Controllers must be an array');
+        });
+        it('should handle null and undefined controllers', () => {
+            const spec = swaggerService.generateSpec([null, undefined, {}]);
+            expect(spec).toBeDefined();
+            expect(spec.paths).toEqual({});
+        });
+        it('should handle error during spec generation', () => {
+            // Test error handling by making getSwaggerMetadata throw
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const swaggerDecorator = require('./swagger.decorator');
+            jest.spyOn(swaggerDecorator, 'getSwaggerMetadata').mockImplementation(() => {
+                throw new Error('Metadata access error');
+            });
+            let TestController = class TestController {
+                getTest() { }
+            };
+            __decorate([
+                (0, core_1.Get)(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "getTest", null);
+            TestController = __decorate([
+                (0, core_1.Controller)({ path: '/test' })
+            ], TestController);
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ propertyKey: 'getTest', path: '', method: 'GET' }], TestController);
+            expect(() => {
+                swaggerService.generateSpec([TestController]);
+            }).toThrow('Metadata access error');
+            // Restore original
+            jest.restoreAllMocks();
+        });
+        it('should normalize paths correctly', () => {
+            const swaggerOptions = {
+                title: 'Test API',
+                description: 'Test API description',
+                version: '1.0.0',
+            };
+            const getOperation = {
+                summary: 'Get test',
+                responses: { '200': { description: 'Success' } },
+            };
+            let TestController = class TestController {
+                getTest() { }
+            };
+            __decorate([
+                (0, core_1.Get)('path') // Path without leading slash
+                ,
+                (0, swagger_decorator_1.ApiOperation)(getOperation),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "getTest", null);
+            TestController = __decorate([
+                (0, swagger_decorator_1.Swagger)(swaggerOptions),
+                (0, core_1.Controller)({ path: 'test' }) // Path without leading slash
+            ], TestController);
+            Reflect.defineMetadata('hazel:controller', { path: 'test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ propertyKey: 'getTest', path: 'path', method: 'GET' }], TestController);
+            const spec = swaggerService.generateSpec([TestController]);
+            // The normalizePath concatenates basePath and path: 'test' + 'path' = 'testpath', then normalizes to '/testpath'
+            // But actually, paths should be joined with '/' if both exist
+            // Let's check what path was actually created
+            const pathKeys = Object.keys(spec.paths);
+            expect(pathKeys.length).toBeGreaterThan(0);
+            // The normalized path should start with '/'
+            const createdPath = pathKeys[0];
+            expect(createdPath.startsWith('/')).toBe(true);
+            expect(spec.paths[createdPath].get).toBeDefined();
+        });
+        it('should handle path with trailing slash', () => {
+            const swaggerOptions = {
+                title: 'Test API',
+                description: 'Test API description',
+                version: '1.0.0',
+            };
+            const getOperation = {
+                summary: 'Get test',
+                responses: { '200': { description: 'Success' } },
+            };
+            let TestController = class TestController {
+                getTest() { }
+            };
+            __decorate([
+                (0, core_1.Get)(),
+                (0, swagger_decorator_1.ApiOperation)(getOperation),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "getTest", null);
+            TestController = __decorate([
+                (0, swagger_decorator_1.Swagger)(swaggerOptions),
+                (0, core_1.Controller)({ path: '/test/' }) // Path with trailing slash
+            ], TestController);
+            Reflect.defineMetadata('hazel:controller', { path: '/test/' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ propertyKey: 'getTest', path: '', method: 'GET' }], TestController);
+            const spec = swaggerService.generateSpec([TestController]);
+            expect(spec.paths['/test']).toBeDefined();
+        });
+        it('should handle multiple controllers with same base path', () => {
+            const swaggerOptions = {
+                title: 'Test API',
+                description: 'Test API description',
+                version: '1.0.0',
+            };
+            const getOperation = {
+                summary: 'Get test',
+                responses: { '200': { description: 'Success' } },
+            };
+            const postOperation = {
+                summary: 'Post test',
+                responses: { '201': { description: 'Created' } },
+            };
+            let TestController = class TestController {
+                getTest() { }
+                postTest() { }
+            };
+            __decorate([
+                (0, core_1.Get)(),
+                (0, swagger_decorator_1.ApiOperation)(getOperation),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "getTest", null);
+            __decorate([
+                (0, core_1.Post)(),
+                (0, swagger_decorator_1.ApiOperation)(postOperation),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "postTest", null);
+            TestController = __decorate([
+                (0, swagger_decorator_1.Swagger)(swaggerOptions),
+                (0, core_1.Controller)({ path: '/test' })
+            ], TestController);
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [
+                { propertyKey: 'getTest', path: '', method: 'GET' },
+                { propertyKey: 'postTest', path: '', method: 'POST' },
+            ], TestController);
+            const spec = swaggerService.generateSpec([TestController]);
+            expect(spec.paths['/test']).toBeDefined();
+            expect(spec.paths['/test'].get).toBeDefined();
+            expect(spec.paths['/test'].post).toBeDefined();
+        });
+        it('should use controller name as tag when operation has no tags', () => {
+            const swaggerOptions = {
+                title: 'Test API',
+                description: 'Test API description',
+                version: '1.0.0',
+            };
+            const getOperation = {
+                summary: 'Get test',
+                responses: { '200': { description: 'Success' } },
+                // No tags property
+            };
+            let TestController = class TestController {
+                getTest() { }
+            };
+            __decorate([
+                (0, core_1.Get)(),
+                (0, swagger_decorator_1.ApiOperation)(getOperation),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestController.prototype, "getTest", null);
+            TestController = __decorate([
+                (0, swagger_decorator_1.Swagger)(swaggerOptions),
+                (0, core_1.Controller)({ path: '/test' })
+            ], TestController);
+            Reflect.defineMetadata('hazel:controller', { path: '/test' }, TestController);
+            Reflect.defineMetadata('hazel:routes', [{ propertyKey: 'getTest', path: '', method: 'GET' }], TestController);
+            const spec = swaggerService.generateSpec([TestController]);
+            expect(spec.paths['/test'].get.tags).toEqual(['TestController']);
+        });
+    });
+});

package/dist/swagger.types.d.ts

@@ -0,0 +1,50 @@
+export interface SwaggerOptions {
+    title: string;
+    description: string;
+    version: string;
+    path?: string;
+    tags?: SwaggerTag[];
+}
+export interface SwaggerTag {
+    name: string;
+    description: string;
+}
+export interface SwaggerOperation {
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    parameters?: SwaggerParameter[];
+    requestBody?: {
+        required?: boolean;
+        content: {
+            [contentType: string]: {
+                schema: SwaggerSchema;
+            };
+        };
+    };
+    responses?: Record<string, SwaggerResponse>;
+}
+export interface SwaggerParameter {
+    name: string;
+    in: 'path' | 'query' | 'header' | 'cookie';
+    description?: string;
+    required?: boolean;
+    schema: SwaggerSchema;
+}
+export interface SwaggerResponse {
+    description: string;
+    content?: {
+        [contentType: string]: {
+            schema: SwaggerSchema;
+        };
+    };
+}
+export interface SwaggerSchema {
+    type: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object';
+    format?: string;
+    items?: SwaggerSchema;
+    properties?: Record<string, SwaggerSchema>;
+    required?: string[];
+    example?: string | number | boolean | null | Record<string, unknown> | unknown[];
+}
+//# sourceMappingURL=swagger.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"swagger.types.d.ts","sourceRoot":"","sources":["../src/swagger.types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,UAAU,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAChC,WAAW,CAAC,EAAE;QACZ,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,OAAO,EAAE;YACP,CAAC,WAAW,EAAE,MAAM,GAAG;gBACrB,MAAM,EAAE,aAAa,CAAC;aACvB,CAAC;SACH,CAAC;KACH,CAAC;IACF,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CAC7C;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAC3C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,aAAa,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE;QACR,CAAC,WAAW,EAAE,MAAM,GAAG;YACrB,MAAM,EAAE,aAAa,CAAC;SACvB,CAAC;KACH,CAAC;CACH;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,CAAC;IACvE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAC3C,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,EAAE,CAAC;CAClF"}

package/dist/swagger.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@hazeljs/swagger",
+  "version": "0.2.0-alpha.1",
+  "description": "Swagger/OpenAPI documentation module for HazelJS framework",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --coverage",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "swagger-ui-express": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.50",
+    "@types/swagger-ui-express": "^4.1.6",
+    "@typescript-eslint/eslint-plugin": "^8.18.2",
+    "@typescript-eslint/parser": "^8.18.2",
+    "eslint": "^8.56.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hazel-js/hazeljs.git",
+    "directory": "packages/swagger"
+  },
+  "keywords": [
+    "hazeljs",
+    "swagger",
+    "openapi",
+    "api-docs",
+    "documentation"
+  ],
+  "author": "Muhammad Arslan <muhammad.arslan@hazeljs.com>",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/hazeljs/hazel-js/issues"
+  },
+  "homepage": "https://hazeljs.com",
+  "peerDependencies": {
+    "@hazeljs/core": ">=0.2.0-beta.0"
+  },
+  "gitHead": "cbc5ee2c12ced28fd0576faf13c5f078c1e8421e"
+}