@avleon/core 0.0.44 → 0.0.45

package/dist/params.js

@@ -14,7 +14,6 @@ function createParamDecorator(type) {
     return function (key, options = {}) {
         return function (target, propertyKey, parameterIndex) {
             var _a, _b, _c, _d;
-            // Determine correct meta key
             let metaKey;
             switch (type) {
                 case "route:param":
@@ -35,15 +34,12 @@ function createParamDecorator(type) {
                 default:
                     throw new Error(`Unknown param decorator type: ${String(type)}`);
             }
-            // Retrieve and preserve existing metadata
             const existingParams = Reflect.getMetadata(metaKey, target, propertyKey) || [];
             // Get parameter names (fallback safe)
             const functionSource = target[propertyKey].toString();
             const paramNames = ((_b = (_a = functionSource.match(/\(([^)]*)\)/)) === null || _a === void 0 ? void 0 : _a[1]) === null || _b === void 0 ? void 0 : _b.split(",").map((n) => n.trim())) || [];
-            // Determine the param type
             const parameterTypes = Reflect.getMetadata("design:paramtypes", target, propertyKey) || [];
             const paramDataType = parameterTypes[parameterIndex];
-            // Append new parameter
             existingParams.push({
                 index: parameterIndex,
                 key: typeof key === "string" ? key : "all",
@@ -57,7 +53,6 @@ function createParamDecorator(type) {
                     : null,
                 type,
             });
-            // Save back using the correct meta key
             Reflect.defineMetadata(metaKey, existingParams, target, propertyKey);
         };
     };

package/dist/queue.d.ts

@@ -1,38 +1,29 @@
-import { EventEmitter } from "events";
-interface Job {
-    id: string;
-    data: any;
-    runAt?: number;
-    status?: "pending" | "running" | "failed" | "completed";
+import Bull, { Queue as BullQueue, Job, JobOptions } from 'bull';
+export interface QueueConfig {
+    name: string;
+    adapter?: any;
+    handler?: (job: Job) => Promise<any>;
+    options?: Bull.QueueOptions;
 }
-interface QueueAdapter {
-    loadJobs(): Promise<Job[]>;
-    saveJobs(jobs: Job[]): Promise<void>;
+export declare class AvleonQueue<T = any> {
+    protected name?: string | undefined;
+    protected adapter?: any | undefined;
+    protected queue: BullQueue<T>;
+    protected handlerFn?: (job: Job<T>) => Promise<any>;
+    constructor(name?: string | undefined, adapter?: any | undefined, handler?: (job: Job<T>) => Promise<any>);
+    handler?(job: Job<T>): Promise<any> | any;
+    add(data: T, options?: JobOptions): Promise<Bull.Job<T>>;
+    delay(data: T, delayMs: number, options?: JobOptions): Promise<Bull.Job<T>>;
+    process(handler: (job: Job<T>) => Promise<any>): void;
+    processConcurrent(concurrency: number, handler: (job: Job<T>) => Promise<any>): void;
+    getQueue(): BullQueue<T>;
+    clean(grace: number, status?: 'completed' | 'wait' | 'active' | 'delayed' | 'failed'): Promise<Job[]>;
+    close(): Promise<void>;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    getJob(jobId: string): Promise<Job<T> | null>;
+    getJobs(types: Array<'completed' | 'waiting' | 'active' | 'delayed' | 'failed' | 'paused'>, start?: number, end?: number): Promise<Job<T>[]>;
 }
-export declare class FileQueueAdapter implements QueueAdapter {
-    private queueFile;
-    constructor(queueName: string);
-    loadJobs(): Promise<Job[]>;
-    saveJobs(jobs: Job[]): Promise<void>;
-}
-export declare class AvleonQueue extends EventEmitter {
-    private name;
-    private processing;
-    private stopped;
-    private jobHandler;
-    private adapter;
-    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 {
-    from(name: string, jobHandler?: (job: Job) => Promise<void>): Promise<AvleonQueue>;
-}
-export {};
+export declare function Queue(config: QueueConfig): <T extends {
+    new (...args: any[]): AvleonQueue;
+}>(target: T) => T;

package/dist/queue.js

@@ -1,116 +1,84 @@
 "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.QueueManager = exports.AvleonQueue = exports.FileQueueAdapter = void 0;
-const fs_1 = require("fs");
-const path_1 = require("path");
-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`);
-    }
-    async loadJobs() {
-        try {
-            const data = await fs_1.promises.readFile(this.queueFile, "utf-8");
-            return JSON.parse(data);
+exports.AvleonQueue = void 0;
+exports.Queue = Queue;
+const bull_1 = __importDefault(require("bull"));
+const typedi_1 = require("typedi");
+class AvleonQueue {
+    constructor(name, adapter, handler) {
+        this.name = name;
+        this.adapter = adapter;
+        // Initialize queue with adapter or default Redis connection
+        this.queue = new bull_1.default(name || 'default', adapter);
+        this.handlerFn = handler;
+        // Check if the instance has a handler method defined
+        // This allows subclasses to define handler as a method
+        if (typeof this.handler === 'function' && !this.handlerFn) {
+            this.handlerFn = (job) => this.handler(job);
         }
-        catch (_a) {
-            return [];
+        // If handler is provided (from decorator or class method), set up processing
+        if (this.handlerFn) {
+            this.queue.process(this.handlerFn);
         }
     }
-    async saveJobs(jobs) {
-        await fs_1.promises.writeFile(this.queueFile, JSON.stringify(jobs, null, 2), "utf-8");
+    // Add job to queue
+    add(data, options) {
+        return this.queue.add(data, options);
     }
-}
-exports.FileQueueAdapter = FileQueueAdapter;
-class AvleonQueue extends events_1.EventEmitter {
-    constructor(name, adapter, jobHandler) {
-        super();
-        this.processing = false;
-        this.stopped = false;
-        this.name = name;
-        this.adapter = adapter ? adapter : new FileQueueAdapter(name);
-        this.jobHandler = jobHandler || this.defaultHandler.bind(this);
-        this.setMaxListeners(10);
+    // Add job with delay
+    delay(data, delayMs, options) {
+        return this.queue.add(data, { ...options, delay: delayMs });
     }
-    async defaultHandler(job) {
-        if (typeof job.data === "function") {
-            await job.data();
-        }
+    // Process jobs (can be called manually if not using handler)
+    process(handler) {
+        this.handlerFn = handler;
+        this.queue.process(handler);
     }
-    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);
-        if (!this.processing)
-            this.processNext();
+    // Process with concurrency
+    processConcurrent(concurrency, handler) {
+        this.handlerFn = handler;
+        this.queue.process(concurrency, handler);
     }
-    async processNext() {
-        if (this.processing || this.stopped)
-            return;
-        this.processing = true;
-        while (!this.stopped) {
-            const jobs = await this.adapter.loadJobs();
-            const nextJob = jobs.find((j) => j.status === "pending");
-            if (!nextJob) {
-                this.processing = false;
-                return;
-            }
-            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.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;
+    // Get the underlying Bull queue
+    getQueue() {
+        return this.queue;
+    }
+    async clean(grace, status) {
+        return this.queue.clean(grace, status);
     }
-    async onDone(cb) {
-        this.on("done", cb);
+    async close() {
+        await this.queue.close();
     }
-    async onFailed(cb) {
-        this.on("failed", cb);
+    async pause() {
+        await this.queue.pause();
     }
-    async getJobs() {
-        return this.adapter.loadJobs();
+    async resume() {
+        await this.queue.resume();
     }
-    async stop() {
-        this.stopped = true;
+    async getJob(jobId) {
+        return this.queue.getJob(jobId);
+    }
+    async getJobs(types, start, end) {
+        return this.queue.getJobs(types, start, end);
     }
 }
 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);
+function Queue(config) {
+    return function (target) {
+        // Create a new class that extends the target
+        const DecoratedClass = class extends target {
+            constructor(...args) {
+                super(config.name, config.adapter, config.handler);
+            }
+        };
+        Object.defineProperty(DecoratedClass, 'name', {
+            value: target.name,
+            writable: false
+        });
+        (0, typedi_1.Service)()(DecoratedClass);
+        return DecoratedClass;
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avleon/core",
-  "version": "0.0.44",
+  "version": "0.0.45",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "keywords": [
@@ -23,6 +23,7 @@
     "test": "."
   },
   "dependencies": {
+    "bull": "^4.16.5",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.2",
     "fastify": "^5.1.0",

package/dist/queue.test.d.ts

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

package/dist/queue.test.js

@@ -1,79 +0,0 @@
-"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: QueueManager;
-    let handler;
-    // beforeEach(() => {
-    //     jest.clearAllMocks();
-    //     adapter = new FileQueueAdapter("testqueue");
-    //     queueManager = QueueManager.getInstance(adapter);
-    //     handler = jest.fn().mockResolvedValue(undefined);
-    //     (fs.readFile as jest.Mock).mockResolvedValue("[]");
-    //     (fs.writeFile as jest.Mock).mockResolvedValue(undefined);
-    // });
-    // it("should create a queue and add a job", async () => {
-    //     const queue = queueManager.createQueue(handler);
-    //     await queue.addJob({ foo: "bar" });
-    //     expect(fs.readFile).toHaveBeenCalled();
-    //     expect(fs.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 = QueueManager.getInstance(adapter);
-    //     expect(another).toBe(queueManager);
-    // });
-});