@avleon/core 0.0.39 → 0.0.42-rc0.1

package/dist/middleware.test.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 __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 middleware_1 = require("./middleware");
+describe("AvleonMiddleware", () => {
+    class TestMiddleware extends middleware_1.AvleonMiddleware {
+        async invoke(req, res) {
+            return req;
+        }
+    }
+    it("should allow AppMiddleware decorator on valid class", () => {
+        expect(() => (0, middleware_1.AppMiddleware)(TestMiddleware)).not.toThrow();
+    });
+    it("should throw error if AppMiddleware is used on class without invoke", () => {
+        class InvalidMiddleware {
+        }
+        expect(() => (0, middleware_1.AppMiddleware)(InvalidMiddleware)).toThrow(/must implement an "invoke" method/);
+    });
+});
+describe("UseMiddleware", () => {
+    class MW1 extends middleware_1.AvleonMiddleware {
+        async invoke(req) {
+            return req;
+        }
+    }
+    class MW2 extends middleware_1.AvleonMiddleware {
+        async invoke(req) {
+            return req;
+        }
+    }
+    it("should attach middleware to class", () => {
+        let TestController = class TestController {
+        };
+        TestController = __decorate([
+            (0, middleware_1.UseMiddleware)([MW1, MW2])
+        ], TestController);
+        const middlewares = Reflect.getMetadata("controller:middleware", TestController);
+        expect(middlewares).toHaveLength(2);
+        expect(middlewares[0]).toBeInstanceOf(MW1);
+        expect(middlewares[1]).toBeInstanceOf(MW2);
+    });
+    it("should attach middleware to method", () => {
+        class TestController {
+            testMethod() { }
+        }
+        __decorate([
+            (0, middleware_1.UseMiddleware)(MW1),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestController.prototype, "testMethod", null);
+        const middlewares = Reflect.getMetadata("route:middleware", TestController.prototype, "testMethod");
+        expect(middlewares).toHaveLength(1);
+        expect(middlewares[0]).toBeInstanceOf(MW1);
+    });
+});
+// describe("Authorized decorator", () => {
+// it("should define metadata on class", () => {
+//     @Authorized({ roles: ["admin"] })
+//     class TestClass {}
+//     const meta = Reflect.getMetadata("AUTHORIZATION_META_KEY", TestClass);
+//     expect(meta).toEqual({ authorize: true, options: { roles: ["admin"] } });
+// });
+// it("should define metadata on method", () => {
+//     class TestClass {
+//         @Authorized({ roles: ["user"] })
+//         testMethod() {}
+//     }
+//     const meta = Reflect.getMetadata(
+//         "AUTHORIZATION_META_KEY",
+//         TestClass.constructor,
+//         "testMethod",
+//     );
+//     expect(meta).toEqual({ authorize: true, options: { roles: ["user"] } });
+// });
+describe("CanAuthorize and AppAuthorization", () => {
+    class ValidAuthorize {
+        authorize(req, options) {
+            return req;
+        }
+    }
+    it("should not throw for valid CanAuthorize", () => {
+        expect(() => (0, middleware_1.CanAuthorize)(ValidAuthorize)).not.toThrow();
+    });
+    it("should throw for invalid CanAuthorize", () => {
+        class InvalidAuthorize {
+        }
+        expect(() => (0, middleware_1.CanAuthorize)(InvalidAuthorize)).toThrow(/must implement an "authorize" method/);
+    });
+    it("should not throw for valid AppAuthorization", () => {
+        expect(() => (0, middleware_1.AppAuthorization)(ValidAuthorize)).not.toThrow();
+    });
+    it("should throw for invalid AppAuthorization", () => {
+        class InvalidAuthorize {
+        }
+        expect(() => (0, middleware_1.AppAuthorization)(InvalidAuthorize)).toThrow(/must implement an "authorize" method/);
+    });
+});
+describe("AuthorizeMiddleware", () => {
+    class TestAuthorizeMiddleware extends middleware_1.AuthorizeMiddleware {
+        authorize(roles) {
+            return (req) => req;
+        }
+    }
+    it("should implement authorize method", () => {
+        const mw = new TestAuthorizeMiddleware();
+        const handler = mw.authorize(["admin"]);
+        expect(typeof handler).toBe("function");
+        const req = {};
+        expect(handler(req)).toBe(req);
+    });
+});

package/dist/multipart.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/multipart.test.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const multipart_1 = require("./multipart");
+const exceptions_1 = require("./exceptions");
+const fs_1 = __importDefault(require("fs"));
+jest.mock("fs");
+jest.mock("stream/promises", () => ({
+    pipeline: jest.fn(() => Promise.resolve()),
+}));
+const mockFileStream = {};
+const mockReq = (fileData) => ({
+    params: {},
+    query: {},
+    body: {},
+    headers: {},
+    method: "POST",
+    url: "/upload",
+    file: jest.fn().mockResolvedValue(fileData),
+    // Add any other required IRequest properties as needed for type compatibility
+});
+describe("UploadFileFromRequest", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        fs_1.default.existsSync.mockReturnValue(false);
+    });
+    // it("should save file to default location", async () => {
+    //     const fileData = {
+    //         file: mockFileStream,
+    //         filename: "test.txt",
+    //     };
+    //     const req = mockReq(fileData);
+    //     const result = await UploadFileFromRequest(req);
+    //     expect(fs.existsSync).toHaveBeenCalled();
+    //     expect(pipeline).toHaveBeenCalledWith(mockFileStream, expect.anything());
+    //     expect(result).toMatchObject({
+    //         ...fileData,
+    //         filename: "test.txt",
+    //     });
+    // });
+    // it("should save file to custom location with saveAs", async () => {
+    //     const fileData = {
+    //         file: mockFileStream,
+    //         filename: "original.txt",
+    //     };
+    //     const req = mockReq(fileData);
+    //     const options = { saveAs: "custom.txt" };
+    //     const result = await UploadFileFromRequest(req, options);
+    //     expect(fs.existsSync).toHaveBeenCalled();
+    //     expect(pipeline).toHaveBeenCalledWith(mockFileStream, expect.anything());
+    //     expect(result).toMatchObject({
+    //         ...fileData,
+    //         filename: "custom.txt",
+    //     });
+    // });
+    // it("should save file to custom dest", async () => {
+    //     const fileData = {
+    //         file: mockFileStream,
+    //         filename: "file.txt",
+    //     };
+    //     const req = mockReq(fileData);
+    //     const options:any = { dest: "/tmp" };
+    //     const result = await UploadFileFromRequest(req, options);
+    //     expect(fs.existsSync).toHaveBeenCalled();
+    //     expect(pipeline).toHaveBeenCalledWith(mockFileStream, expect.anything());
+    //     expect(result).toMatchObject({
+    //         ...fileData,
+    //         filename: "file.txt",
+    //     });
+    // });
+    it("should throw error if file already exists", async () => {
+        fs_1.default.existsSync.mockReturnValue(true);
+        const fileData = {
+            file: mockFileStream,
+            filename: "exists.txt",
+        };
+        const req = mockReq(fileData);
+        await expect((0, multipart_1.UploadFileFromRequest)(req)).rejects.toThrow(exceptions_1.InternalErrorException);
+    });
+    it("should return undefined if no file is present", async () => {
+        const req = mockReq(null);
+        const result = await (0, multipart_1.UploadFileFromRequest)(req);
+        expect(result).toBeUndefined();
+    });
+});

