@pikku/queue-pg-boss 0.11.1 → 0.11.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## 0.11.0
 
+## 0.11.2
+
+### Patch Changes
+
+- db9c7bf: Simplify CreateWireServices type signature for custom Config compatibility
+- Updated dependencies [db9c7bf]
+  - @pikku/core@0.11.2
+
+## 0.11.2
+
+### Fixes
+
+- ddd87eaf: Simplify CreateWireServices type signature for custom Config compatibility
+
 ## 0.11.1
 
 ### Patch Changes

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

@@ -1,6 +1,6 @@
 import { PgBoss, type WorkOptions } from 'pg-boss';
 import type { QueueWorkers, PikkuWorkerConfig, QueueConfigMapping, ConfigValidationResult } from '@pikku/core/queue';
-import { CoreServices, CoreSingletonServices, CreateWireServices } from '@pikku/core';
+import { CoreSingletonServices, CreateWireServices } from '@pikku/core';
 export declare const mapPikkuWorkerToPgBoss: (workerConfig?: PikkuWorkerConfig) => WorkOptions;
 /**
  * pg-boss/PostgreSQL queue worker implementation
@@ -18,7 +18,7 @@ export declare class PgBossQueueWorkers implements QueueWorkers {
     readonly configMappings: QueueConfigMapping;
     private pgBoss;
     private activeWorkers;
-    constructor(pgBoss: PgBoss, singletonServices: CoreSingletonServices, createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices, any> | undefined);
+    constructor(pgBoss: PgBoss, singletonServices: CoreSingletonServices, createWireServices?: CreateWireServices | undefined);
     /**
      * Scan state and register all compatible processors
      */

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

@@ -1,7 +1,9 @@
 import { runQueueJob, registerQueueWorkers, QueueJobFailedError, QueueJobDiscardedError, } from '@pikku/core/queue';
 import { mapPgBossJobToQueueJob } from './utils.js';
 export const mapPikkuWorkerToPgBoss = (workerConfig) => {
-    const workerOptions = {};
+    const workerOptions = {
+        batchSize: 10,
+    };
     if (workerConfig?.batchSize !== undefined) {
         workerOptions.batchSize = workerConfig.batchSize;
     }
@@ -28,7 +30,7 @@ export class PgBossQueueWorkers {
         supported: {
             batchSize: {
                 queueProperty: 'batchSize',
-                description: 'Number of jobs to process in a single batch',
+                description: 'Number of jobs to fetch and process concurrently in parallel',
             },
             pollInterval: {
                 queueProperty: 'pollingIntervalSeconds',
@@ -97,33 +99,45 @@ export class PgBossQueueWorkers {
             const workerId = await this.pgBoss.work(processor.queueName, {
                 ...mapPikkuWorkerToPgBoss(processor.config),
                 includeMetadata: true,
-            }, async ([job]) => {
+            }, async (jobs) => {
                 if (!this.singletonServices) {
                     throw new Error('Singleton services not available');
                 }
-                if (!job) {
-                    this.singletonServices.logger.warn(`No job received for queue ${queueName}`);
+                if (!jobs || jobs.length === 0) {
+                    this.singletonServices.logger.warn(`No jobs received for queue ${queueName}`);
                     return;
                 }
-                try {
-                    await runQueueJob({
-                        singletonServices: this.singletonServices,
-                        createWireServices: this.createWireServices,
-                        job: mapPgBossJobToQueueJob(job, this.pgBoss),
-                    });
-                }
-                catch (error) {
-                    if (error instanceof QueueJobFailedError) {
-                        // Let pg-boss handle this as a failed job
-                        throw new Error(error.message);
+                // 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),
+                        });
                     }
-                    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}`);
-                        return; // Successfully "completed" by discarding
+                    catch (error) {
+                        if (error instanceof QueueJobFailedError) {
+                            // Mark this specific job as failed
+                            await this.pgBoss.fail(queueName, job.id, {
+                                message: error.message,
+                            });
+                        }
+                        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}`);
+                            await this.pgBoss.complete(queueName, job.id);
+                        }
+                        else {
+                            // For other errors, fail the job
+                            await this.pgBoss.fail(queueName, job.id, {
+                                message: error instanceof Error
+                                    ? error.message
+                                    : 'Unknown error',
+                            });
+                        }
                     }
-                    throw error;
-                }
+                }));
             });
             this.activeWorkers.set(queueName, workerId);
         });

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

@@ -2,7 +2,7 @@ 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 { CoreServices, CoreSingletonServices, CreateWireServices } from '@pikku/core';
+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 +25,7 @@ export declare class PgBossServiceFactory {
     /**
      * Get the queue workers for processing jobs
      */
-    getQueueWorkers(singletonServices: CoreSingletonServices, createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices, any>): PgBossQueueWorkers;
+    getQueueWorkers(singletonServices: CoreSingletonServices, createWireServices?: CreateWireServices): PgBossQueueWorkers;
     /**
      * Get the scheduler service for managing recurring tasks
      */
@@ -34,4 +34,8 @@ export declare class PgBossServiceFactory {
      * Close all services and the pg-boss connection
      */
     close(): Promise<void>;
+    /**
+     * Alias for close() - used by stopSingletonServices
+     */
+    stop(): Promise<void>;
 }

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

@@ -68,4 +68,10 @@ export class PgBossServiceFactory {
             this.initialized = false;
         }
     }
