@pikku/queue-pg-boss 0.11.2 → 0.12.1

package/CHANGELOG.md

@@ -1,3 +1,27 @@
+## 0.12.0
+
+## 0.12.1
+
+### Patch Changes
+
+- 62a8725: Fix pg-boss queue initialisation: create the queue before registering a worker to avoid a race condition on first startup. Also sanitise scheduler names to meet pg-boss naming constraints.
+- 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
+
+- `setServices()`, `start()`, `stop()` lifecycle methods on scheduler and queue workers
+
 ## 0.11.0
 
 ## 0.11.2
@@ -8,8 +32,6 @@
 - Updated dependencies [db9c7bf]
   - @pikku/core@0.11.2
 
-## 0.11.2
-
 ### Fixes
 
 - ddd87eaf: Simplify CreateWireServices type signature for custom Config compatibility

package/dist/pg-boss-queue-service.d.ts

@@ -1,4 +1,4 @@
-import { PgBoss, Request as PgBossRequest } from 'pg-boss';
+import type { PgBoss, Request as PgBossRequest } from 'pg-boss';
 import type { QueueService, QueueJob, JobOptions } from '@pikku/core/queue';
 export declare const mapPikkuJobToPgBoss: (options?: JobOptions) => PgBossRequest["options"];
 /**

package/dist/pg-boss-queue-worker.d.ts

@@ -1,14 +1,11 @@
-import { PgBoss, type WorkOptions } from 'pg-boss';
+import type { PgBoss, WorkOptions } from 'pg-boss';
 import type { QueueWorkers, PikkuWorkerConfig, QueueConfigMapping, ConfigValidationResult } from '@pikku/core/queue';
-import { CoreSingletonServices, CreateWireServices } from '@pikku/core';
 export declare const mapPikkuWorkerToPgBoss: (workerConfig?: PikkuWorkerConfig) => WorkOptions;
 /**
  * pg-boss/PostgreSQL queue worker implementation
  * Supports job results, retries, and PostgreSQL-based queuing
  */
 export declare class PgBossQueueWorkers implements QueueWorkers {
-    private singletonServices;
-    private createWireServices?;
     readonly name = "pg-boss";
     readonly supportsResults = true;
     /**
@@ -18,7 +15,7 @@ export declare class PgBossQueueWorkers implements QueueWorkers {
     readonly configMappings: QueueConfigMapping;
     private pgBoss;
     private activeWorkers;
-    constructor(pgBoss: PgBoss, singletonServices: CoreSingletonServices, createWireServices?: CreateWireServices | undefined);
+    constructor(pgBoss: PgBoss);
     /**
      * Scan state and register all compatible processors
      */

package/dist/pg-boss-queue-worker.js

@@ -1,4 +1,5 @@
-import { runQueueJob, registerQueueWorkers, QueueJobFailedError, QueueJobDiscardedError, } from '@pikku/core/queue';
+import { registerQueueWorkers, runQueueJob, QueueJobFailedError, QueueJobDiscardedError, } from '@pikku/core/queue';
+import { pikkuState } from '@pikku/core/internal';
 import { mapPgBossJobToQueueJob } from './utils.js';
 export const mapPikkuWorkerToPgBoss = (workerConfig) => {
     const workerOptions = {
@@ -17,8 +18,6 @@ export const mapPikkuWorkerToPgBoss = (workerConfig) => {
  * Supports job results, retries, and PostgreSQL-based queuing
  */
 export class PgBossQueueWorkers {
-    singletonServices;
-    createWireServices;
     name = 'pg-boss';
     supportsResults = true;
     /**
@@ -85,34 +84,28 @@ export class PgBossQueueWorkers {
     };
     pgBoss;
     activeWorkers = new Map();
-    constructor(pgBoss, singletonServices, createWireServices) {
-        this.singletonServices = singletonServices;
-        this.createWireServices = createWireServices;
+    constructor(pgBoss) {
         this.pgBoss = pgBoss;
     }
     /**
      * Scan state and register all compatible processors
      */
     async registerQueues() {
-        return await registerQueueWorkers(this.configMappings, this.singletonServices.logger, async (queueName, processor) => {
+        const logger = pikkuState(null, 'package', 'singletonServices').logger;
+        return await registerQueueWorkers(this.configMappings, logger, async (queueName, processor) => {
             await this.pgBoss.createQueue(queueName);
-            const workerId = await this.pgBoss.work(processor.queueName, {
+            const workerId = await this.pgBoss.work(processor.name, {
                 ...mapPikkuWorkerToPgBoss(processor.config),
                 includeMetadata: true,
             }, async (jobs) => {
-                if (!this.singletonServices) {
-                    throw new Error('Singleton services not available');
-                }
                 if (!jobs || jobs.length === 0) {
-                    this.singletonServices.logger.warn(`No jobs received for queue ${queueName}`);
+                    logger.warn(`No jobs received for queue ${queueName}`);
                     return;
                 }
                 // Process all jobs in parallel
                 await Promise.all(jobs.map(async (job) => {
                     try {
                         await runQueueJob({
-                            singletonServices: this.singletonServices,
-                            createWireServices: this.createWireServices,
                             job: mapPgBossJobToQueueJob(job, this.pgBoss),
                         });
                     }
@@ -125,7 +118,7 @@ export class PgBossQueueWorkers {
                         }
                         else if (error instanceof QueueJobDiscardedError) {
                             // For pg-boss, complete the job successfully to discard it
-                            this.singletonServices.logger.info(`PgBoss job ${job.id} discarded: ${error.message}`);
+                            logger.info(`PgBoss job ${job.id} discarded: ${error.message}`);
                             await this.pgBoss.complete(queueName, job.id);
                         }
                         else {

package/dist/pg-boss-scheduler-service.d.ts

@@ -1,11 +1,14 @@
-import { PgBoss } from 'pg-boss';
-import { SchedulerService, ScheduledTaskInfo, ScheduledTaskSummary, CoreUserSession } from '@pikku/core';
+import type { PgBoss } from 'pg-boss';
+import type { ScheduledTaskInfo, ScheduledTaskSummary, CoreUserSession } from '@pikku/core';
+import { SchedulerService } from '@pikku/core';
 /**
  * pg-boss scheduler service implementation
- * Uses pg-boss's schedule() API to store recurring jobs in PostgreSQL
+ * Uses pg-boss's schedule() API to store recurring jobs in PostgreSQL.
+ * Handles both one-off delayed RPCs and recurring cron-scheduled tasks.
  */
 export declare class PgBossSchedulerService extends SchedulerService {
     private pgBoss;
+    private scheduledCronNames;
     constructor(pgBoss: PgBoss);
     /**
      * Initialize - no-op as pg-boss is already initialized by factory
@@ -32,4 +35,13 @@ export declare class PgBossSchedulerService extends SchedulerService {
      * Close - no-op as pg-boss lifecycle is managed by factory
      */
     close(): Promise<void>;
+    /**
+     * Start recurring scheduled tasks.
+     * Registers a pg-boss worker to process recurring jobs via runScheduledTask.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop recurring scheduled tasks by unscheduling them from pg-boss.
+     */
+    stop(): Promise<void>;
 }

package/dist/pg-boss-scheduler-service.js

@@ -1,10 +1,14 @@
-import { SchedulerService, parseDurationString, } from '@pikku/core';
+import { SchedulerService, parseDurationString } from '@pikku/core';
+import { pikkuState } from '@pikku/core/internal';
+import { runScheduledTask, getScheduledTasks } from '@pikku/core/scheduler';
 /**
  * pg-boss scheduler service implementation
- * Uses pg-boss's schedule() API to store recurring jobs in PostgreSQL
+ * Uses pg-boss's schedule() API to store recurring jobs in PostgreSQL.
+ * Handles both one-off delayed RPCs and recurring cron-scheduled tasks.
  */
 export class PgBossSchedulerService extends SchedulerService {
     pgBoss;
+    scheduledCronNames = [];
     constructor(pgBoss) {
         super();
         this.pgBoss = pgBoss;
@@ -77,4 +81,37 @@ export class PgBossSchedulerService extends SchedulerService {
     async close() {
         // No-op - pg-boss lifecycle is managed by factory
     }
+    /**
+     * Start recurring scheduled tasks.
+     * Registers a pg-boss worker to process recurring jobs via runScheduledTask.
+     */
+    async start() {
+        const logger = pikkuState(null, 'package', 'singletonServices').logger;
+        const scheduledTasks = getScheduledTasks();
+        for (const [name, task] of scheduledTasks) {
+            const cronName = `pikku-recurring-scheduled-task_${name.replace(/[^a-zA-Z0-9_\-.]/g, '_')}`;
+            await this.pgBoss.createQueue(cronName);
+            await this.pgBoss.schedule(cronName, task.schedule, {
+                rpcName: name,
+            });
+            this.scheduledCronNames.push(cronName);
+            // Register a worker to process the scheduled jobs
+            await this.pgBoss.work(cronName, async (jobs) => {
+                for (const job of jobs) {
+                    const { rpcName } = job.data;
+                    logger.info(`Running scheduled task: ${rpcName}`);
+                    await runScheduledTask({ name: rpcName });
+                }
+            });
+        }
+    }
+    /**
+     * Stop recurring scheduled tasks by unscheduling them from pg-boss.
+     */
+    async stop() {
+        for (const cronName of this.scheduledCronNames) {
+            await this.pgBoss.unschedule(cronName);
+        }
+        this.scheduledCronNames = [];
+    }
 }

package/dist/pg-boss-service-factory.d.ts

@@ -2,7 +2,6 @@ import { PgBoss, type ConstructorOptions } from 'pg-boss';
 import { PgBossQueueService } from './pg-boss-queue-service.js';
 import { PgBossQueueWorkers } from './pg-boss-queue-worker.js';
 import { PgBossSchedulerService } from './pg-boss-scheduler-service.js';
-import type { CoreSingletonServices, CreateWireServices } from '@pikku/core';
 /**
  * Factory class for pg-boss services
  * Manages a single PgBoss instance shared across queue, worker, and scheduler services
@@ -25,7 +24,7 @@ export declare class PgBossServiceFactory {
     /**
      * Get the queue workers for processing jobs
      */
-    getQueueWorkers(singletonServices: CoreSingletonServices, createWireServices?: CreateWireServices): PgBossQueueWorkers;
+    getQueueWorkers(): PgBossQueueWorkers;
     /**
      * Get the scheduler service for managing recurring tasks
      */

package/dist/pg-boss-service-factory.js

@@ -44,9 +44,9 @@ export class PgBossServiceFactory {
     /**
      * Get the queue workers for processing jobs
      */
-    getQueueWorkers(singletonServices, createWireServices) {
+    getQueueWorkers() {
         if (!this.queueWorkers) {
-            this.queueWorkers = new PgBossQueueWorkers(this.pgBoss, singletonServices, createWireServices);
+            this.queueWorkers = new PgBossQueueWorkers(this.pgBoss);
         }
         return this.queueWorkers;
     }

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { QueueJob } from '@pikku/core/queue';
-import { PgBoss, type JobWithMetadata } from 'pg-boss';
+import type { QueueJob } from '@pikku/core/queue';
+import type { PgBoss, JobWithMetadata } from 'pg-boss';
 /**
  * Map pg-boss job to QueueJob interface
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/queue-pg-boss",
-  "version": "0.11.2",
+  "version": "0.12.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.11.2"
+    "@pikku/core": "^0.12.1"
   },
   "dependencies": {
-    "pg-boss": "^12.2.0"
+    "pg-boss": "^12.9.0"
   },
   "devDependencies": {
     "typescript": "^5.9"

package/src/pg-boss-queue-service.ts

@@ -1,4 +1,4 @@
-import { PgBoss, Request as PgBossRequest } from 'pg-boss'
+import type { PgBoss, Request as PgBossRequest } from 'pg-boss'
 import type { QueueService, QueueJob, JobOptions } from '@pikku/core/queue'
 import { mapPgBossJobToQueueJob } from './utils.js'
 

package/src/pg-boss-queue-worker.test.ts

@@ -0,0 +1,15 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { PgBossQueueWorkers } from './pg-boss-queue-worker.js'
+
+describe('PgBossQueueWorkers', () => {
+  test('requires setJobRunner before registerQueues', async () => {
+    const workers = new PgBossQueueWorkers({} as any)
+
+    await assert.rejects(() => workers.registerQueues(), {
+      message:
+        'PgBossQueueWorkers requires setJobRunner() before registerQueues()',
+    })
+  })
+})

package/src/pg-boss-queue-worker.ts

@@ -1,4 +1,4 @@
-import { PgBoss, type WorkOptions } from 'pg-boss'
+import type { PgBoss, WorkOptions } from 'pg-boss'
 import type {
   QueueWorkers,
   PikkuWorkerConfig,
@@ -6,12 +6,12 @@ import type {
   ConfigValidationResult,
 } from '@pikku/core/queue'
 import {
-  runQueueJob,
   registerQueueWorkers,
+  runQueueJob,
   QueueJobFailedError,
   QueueJobDiscardedError,
 } from '@pikku/core/queue'
-import { CoreSingletonServices, CreateWireServices } from '@pikku/core'
+import { pikkuState } from '@pikku/core/internal'
 import { mapPgBossJobToQueueJob } from './utils.js'
 
 export const mapPikkuWorkerToPgBoss = (
@@ -121,11 +121,7 @@ export class PgBossQueueWorkers implements QueueWorkers {
   private pgBoss: PgBoss
   private activeWorkers = new Map<string, string>()
 
-  constructor(
-    pgBoss: PgBoss,
-    private singletonServices: CoreSingletonServices,
-    private createWireServices?: CreateWireServices
-  ) {
+  constructor(pgBoss: PgBoss) {
     this.pgBoss = pgBoss
   }
 
@@ -133,25 +129,22 @@ export class PgBossQueueWorkers implements QueueWorkers {
    * Scan state and register all compatible processors
    */
   async registerQueues(): Promise<Record<string, ConfigValidationResult[]>> {
+    const logger = pikkuState(null, 'package', 'singletonServices')!.logger
+
     return await registerQueueWorkers(
       this.configMappings,
-      this.singletonServices.logger,
+      logger,
       async (queueName, processor) => {
         await this.pgBoss.createQueue(queueName)
         const workerId = await this.pgBoss.work<any>(
-          processor.queueName,
+          processor.name,
           {
             ...mapPikkuWorkerToPgBoss(processor.config),
             includeMetadata: true,
           },
           async (jobs) => {
-            if (!this.singletonServices) {
-              throw new Error('Singleton services not available')
-            }
             if (!jobs || jobs.length === 0) {
-              this.singletonServices.logger.warn(
-                `No jobs received for queue ${queueName}`
-              )
+              logger.warn(`No jobs received for queue ${queueName}`)
               return
             }
             // Process all jobs in parallel
@@ -159,8 +152,6 @@ export class PgBossQueueWorkers implements QueueWorkers {
               jobs.map(async (job) => {
                 try {
                   await runQueueJob({
-                    singletonServices: this.singletonServices,
-                    createWireServices: this.createWireServices,
                     job: mapPgBossJobToQueueJob(job, this.pgBoss),
                   })
                 } catch (error: unknown) {
@@ -171,7 +162,7 @@ export class PgBossQueueWorkers implements QueueWorkers {
                     })
                   } else if (error instanceof QueueJobDiscardedError) {
                     // For pg-boss, complete the job successfully to discard it
-                    this.singletonServices.logger.info(
+                    logger.info(
                       `PgBoss job ${job.id} discarded: ${error.message}`
                     )
                     await this.pgBoss.complete(queueName, job.id)

package/src/pg-boss-scheduler-service.ts

@@ -1,11 +1,12 @@
-import { PgBoss } from 'pg-boss'
-import {
-  SchedulerService,
+import type { PgBoss } from 'pg-boss'
+import type {
   ScheduledTaskInfo,
   ScheduledTaskSummary,
   CoreUserSession,
-  parseDurationString,
 } from '@pikku/core'
+import { SchedulerService, parseDurationString } from '@pikku/core'
+import { pikkuState } from '@pikku/core/internal'
+import { runScheduledTask, getScheduledTasks } from '@pikku/core/scheduler'
 
 /**
  * Data stored in scheduled job
@@ -18,9 +19,12 @@ interface ScheduledJobData {
 
 /**
  * pg-boss scheduler service implementation
- * Uses pg-boss's schedule() API to store recurring jobs in PostgreSQL
+ * Uses pg-boss's schedule() API to store recurring jobs in PostgreSQL.
+ * Handles both one-off delayed RPCs and recurring cron-scheduled tasks.
  */
 export class PgBossSchedulerService extends SchedulerService {
+  private scheduledCronNames: string[] = []
+
   constructor(private pgBoss: PgBoss) {
     super()
   }
@@ -118,4 +122,41 @@ export class PgBossSchedulerService extends SchedulerService {
   async close(): Promise<void> {
     // No-op - pg-boss lifecycle is managed by factory
   }
+
+  /**
+   * Start recurring scheduled tasks.
+   * Registers a pg-boss worker to process recurring jobs via runScheduledTask.
+   */
+  async start(): Promise<void> {
+    const logger = pikkuState(null, 'package', 'singletonServices')!.logger
+    const scheduledTasks = getScheduledTasks()
+
+    for (const [name, task] of scheduledTasks) {
+      const cronName = `pikku-recurring-scheduled-task_${name.replace(/[^a-zA-Z0-9_\-.]/g, '_')}`
+      await this.pgBoss.createQueue(cronName)
+      await this.pgBoss.schedule(cronName, task.schedule, {
+        rpcName: name,
+      } as ScheduledJobData)
+      this.scheduledCronNames.push(cronName)
+
+      // Register a worker to process the scheduled jobs
+      await this.pgBoss.work<ScheduledJobData>(cronName, async (jobs) => {
+        for (const job of jobs) {
+          const { rpcName } = job.data
+          logger.info(`Running scheduled task: ${rpcName}`)
+          await runScheduledTask({ name: rpcName })
+        }
+      })
+    }
+  }
+
+  /**
+   * Stop recurring scheduled tasks by unscheduling them from pg-boss.
+   */
+  async stop(): Promise<void> {
+    for (const cronName of this.scheduledCronNames) {
+      await this.pgBoss.unschedule(cronName)
+    }
+    this.scheduledCronNames = []
+  }
 }

package/src/pg-boss-service-factory.ts

@@ -2,7 +2,6 @@ import { PgBoss, type ConstructorOptions } from 'pg-boss'
 import { PgBossQueueService } from './pg-boss-queue-service.js'
 import { PgBossQueueWorkers } from './pg-boss-queue-worker.js'
 import { PgBossSchedulerService } from './pg-boss-scheduler-service.js'
-import type { CoreSingletonServices, CreateWireServices } from '@pikku/core'
 
 /**
  * Factory class for pg-boss services
@@ -50,16 +49,9 @@ export class PgBossServiceFactory {
   /**
    * Get the queue workers for processing jobs
    */
-  getQueueWorkers(
-    singletonServices: CoreSingletonServices,
-    createWireServices?: CreateWireServices
-  ): PgBossQueueWorkers {
+  getQueueWorkers(): PgBossQueueWorkers {
     if (!this.queueWorkers) {
-      this.queueWorkers = new PgBossQueueWorkers(
-        this.pgBoss,
-        singletonServices,
-        createWireServices
-      )
+      this.queueWorkers = new PgBossQueueWorkers(this.pgBoss)
     }
     return this.queueWorkers
   }

package/src/utils.ts

@@ -1,5 +1,5 @@
-import { QueueJob, QueueJobStatus } from '@pikku/core/queue'
-import { PgBoss, type JobWithMetadata } from 'pg-boss'
+import type { QueueJob, QueueJobStatus } from '@pikku/core/queue'
+import type { PgBoss, JobWithMetadata } from 'pg-boss'
 
 /**
  * Map pg-boss job state to our queue job status