package/dist/openapi.test.d.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';

package/dist/openapi.test.js

@@ -0,0 +1,111 @@
+"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 openapi_1 = require("./openapi");
+describe('OpenApi Decorator', () => {
+    it('should define metadata on class', () => {
+        let TestController = class TestController {
+        };
+        TestController = __decorate([
+            (0, openapi_1.OpenApi)({ description: 'Test Controller' })
+        ], TestController);
+        const metadata = Reflect.getMetadata('controller:openapi', TestController);
+        expect(metadata).toEqual({ description: 'Test Controller' });
+    });
+    it('should define metadata on method', () => {
+        class TestController {
+            testMethod() { }
+        }
+        __decorate([
+            (0, openapi_1.OpenApi)({ description: 'Test Route' }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestController.prototype, "testMethod", null);
+        const metadata = Reflect.getMetadata('route:openapi', TestController.prototype, 'testMethod');
+        expect(metadata).toEqual({ description: 'Test Route' });
+    });
+    it('should define metadata on property', () => {
+        class TestController {
+            constructor() {
+                this.testProperty = '';
+            }
+        }
+        __decorate([
+            (0, openapi_1.OpenApi)({ description: 'Test Property' }),
+            __metadata("design:type", String)
+        ], TestController.prototype, "testProperty", void 0);
+        const metadata = Reflect.getMetadata('property:openapi', TestController.prototype, 'testProperty');
+        expect(metadata).toEqual({ description: 'Test Property' });
+    });
+});
+describe('Type Definitions', () => {
+    it('InfoObject should allow optional description', () => {
+        const info = {
+            title: 'API',
+            version: '1.0.0',
+            description: 'API Description',
+        };
+        expect(info.description).toBe('API Description');
+    });
+    it('ContactObject should allow optional fields', () => {
+        const contact = {
+            name: 'John Doe',
+            email: 'john@example.com',
+        };
+        expect(contact.name).toBe('John Doe');
+        expect(contact.email).toBe('john@example.com');
+    });
+    it('LicenseObject should require name', () => {
+        const license = {
+            name: 'MIT',
+        };
+        expect(license.name).toBe('MIT');
+    });
+    it('ServerObject should allow variables', () => {
+        var _a;
+        const server = {
+            url: 'https://api.example.com',
+            variables: {
+                version: {
+                    default: 'v1',
+                    enum: ['v1', 'v2'],
+                },
+            },
+        };
+        expect((_a = server.variables) === null || _a === void 0 ? void 0 : _a.version.default).toBe('v1');
+    });
+    it('SchemaObject should allow array and non-array types', () => {
+        const arraySchema = {
+            type: 'array',
+            items: { type: 'string' },
+        };
+        expect(arraySchema.type).toBe('array');
+        const nonArraySchema = {
+            type: 'string',
+        };
+        expect(nonArraySchema.type).toBe('string');
+    });
+    it('ComponentsObject should allow schemas and responses', () => {
+        var _a, _b;
+        const components = {
+            schemas: {
+                User: { type: 'object' },
+            },
+            responses: {
+                NotFound: { description: 'Not found' },
+            },
+        };
+        expect((_a = components.schemas) === null || _a === void 0 ? void 0 : _a.User).toBeDefined();
+        expect(((_b = components.responses) === null || _b === void 0 ? void 0 : _b.NotFound).description).toBe('Not found');
+    });
+});

package/dist/params.test.d.ts

@@ -0,0 +1 @@
+import "reflect-metadata";

package/dist/params.test.js

@@ -0,0 +1,83 @@
+"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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const params_1 = require("./params");
+const container_1 = require("./container");
+describe("Parameter Decorators", () => {
+    class DummyValidator {
+    }
+    class TestController {
+        testMethod(id, search, body, token, user) { }
+    }
+    __decorate([
+        __param(0, (0, params_1.Param)("id")),
+        __param(1, (0, params_1.Query)("search")),
+        __param(2, (0, params_1.Body)()),
+        __param(3, (0, params_1.Header)("x-token")),
+        __param(4, (0, params_1.AuthUser)()),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [String, String, DummyValidator, String, Object]),
+        __metadata("design:returntype", void 0)
+    ], TestController.prototype, "testMethod", null);
+    it("should define metadata for Param decorator", () => {
+        const meta = Reflect.getMetadata(container_1.PARAM_META_KEY, TestController.prototype, "testMethod");
+        expect(meta).toBeDefined();
+        expect(meta[0].key).toBe("id");
+        expect(meta[0].type).toBe("route:param");
+    });
+    it("should define metadata for Query decorator", () => {
+        const meta = Reflect.getMetadata(container_1.QUERY_META_KEY, TestController.prototype, "testMethod");
+        expect(meta).toBeDefined();
+        expect(meta[1].key).toBe("search");
+        expect(meta[1].type).toBe("route:query");
+    });
+    it("should define metadata for Body decorator", () => {
+        const meta = Reflect.getMetadata(container_1.REQUEST_BODY_META_KEY, TestController.prototype, "testMethod");
+        expect(meta).toBeDefined();
+        expect(meta[2].key).toBe("all");
+        expect(meta[2].type).toBe("route:body");
+    });
+    it("should define metadata for Header decorator", () => {
+        const meta = Reflect.getMetadata(container_1.REQUEST_HEADER_META_KEY, TestController.prototype, "testMethod");
+        expect(meta).toBeDefined();
+        expect(meta[3].key).toBe("x-token");
+        expect(meta[3].type).toBe("route:header");
+    });
+    it("should define metadata for AuthUser decorator", () => {
+        const meta = Reflect.getMetadata(container_1.REQUEST_USER_META_KEY, TestController.prototype, "testMethod");
+        expect(meta).toBeDefined();
+        expect(meta[4].key).toBe("all");
+        expect(meta[4].type).toBe("route:user");
+    });
+    it("should set required and validate options to true by default", () => {
+        const meta = Reflect.getMetadata(container_1.PARAM_META_KEY, TestController.prototype, "testMethod");
+        expect(meta[0].required).toBe(true);
+        expect(meta[0].validate).toBe(true);
+    });
+    it("should allow overriding required and validate options", () => {
+        class AnotherController {
+            test(id) { }
+        }
+        __decorate([
+            __param(0, (0, params_1.Param)("id", { required: false, validate: false })),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [String]),
+            __metadata("design:returntype", void 0)
+        ], AnotherController.prototype, "test", null);
+        const meta = Reflect.getMetadata(container_1.PARAM_META_KEY, AnotherController.prototype, "test");
+        expect(meta[0].required).toBe(false);
+        expect(meta[0].validate).toBe(false);
+    });
+});

