@pikku/queue-pg-boss 0.12.0 → 0.12.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 ## 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

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,6 +1,5 @@
-import { PgBoss, type WorkOptions } from 'pg-boss';
-import type { QueueWorkers, PikkuWorkerConfig, QueueConfigMapping, ConfigValidationResult, QueueJob } from '@pikku/core/queue';
-import type { Logger } from '@pikku/core/services';
+import type { PgBoss, WorkOptions } from 'pg-boss';
+import type { QueueWorkers, PikkuWorkerConfig, QueueConfigMapping, ConfigValidationResult } from '@pikku/core/queue';
 export declare const mapPikkuWorkerToPgBoss: (workerConfig?: PikkuWorkerConfig) => WorkOptions;
 /**
  * pg-boss/PostgreSQL queue worker implementation
@@ -16,13 +15,7 @@ export declare class PgBossQueueWorkers implements QueueWorkers {
     readonly configMappings: QueueConfigMapping;
     private pgBoss;
     private activeWorkers;
-    private runJob?;
-    private logger?;
     constructor(pgBoss: PgBoss);
-    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/pg-boss-queue-worker.js

@@ -1,4 +1,5 @@
-import { 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 = {
@@ -83,36 +84,28 @@ export class PgBossQueueWorkers {
     };
     pgBoss;
     activeWorkers = new Map();
-    runJob;
-    logger;
     constructor(pgBoss) {
         this.pgBoss = pgBoss;
     }
-    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('PgBossQueueWorkers 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) => {
             await this.pgBoss.createQueue(queueName);
             const workerId = await this.pgBoss.work(processor.name, {
                 ...mapPikkuWorkerToPgBoss(processor.config),
                 includeMetadata: true,
             }, async (jobs) => {
                 if (!jobs || jobs.length === 0) {
-                    this.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 this.runJob({
+                        await runQueueJob({
                             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.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,5 +1,6 @@
-import { PgBoss } from 'pg-boss';
-import { SchedulerService, SchedulerRuntimeHandlers, 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.
@@ -8,14 +9,7 @@ import { SchedulerService, SchedulerRuntimeHandlers, ScheduledTaskInfo, Schedule
 export declare class PgBossSchedulerService extends SchedulerService {
     private pgBoss;
     private scheduledCronNames;
-    private handlers?;
     constructor(pgBoss: PgBoss);
-    /**
-     * 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 - no-op as pg-boss is already initialized by factory
      */

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

@@ -1,5 +1,6 @@
-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';
 /**
  * pg-boss scheduler service implementation
  * Uses pg-boss's schedule() API to store recurring jobs in PostgreSQL.
@@ -8,19 +9,10 @@ import { getScheduledTasks } from '@pikku/core/scheduler';
 export class PgBossSchedulerService extends SchedulerService {
     pgBoss;
     scheduledCronNames = [];
-    handlers;
     constructor(pgBoss) {
         super();
         this.pgBoss = pgBoss;
     }
-    /**
-     * 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 - no-op as pg-boss is already initialized by factory
      */
@@ -94,12 +86,11 @@ export class PgBossSchedulerService extends SchedulerService {
      * Registers a pg-boss worker to process recurring jobs via runScheduledTask.
      */
     async start() {
-        if (!this.handlers) {
-            throw new Error('PgBossSchedulerService requires setServices() before start()');
-        }
+        const logger = pikkuState(null, 'package', 'singletonServices').logger;
         const scheduledTasks = getScheduledTasks();
         for (const [name, task] of scheduledTasks) {
-            const cronName = `pikku-recurring-scheduled-task:${name}`;
+            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,
             });
@@ -108,8 +99,8 @@ export class PgBossSchedulerService extends SchedulerService {
             await this.pgBoss.work(cronName, async (jobs) => {
                 for (const job of jobs) {
                     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 });
                 }
             });
         }

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,12 +24,11 @@ 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
      */
     getSchedulerService(): PgBossSchedulerService;
-    setSchedulerRuntime(singletonServices: CoreSingletonServices, createWireServices?: CreateWireServices): void;
     /**
      * Close all services and the pg-boss connection
      */

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

@@ -2,8 +2,6 @@ import { PgBoss } 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 { createQueueJobRunner } from '@pikku/core/queue';
-import { createSchedulerRuntimeHandlers } from '@pikku/core/scheduler';
 /**
  * Factory class for pg-boss services
  * Manages a single PgBoss instance shared across queue, worker, and scheduler services
@@ -46,11 +44,10 @@ export class PgBossServiceFactory {
     /**
      * Get the queue workers for processing jobs
      */
