@cinnabun/queue 0.0.1

package/dist/adapters/memory.adapter.d.ts

@@ -0,0 +1,22 @@
+import type { Job } from "../interfaces/job.js";
+import type { JobOptions } from "../interfaces/job-options.js";
+import type { QueueAdapter } from "../interfaces/queue-adapter.js";
+export declare class MemoryAdapter implements QueueAdapter {
+    private connected;
+    private processing;
+    private readonly queues;
+    private readonly handlers;
+    private readonly defaultOptions;
+    private processInterval;
+    constructor(defaultOptions?: JobOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    enqueue<T>(queueName: string, jobName: string, data: T, options?: JobOptions): Promise<Job<T>>;
+    process(queueName: string, jobName: string, handler: (job: Job) => Promise<void>): void;
+    getJob(queueName: string, id: string): Promise<Job | null>;
+    removeJob(queueName: string, id: string): Promise<void>;
+    startProcessing(): Promise<void>;
+    stopProcessing(): Promise<void>;
+    private sortQueue;
+    private processNext;
+}

package/dist/adapters/memory.adapter.js

@@ -0,0 +1,132 @@
+export class MemoryAdapter {
+    connected = false;
+    processing = false;
+    queues = new Map();
+    handlers = new Map();
+    defaultOptions;
+    processInterval = null;
+    constructor(defaultOptions = {}) {
+        this.defaultOptions = {
+            attempts: 3,
+            backoff: 1000,
+            ...defaultOptions,
+        };
+    }
+    async connect() {
+        this.connected = true;
+    }
+    async disconnect() {
+        await this.stopProcessing();
+        this.connected = false;
+    }
+    async enqueue(queueName, jobName, data, options) {
+        if (!this.connected) {
+            throw new Error("Adapter not connected");
+        }
+        const opts = { ...this.defaultOptions, ...options };
+        const maxAttempts = opts.attempts ?? 3;
+        const delay = opts.delay ?? 0;
+        const priority = opts.priority ?? 0;
+        const job = {
+            id: `mem-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
+            name: jobName,
+            data,
+            attempts: 0,
+            maxAttempts,
+            priority,
+            delay,
+            createdAt: new Date(),
+        };
+        const runAt = Date.now() + delay;
+        const queued = { job, runAt };
+        if (!this.queues.has(queueName)) {
+            this.queues.set(queueName, []);
+        }
+        this.queues.get(queueName).push(queued);
+        this.sortQueue(queueName);
+        return job;
+    }
+    process(queueName, jobName, handler) {
+        const key = `${queueName}:${jobName}`;
+        this.handlers.set(key, handler);
+    }
+    async getJob(queueName, id) {
+        const queue = this.queues.get(queueName);
+        if (!queue)
+            return null;
+        const queued = queue.find((q) => q.job.id === id);
+        return queued ? queued.job : null;
+    }
+    async removeJob(queueName, id) {
+        const queue = this.queues.get(queueName);
+        if (!queue)
+            return;
+        const idx = queue.findIndex((q) => q.job.id === id);
+        if (idx >= 0) {
+            queue.splice(idx, 1);
+        }
+    }
+    async startProcessing() {
+        if (this.processing)
+            return;
+        this.processing = true;
+        this.processInterval = setInterval(() => {
+            this.processNext().catch(() => { });
+        }, 50);
+    }
+    async stopProcessing() {
+        this.processing = false;
+        if (this.processInterval) {
+            clearInterval(this.processInterval);
+            this.processInterval = null;
+        }
+    }
+    sortQueue(queueName) {
+        const queue = this.queues.get(queueName);
+        if (!queue)
+            return;
+        queue.sort((a, b) => {
+            if (a.runAt !== b.runAt)
+                return a.runAt - b.runAt;
+            return (b.job.priority ?? 0) - (a.job.priority ?? 0);
+        });
+    }
+    async processNext() {
+        const now = Date.now();
+        for (const [queueName, queue] of this.queues) {
+            if (queue.length === 0)
+                continue;
+            const next = queue[0];
+            if (next.runAt > now)
+                continue;
+            queue.shift();
+            const job = next.job;
+            const handlerKey = `${queueName}:${job.name}`;
+            const handler = this.handlers.get(handlerKey);
+            if (!handler) {
+                continue;
+            }
+            try {
+                job.processedAt = new Date();
+                job.attempts++;
+                await handler(job);
+                job.completedAt = new Date();
+            }
+            catch (err) {
+                const error = err instanceof Error ? err.message : String(err);
+                job.error = error;
+                job.failedAt = new Date();
+                const maxAttempts = job.maxAttempts ?? 3;
+                if (job.attempts < maxAttempts) {
+                    const backoff = this.defaultOptions.backoff ?? 1000;
+                    const retry = {
+                        job,
+                        runAt: now + backoff,
+                    };
+                    queue.push(retry);
+                    this.sortQueue(queueName);
+                }
+            }
+        }
+    }
+}

package/dist/adapters/redis.adapter.d.ts

@@ -0,0 +1,27 @@
+import type { Job } from "../interfaces/job.js";
+import type { JobOptions } from "../interfaces/job-options.js";
+import type { QueueAdapter } from "../interfaces/queue-adapter.js";
+export declare class RedisAdapter implements QueueAdapter {
+    private readonly redisConfig;
+    private readonly defaultOptions;
+    private readonly bullQueues;
+    private readonly bullWorkers;
+    private connected;
+    constructor(redisConfig: {
+        host: string;
+        port: number;
+        password?: string;
+        db?: number;
+    }, defaultOptions?: JobOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    private getConnection;
+    private getQueue;
+    enqueue<T>(queueName: string, jobName: string, data: T, options?: JobOptions): Promise<Job<T>>;
+    process(queueName: string, jobName: string, handler: (job: Job) => Promise<void>): void;
+    getJob(queueName: string, id: string): Promise<Job | null>;
+    removeJob(queueName: string, id: string): Promise<void>;
+    startProcessing(): Promise<void>;
+    stopProcessing(): Promise<void>;
+    private bullJobToJob;
+}

package/dist/adapters/redis.adapter.js

@@ -0,0 +1,140 @@
+export class RedisAdapter {
+    redisConfig;
+    defaultOptions;
+    bullQueues = new Map();
+    bullWorkers = new Map();
+    connected = false;
+    constructor(redisConfig, defaultOptions = {}) {
+        this.redisConfig = redisConfig;
+        this.defaultOptions = {
+            attempts: 3,
+            backoff: 1000,
+            ...defaultOptions,
+        };
+    }
+    async connect() {
+        this.connected = true;
+    }
+    async disconnect() {
+        for (const worker of this.bullWorkers.values()) {
+            await worker.close();
+        }
+        this.bullWorkers.clear();
+        for (const queue of this.bullQueues.values()) {
+            await queue.close();
+        }
+        this.bullQueues.clear();
+        this.connected = false;
+    }
+    getConnection() {
+        return {
+            host: this.redisConfig.host,
+            port: this.redisConfig.port,
+            password: this.redisConfig.password,
+            db: this.redisConfig.db,
+        };
+    }
+    getQueue(queueName) {
+        let queue = this.bullQueues.get(queueName);
+        if (!queue) {
+            const { Queue } = require("bullmq");
+            queue = new Queue(queueName, {
+                connection: this.getConnection(),
+                defaultJobOptions: {
+                    attempts: this.defaultOptions.attempts ?? 3,
+                    backoff: {
+                        type: "fixed",
+                        delay: this.defaultOptions.backoff ?? 1000,
+                    },
+                    removeOnComplete: false,
+                    removeOnFail: false,
+                },
+            });
+            this.bullQueues.set(queueName, queue);
+        }
+        return queue;
+    }
+    async enqueue(queueName, jobName, data, options) {
+        if (!this.connected) {
+            throw new Error("Adapter not connected");
+        }
+        const queue = this.getQueue(queueName);
+        const opts = {};
+        if (options?.priority != null)
+            opts.priority = options.priority;
+        if (options?.delay != null)
+            opts.delay = options.delay;
+        if (options?.attempts != null)
+            opts.attempts = options.attempts;
+        if (options?.backoff != null) {
+            opts.backoff = { type: "fixed", delay: options.backoff };
+        }
+        const bullJob = await queue.add(jobName, data, opts);
+        return this.bullJobToJob(bullJob, jobName, data);
+    }
+    process(queueName, jobName, handler) {
+        const workerKey = queueName;
+        let worker = this.bullWorkers.get(workerKey);
+        if (!worker) {
+            const { Worker } = require("bullmq");
+            worker = new Worker(queueName, async (bullJob) => {
+                const handlerKey = `${queueName}:${bullJob.name}`;
+                const registeredHandler = worker.__handlers?.get(handlerKey);
+                if (registeredHandler) {
+                    const job = this.bullJobToJob(bullJob, bullJob.name, bullJob.data);
+                    await registeredHandler(job);
+                }
+            }, {
+                connection: this.getConnection(),
+                concurrency: 1,
+            });
+            worker.__handlers = new Map();
+            this.bullWorkers.set(workerKey, worker);
+        }
+        const handlerKey = `${queueName}:${jobName}`;
+        worker.__handlers.set(handlerKey, handler);
+    }
+    async getJob(queueName, id) {
+        const queue = this.getQueue(queueName);
+        const bullJob = await queue.getJob(id);
+        if (!bullJob)
+            return null;
+        return this.bullJobToJob(bullJob, bullJob.name, bullJob.data);
+    }
+    async removeJob(queueName, id) {
+        const queue = this.getQueue(queueName);
+        const bullJob = await queue.getJob(id);
+        if (bullJob) {
+            await bullJob.remove();
+        }
+    }
+    async startProcessing() {
+        // BullMQ workers start processing when created
+        // We register handlers via process(), workers are created on first process() call
+    }
+    async stopProcessing() {
+        for (const worker of this.bullWorkers.values()) {
+            await worker.pause();
+        }
+    }
+    bullJobToJob(bullJob, name, data) {
+        return {
+            id: bullJob.id ?? String(bullJob.id),
+            name,
+            data,
+            attempts: bullJob.attemptsMade ?? 0,
+            maxAttempts: bullJob.opts?.attempts,
+            priority: bullJob.opts?.priority,
+            delay: bullJob.opts?.delay,
+            createdAt: new Date(bullJob.timestamp ?? Date.now()),
+            processedAt: bullJob.processedOn
+                ? new Date(bullJob.processedOn)
+                : undefined,
+            completedAt: bullJob.finishedOn
+                ? new Date(bullJob.finishedOn)
+                : undefined,
+            failedAt: bullJob.failedReason ? new Date() : undefined,
+            error: bullJob.failedReason,
+        };
+    }
+}

package/dist/cli/register-queue-commands.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerQueueCommands(program: Command): void;

package/dist/cli/register-queue-commands.js

@@ -0,0 +1,44 @@
+import { pathToFileURL } from "url";
+export function registerQueueCommands(program) {
+    program
+        .command("worker")
+        .description("Start the queue worker process")
+        .option("-e, --entry <path>", "Entry file (default: src/main.ts or src/worker.ts)", "")
+        .action(async (options) => {
+        try {
+            const entry = options.entry || (await findWorkerEntry());
+            const mod = await import(pathToFileURL(entry).href);
+            const appClass = mod.App ?? mod.default;
+            if (!appClass) {
+                console.error("Entry file must export App or default. Example:\n" +
+                    "  export const App = MyApp;\n" +
+                    "  // or: export default MyApp;");
+                process.exit(1);
+            }
+            const { runWorker } = await import("../worker-bootstrap.js");
+            await runWorker(appClass);
+        }
+        catch (error) {
+            console.error("Worker failed:", error instanceof Error ? error.message : error);
+            process.exit(1);
+        }
+    });
+}
+async function findWorkerEntry() {
+    const { resolve } = await import("path");
+    const { existsSync } = await import("fs");
+    const cwd = process.cwd();
+    const candidates = [
+        resolve(cwd, "src/worker.ts"),
+        resolve(cwd, "src/worker.js"),
+        resolve(cwd, "src/main.ts"),
+        resolve(cwd, "src/main.js"),
+    ];
+    for (const p of candidates) {
+        if (existsSync(p)) {
+            return p;
+        }
+    }
+    throw new Error("No entry file found. Create src/worker.ts or src/main.ts, or use -e <path>.\n" +
+        "Worker entry must export: export const App = YourAppClass;");
+}

package/dist/decorators/job.d.ts

@@ -0,0 +1 @@
+export declare function Job(name: string): MethodDecorator;

package/dist/decorators/job.js

@@ -0,0 +1,6 @@
+import { queueMetadataStorage } from "../metadata/queue-storage.js";
+export function Job(name) {
+    return (target, propertyKey) => {
+        queueMetadataStorage.addJob(target.constructor, propertyKey, name);
+    };
+}

package/dist/decorators/processor.d.ts

@@ -0,0 +1 @@
+export declare function Processor(queueName: string): ClassDecorator;

package/dist/decorators/processor.js

@@ -0,0 +1,6 @@
+import { queueMetadataStorage } from "../metadata/queue-storage.js";
+export function Processor(queueName) {
+    return (target) => {
+        queueMetadataStorage.setProcessor(target, queueName);
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export type { Job as JobData } from "./interfaces/job.js";
+export type { JobOptions } from "./interfaces/job-options.js";
+export type { QueueAdapter } from "./interfaces/queue-adapter.js";
+export type { QueueModuleOptions } from "./interfaces/queue-options.js";
+export { MemoryAdapter } from "./adapters/memory.adapter.js";
+export { RedisAdapter } from "./adapters/redis.adapter.js";
+export { Job } from "./decorators/job.js";
+export { Processor } from "./decorators/processor.js";
+export { QueueService } from "./services/queue.service.js";
+export { WorkerService } from "./services/worker.service.js";
+export { QueueModule } from "./queue.module.js";
+export { QueuePlugin } from "./queue.plugin.js";
+export { runWorker } from "./worker-bootstrap.js";
+export { getQueueService } from "./queue-service-holder.js";
+export { queueMetadataStorage } from "./metadata/queue-storage.js";

package/dist/index.js

@@ -0,0 +1,11 @@
+export { MemoryAdapter } from "./adapters/memory.adapter.js";
+export { RedisAdapter } from "./adapters/redis.adapter.js";
+export { Job } from "./decorators/job.js";
+export { Processor } from "./decorators/processor.js";
+export { QueueService } from "./services/queue.service.js";
+export { WorkerService } from "./services/worker.service.js";
+export { QueueModule } from "./queue.module.js";
+export { QueuePlugin } from "./queue.plugin.js";
+export { runWorker } from "./worker-bootstrap.js";
+export { getQueueService } from "./queue-service-holder.js";
+export { queueMetadataStorage } from "./metadata/queue-storage.js";

package/dist/interfaces/job-options.d.ts

@@ -0,0 +1,6 @@
+export interface JobOptions {
+    priority?: number;
+    delay?: number;
+    attempts?: number;
+    backoff?: number;
+}

package/dist/interfaces/job-options.js

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

package/dist/interfaces/job.d.ts

@@ -0,0 +1,14 @@
+export interface Job<T = unknown> {
+    id: string;
+    name: string;
+    data: T;
+    attempts: number;
+    maxAttempts?: number;
+    priority?: number;
+    delay?: number;
+    createdAt: Date;
+    processedAt?: Date;
+    completedAt?: Date;
+    failedAt?: Date;
+    error?: string;
+}

package/dist/interfaces/job.js

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

package/dist/interfaces/queue-adapter.d.ts

@@ -0,0 +1,12 @@
+import type { Job } from "./job.js";
+import type { JobOptions } from "./job-options.js";
+export interface QueueAdapter {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    enqueue<T>(queueName: string, jobName: string, data: T, options?: JobOptions): Promise<Job<T>>;
+    process(queueName: string, jobName: string, handler: (job: Job) => Promise<void>): void;
+    getJob(queueName: string, id: string): Promise<Job | null>;
+    removeJob(queueName: string, id: string): Promise<void>;
+    startProcessing(): Promise<void>;
+    stopProcessing(): Promise<void>;
+}

package/dist/interfaces/queue-adapter.js

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

package/dist/interfaces/queue-options.d.ts

@@ -0,0 +1,11 @@
+import type { JobOptions } from "./job-options.js";
+export interface QueueModuleOptions {
+    adapter: "redis" | "memory";
+    redis?: {
+        host: string;
+        port: number;
+        password?: string;
+        db?: number;
+    };
+    defaultJobOptions?: JobOptions;
+}

package/dist/interfaces/queue-options.js

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

package/dist/metadata/queue-storage.d.ts

@@ -0,0 +1,21 @@
+export interface ProcessorMetadata {
+    target: Function;
+    queueName: string;
+}
+export interface JobMetadata {
+    target: Function;
+    methodKey: string;
+    jobName: string;
+}
+declare class QueueMetadataStorage {
+    private processors;
+    private jobs;
+    setProcessor(target: Function, queueName: string): void;
+    getProcessor(target: Function): ProcessorMetadata | undefined;
+    getAllProcessors(): ProcessorMetadata[];
+    addJob(target: Function, methodKey: string, jobName: string): void;
+    getJobs(target: Function): JobMetadata[];
+    reset(): void;
+}
+export declare const queueMetadataStorage: QueueMetadataStorage;
+export {};

package/dist/metadata/queue-storage.js

@@ -0,0 +1,24 @@
+class QueueMetadataStorage {
+    processors = new Map();
+    jobs = [];
+    setProcessor(target, queueName) {
+        this.processors.set(target, { target, queueName });
+    }
+    getProcessor(target) {
+        return this.processors.get(target);
+    }
+    getAllProcessors() {
+        return Array.from(this.processors.values());
+    }
+    addJob(target, methodKey, jobName) {
+        this.jobs.push({ target, methodKey, jobName });
+    }
+    getJobs(target) {
+        return this.jobs.filter((j) => j.target === target);
+    }
+    reset() {
+        this.processors.clear();
+        this.jobs = [];
+    }
+}
+export const queueMetadataStorage = new QueueMetadataStorage();

package/dist/queue-service-holder.d.ts

@@ -0,0 +1,3 @@
+import type { QueueService } from "./services/queue.service.js";
+export declare function setQueueService(service: QueueService): void;
+export declare function getQueueService(): QueueService | null;

package/dist/queue-service-holder.js

@@ -0,0 +1,12 @@
+/**
+ * Holder for QueueService instance.
+ * Set by QueuePlugin on init. Use getQueueService() to obtain the service
+ * in controllers (since constructor injection runs before the plugin initializes).
+ */
+let queueServiceInstance = null;
+export function setQueueService(service) {
+    queueServiceInstance = service;
+}
+export function getQueueService() {
+    return queueServiceInstance;
+}

package/dist/queue.module.d.ts

@@ -0,0 +1,7 @@
+import type { QueueModuleOptions } from "./interfaces/queue-options.js";
+import type { QueueAdapter } from "./interfaces/queue-adapter.js";
+export declare class QueueModule {
+    static forRoot(options: QueueModuleOptions): Function;
+    static getOptions(): QueueModuleOptions;
+    static createAdapter(): QueueAdapter;
+}

package/dist/queue.module.js

@@ -0,0 +1,43 @@
+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;
+};
+import { Module } from "@cinnabun/core";
+import { MemoryAdapter } from "./adapters/memory.adapter.js";
+import { RedisAdapter } from "./adapters/redis.adapter.js";
+let moduleOptions = null;
+export class QueueModule {
+    static forRoot(options) {
+        moduleOptions = options;
+        let QueueDynamicModule = class QueueDynamicModule {
+        };
+        QueueDynamicModule = __decorate([
+            Module({
+                imports: [],
+                controllers: [],
+                providers: [],
+                exports: [],
+            })
+        ], QueueDynamicModule);
+        return QueueDynamicModule;
+    }
+    static getOptions() {
+        if (!moduleOptions) {
+            throw new Error("QueueModule not initialized. Call QueueModule.forRoot() first.");
+        }
+        return moduleOptions;
+    }
+    static createAdapter() {
+        const options = QueueModule.getOptions();
+        const opts = options.defaultJobOptions ?? {};
+        if (options.adapter === "memory") {
+            return new MemoryAdapter(opts);
+        }
+        if (options.adapter === "redis" && options.redis) {
+            return new RedisAdapter(options.redis, opts);
+        }
+        throw new Error("QueueModule: redis adapter requires redis config (host, port)");
+    }
+}

package/dist/queue.plugin.d.ts

@@ -0,0 +1,9 @@
+import type { CinnabunPlugin, PluginContext } from "@cinnabun/core";
+export declare class QueuePlugin implements CinnabunPlugin {
+    name: string;
+    private workerService;
+    private adapter;
+    onInit(context: PluginContext): Promise<void>;
+    onReady(_context: PluginContext): Promise<void>;
+    onShutdown(_context: PluginContext): Promise<void>;
+}

package/dist/queue.plugin.js

@@ -0,0 +1,41 @@
+import { Logger } from "@cinnabun/core";
+import { QueueModule } from "./queue.module.js";
+import { WorkerService } from "./services/worker.service.js";
+import { QueueService } from "./services/queue.service.js";
+import { setQueueService } from "./queue-service-holder.js";
+export class QueuePlugin {
+    name = "QueuePlugin";
+    workerService = null;
+    adapter = null;
+    async onInit(context) {
+        const logger = new Logger("QueuePlugin");
+        const options = QueueModule.getOptions();
+        const container = context.container;
+        const adapter = QueueModule.createAdapter();
+        await adapter.connect();
+        this.adapter = adapter;
+        const workerService = new WorkerService(adapter, container);
+        workerService.registerHandlers();
+        this.workerService = workerService;
+        const jobToQueue = workerService.getJobToQueueMap();
+        const queueService = new QueueService(adapter, jobToQueue);
+        container.registerInstance(QueueService, queueService);
+        setQueueService(queueService);
+        logger.info(`Queue module initialized (adapter: ${options.adapter})`);
+    }
+    async onReady(_context) {
+        if (this.workerService) {
+            await this.workerService.start();
+        }
+    }
+    async onShutdown(_context) {
+        if (this.workerService) {
+            await this.workerService.stop();
+            this.workerService = null;
+        }
+        if (this.adapter) {
+            await this.adapter.disconnect();
+            this.adapter = null;
+        }
+    }
+}

package/dist/services/queue.service.d.ts

@@ -0,0 +1,12 @@
+import type { Job } from "../interfaces/job.js";
+import type { JobOptions } from "../interfaces/job-options.js";
+import type { QueueAdapter } from "../interfaces/queue-adapter.js";
+export declare class QueueService {
+    private readonly adapter;
+    private readonly jobToQueue;
+    private readonly jobIdToQueue;
+    constructor(adapter: QueueAdapter, jobToQueue: Map<string, string>);
+    enqueue<T>(jobName: string, data: T, options?: JobOptions): Promise<Job<T>>;
+    getJob(id: string): Promise<Job | null>;
+    removeJob(id: string): Promise<void>;
+}

package/dist/services/queue.service.js

@@ -0,0 +1,31 @@
+export class QueueService {
+    adapter;
+    jobToQueue;
+    jobIdToQueue = new Map();
+    constructor(adapter, jobToQueue) {
+        this.adapter = adapter;
+        this.jobToQueue = jobToQueue;
+    }
+    async enqueue(jobName, data, options) {
+        const queueName = this.jobToQueue.get(jobName);
+        if (!queueName) {
+            throw new Error(`No queue registered for job "${jobName}". Add a @Processor with @Job("${jobName}") handler.`);
+        }
+        const job = await this.adapter.enqueue(queueName, jobName, data, options);
+        this.jobIdToQueue.set(job.id, queueName);
+        return job;
+    }
+    async getJob(id) {
+        const queueName = this.jobIdToQueue.get(id);
+        if (!queueName)
+            return null;
+        return this.adapter.getJob(queueName, id);
+    }
+    async removeJob(id) {
+        const queueName = this.jobIdToQueue.get(id);
+        if (queueName) {
+            await this.adapter.removeJob(queueName, id);
+            this.jobIdToQueue.delete(id);
+        }
+    }
+}

package/dist/services/worker.service.d.ts

@@ -0,0 +1,13 @@
+import type { Container } from "@cinnabun/core";
+import type { QueueAdapter } from "../interfaces/queue-adapter.js";
+export declare class WorkerService {
+    private readonly adapter;
+    private readonly container;
+    private readonly jobToQueue;
+    private started;
+    constructor(adapter: QueueAdapter, container: Container);
+    registerHandlers(): void;
+    getJobToQueueMap(): Map<string, string>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/services/worker.service.js

@@ -0,0 +1,52 @@
+import { queueMetadataStorage } from "../metadata/queue-storage.js";
+export class WorkerService {
+    adapter;
+    container;
+    jobToQueue = new Map();
+    started = false;
+    constructor(adapter, container) {
+        this.adapter = adapter;
+        this.container = container;
+    }
+    registerHandlers() {
+        const processors = queueMetadataStorage.getAllProcessors();
+        for (const { target: processorClass } of processors) {
+            let instance;
+            try {
+                instance = this.container.resolve(processorClass);
+            }
+            catch {
+                continue;
+            }
+            const processorMeta = queueMetadataStorage.getProcessor(processorClass);
+            if (!processorMeta)
+                continue;
+            const queueName = processorMeta.queueName;
+            const jobs = queueMetadataStorage.getJobs(processorClass);
+            for (const jobMeta of jobs) {
+                this.jobToQueue.set(jobMeta.jobName, queueName);
+                const method = instance[jobMeta.methodKey];
+                if (typeof method !== "function")
+                    continue;
+                const handler = (job) => method.call(instance, job);
+                this.adapter.process(queueName, jobMeta.jobName, handler);
+            }
+        }
+    }
+    getJobToQueueMap() {
+        return new Map(this.jobToQueue);
+    }
+    async start() {
+        if (this.started)
+            return;
+        this.registerHandlers();
+        await this.adapter.startProcessing();
+        this.started = true;
+    }
+    async stop() {
+        if (!this.started)
+            return;
+        await this.adapter.stopProcessing();
+        this.started = false;
+    }
+}

package/dist/worker-bootstrap.d.ts

@@ -0,0 +1,6 @@
+import { type Constructor } from "@cinnabun/core";
+/**
+ * Bootstraps the app in worker-only mode (no HTTP server).
+ * Replicates CinnabunFactory bootstrap but skips listen().
+ */
+export declare function runWorker(appClass: Constructor): Promise<void>;

package/dist/worker-bootstrap.js

@@ -0,0 +1,79 @@
+import { metadataStorage, } from "@cinnabun/core";
+import { scanComponents } from "@cinnabun/core";
+import { resolveModuleTree } from "@cinnabun/core";
+import { CinnabunApplication } from "@cinnabun/core";
+import { FileConfigService } from "@cinnabun/core";
+import { loadConfig } from "@cinnabun/core";
+import { Logger } from "@cinnabun/core";
+import { validateDependencies } from "@cinnabun/core";
+/**
+ * Bootstraps the app in worker-only mode (no HTTP server).
+ * Replicates CinnabunFactory bootstrap but skips listen().
+ */
+export async function runWorker(appClass) {
+    const logger = new Logger("QueueWorker");
+    const meta = metadataStorage.getAppMetadata(appClass);
+    if (!meta) {
+        throw new Error(`${appClass.name} is not decorated with @CinnabunApplication().`);
+    }
+    const rawConfig = await loadConfig();
+    const configService = new FileConfigService(rawConfig);
+    logger.info("Scanning components...");
+    const scanned = await scanComponents(meta.scanPaths);
+    const moduleProviders = [];
+    const moduleControllers = [];
+    for (const mod of [...meta.imports, ...scanned.modules]) {
+        const resolved = await resolveModuleTree(mod);
+        moduleProviders.push(...resolved.providers);
+        moduleControllers.push(...resolved.controllers);
+    }
+    const controllers = [...moduleControllers, ...scanned.controllers];
+    const providers = [...moduleProviders, ...scanned.providers];
+    if (metadataStorage.controllerPaths.has(appClass)) {
+        controllers.push(appClass);
+    }
+    try {
+        validateDependencies(providers);
+    }
+    catch (error) {
+        logger.error("Dependency validation failed");
+        throw error;
+    }
+    const plugins = meta.plugins ?? [];
+    const app = await CinnabunApplication.create({
+        controllers,
+        providers,
+        middleware: meta.middleware,
+        websocket: undefined,
+        plugins,
+        timeout: meta.timeout,
+        shutdownTimeout: meta.shutdownTimeout,
+        preRegister: (container) => {
+            container.registerInstance(FileConfigService, configService);
+        },
+    });
+    const pluginContext = {
+        container: app.getContainer(),
+        config: configService,
+    };
+    app.setPluginContext(pluginContext);
+    for (const plugin of plugins) {
+        if (plugin.onInit) {
+            logger.info(`Plugin "${plugin.name}" initializing...`);
+            await plugin.onInit(pluginContext);
+        }
+    }
+    for (const plugin of plugins) {
+        if (plugin.onReady) {
+            await plugin.onReady(pluginContext);
+        }
+    }
+    logger.info("Worker started, processing jobs...");
+    const shutdown = async (signal) => {
+        logger.info(`Received ${signal}, shutting down...`);
+        await app.close();
+        process.exit(0);
+    };
+    process.on("SIGINT", () => shutdown("SIGINT"));
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@cinnabun/queue",
+  "version": "0.0.1",
+  "description": "Job queue system for Cinnabun with Redis and in-memory adapters",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "exports": {
+    ".": "./dist/index.js",
+    "./cli": "./dist/cli/register-queue-commands.js"
+  },
+  "scripts": {
+    "test": "bun test",
+    "build": "tsc",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": ["cinnabun", "queue", "jobs", "bullmq", "redis"],
+  "peerDependencies": {
+    "@cinnabun/core": "^0.0.3",
+    "bullmq": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "bullmq": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@cinnabun/core": "workspace:*",
+    "@types/bun": "latest",
+    "reflect-metadata": "^0.2.2",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "commander": "^14.0.3"
+  }
+}