package/dist/queue.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/queue.test.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const queue_1 = require("./queue");
+const fs_1 = require("fs");
+const path_1 = require("path");
+jest.mock("fs", () => ({
+    promises: {
+        readFile: jest.fn(),
+        writeFile: jest.fn(),
+    },
+}));
+const mockQueueFile = (0, path_1.join)(__dirname, "testqueue.json");
+describe("FileQueueAdapter", () => {
+    const jobs = [{ id: "1", data: "foo" }, { id: "2", data: "bar" }];
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it("should load jobs from file", async () => {
+        fs_1.promises.readFile.mockResolvedValue(JSON.stringify(jobs));
+        const adapter = new queue_1.FileQueueAdapter("testqueue");
+        const loaded = await adapter.loadJobs();
+        expect(loaded).toEqual(jobs);
+        expect(fs_1.promises.readFile).toHaveBeenCalledWith(mockQueueFile, "utf-8");
+    });
+    it("should return empty array if file does not exist", async () => {
+        fs_1.promises.readFile.mockRejectedValue(new Error("not found"));
+        const adapter = new queue_1.FileQueueAdapter("testqueue");
+        const loaded = await adapter.loadJobs();
+        expect(loaded).toEqual([]);
+    });
+    it("should save jobs to file", async () => {
+        const adapter = new queue_1.FileQueueAdapter("testqueue");
+        await adapter.saveJobs(jobs);
+        expect(fs_1.promises.writeFile).toHaveBeenCalledWith(mockQueueFile, JSON.stringify(jobs, null, 2), "utf-8");
+    });
+});
+describe("QueueManager and SimpleQueue", () => {
+    let adapter;
+    let queueManager;
+    let handler;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        adapter = new queue_1.FileQueueAdapter("testqueue");
+        queueManager = queue_1.QueueManager.getInstance(adapter);
+        handler = jest.fn().mockResolvedValue(undefined);
+        fs_1.promises.readFile.mockResolvedValue("[]");
+        fs_1.promises.writeFile.mockResolvedValue(undefined);
+    });
+    it("should create a queue and add a job", async () => {
+        const queue = queueManager.createQueue(handler);
+        await queue.addJob({ foo: "bar" });
+        expect(fs_1.promises.readFile).toHaveBeenCalled();
+        expect(fs_1.promises.writeFile).toHaveBeenCalled();
+    });
+    // it("should process jobs using handler", async () => {
+    //     (fs.readFile as jest.Mock)
+    //         .mockResolvedValueOnce("[]")
+    //         .mockResolvedValueOnce(JSON.stringify([{ id: "1", data: "baz" }]))
+    //         .mockResolvedValueOnce("[]");
+    //     const queue = queueManager.createQueue(handler);
+    //     await queue.addJob("baz");
+    //     expect(handler).toHaveBeenCalled();
+    // });
+    // it("should requeue job if handler throws", async () => {
+    //     handler.mockRejectedValueOnce(new Error("fail"));
+    //     (fs.readFile as jest.Mock)
+    //         .mockResolvedValueOnce("[]")
+    //         .mockResolvedValueOnce(JSON.stringify([{ id: "1", data: "baz" }]))
+    //         .mockResolvedValueOnce(JSON.stringify([{ id: "1", data: "baz" }]));
+    //     const queue = queueManager.createQueue(handler);
+    //     await queue.addJob("baz");
+    //     expect(handler).toHaveBeenCalled();
+    //     expect(fs.writeFile).toHaveBeenCalledTimes(2);
+    // });
+    it("QueueManager should be singleton", () => {
+        const another = queue_1.QueueManager.getInstance(adapter);
+        expect(another).toBe(queueManager);
+    });
+});

