@pikku/queue-bullmq 0.10.0 → 0.11.1

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+## 0.11.0
+
+## 0.11.1
+
+### Patch Changes
+
+- 4b811db: chore: updating all dependencies
+- 06e1a31: breaking: change session services to wire services
+- Updated dependencies [4b811db]
+- Updated dependencies [e12a00c]
+- Updated dependencies [4579434]
+- Updated dependencies [28aeb7f]
+- Updated dependencies [ce902b1]
+- Updated dependencies [06e1a31]
+  - @pikku/core@0.11.1
+
+### Minor Changes
+
+- Add scheduler service implementation
+- Add service factory for queue and scheduler creation
+
 # @pikku/queue-bullmq
 
 ## 0.10.0

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

@@ -1,6 +1,6 @@
 import { ConnectionOptions, WorkerOptions } from 'bullmq';
 import type { QueueWorkers, PikkuWorkerConfig, QueueConfigMapping, ConfigValidationResult } from '@pikku/core/queue';
-import { CoreServices, CoreSingletonServices, CreateSessionServices } from '@pikku/core';
+import type { CoreServices, CoreSingletonServices, CreateWireServices } from '@pikku/core';
 export declare const mapPikkuWorkerToBull: (workerConfig?: PikkuWorkerConfig) => Omit<WorkerOptions, "connection">;
 /**
  * Bull/Redis queue service implementation
@@ -9,7 +9,7 @@ export declare const mapPikkuWorkerToBull: (workerConfig?: PikkuWorkerConfig) =>
 export declare class BullQueueWorkers implements QueueWorkers {
     private redisConnectionOptions;
     private singletonServices;
-    private createSessionServices?;
+    private createWireServices?;
     readonly name = "bull";
     readonly supportsResults = true;
     /**
@@ -19,7 +19,7 @@ export declare class BullQueueWorkers implements QueueWorkers {
     readonly configMappings: QueueConfigMapping;
     private workers;
     private queueEvents;
-    constructor(redisConnectionOptions: ConnectionOptions, singletonServices: CoreSingletonServices, createSessionServices?: CreateSessionServices<CoreSingletonServices, CoreServices, any> | undefined);
+    constructor(redisConnectionOptions: ConnectionOptions, singletonServices: CoreSingletonServices, createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices, any> | undefined);
     /**
      * Scan state and register all compatible processors
      */

package/dist/bull-queue-worker.js

