@pikku/queue-bullmq 0.12.0 → 0.12.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 ## 0.12.0
 
+## 0.12.1
+
+### Patch Changes
+
+- e04531f: Code quality improvements: resolve oxlint warnings and apply autofixes across the codebase (unused bindings, unnecessary constructors, prefer `const` over `let`, etc.). No behaviour changes.
+- Updated dependencies [62a8725]
+- Updated dependencies [a3bdb0d]
+- Updated dependencies [e0349ff]
+- Updated dependencies [62a8725]
+- Updated dependencies [e04531f]
+- Updated dependencies [62a8725]
+- Updated dependencies [a83efb8]
+- Updated dependencies [8eed717]
+- Updated dependencies [62a8725]
+- Updated dependencies [62a8725]
+- Updated dependencies [62a8725]
+  - @pikku/core@0.12.1
+
 ### New Features
 
 - Recurring cron scheduled tasks support via `BullSchedulerService`

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

@@ -1,4 +1,5 @@
-import Bull, { ConnectionOptions, JobsOptions } from 'bullmq';
+import type { ConnectionOptions, JobsOptions } from 'bullmq';
+import type Bull from 'bullmq';
 import type { QueueService, QueueJob, JobOptions } from '@pikku/core/queue';
 export declare const mapPikkuJobToBull: (options?: JobOptions) => JobsOptions;
 /**

package/dist/bull-queue-service.js

@@ -1,4 +1,4 @@
-import { Queue, RedisConnection, } from 'bullmq';
+import { Queue, QueueEvents, RedisConnection } from 'bullmq';
 import { mapBullJobToQueueJob } from './utils.js';
 export const mapPikkuJobToBull = (options) => {
     const bullOptions = {};
@@ -53,6 +53,13 @@ export class BullQueueService {
         const queue = new Queue(queueName, config, PikkuRedisConnection);
         await queue.waitUntilReady();
         this.queues.set(queueName, queue);
+        if (!this.queueEvents.has(queueName)) {
+            const queueEvents = new QueueEvents(queueName, this.redisConnectionOptions
+                ? { connection: this.redisConnectionOptions }
+                : undefined);
+            await queueEvents.waitUntilReady();
+            this.queueEvents.set(queueName, queueEvents);
+        }
         return queue;
     }
     /**

package/dist/bull-queue-worker.d.ts

@@ -1,6 +1,5 @@
-import { ConnectionOptions, WorkerOptions } from 'bullmq';
-import type { QueueWorkers, PikkuWorkerConfig, QueueConfigMapping, ConfigValidationResult, QueueJob } from '@pikku/core/queue';
-import type { Logger } from '@pikku/core/services';
+import type { ConnectionOptions, WorkerOptions } from 'bullmq';
+import type { QueueWorkers, PikkuWorkerConfig, QueueConfigMapping, ConfigValidationResult } from '@pikku/core/queue';
 export declare const mapPikkuWorkerToBull: (workerConfig?: PikkuWorkerConfig) => Omit<WorkerOptions, "connection">;
 /**
  * Bull/Redis queue service implementation
@@ -17,13 +16,7 @@ export declare class BullQueueWorkers implements QueueWorkers {
     readonly configMappings: QueueConfigMapping;
     private workers;
     private queueEvents;
-    private runJob?;
-    private logger?;
     constructor(redisConnectionOptions: ConnectionOptions);
-    setJobRunner(runJob: (params: {
-        job: QueueJob;
-        updateProgress?: (progress: number | string | object) => Promise<void>;
-    }) => Promise<void>, logger: Logger): void;
     /**
      * Scan state and register all compatible processors
      */

package/dist/bull-queue-worker.js