package/dist/route-methods.test.d.ts

@@ -0,0 +1 @@
+import "reflect-metadata";

package/dist/route-methods.test.js

@@ -0,0 +1,129 @@
+"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 route_methods_1 = require("./route-methods");
+describe("Route Decorators", () => {
+    class TestController {
+        getMethod() { }
+        postMethod() { }
+        putMethod() { }
+        deleteMethod() { }
+        patchMethod() { }
+        optionsMethod() { }
+        allMethod() { }
+        customRouteMethod() { }
+    }
+    __decorate([
+        (0, route_methods_1.Get)("/get"),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestController.prototype, "getMethod", null);
+    __decorate([
+        (0, route_methods_1.Post)({ path: "/post", name: "customPost" }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestController.prototype, "postMethod", null);
+    __decorate([
+        (0, route_methods_1.Put)("/put", { name: "putMethod" }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestController.prototype, "putMethod", null);
+    __decorate([
+        (0, route_methods_1.Delete)(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestController.prototype, "deleteMethod", null);
+    __decorate([
+        (0, route_methods_1.Patch)({ name: "patchMethod" }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestController.prototype, "patchMethod", null);
+    __decorate([
+        (0, route_methods_1.Options)("/options"),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestController.prototype, "optionsMethod", null);
+    __decorate([
+        (0, route_methods_1.All)({ path: "/all" }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestController.prototype, "allMethod", null);
+    __decorate([
+        (0, route_methods_1.Route)("GET", "/custom", { name: "customRoute" }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestController.prototype, "customRouteMethod", null);
+    it("should define metadata for Get decorator", () => {
+        const meta = Reflect.getMetadata("route:method", TestController.prototype, "getMethod");
+        expect(meta).toBe("GET");
+        const path = Reflect.getMetadata("route:path", TestController.prototype, "getMethod");
+        expect(path).toBe("/get");
+    });
+    // it("should define metadata for Post decorator with options object", () => {
+    //     const meta = Reflect.getMetadata("route:method", TestController.prototype, "postMethod");
+    //     expect(meta).toBe("POST");
+    //     const path = Reflect.getMetadata("route:path", TestController.prototype, "postMethod");
+    //     expect(path).toBe("/post");
+    //     const options = Reflect.getMetadata("route:options", TestController.prototype, "postMethod");
+    //     expect(options).toMatchObject({ path: "/post", name: "customPost" });
+    // });
+    it("should define metadata for Put decorator with path and options", () => {
+        const meta = Reflect.getMetadata("route:method", TestController.prototype, "putMethod");
+        expect(meta).toBe("PUT");
+        const path = Reflect.getMetadata("route:path", TestController.prototype, "putMethod");
+        expect(path).toBe("/put");
+        const options = Reflect.getMetadata("route:options", TestController.prototype, "putMethod");
+        expect(options).toMatchObject({ name: "putMethod" });
+    });
+    it("should define metadata for Delete decorator with default path", () => {
+        const meta = Reflect.getMetadata("route:method", TestController.prototype, "deleteMethod");
+        expect(meta).toBe("DELETE");
+        const path = Reflect.getMetadata("route:path", TestController.prototype, "deleteMethod");
+        expect(path).toBe("/");
+    });
+    it("should define metadata for Patch decorator with options object", () => {
+        const meta = Reflect.getMetadata("route:method", TestController.prototype, "patchMethod");
+        expect(meta).toBe("PATCH");
+        const path = Reflect.getMetadata("route:path", TestController.prototype, "patchMethod");
+        expect(path).toBe("patchMethod");
+        const options = Reflect.getMetadata("route:options", TestController.prototype, "patchMethod");
+        expect(options).toMatchObject({ name: "patchMethod" });
+    });
+    it("should define metadata for Options decorator with path", () => {
+        const meta = Reflect.getMetadata("route:method", TestController.prototype, "optionsMethod");
+        expect(meta).toBe("OPTIONS");
+        const path = Reflect.getMetadata("route:path", TestController.prototype, "optionsMethod");
+        expect(path).toBe("/options");
+    });
+    it("should define metadata for All decorator with options object", () => {
+        const meta = Reflect.getMetadata("route:method", TestController.prototype, "allMethod");
+        expect(meta).toBe("ALL");
+        const path = Reflect.getMetadata("route:path", TestController.prototype, "allMethod");
+        expect(path).toBe("/all");
+    });
+    it("should define metadata for generic Route decorator", () => {
+        const meta = Reflect.getMetadata("route:method", TestController.prototype, "customRouteMethod");
+        expect(meta).toBe("GET");
+        const path = Reflect.getMetadata("route:path", TestController.prototype, "customRouteMethod");
+        expect(path).toBe("/custom");
+        const options = Reflect.getMetadata("route:options", TestController.prototype, "customRouteMethod");
+        expect(options).toMatchObject({ name: "customRoute" });
+    });
+});

package/dist/swagger-schema.d.ts

@@ -1 +1,43 @@
+export declare function OpenApiProperty(options?: {
+    type?: any;
+    description?: string;
+    deprecated?: boolean;
+    example?: any;
+    enum?: any[];
+    format?: string;
+    default?: any;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    oneOf?: any[];
+    allOf?: any[];
+    anyOf?: any[];
+    exclude?: boolean;
+    isArray?: boolean;
+    items?: Record<string, any>;
+}): (target: any, propertyKey: string) => void;
+export declare function CreateSwaggerObjectSchema(classType: any): any;
 export declare function generateSwaggerSchema(classType: any): any;
+export declare function OpenApiResponse(code: number | undefined, model: any, description?: string): {
+    description: string;
+    content: {
+        "application/json": {
+            schema: {
+                type: string;
+                properties: {
+                    code: {
+                        type: string;
+                        example: number;
+                    };
+                    status: {
+                        type: string;
+                        example: string;
+                    };
+                    data: any;
+                };
+            };
+        };
+    };
+};