@@ -38,7 +38,7 @@ export const mapPikkuWorkerToBull = (workerConfig) => {
 export class BullQueueWorkers {
     redisConnectionOptions;
     singletonServices;
-    createSessionServices;
+    createWireServices;
     name = 'bull';
     supportsResults = true;
     /**
@@ -101,10 +101,10 @@ export class BullQueueWorkers {
     };
     workers = new Map();
     queueEvents = new Map();
-    constructor(redisConnectionOptions, singletonServices, createSessionServices) {
+    constructor(redisConnectionOptions, singletonServices, createWireServices) {
         this.redisConnectionOptions = redisConnectionOptions;
         this.singletonServices = singletonServices;
-        this.createSessionServices = createSessionServices;
+        this.createWireServices = createWireServices;
     }
     /**
      * Scan state and register all compatible processors
@@ -115,7 +115,7 @@ export class BullQueueWorkers {
                 try {
                     return await runQueueJob({
                         singletonServices: this.singletonServices,
-                        createSessionServices: this.createSessionServices,
+                        createWireServices: this.createWireServices,
                         job: await mapBullJobToQueueJob(job, this.redisConnectionOptions, this.queueEvents),
                         updateProgress: async (progress) => {
                             await job.updateProgress(progress);

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

@@ -0,0 +1,35 @@
+import { ConnectionOptions } from 'bullmq';
+import { SchedulerService, ScheduledTaskInfo, ScheduledTaskSummary, CoreUserSession } from '@pikku/core';
+/**
+ * BullMQ scheduler service implementation
+ * Uses BullMQ's delayed jobs for one-time execution
+ */
+export declare class BullSchedulerService extends SchedulerService {
+    private queue;
+    constructor(redisConnectionOptions: ConnectionOptions);
+    /**
+     * Initialize - wait for queue to be ready
+     */
+    init(): Promise<void>;
+    /**
+     * Schedule a one-off delayed RPC call
+     * Uses BullMQ add() with delay option
+     */
+    scheduleRPC(delay: number | string, rpcName: string, data?: any, session?: CoreUserSession): Promise<string>;
+    /**
+     * Unschedule (remove) a task by ID
+     */
+    unschedule(taskId: string): Promise<boolean>;
+    /**
+     * Get a scheduled task by ID with full details
+     */
+    getTask(taskId: string): Promise<ScheduledTaskInfo | null>;
+    /**
+     * Get all scheduled tasks with minimal info
+     */
+    getAllTasks(): Promise<ScheduledTaskSummary[]>;
+    /**
+     * Close the queue connection
+     */
+    close(): Promise<void>;
+}

package/dist/bull-scheduler-service.js

@@ -0,0 +1,100 @@
+import { Queue } from 'bullmq';
+import { SchedulerService, parseDurationString, } from '@pikku/core';
+/**
+ * BullMQ scheduler service implementation
+ * Uses BullMQ's delayed jobs for one-time execution
+ */
+export class BullSchedulerService extends SchedulerService {
+    queue;
+    constructor(redisConnectionOptions) {
+        super();
+        this.queue = new Queue('pikku-remote-internal-rpc', {
+            connection: redisConnectionOptions,
+        });
+    }
+    /**
+     * Initialize - wait for queue to be ready
+     */
+    async init() {
+        await this.queue.waitUntilReady();
+    }
+    /**
+     * Schedule a one-off delayed RPC call
+     * Uses BullMQ add() with delay option
+     */
+    async scheduleRPC(delay, rpcName, data, session) {
+        // Parse delay if it's a string
+        const delayMs = typeof delay === 'string' ? parseDurationString(delay) : delay;
+        const jobData = {
+            rpcName,
+            data,
+            session,
+        };
+        // Use add() with delay for one-off delayed execution
+        const job = await this.queue.add('pikku-remote-internal-rpc', jobData, {
+            delay: delayMs, // delay in milliseconds
+            jobId: `${rpcName}-${Date.now()}`, // Ensure uniqueness
+        });
+        if (!job.id) {
+            throw new Error('Failed to schedule RPC');
+        }
+        return job.id;
+    }
+    /**
+     * Unschedule (remove) a task by ID
+     */
+    async unschedule(taskId) {
+        const job = await this.queue.getJob(taskId);
+        if (job) {
+            await job.remove();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get a scheduled task by ID with full details
+     */
+    async getTask(taskId) {
+        const job = await this.queue.getJob(taskId);
+        if (!job) {
+            return null;
+        }
+        const jobData = job.data;
+        const state = await job.getState();
+        // Calculate scheduled time from delay or processedOn
+        const scheduledFor = job.delay
+            ? new Date(job.timestamp + job.delay)
+            : new Date(job.timestamp);
+        return {
+            taskId: job.id,
+            rpcName: jobData.rpcName,
+            scheduledFor,
+            data: jobData.data,
+            session: jobData.session,
+            status: state,
+        };
+    }
+    /**
+     * Get all scheduled tasks with minimal info
+     */
+    async getAllTasks() {
+        const jobs = await this.queue.getJobs(['delayed', 'waiting']);
+        return jobs.map((job) => {
+            const jobData = job.data;
+            const scheduledFor = job.delay
+                ? new Date(job.timestamp + job.delay)
+                : new Date(job.timestamp);
+            return {
+                taskId: job.id,
+                rpcName: jobData.rpcName,
+                scheduledFor,
+            };
+        });
+    }
+    /**
+     * Close the queue connection
+     */
+    async close() {
+        await this.queue.close();
+    }
+}

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

@@ -0,0 +1,36 @@
+import { 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 { CoreServices, CoreSingletonServices, CreateWireServices } from '@pikku/core';
+/**
+ * Factory class for BullMQ services
+ * Manages Redis connection options shared across queue, worker, and scheduler services
+ */
+export declare class BullServiceFactory {
+    private redisConnectionOptions;
+    private queueService?;
+    private queueWorkers?;
+    private schedulerService?;
+    constructor(redisConnectionOptions?: ConnectionOptions);
+    /**
+     * Initialize - no-op for BullMQ as connections are lazy
+     */
+    init(): Promise<void>;
+    /**
+     * Get the queue service for publishing jobs
+     */
+    getQueueService(): BullQueueService;
+    /**
+     * Get the queue workers for processing jobs
+     */
+    getQueueWorkers(singletonServices: CoreSingletonServices, createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices, any>): BullQueueWorkers;
+    /**
+     * Get the scheduler service for managing delayed tasks
+     */
+    getSchedulerService(): BullSchedulerService;
+    /**
+     * Close all services
+     */
+    close(): Promise<void>;
+}

package/dist/bull-service-factory.js

@@ -0,0 +1,65 @@
+import { BullQueueService } from './bull-queue-service.js';
+import { BullQueueWorkers } from './bull-queue-worker.js';
+import { BullSchedulerService } from './bull-scheduler-service.js';
+/**
+ * Factory class for BullMQ services
+ * Manages Redis connection options shared across queue, worker, and scheduler services
+ */
+export class BullServiceFactory {
+    redisConnectionOptions;
+    queueService;
+    queueWorkers;
+    schedulerService;
+    constructor(redisConnectionOptions = {}) {
+        this.redisConnectionOptions = redisConnectionOptions;
+    }
+    /**
+     * Initialize - no-op for BullMQ as connections are lazy
+     */
+    async init() {
+        // No-op - BullMQ creates connections lazily
+    }
+    /**
+     * Get the queue service for publishing jobs
+     */
+    getQueueService() {
+        if (!this.queueService) {
+            this.queueService = new BullQueueService(this.redisConnectionOptions);
+        }
+        return this.queueService;
+    }
+    /**
+     * Get the queue workers for processing jobs
+     */
+    getQueueWorkers(singletonServices, createWireServices) {
+        if (!this.queueWorkers) {
+            this.queueWorkers = new BullQueueWorkers(this.redisConnectionOptions, singletonServices, createWireServices);
+        }
+        return this.queueWorkers;
+    }
+    /**
+     * Get the scheduler service for managing delayed tasks
+     */
+    getSchedulerService() {
+        if (!this.schedulerService) {
+            this.schedulerService = new BullSchedulerService(this.redisConnectionOptions);
+        }
+        return this.schedulerService;
+    }
+    /**
+     * Close all services
+     */
+    async close() {
+        const closePromises = [];
+        if (this.queueService) {
+            // BullQueueService doesn't have close method currently
+        }
+        if (this.queueWorkers) {
+            closePromises.push(this.queueWorkers.close());
+        }
+        if (this.schedulerService) {
+            closePromises.push(this.schedulerService.close());
+        }
+        await Promise.all(closePromises);
+    }
+}

package/dist/index.d.ts

@@ -4,6 +4,8 @@
  * Bull/Redis queue service for Pikku
  * Provides job results, retries, priorities, and most queue features
  */
+export { BullServiceFactory } from './bull-service-factory.js';
 export { BullQueueService } from './bull-queue-service.js';
 export { BullQueueWorkers } from './bull-queue-worker.js';
+export { BullSchedulerService } from './bull-scheduler-service.js';
 export type { QueueService, PikkuWorkerConfig, PikkuJobConfig, QueueJob, JobOptions, } from '@pikku/core/queue';

package/dist/index.js

@@ -4,5 +4,7 @@
  * Bull/Redis queue service for Pikku
  * Provides job results, retries, priorities, and most queue features
  */
+export { BullServiceFactory } from './bull-service-factory.js';
 export { BullQueueService } from './bull-queue-service.js';
 export { BullQueueWorkers } from './bull-queue-worker.js';
+export { BullSchedulerService } from './bull-scheduler-service.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/queue-bullmq",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",
@@ -13,10 +13,10 @@
     "release": "npm run build && npm test"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.10.0"
+    "@pikku/core": "^0.11.1"
   },
   "dependencies": {
-    "bullmq": "^5.61.0",
+    "bullmq": "^5.63.2",
     "ioredis": "^5.8.2"
   },
   "devDependencies": {

package/src/bull-queue-worker.ts

@@ -16,10 +16,10 @@ import {
   QueueJobFailedError,
   QueueJobDiscardedError,
 } from '@pikku/core/queue'
-import {
+import type {
   CoreServices,
   CoreSingletonServices,
-  CreateSessionServices,
+  CreateWireServices,
 } from '@pikku/core'
 import { mapBullJobToQueueJob } from './utils.js'
 
@@ -145,7 +145,7 @@ export class BullQueueWorkers implements QueueWorkers {
   constructor(
     private redisConnectionOptions: ConnectionOptions,
     private singletonServices: CoreSingletonServices,
-    private createSessionServices?: CreateSessionServices<
+    private createWireServices?: CreateWireServices<
       CoreSingletonServices,
       CoreServices,
       any
@@ -166,7 +166,7 @@ export class BullQueueWorkers implements QueueWorkers {
             try {
               return await runQueueJob({
                 singletonServices: this.singletonServices,
-                createSessionServices: this.createSessionServices,
+                createWireServices: this.createWireServices,
                 job: await mapBullJobToQueueJob(
                   job,
                   this.redisConnectionOptions,

package/src/bull-scheduler-service.ts

@@ -0,0 +1,139 @@
+import { ConnectionOptions, Queue } from 'bullmq'
+import {
+  SchedulerService,
+  ScheduledTaskInfo,
+  ScheduledTaskSummary,
+  CoreUserSession,
+  parseDurationString,
+} from '@pikku/core'
+
+/**
+ * Data stored in scheduled job
+ */
+interface ScheduledJobData {
+  rpcName: string
+  data?: any
+  session?: CoreUserSession
+}
+
+/**
+ * BullMQ scheduler service implementation
+ * Uses BullMQ's delayed jobs for one-time execution
+ */
+export class BullSchedulerService extends SchedulerService {
+  private queue: Queue
+
+  constructor(redisConnectionOptions: ConnectionOptions) {
+    super()
+    this.queue = new Queue('pikku-remote-internal-rpc', {
+      connection: redisConnectionOptions,
+    })
+  }
+
+  /**
+   * Initialize - wait for queue to be ready
+   */
+  async init(): Promise<void> {
+    await this.queue.waitUntilReady()
+  }
+
+  /**
+   * Schedule a one-off delayed RPC call
+   * Uses BullMQ add() with delay option
+   */
+  async scheduleRPC(
+    delay: number | string,
+    rpcName: string,
+    data?: any,
+    session?: CoreUserSession
+  ): Promise<string> {
+    // Parse delay if it's a string
+    const delayMs =
+      typeof delay === 'string' ? parseDurationString(delay) : delay
+
+    const jobData: ScheduledJobData = {
+      rpcName,
+      data,
+      session,
+    }
+
+    // Use add() with delay for one-off delayed execution
+    const job = await this.queue.add('pikku-remote-internal-rpc', jobData, {
+      delay: delayMs, // delay in milliseconds
+      jobId: `${rpcName}-${Date.now()}`, // Ensure uniqueness
+    })
+
+    if (!job.id) {
+      throw new Error('Failed to schedule RPC')
+    }
+
+    return job.id
+  }
+
+  /**
+   * Unschedule (remove) a task by ID
+   */
+  async unschedule(taskId: string): Promise<boolean> {
+    const job = await this.queue.getJob(taskId)
+    if (job) {
+      await job.remove()
+      return true
+    }
+    return false
+  }
+
+  /**
+   * Get a scheduled task by ID with full details
+   */
+  async getTask(taskId: string): Promise<ScheduledTaskInfo | null> {
+    const job = await this.queue.getJob(taskId)
+
+    if (!job) {
+      return null
+    }
+
+    const jobData = job.data as ScheduledJobData
+    const state = await job.getState()
+
+    // Calculate scheduled time from delay or processedOn
+    const scheduledFor = job.delay
+      ? new Date(job.timestamp + job.delay)
+      : new Date(job.timestamp)
+
+    return {
+      taskId: job.id!,
+      rpcName: jobData.rpcName,
+      scheduledFor,
+      data: jobData.data,
+      session: jobData.session,
+      status: state as any,
+    }
+  }
+
+  /**
+   * Get all scheduled tasks with minimal info
+   */
+  async getAllTasks(): Promise<ScheduledTaskSummary[]> {
+    const jobs = await this.queue.getJobs(['delayed', 'waiting'])
+
+    return jobs.map((job) => {
+      const jobData = job.data as ScheduledJobData
+      const scheduledFor = job.delay
+        ? new Date(job.timestamp + job.delay)
+        : new Date(job.timestamp)
+
+      return {
+        taskId: job.id!,
+        rpcName: jobData.rpcName,
+        scheduledFor,
+      }
+    })
+  }
+
+  /**
+   * Close the queue connection
+   */
+  async close(): Promise<void> {
+    await this.queue.close()
+  }
+}

package/src/bull-service-factory.ts

@@ -0,0 +1,92 @@
+import { 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 {
+  CoreServices,
+  CoreSingletonServices,
+  CreateWireServices,
+} from '@pikku/core'
+
+/**
+ * Factory class for BullMQ services
+ * Manages Redis connection options shared across queue, worker, and scheduler services
+ */
+export class BullServiceFactory {
+  private queueService?: BullQueueService
+  private queueWorkers?: BullQueueWorkers
+  private schedulerService?: BullSchedulerService
+
+  constructor(private redisConnectionOptions: ConnectionOptions = {}) {}
+
+  /**
+   * Initialize - no-op for BullMQ as connections are lazy
+   */
+  async init(): Promise<void> {
+    // No-op - BullMQ creates connections lazily
+  }
+
+  /**
+   * Get the queue service for publishing jobs
+   */
+  getQueueService(): BullQueueService {
+    if (!this.queueService) {
+      this.queueService = new BullQueueService(this.redisConnectionOptions)
+    }
+    return this.queueService
+  }
+
+  /**
+   * Get the queue workers for processing jobs
+   */
+  getQueueWorkers(
+    singletonServices: CoreSingletonServices,
+    createWireServices?: CreateWireServices<
+      CoreSingletonServices,
+      CoreServices,
+      any
+    >
+  ): BullQueueWorkers {
+    if (!this.queueWorkers) {
+      this.queueWorkers = new BullQueueWorkers(
+        this.redisConnectionOptions,
+        singletonServices,
+        createWireServices
+      )
+    }
+    return this.queueWorkers
+  }
+
+  /**
+   * Get the scheduler service for managing delayed tasks
+   */
+  getSchedulerService(): BullSchedulerService {
+    if (!this.schedulerService) {
+      this.schedulerService = new BullSchedulerService(
+        this.redisConnectionOptions
+      )
+    }
+    return this.schedulerService
+  }
+
+  /**
+   * Close all services
+   */
+  async close(): Promise<void> {
+    const closePromises: Promise<void>[] = []
+
+    if (this.queueService) {
+      // BullQueueService doesn't have close method currently
+    }
+
+    if (this.queueWorkers) {
+      closePromises.push(this.queueWorkers.close())
+    }
+
+    if (this.schedulerService) {
+      closePromises.push(this.schedulerService.close())
+    }
+
+    await Promise.all(closePromises)
+  }
+}

package/src/index.ts

@@ -5,8 +5,10 @@
  * Provides job results, retries, priorities, and most queue features
  */
 
+export { BullServiceFactory } from './bull-service-factory.js'
 export { BullQueueService } from './bull-queue-service.js'
 export { BullQueueWorkers } from './bull-queue-worker.js'
+export { BullSchedulerService } from './bull-scheduler-service.js'
 
 // Re-export core queue types for convenience
 export type {

package/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/bull-queue-service.ts","./src/bull-queue-worker.ts","./src/index.ts","./src/utils.ts"],"version":"5.9.3"}
+{"root":["./src/bull-queue-service.ts","./src/bull-queue-worker.ts","./src/bull-scheduler-service.ts","./src/bull-service-factory.ts","./src/index.ts","./src/utils.ts"],"version":"5.9.3"}