@@ -1,5 +1,6 @@
-import { Worker, } from 'bullmq';
-import { registerQueueWorkers, QueueJobFailedError, QueueJobDiscardedError, } from '@pikku/core/queue';
+import { Worker } from 'bullmq';
+import { registerQueueWorkers, runQueueJob, QueueJobFailedError, QueueJobDiscardedError, } from '@pikku/core/queue';
+import { pikkuState } from '@pikku/core/internal';
 import { mapBullJobToQueueJob } from './utils.js';
 export const mapPikkuWorkerToBull = (workerConfig) => {
     const workerOptions = {};
@@ -99,26 +100,18 @@ export class BullQueueWorkers {
     };
     workers = new Map();
     queueEvents = new Map();
-    runJob;
-    logger;
     constructor(redisConnectionOptions) {
         this.redisConnectionOptions = redisConnectionOptions;
     }
-    setJobRunner(runJob, logger) {
-        this.runJob = runJob;
-        this.logger = logger;
-    }
     /**
      * Scan state and register all compatible processors
      */
     async registerQueues() {
-        if (!this.runJob || !this.logger) {
-            throw new Error('BullQueueWorkers requires setJobRunner() before registerQueues()');
-        }
-        return await registerQueueWorkers(this.configMappings, this.logger, async (queueName, processor) => {
+        const logger = pikkuState(null, 'package', 'singletonServices').logger;
+        return await registerQueueWorkers(this.configMappings, logger, async (queueName, processor) => {
             const worker = new Worker(processor.name, async (job) => {
                 try {
-                    return await this.runJob({
+                    return await runQueueJob({
                         job: await mapBullJobToQueueJob(job, this.redisConnectionOptions, this.queueEvents),
                         updateProgress: async (progress) => {
                             await job.updateProgress(progress);

package/dist/bull-scheduler-service.d.ts

@@ -1,19 +1,13 @@
-import { ConnectionOptions } from 'bullmq';
-import { SchedulerService, SchedulerRuntimeHandlers, ScheduledTaskInfo, ScheduledTaskSummary, CoreUserSession } from '@pikku/core';
+import type { ConnectionOptions } from 'bullmq';
+import type { ScheduledTaskInfo, ScheduledTaskSummary, CoreUserSession } from '@pikku/core';
+import { SchedulerService } from '@pikku/core';
 export declare class BullSchedulerService extends SchedulerService {
     private redisConnectionOptions;
     private queue;
     private recurringQueue;
     private recurringWorker?;
     private repeatJobKeys;
-    private handlers?;
     constructor(redisConnectionOptions: ConnectionOptions);
-    /**
-     * Set services needed for processing recurring tasks.
-     * Must be called before start() since the scheduler is typically
-     * created before singletonServices are available.
-     */
-    setServices(handlers: SchedulerRuntimeHandlers): void;
     /**
      * Initialize - wait for queue to be ready
      */

package/dist/bull-scheduler-service.js

@@ -1,6 +1,7 @@
 import { Queue, Worker } from 'bullmq';
-import { SchedulerService, parseDurationString, } from '@pikku/core';
-import { getScheduledTasks } from '@pikku/core/scheduler';
+import { SchedulerService, parseDurationString } from '@pikku/core';
+import { pikkuState } from '@pikku/core/internal';
+import { runScheduledTask, getScheduledTasks } from '@pikku/core/scheduler';
 const RECURRING_QUEUE_NAME = 'pikku-recurring-scheduled-task';
 export class BullSchedulerService extends SchedulerService {
     redisConnectionOptions;
@@ -8,7 +9,6 @@ export class BullSchedulerService extends SchedulerService {
     recurringQueue;
     recurringWorker;
     repeatJobKeys = [];
-    handlers;
     constructor(redisConnectionOptions) {
         super();
         this.redisConnectionOptions = redisConnectionOptions;
@@ -19,14 +19,6 @@ export class BullSchedulerService extends SchedulerService {
             connection: redisConnectionOptions,
         });
     }
-    /**
-     * Set services needed for processing recurring tasks.
-     * Must be called before start() since the scheduler is typically
-     * created before singletonServices are available.
-     */
-    setServices(handlers) {
-        this.handlers = handlers;
-    }
     /**
      * Initialize - wait for queue to be ready
      */
@@ -121,18 +113,16 @@ export class BullSchedulerService extends SchedulerService {
      * Creates a BullMQ Worker to process repeat jobs via runScheduledTask.
      */
     async start() {
-        if (!this.handlers) {
-            throw new Error('BullSchedulerService requires setServices() before start()');
-        }
+        const logger = pikkuState(null, 'package', 'singletonServices').logger;
         const scheduledTasks = getScheduledTasks();
         // Create a worker to process recurring scheduled task jobs
         this.recurringWorker = new Worker(RECURRING_QUEUE_NAME, async (job) => {
             const { rpcName } = job.data;
-            this.handlers.logger.info(`Running scheduled task: ${rpcName}`);
-            await this.handlers.runScheduledTask(rpcName);
+            logger.info(`Running scheduled task: ${rpcName}`);
+            await runScheduledTask({ name: rpcName });
         }, { connection: this.redisConnectionOptions });
         this.recurringWorker.on('error', (err) => {
-            this.handlers.logger.error(`Recurring task worker error: ${err}`);
+            logger.error(`Recurring task worker error: ${err}`);
         });
         for (const [name, task] of scheduledTasks) {
             const job = await this.recurringQueue.add(name, { rpcName: name }, {

package/dist/bull-service-factory.d.ts

@@ -1,8 +1,7 @@
-import { ConnectionOptions } from 'bullmq';
+import type { ConnectionOptions } from 'bullmq';
 import { BullQueueService } from './bull-queue-service.js';
 import { BullQueueWorkers } from './bull-queue-worker.js';
 import { BullSchedulerService } from './bull-scheduler-service.js';
-import type { CoreSingletonServices, CreateWireServices } from '@pikku/core';
 /**
  * Factory class for BullMQ services
  * Manages Redis connection options shared across queue, worker, and scheduler services
@@ -24,12 +23,11 @@ export declare class BullServiceFactory {
     /**
      * Get the queue workers for processing jobs
      */
-    getQueueWorkers(singletonServices: CoreSingletonServices, createWireServices?: CreateWireServices): BullQueueWorkers;
+    getQueueWorkers(): BullQueueWorkers;
     /**
      * Get the scheduler service for managing delayed tasks
      */
     getSchedulerService(): BullSchedulerService;
-    setSchedulerRuntime(singletonServices: CoreSingletonServices, createWireServices?: CreateWireServices): void;
     /**
      * Close all services
      */

package/dist/bull-service-factory.js

@@ -1,8 +1,6 @@
 import { BullQueueService } from './bull-queue-service.js';
 import { BullQueueWorkers } from './bull-queue-worker.js';
 import { BullSchedulerService } from './bull-scheduler-service.js';
-import { createQueueJobRunner } from '@pikku/core/queue';
-import { createSchedulerRuntimeHandlers } from '@pikku/core/scheduler';
 /**
  * Factory class for BullMQ services
  * Manages Redis connection options shared across queue, worker, and scheduler services
@@ -33,11 +31,10 @@ export class BullServiceFactory {
     /**
      * Get the queue workers for processing jobs
      */
-    getQueueWorkers(singletonServices, createWireServices) {
+    getQueueWorkers() {
         if (!this.queueWorkers) {
             this.queueWorkers = new BullQueueWorkers(this.redisConnectionOptions);
         }
-        this.queueWorkers.setJobRunner(createQueueJobRunner({ singletonServices, createWireServices }), singletonServices.logger);
         return this.queueWorkers;
     }
     /**
@@ -49,12 +46,6 @@ export class BullServiceFactory {
         }
         return this.schedulerService;
     }
-    setSchedulerRuntime(singletonServices, createWireServices) {
-        this.getSchedulerService().setServices(createSchedulerRuntimeHandlers({
-            singletonServices,
-            createWireServices,
-        }));
-    }
     /**
      * Close all services
      */

package/dist/utils.d.ts

@@ -1,5 +1,6 @@
-import { QueueJob } from '@pikku/core/queue';
-import { ConnectionOptions, Job, QueueEvents } from 'bullmq';
+import type { QueueJob } from '@pikku/core/queue';
+import type { ConnectionOptions, Job } from 'bullmq';
+import { QueueEvents } from 'bullmq';
 /**
  * Map Bull job to QueueJob interface
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/queue-bullmq",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",
@@ -13,7 +13,7 @@
     "release": "npm run build && npm test"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.0"
+    "@pikku/core": "^0.12.1"
   },
   "dependencies": {
     "bullmq": "^5.67.3",

package/src/bull-queue-service.ts

@@ -1,9 +1,6 @@
-import Bull, {
-  ConnectionOptions,
-  JobsOptions,
-  Queue,
-  RedisConnection,
-} from 'bullmq'
+import type { ConnectionOptions, JobsOptions } from 'bullmq'
+import type Bull from 'bullmq'
+import { Queue, QueueEvents, RedisConnection } from 'bullmq'
 import type { QueueService, QueueJob, JobOptions } from '@pikku/core/queue'
 import { mapBullJobToQueueJob } from './utils.js'
 
@@ -73,6 +70,18 @@ export class BullQueueService implements QueueService {
     await queue.waitUntilReady()
 
     this.queues.set(queueName, queue)
+
+    if (!this.queueEvents.has(queueName)) {
+      const queueEvents = new QueueEvents(
+        queueName,
+        this.redisConnectionOptions
+          ? { connection: this.redisConnectionOptions }
+          : undefined
+      )
+      await queueEvents.waitUntilReady()
+      this.queueEvents.set(queueName, queueEvents)
+    }
+
     return queue
   }
 

package/src/bull-queue-worker.ts

@@ -1,22 +1,19 @@
-import Bull, {
-  ConnectionOptions,
-  WorkerOptions,
-  Worker,
-  QueueEvents,
-} from 'bullmq'
+import type { ConnectionOptions, WorkerOptions, QueueEvents } from 'bullmq'
+import type Bull from 'bullmq'
+import { Worker } from 'bullmq'
 import type {
   QueueWorkers,
   PikkuWorkerConfig,
   QueueConfigMapping,
   ConfigValidationResult,
-  QueueJob,
 } from '@pikku/core/queue'
 import {
   registerQueueWorkers,
+  runQueueJob,
   QueueJobFailedError,
   QueueJobDiscardedError,
 } from '@pikku/core/queue'
-import type { Logger } from '@pikku/core/services'
+import { pikkuState } from '@pikku/core/internal'
 import { mapBullJobToQueueJob } from './utils.js'
 
 export const mapPikkuWorkerToBull = (
@@ -137,46 +134,24 @@ export class BullQueueWorkers implements QueueWorkers {
 
   private workers = new Map<string, Bull.Worker>()
   private queueEvents = new Map<string, QueueEvents>()
-  private runJob?:
-    | ((params: {
-        job: QueueJob
-        updateProgress?: (progress: number | string | object) => Promise<void>
-      }) => Promise<void>)
-    | undefined
-  private logger?: Logger
 
   constructor(private redisConnectionOptions: ConnectionOptions) {}
 
-  setJobRunner(
-    runJob: (params: {
-      job: QueueJob
-      updateProgress?: (progress: number | string | object) => Promise<void>
-    }) => Promise<void>,
-    logger: Logger
-  ): void {
-    this.runJob = runJob
-    this.logger = logger
-  }
-
   /**
    * Scan state and register all compatible processors
    */
   async registerQueues(): Promise<Record<string, ConfigValidationResult[]>> {
-    if (!this.runJob || !this.logger) {
-      throw new Error(
-        'BullQueueWorkers requires setJobRunner() before registerQueues()'
-      )
-    }
+    const logger = pikkuState(null, 'package', 'singletonServices')!.logger
 
     return await registerQueueWorkers(
       this.configMappings,
-      this.logger,
+      logger,
       async (queueName, processor) => {
         const worker = new Worker(
           processor.name,
           async (job: Bull.Job) => {
             try {
-              return await this.runJob!({
+              return await runQueueJob({
                 job: await mapBullJobToQueueJob(
                   job,
                   this.redisConnectionOptions,

package/src/bull-scheduler-service.ts

@@ -1,13 +1,13 @@
-import { ConnectionOptions, Queue, Worker } from 'bullmq'
-import {
-  SchedulerService,
-  SchedulerRuntimeHandlers,
+import type { ConnectionOptions } from 'bullmq'
+import { Queue, Worker } from 'bullmq'
+import type {
   ScheduledTaskInfo,
   ScheduledTaskSummary,
   CoreUserSession,
-  parseDurationString,
 } from '@pikku/core'
-import { getScheduledTasks } from '@pikku/core/scheduler'
+import { SchedulerService, parseDurationString } from '@pikku/core'
+import { pikkuState } from '@pikku/core/internal'
+import { runScheduledTask, getScheduledTasks } from '@pikku/core/scheduler'
 
 /**
  * Data stored in scheduled job
@@ -25,7 +25,6 @@ export class BullSchedulerService extends SchedulerService {
   private recurringQueue: Queue
   private recurringWorker?: Worker
   private repeatJobKeys: string[] = []
-  private handlers?: SchedulerRuntimeHandlers
 
   constructor(private redisConnectionOptions: ConnectionOptions) {
     super()
@@ -37,15 +36,6 @@ export class BullSchedulerService extends SchedulerService {
     })
   }
 
-  /**
-   * Set services needed for processing recurring tasks.
-   * Must be called before start() since the scheduler is typically
-   * created before singletonServices are available.
-   */
-  setServices(handlers: SchedulerRuntimeHandlers): void {
-    this.handlers = handlers
-  }
-
   /**
    * Initialize - wait for queue to be ready
    */
@@ -162,12 +152,7 @@ export class BullSchedulerService extends SchedulerService {
    * Creates a BullMQ Worker to process repeat jobs via runScheduledTask.
    */
   async start(): Promise<void> {
-    if (!this.handlers) {
-      throw new Error(
-        'BullSchedulerService requires setServices() before start()'
-      )
-    }
-
+    const logger = pikkuState(null, 'package', 'singletonServices')!.logger
     const scheduledTasks = getScheduledTasks()
 
     // Create a worker to process recurring scheduled task jobs
@@ -175,13 +160,13 @@ export class BullSchedulerService extends SchedulerService {
       RECURRING_QUEUE_NAME,
       async (job) => {
         const { rpcName } = job.data as ScheduledJobData
-        this.handlers!.logger.info(`Running scheduled task: ${rpcName}`)
-        await this.handlers!.runScheduledTask(rpcName)
+        logger.info(`Running scheduled task: ${rpcName}`)
+        await runScheduledTask({ name: rpcName })
       },
       { connection: this.redisConnectionOptions }
     )
     this.recurringWorker.on('error', (err) => {
-      this.handlers!.logger.error(`Recurring task worker error: ${err}`)
+      logger.error(`Recurring task worker error: ${err}`)
     })
 
     for (const [name, task] of scheduledTasks) {

package/src/bull-service-factory.ts

@@ -1,10 +1,7 @@
-import { ConnectionOptions } from 'bullmq'
+import type { ConnectionOptions } from 'bullmq'
 import { BullQueueService } from './bull-queue-service.js'
 import { BullQueueWorkers } from './bull-queue-worker.js'
 import { BullSchedulerService } from './bull-scheduler-service.js'
-import type { CoreSingletonServices, CreateWireServices } from '@pikku/core'
-import { createQueueJobRunner } from '@pikku/core/queue'
-import { createSchedulerRuntimeHandlers } from '@pikku/core/scheduler'
 
 /**
  * Factory class for BullMQ services
@@ -37,17 +34,10 @@ export class BullServiceFactory {
   /**
    * Get the queue workers for processing jobs
    */
-  getQueueWorkers(
-    singletonServices: CoreSingletonServices,
-    createWireServices?: CreateWireServices
-  ): BullQueueWorkers {
+  getQueueWorkers(): BullQueueWorkers {
     if (!this.queueWorkers) {
       this.queueWorkers = new BullQueueWorkers(this.redisConnectionOptions)
     }
-    this.queueWorkers.setJobRunner(
-      createQueueJobRunner({ singletonServices, createWireServices }),
-      singletonServices.logger
-    )
     return this.queueWorkers
   }
 
@@ -63,18 +53,6 @@ export class BullServiceFactory {
     return this.schedulerService
   }
 
-  setSchedulerRuntime(
-    singletonServices: CoreSingletonServices,
-    createWireServices?: CreateWireServices
-  ): void {
-    this.getSchedulerService().setServices(
-      createSchedulerRuntimeHandlers({
-        singletonServices,
-        createWireServices,
-      })
-    )
-  }
-
   /**
    * Close all services
    */

package/src/utils.ts

@@ -1,5 +1,6 @@
-import { QueueJob, QueueJobStatus } from '@pikku/core/queue'
-import { ConnectionOptions, Job, QueueEvents } from 'bullmq'
+import type { QueueJob, QueueJobStatus } from '@pikku/core/queue'
+import type { ConnectionOptions, Job } from 'bullmq'
+import { QueueEvents } from 'bullmq'
 
 /**
  * Map Bull job state to our queue job status