@avleon/core 0.0.40 → 0.0.43

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.d.ts

@@ -1,12 +1,9 @@
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
+import { EventEmitter } from "events";
 interface Job {
     id: string;
     data: any;
+    runAt?: number;
+    status?: "pending" | "running" | "failed" | "completed";
 }
 interface QueueAdapter {
     loadJobs(): Promise<Job[]>;
@@ -18,19 +15,24 @@ export declare class FileQueueAdapter implements QueueAdapter {
     loadJobs(): Promise<Job[]>;
     saveJobs(jobs: Job[]): Promise<void>;
 }
-declare class SimpleQueue {
+export declare class AvleonQueue extends EventEmitter {
+    private name;
     private processing;
+    private stopped;
     private jobHandler;
     private adapter;
-    constructor(adapter: QueueAdapter, jobHandler: (job: Job) => Promise<void>);
-    addJob(data: any): Promise<void>;
+    constructor(name: string, adapter?: QueueAdapter, jobHandler?: (job: Job) => Promise<void>);
+    private defaultHandler;
+    addJob(data: any, options?: {
+        delay?: number;
+    }): Promise<void>;
     private processNext;
+    onDone(cb: (job: Job) => void): Promise<void>;
+    onFailed(cb: (error: any, job: Job) => void): Promise<void>;
+    getJobs(): Promise<Job[]>;
+    stop(): Promise<void>;
 }
 export declare class QueueManager {
-    private static instance;
-    private adapter;
-    private constructor();
-    static getInstance(adapter: QueueAdapter): QueueManager;
-    createQueue(jobHandler: (job: Job) => Promise<void>): SimpleQueue;
+    from(name: string, jobHandler?: (job: Job) => Promise<void>): Promise<AvleonQueue>;
 }
 export {};

package/dist/queue.js

@@ -1,15 +1,17 @@
 "use strict";
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
+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;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueueManager = exports.FileQueueAdapter = void 0;
+exports.QueueManager = exports.AvleonQueue = exports.FileQueueAdapter = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
-const helpers_1 = require("./helpers");
+const crypto_1 = require("crypto");
+const events_1 = require("events");
+const decorators_1 = require("./decorators");
 class FileQueueAdapter {
     constructor(queueName) {
         this.queueFile = (0, path_1.join)(__dirname, `${queueName}.json`);
@@ -19,7 +21,7 @@ class FileQueueAdapter {
             const data = await fs_1.promises.readFile(this.queueFile, "utf-8");
             return JSON.parse(data);
         }
-        catch (error) {
+        catch (_a) {
             return [];
         }
     }
@@ -28,76 +30,87 @@ class FileQueueAdapter {
     }
 }
 exports.FileQueueAdapter = FileQueueAdapter;
-// class RedisQueueAdapter implements QueueAdapter {
-//   private client = createClient();
-//   private queueKey: string;
-//
-//   constructor(queueName: string) {
-//     this.queueKey = `queue:${queueName}`;
-//     this.client.connect();
-//   }
-//
-//   async loadJobs(): Promise<Job[]> {
-//     const jobs = await this.client.lRange(this.queueKey, 0, -1);
-//     return jobs.map((job) => JSON.parse(job));
-//   }
-//
-//   async saveJobs(jobs: Job[]) {
-//     await this.client.del(this.queueKey);
-//     if (jobs.length > 0) {
-//       await this.client.rPush(this.queueKey, ...jobs.map(job => JSON.stringify(job)));
-//     }
-//   }
-// }
-class SimpleQueue {
-    constructor(adapter, jobHandler) {
+class AvleonQueue extends events_1.EventEmitter {
+    constructor(name, adapter, jobHandler) {
+        super();
         this.processing = false;
-        this.adapter = adapter;
-        this.jobHandler = jobHandler;
+        this.stopped = false;
+        this.name = name;
+        this.adapter = adapter ? adapter : new FileQueueAdapter(name);
+        this.jobHandler = jobHandler || this.defaultHandler.bind(this);
+        this.setMaxListeners(10);
     }
-    async addJob(data) {
-        const job = { id: helpers_1.uuid, data };
+    async defaultHandler(job) {
+        if (typeof job.data === "function") {
+            await job.data();
+        }
+    }
+    async addJob(data, options) {
+        const job = {
+            id: (0, crypto_1.randomUUID)(),
+            data,
+            runAt: Date.now() + ((options === null || options === void 0 ? void 0 : options.delay) || 0),
+            status: "pending",
+        };
         const jobs = await this.adapter.loadJobs();
         jobs.push(job);
         await this.adapter.saveJobs(jobs);
-        this.processNext();
+        if (!this.processing)
+            this.processNext();
     }
     async processNext() {
-        if (this.processing)
+        if (this.processing || this.stopped)
             return;
         this.processing = true;
-        const jobs = await this.adapter.loadJobs();
-        if (jobs.length === 0) {
-            this.processing = false;
-            return;
-        }
-        const job = jobs.shift();
-        if (job) {
-            try {
-                await this.jobHandler(job);
+        while (!this.stopped) {
+            const jobs = await this.adapter.loadJobs();
+            const nextJob = jobs.find((j) => j.status === "pending");
+            if (!nextJob) {
+                this.processing = false;
+                return;
             }
-            catch (error) {
-                console.error(`Error processing job ${job.id}:`, error);
-                jobs.unshift(job);
+            const now = Date.now();
+            if (nextJob.runAt && nextJob.runAt > now) {
+                const delay = nextJob.runAt - now;
+                await new Promise((res) => setTimeout(res, delay));
             }
+            nextJob.status = "running";
             await this.adapter.saveJobs(jobs);
-            this.processing = false;
-            this.processNext();
+            this.emit("start", nextJob);
+            try {
+                await this.jobHandler(nextJob);
+                nextJob.status = "completed";
+                this.emit("done", nextJob);
+            }
+            catch (err) {
+                nextJob.status = "failed";
+                this.emit("failed", err, nextJob);
+            }
+            await this.adapter.saveJobs(jobs.filter((j) => j.id !== nextJob.id));
         }
+        this.processing = false;
     }
-}
-class QueueManager {
-    constructor(adapter) {
-        this.adapter = adapter;
+    async onDone(cb) {
+        this.on("done", cb);
     }
-    static getInstance(adapter) {
-        if (!QueueManager.instance) {
-            QueueManager.instance = new QueueManager(adapter);
-        }
-        return QueueManager.instance;
+    async onFailed(cb) {
+        this.on("failed", cb);
     }
-    createQueue(jobHandler) {
-        return new SimpleQueue(this.adapter, jobHandler);
+    async getJobs() {
+        return this.adapter.loadJobs();
+    }
+    async stop() {
+        this.stopped = true;
     }
 }
+exports.AvleonQueue = AvleonQueue;
+let QueueManager = class QueueManager {
+    async from(name, jobHandler) {
+        const q = new AvleonQueue(name, new FileQueueAdapter(name), jobHandler);
+        return q;
+    }
+};
 exports.QueueManager = QueueManager;
+exports.QueueManager = QueueManager = __decorate([
+    decorators_1.AppService
+], QueueManager);

package/dist/queue.test.d.ts

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