+    /**
+     * Alias for close() - used by stopSingletonServices
+     */
+    async stop() {
+        await this.close();
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/queue-pg-boss",
-  "version": "0.11.1",
+  "version": "0.11.2",
   "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.11.1"
+    "@pikku/core": "^0.11.2"
   },
   "dependencies": {
     "pg-boss": "^12.2.0"

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

@@ -11,17 +11,15 @@ import {
   QueueJobFailedError,
   QueueJobDiscardedError,
 } from '@pikku/core/queue'
-import {
-  CoreServices,
-  CoreSingletonServices,
-  CreateWireServices,
-} from '@pikku/core'
+import { CoreSingletonServices, CreateWireServices } from '@pikku/core'
 import { mapPgBossJobToQueueJob } from './utils.js'
 
 export const mapPikkuWorkerToPgBoss = (
   workerConfig?: PikkuWorkerConfig
 ): WorkOptions => {
-  const workerOptions: WorkOptions = {}
+  const workerOptions: WorkOptions = {
+    batchSize: 10,
+  }
 
   if (workerConfig?.batchSize !== undefined) {
     workerOptions.batchSize = workerConfig.batchSize
@@ -53,7 +51,8 @@ export class PgBossQueueWorkers implements QueueWorkers {
     supported: {
       batchSize: {
         queueProperty: 'batchSize',
-        description: 'Number of jobs to process in a single batch',
+        description:
+          'Number of jobs to fetch and process concurrently in parallel',
       },
       pollInterval: {
         queueProperty: 'pollingIntervalSeconds',
@@ -125,11 +124,7 @@ export class PgBossQueueWorkers implements QueueWorkers {
   constructor(
     pgBoss: PgBoss,
     private singletonServices: CoreSingletonServices,
-    private createWireServices?: CreateWireServices<
-      CoreSingletonServices,
-      CoreServices,
-      any
-    >
+    private createWireServices?: CreateWireServices
   ) {
     this.pgBoss = pgBoss
   }
@@ -149,35 +144,49 @@ export class PgBossQueueWorkers implements QueueWorkers {
             ...mapPikkuWorkerToPgBoss(processor.config),
             includeMetadata: true,
           },
-          async ([job]) => {
+          async (jobs) => {
             if (!this.singletonServices) {
               throw new Error('Singleton services not available')
             }
-            if (!job) {
+            if (!jobs || jobs.length === 0) {
               this.singletonServices.logger.warn(
-                `No job received for queue ${queueName}`
+                `No jobs received for queue ${queueName}`
               )
               return
             }
-            try {
-              await runQueueJob({
-                singletonServices: this.singletonServices,
-                createWireServices: this.createWireServices,
-                job: mapPgBossJobToQueueJob(job, this.pgBoss),
+            // 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),
+                  })
+                } catch (error: unknown) {
+                  if (error instanceof QueueJobFailedError) {
+                    // Mark this specific job as failed
+                    await this.pgBoss.fail(queueName, job.id, {
+                      message: error.message,
+                    })
+                  } 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}`
+                    )
+                    await this.pgBoss.complete(queueName, job.id)
+                  } else {
+                    // For other errors, fail the job
+                    await this.pgBoss.fail(queueName, job.id, {
+                      message:
+                        error instanceof Error
+                          ? error.message
+                          : 'Unknown error',
+                    })
+                  }
+                }
               })
-            } catch (error: unknown) {
-              if (error instanceof QueueJobFailedError) {
-                // Let pg-boss handle this as a failed job
-                throw new Error(error.message)
-              } 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}`
-                )
-                return // Successfully "completed" by discarding
-              }
-              throw error
-            }
+            )
           }
         )
         this.activeWorkers.set(queueName, workerId)

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

@@ -2,11 +2,7 @@ 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 {
-  CoreServices,
-  CoreSingletonServices,
-  CreateWireServices,
-} from '@pikku/core'
+import type { CoreSingletonServices, CreateWireServices } from '@pikku/core'
 
 /**
  * Factory class for pg-boss services
@@ -56,11 +52,7 @@ export class PgBossServiceFactory {
    */
   getQueueWorkers(
     singletonServices: CoreSingletonServices,
-    createWireServices?: CreateWireServices<
-      CoreSingletonServices,
-      CoreServices,
-      any
-    >
+    createWireServices?: CreateWireServices
   ): PgBossQueueWorkers {
     if (!this.queueWorkers) {
       this.queueWorkers = new PgBossQueueWorkers(
@@ -91,4 +83,11 @@ export class PgBossServiceFactory {
       this.initialized = false
     }
   }
+
+  /**
+   * Alias for close() - used by stopSingletonServices
+   */
+  async stop(): Promise<void> {
+    await this.close()
+  }
 }