-    getQueueWorkers(singletonServices, createWireServices) {
+    getQueueWorkers() {
         if (!this.queueWorkers) {
             this.queueWorkers = new PgBossQueueWorkers(this.pgBoss);
         }
-        this.queueWorkers.setJobRunner(createQueueJobRunner({ singletonServices, createWireServices }), singletonServices.logger);
         return this.queueWorkers;
     }
     /**
@@ -62,12 +59,6 @@ export class PgBossServiceFactory {
         }
         return this.schedulerService;
     }
-    setSchedulerRuntime(singletonServices, createWireServices) {
-        this.getSchedulerService().setServices(createSchedulerRuntimeHandlers({
-            singletonServices,
-            createWireServices,
-        }));
-    }
     /**
      * Close all services and the pg-boss connection
      */

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.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": {
     "pg-boss": "^12.9.0"

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.ts

@@ -1,17 +1,17 @@
-import { PgBoss, type WorkOptions } from 'pg-boss'
+import type { PgBoss, WorkOptions } from 'pg-boss'
 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 { mapPgBossJobToQueueJob } from './utils.js'
 
 export const mapPikkuWorkerToPgBoss = (
@@ -120,42 +120,20 @@ export class PgBossQueueWorkers implements QueueWorkers {
 
   private pgBoss: PgBoss
   private activeWorkers = new Map<string, string>()
-  private runJob?:
-    | ((params: {
-        job: QueueJob
-        updateProgress?: (progress: number | string | object) => Promise<void>
-      }) => Promise<void>)
-    | undefined
-  private logger?: Logger
 
   constructor(pgBoss: PgBoss) {
     this.pgBoss = pgBoss
   }
 
-  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(
-        'PgBossQueueWorkers requires setJobRunner() before registerQueues()'
-      )
-    }
+    const logger = pikkuState(null, 'package', 'singletonServices')!.logger
 
     return await registerQueueWorkers(
       this.configMappings,
-      this.logger,
+      logger,
       async (queueName, processor) => {
         await this.pgBoss.createQueue(queueName)
         const workerId = await this.pgBoss.work<any>(
@@ -166,14 +144,14 @@ export class PgBossQueueWorkers implements QueueWorkers {
           },
           async (jobs) => {
             if (!jobs || jobs.length === 0) {
-              this.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 this.runJob!({
+                  await runQueueJob({
                     job: mapPgBossJobToQueueJob(job, this.pgBoss),
                   })
                 } catch (error: unknown) {
@@ -184,7 +162,7 @@ export class PgBossQueueWorkers implements QueueWorkers {
                     })
                   } else if (error instanceof QueueJobDiscardedError) {
                     // For pg-boss, complete the job successfully to discard it
-                    this.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,13 +1,12 @@
-import { PgBoss } from 'pg-boss'
-import {
-  SchedulerService,
-  SchedulerRuntimeHandlers,
+import type { PgBoss } from 'pg-boss'
+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,21 +24,11 @@ interface ScheduledJobData {
  */
 export class PgBossSchedulerService extends SchedulerService {
   private scheduledCronNames: string[] = []
-  private handlers?: SchedulerRuntimeHandlers
 
   constructor(private pgBoss: PgBoss) {
     super()
   }
 
-  /**
-   * 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 - no-op as pg-boss is already initialized by factory
    */
@@ -139,16 +128,12 @@ export class PgBossSchedulerService extends SchedulerService {
    * Registers a pg-boss worker to process recurring jobs via runScheduledTask.
    */
   async start(): Promise<void> {
-    if (!this.handlers) {
-      throw new Error(
-        'PgBossSchedulerService requires setServices() before start()'
-      )
-    }
-
+    const logger = pikkuState(null, 'package', 'singletonServices')!.logger
     const scheduledTasks = getScheduledTasks()
 
     for (const [name, task] of scheduledTasks) {
-      const cronName = `pikku-recurring-scheduled-task:${name}`
+      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)
@@ -158,8 +143,8 @@ export class PgBossSchedulerService extends SchedulerService {
       await this.pgBoss.work<ScheduledJobData>(cronName, async (jobs) => {
         for (const job of jobs) {
           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 })
         }
       })
     }

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

@@ -2,9 +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'
-import { createQueueJobRunner } from '@pikku/core/queue'
-import { createSchedulerRuntimeHandlers } from '@pikku/core/scheduler'
 
 /**
  * Factory class for pg-boss services
@@ -52,17 +49,10 @@ 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)
     }
-    this.queueWorkers.setJobRunner(
-      createQueueJobRunner({ singletonServices, createWireServices }),
-      singletonServices.logger
-    )
     return this.queueWorkers
   }
 
@@ -76,18 +66,6 @@ export class PgBossServiceFactory {
     return this.schedulerService
   }
 
-  setSchedulerRuntime(
-    singletonServices: CoreSingletonServices,
-    createWireServices?: CreateWireServices
-  ): void {
-    this.getSchedulerService().setServices(
-      createSchedulerRuntimeHandlers({
-        singletonServices,
-        createWireServices,
-      })
-    )
-  }
-
   /**
    * Close all services and the pg-boss connection
    */

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