@pikku/queue-pg-boss 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-pg-boss
 
 ## 0.10.0

package/dist/index.d.ts

@@ -4,6 +4,8 @@
  * PostgreSQL queue service for Pikku using pg-boss
  * Provides job results, retries, priorities, and PostgreSQL-based queuing
  */
+export { PgBossServiceFactory } from './pg-boss-service-factory.js';
 export { PgBossQueueService } from './pg-boss-queue-service.js';
 export { PgBossQueueWorkers } from './pg-boss-queue-worker.js';
+export { PgBossSchedulerService } from './pg-boss-scheduler-service.js';
 export type { QueueService, PikkuWorkerConfig, PikkuJobConfig, QueueJob, JobOptions, } from '@pikku/core/queue';

package/dist/index.js

@@ -4,5 +4,7 @@
  * PostgreSQL queue service for Pikku using pg-boss
  * Provides job results, retries, priorities, and PostgreSQL-based queuing
  */
+export { PgBossServiceFactory } from './pg-boss-service-factory.js';
 export { PgBossQueueService } from './pg-boss-queue-service.js';
 export { PgBossQueueWorkers } from './pg-boss-queue-worker.js';
+export { PgBossSchedulerService } from './pg-boss-scheduler-service.js';

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

@@ -1,6 +1,6 @@
-import PgBoss from 'pg-boss';
+import { PgBoss, Request as PgBossRequest } from 'pg-boss';
 import type { QueueService, QueueJob, JobOptions } from '@pikku/core/queue';
-export declare const mapPikkuJobToPgBoss: (options?: JobOptions) => PgBoss.JobOptions;
+export declare const mapPikkuJobToPgBoss: (options?: JobOptions) => PgBossRequest["options"];
 /**
  * pg-boss/PostgreSQL queue service implementation
  * Supports job results, retries, and PostgreSQL-based queuing
@@ -9,11 +9,7 @@ export declare class PgBossQueueService implements QueueService {
     readonly name = "pg-boss";
     readonly supportsResults = true;
     protected pgBoss: PgBoss;
-    constructor(optionsOrUrl: PgBoss.ConstructorOptions | string);
-    /**
-     * Initialize the pg-boss instance
-     */
-    init(): Promise<void>;
+    constructor(pgBoss: PgBoss);
     /**
      * Add a job to the queue
      */
@@ -22,8 +18,4 @@ export declare class PgBossQueueService implements QueueService {
      * Get job by ID
      */
     getJob<T, R>(queueName: string, jobId: string): Promise<QueueJob<T, R> | null>;
-    /**
-     * Close the pg-boss connection
-     */
-    close(): Promise<void>;
 }

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

@@ -1,4 +1,3 @@
-import PgBoss from 'pg-boss';
 import { mapPgBossJobToQueueJob } from './utils.js';
 export const mapPikkuJobToPgBoss = (options) => {
     const pgBossOptions = {};
@@ -11,6 +10,30 @@ export const mapPikkuJobToPgBoss = (options) => {
     if (options?.jobId !== undefined) {
         pgBossOptions.singletonKey = options.jobId;
     }
+    // Map retry options
+    if (options?.attempts !== undefined) {
+        pgBossOptions.retryLimit = options.attempts - 1;
+    }
+    if (options?.backoff !== undefined) {
+        if (typeof options.backoff === 'string') {
+            // If backoff is a string, assume it's 'exponential' or 'fixed'
+            pgBossOptions.retryBackoff = options.backoff === 'exponential';
+        }
+        else if (typeof options.backoff === 'object') {
+            pgBossOptions.retryBackoff = options.backoff.type === 'exponential';
+            if (options.backoff.delay !== undefined) {
+                // pg-boss uses seconds, we use milliseconds
+                pgBossOptions.retryDelay = Math.floor(options.backoff.delay / 1000);
+            }
+        }
+    }
+    if (options?.removeOnComplete !== undefined) {
+        pgBossOptions.onComplete = options.removeOnComplete === 0;
+    }
+    if (options?.removeOnFail !== undefined) {
+        // pg-boss doesn't have a direct equivalent, but we can track this for consistency
+        // Note: pg-boss keeps failed jobs by default
+    }
     return pgBossOptions;
 };
 /**
@@ -21,23 +44,14 @@ export class PgBossQueueService {
     name = 'pg-boss';
     supportsResults = true;
     pgBoss;
-    constructor(optionsOrUrl) {
-        if (typeof optionsOrUrl === 'string') {
-            // If a string is provided, treat it as the connection URL
-            optionsOrUrl = { connectionString: optionsOrUrl };
-        }
-        this.pgBoss = new PgBoss(optionsOrUrl);
-    }
-    /**
-     * Initialize the pg-boss instance
-     */
-    async init() {
-        await this.pgBoss.start();
+    constructor(pgBoss) {
+        this.pgBoss = pgBoss;
     }
     /**
      * Add a job to the queue
      */
     async add(queueName, data, options) {
+        await this.pgBoss.createQueue(queueName);
         const jobId = await this.pgBoss.send(queueName, data, mapPikkuJobToPgBoss(options));
         if (!jobId) {
             throw new Error('Failed to create job');
@@ -54,10 +68,4 @@ export class PgBossQueueService {
         }
         return mapPgBossJobToQueueJob(job, this.pgBoss);
     }
-    /**
-     * Close the pg-boss connection
-     */
-    async close() {
-        await this.pgBoss.stop();
-    }
 }

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

@@ -1,14 +1,14 @@
-import PgBoss from 'pg-boss';
+import { PgBoss, type WorkOptions } from 'pg-boss';
 import type { QueueWorkers, PikkuWorkerConfig, QueueConfigMapping, ConfigValidationResult } from '@pikku/core/queue';
-import { CoreServices, CoreSingletonServices, CreateSessionServices } from '@pikku/core';
-export declare const mapPikkuWorkerToPgBoss: (workerConfig?: PikkuWorkerConfig) => PgBoss.WorkOptions;
+import { CoreServices, 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 createSessionServices?;
+    private createWireServices?;
     readonly name = "pg-boss";
     readonly supportsResults = true;
     /**
@@ -18,17 +18,9 @@ export declare class PgBossQueueWorkers implements QueueWorkers {
     readonly configMappings: QueueConfigMapping;
     private pgBoss;
     private activeWorkers;
-    constructor(options: PgBoss.ConstructorOptions | string, singletonServices: CoreSingletonServices, createSessionServices?: CreateSessionServices<CoreSingletonServices, CoreServices, any> | undefined);
-    /**
-     * Initialize pg-boss
-     */
-    init(): Promise<void>;
+    constructor(pgBoss: PgBoss, singletonServices: CoreSingletonServices, createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices, any> | undefined);
     /**
      * Scan state and register all compatible processors
      */
     registerQueues(): Promise<Record<string, ConfigValidationResult[]>>;
-    /**
-     * Close all workers and connections
-     */
-    close(): Promise<void>;
 }

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

@@ -1,4 +1,3 @@
-import PgBoss from 'pg-boss';
 import { runQueueJob, registerQueueWorkers, QueueJobFailedError, QueueJobDiscardedError, } from '@pikku/core/queue';
 import { mapPgBossJobToQueueJob } from './utils.js';
 export const mapPikkuWorkerToPgBoss = (workerConfig) => {
@@ -17,7 +16,7 @@ export const mapPikkuWorkerToPgBoss = (workerConfig) => {
  */
 export class PgBossQueueWorkers {
     singletonServices;
-    createSessionServices;
+    createWireServices;
     name = 'pg-boss';
     supportsResults = true;
     /**
@@ -84,20 +83,10 @@ export class PgBossQueueWorkers {
     };
     pgBoss;
     activeWorkers = new Map();
-    constructor(options, singletonServices, createSessionServices) {
+    constructor(pgBoss, singletonServices, createWireServices) {
         this.singletonServices = singletonServices;
-        this.createSessionServices = createSessionServices;
-        if (typeof options === 'string') {
-            // If a string is provided, treat it as the connection string
-            options = { connectionString: options };
-        }
-        this.pgBoss = new PgBoss(options);
-    }
-    /**
-     * Initialize pg-boss
-     */
-    async init() {
-        await this.pgBoss.start();
+        this.createWireServices = createWireServices;
+        this.pgBoss = pgBoss;
     }
     /**
      * Scan state and register all compatible processors
@@ -119,7 +108,7 @@ export class PgBossQueueWorkers {
                 try {
                     await runQueueJob({
                         singletonServices: this.singletonServices,
-                        createSessionServices: this.createSessionServices,
+                        createWireServices: this.createWireServices,
                         job: mapPgBossJobToQueueJob(job, this.pgBoss),
                     });
                 }
@@ -139,10 +128,4 @@ export class PgBossQueueWorkers {
             this.activeWorkers.set(queueName, workerId);
         });
     }
-    /**
-     * Close all workers and connections
-     */
-    async close() {
-        await this.pgBoss.stop();
-    }
 }

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

@@ -0,0 +1,35 @@
+import { PgBoss } from 'pg-boss';
+import { SchedulerService, ScheduledTaskInfo, ScheduledTaskSummary, CoreUserSession } from '@pikku/core';
+/**
+ * pg-boss scheduler service implementation
+ * Uses pg-boss's schedule() API to store recurring jobs in PostgreSQL
+ */
+export declare class PgBossSchedulerService extends SchedulerService {
+    private pgBoss;
+    constructor(pgBoss: PgBoss);
+    /**
+     * Initialize - no-op as pg-boss is already initialized by factory
+     */
+    init(): Promise<void>;
+    /**
+     * Schedule a one-off delayed RPC call
+     * Uses pg-boss send() with startAfter for one-time execution
+     */
+    scheduleRPC(delay: number | string, rpcName: string, data?: any, session?: CoreUserSession): Promise<string>;
+    /**
+     * Unschedule (cancel) 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 - no-op as pg-boss lifecycle is managed by factory
+     */
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,80 @@
+import { SchedulerService, parseDurationString, } from '@pikku/core';
+/**
+ * pg-boss scheduler service implementation
+ * Uses pg-boss's schedule() API to store recurring jobs in PostgreSQL
+ */
+export class PgBossSchedulerService extends SchedulerService {
+    pgBoss;
+    constructor(pgBoss) {
+        super();
+        this.pgBoss = pgBoss;
+    }
+    /**
+     * Initialize - no-op as pg-boss is already initialized by factory
+     */
+    async init() {
+        // No-op - pg-boss is already initialized by factory
+    }
+    /**
+     * Schedule a one-off delayed RPC call
+     * Uses pg-boss send() with startAfter for one-time execution
+     */
+    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 send() with startAfter for one-off delayed execution
+        const taskId = await this.pgBoss.send('pikku-remote-internal-rpc', jobData, {
+            startAfter: new Date(Date.now() + delayMs),
+            singletonKey: `${rpcName}-${Date.now()}`, // Ensure uniqueness
+        });
+        if (!taskId) {
+            throw new Error('Failed to schedule RPC');
+        }
+        return taskId;
+    }
+    /**
+     * Unschedule (cancel) a task by ID
+     */
+    async unschedule(taskId) {
+        await this.pgBoss.cancel('pikku-remote-internal-rpc', taskId);
+        return true;
+    }
+    /**
+     * Get a scheduled task by ID with full details
+     */
+    async getTask(taskId) {
+        const job = await this.pgBoss.getJobById('pikku-remote-internal-rpc', taskId);
+        if (!job) {
+            return null;
+        }
+        const jobData = job.data;
+        return {
+            taskId: job.id,
+            rpcName: jobData.rpcName,
+            scheduledFor: job.startAfter || job.createdOn,
+            data: jobData.data,
+            session: jobData.session,
+            status: job.state,
+        };
+    }
+    /**
+     * Get all scheduled tasks with minimal info
+     */
+    async getAllTasks() {
+        // pg-boss doesn't have a simple way to list all pending jobs
+        // This would require querying the database directly or maintaining a separate index
+        // For now, return empty array - can be implemented if needed
+        return [];
+    }
+    /**
+     * Close - no-op as pg-boss lifecycle is managed by factory
+     */
+    async close() {
+        // No-op - pg-boss lifecycle is managed by factory
+    }
+}

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

@@ -0,0 +1,37 @@
+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';
+/**
+ * Factory class for pg-boss services
+ * Manages a single PgBoss instance shared across queue, worker, and scheduler services
+ */
+export declare class PgBossServiceFactory {
+    private pgBoss;
+    private queueService?;
+    private queueWorkers?;
+    private schedulerService?;
+    private initialized;
+    constructor(optionsOrInstance: ConstructorOptions | string | PgBoss);
+    /**
+     * Initialize the pg-boss instance
+     */
+    init(): Promise<void>;
+    /**
+     * Get the queue service for publishing jobs
+     */
+    getQueueService(): PgBossQueueService;
+    /**
+     * Get the queue workers for processing jobs
+     */
+    getQueueWorkers(singletonServices: CoreSingletonServices, createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices, any>): PgBossQueueWorkers;
+    /**
+     * Get the scheduler service for managing recurring tasks
+     */
+    getSchedulerService(): PgBossSchedulerService;
+    /**
+     * Close all services and the pg-boss connection
+     */
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,71 @@
+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';
+/**
+ * Factory class for pg-boss services
+ * Manages a single PgBoss instance shared across queue, worker, and scheduler services
+ */
+export class PgBossServiceFactory {
+    pgBoss;
+    queueService;
+    queueWorkers;
+    schedulerService;
+    initialized = false;
+    constructor(optionsOrInstance) {
+        if (optionsOrInstance instanceof PgBoss) {
+            this.pgBoss = optionsOrInstance;
+        }
+        else {
+            const options = typeof optionsOrInstance === 'string'
+                ? { connectionString: optionsOrInstance }
+                : optionsOrInstance;
+            this.pgBoss = new PgBoss(options);
+        }
+    }
+    /**
+     * Initialize the pg-boss instance
+     */
+    async init() {
+        if (!this.initialized) {
+            await this.pgBoss.start();
+            this.initialized = true;
+        }
+    }
+    /**
+     * Get the queue service for publishing jobs
+     */
+    getQueueService() {
+        if (!this.queueService) {
+            this.queueService = new PgBossQueueService(this.pgBoss);
+        }
+        return this.queueService;
+    }
+    /**
+     * Get the queue workers for processing jobs
+     */
+    getQueueWorkers(singletonServices, createWireServices) {
+        if (!this.queueWorkers) {
+            this.queueWorkers = new PgBossQueueWorkers(this.pgBoss, singletonServices, createWireServices);
+        }
+        return this.queueWorkers;
+    }
+    /**
+     * Get the scheduler service for managing recurring tasks
+     */
+    getSchedulerService() {
+        if (!this.schedulerService) {
+            this.schedulerService = new PgBossSchedulerService(this.pgBoss);
+        }
+        return this.schedulerService;
+    }
+    /**
+     * Close all services and the pg-boss connection
+     */
+    async close() {
+        if (this.initialized) {
+            await this.pgBoss.stop();
+            this.initialized = false;
+        }
+    }
+}

package/dist/utils.d.ts

@@ -1,6 +1,6 @@
 import { QueueJob } from '@pikku/core/queue';
-import PgBoss from 'pg-boss';
+import { PgBoss, type JobWithMetadata } from 'pg-boss';
 /**
  * Map pg-boss job to QueueJob interface
  */
-export declare const mapPgBossJobToQueueJob: <In, Out>(pgBossJob: PgBoss.JobWithMetadata<In>, pgBossInstance: PgBoss) => QueueJob<In, Out>;
+export declare const mapPgBossJobToQueueJob: <In, Out>(pgBossJob: JobWithMetadata<In>, pgBossInstance: PgBoss) => QueueJob<In, Out>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/queue-pg-boss",
-  "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": {
-    "pg-boss": "^11.1.1"
+    "pg-boss": "^12.2.0"
   },
   "devDependencies": {
     "typescript": "^5.9"

package/src/index.ts

@@ -5,8 +5,10 @@
  * Provides job results, retries, priorities, and PostgreSQL-based queuing
  */
 
+export { PgBossServiceFactory } from './pg-boss-service-factory.js'
 export { PgBossQueueService } from './pg-boss-queue-service.js'
 export { PgBossQueueWorkers } from './pg-boss-queue-worker.js'
+export { PgBossSchedulerService } from './pg-boss-scheduler-service.js'
 
 // Re-export core queue types for convenience
 export type {

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

@@ -1,11 +1,11 @@
-import PgBoss from 'pg-boss'
+import { PgBoss, Request as PgBossRequest } from 'pg-boss'
 import type { QueueService, QueueJob, JobOptions } from '@pikku/core/queue'
 import { mapPgBossJobToQueueJob } from './utils.js'
 
 export const mapPikkuJobToPgBoss = (
   options?: JobOptions
-): PgBoss.JobOptions => {
-  const pgBossOptions: PgBoss.JobOptions = {}
+): PgBossRequest['options'] => {
+  const pgBossOptions: any = {}
 
   if (options?.priority !== undefined) {
     pgBossOptions.priority = options.priority
@@ -19,7 +19,34 @@ export const mapPikkuJobToPgBoss = (
     pgBossOptions.singletonKey = options.jobId
   }
 
-  return pgBossOptions
+  // Map retry options
+  if (options?.attempts !== undefined) {
+    pgBossOptions.retryLimit = options.attempts - 1
+  }
+
+  if (options?.backoff !== undefined) {
+    if (typeof options.backoff === 'string') {
+      // If backoff is a string, assume it's 'exponential' or 'fixed'
+      pgBossOptions.retryBackoff = options.backoff === 'exponential'
+    } else if (typeof options.backoff === 'object') {
+      pgBossOptions.retryBackoff = options.backoff.type === 'exponential'
+      if (options.backoff.delay !== undefined) {
+        // pg-boss uses seconds, we use milliseconds
+        pgBossOptions.retryDelay = Math.floor(options.backoff.delay / 1000)
+      }
+    }
+  }
+
+  if (options?.removeOnComplete !== undefined) {
+    pgBossOptions.onComplete = options.removeOnComplete === 0
+  }
+
+  if (options?.removeOnFail !== undefined) {
+    // pg-boss doesn't have a direct equivalent, but we can track this for consistency
+    // Note: pg-boss keeps failed jobs by default
+  }
+
+  return pgBossOptions as PgBossRequest['options']
 }
 
 /**
@@ -31,19 +58,8 @@ export class PgBossQueueService implements QueueService {
   readonly supportsResults = true
   protected pgBoss: PgBoss
 
-  constructor(optionsOrUrl: PgBoss.ConstructorOptions | string) {
-    if (typeof optionsOrUrl === 'string') {
-      // If a string is provided, treat it as the connection URL
-      optionsOrUrl = { connectionString: optionsOrUrl }
-    }
-    this.pgBoss = new PgBoss(optionsOrUrl)
-  }
-
-  /**
-   * Initialize the pg-boss instance
-   */
-  async init(): Promise<void> {
-    await this.pgBoss.start()
+  constructor(pgBoss: PgBoss) {
+    this.pgBoss = pgBoss
   }
 
   /**
@@ -54,6 +70,7 @@ export class PgBossQueueService implements QueueService {
     data: In,
     options?: JobOptions
   ): Promise<string> {
+    await this.pgBoss.createQueue(queueName)
     const jobId = await this.pgBoss.send(
       queueName,
       data as any,
@@ -78,11 +95,4 @@ export class PgBossQueueService implements QueueService {
     }
     return mapPgBossJobToQueueJob<T, R>(job, this.pgBoss)
   }
-
-  /**
-   * Close the pg-boss connection
-   */
-  async close(): Promise<void> {
-    await this.pgBoss.stop()
-  }
 }

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

@@ -1,4 +1,4 @@
-import PgBoss from 'pg-boss'
+import { PgBoss, type WorkOptions } from 'pg-boss'
 import type {
   QueueWorkers,
   PikkuWorkerConfig,
@@ -14,14 +14,14 @@ import {
 import {
   CoreServices,
   CoreSingletonServices,
-  CreateSessionServices,
+  CreateWireServices,
 } from '@pikku/core'
 import { mapPgBossJobToQueueJob } from './utils.js'
 
 export const mapPikkuWorkerToPgBoss = (
   workerConfig?: PikkuWorkerConfig
-): PgBoss.WorkOptions => {
-  const workerOptions: PgBoss.WorkOptions = {}
+): WorkOptions => {
+  const workerOptions: WorkOptions = {}
 
   if (workerConfig?.batchSize !== undefined) {
     workerOptions.batchSize = workerConfig.batchSize
@@ -123,26 +123,15 @@ export class PgBossQueueWorkers implements QueueWorkers {
   private activeWorkers = new Map<string, string>()
 
   constructor(
-    options: PgBoss.ConstructorOptions | string,
+    pgBoss: PgBoss,
     private singletonServices: CoreSingletonServices,
-    private createSessionServices?: CreateSessionServices<
+    private createWireServices?: CreateWireServices<
       CoreSingletonServices,
       CoreServices,
       any
     >
   ) {
-    if (typeof options === 'string') {
-      // If a string is provided, treat it as the connection string
-      options = { connectionString: options }
-    }
-    this.pgBoss = new PgBoss(options)
-  }
-
-  /**
-   * Initialize pg-boss
-   */
-  async init(): Promise<void> {
-    await this.pgBoss.start()
+    this.pgBoss = pgBoss
   }
 
   /**
@@ -173,7 +162,7 @@ export class PgBossQueueWorkers implements QueueWorkers {
             try {
               await runQueueJob({
                 singletonServices: this.singletonServices,
-                createSessionServices: this.createSessionServices,
+                createWireServices: this.createWireServices,
                 job: mapPgBossJobToQueueJob(job, this.pgBoss),
               })
             } catch (error: unknown) {
@@ -195,11 +184,4 @@ export class PgBossQueueWorkers implements QueueWorkers {
       }
     )
   }
-
-  /**
-   * Close all workers and connections
-   */
-  async close(): Promise<void> {
-    await this.pgBoss.stop()
-  }
 }

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

@@ -0,0 +1,121 @@
+import { PgBoss } from 'pg-boss'
+import {
+  SchedulerService,
+  ScheduledTaskInfo,
+  ScheduledTaskSummary,
+  CoreUserSession,
+  parseDurationString,
+} from '@pikku/core'
+
+/**
+ * Data stored in scheduled job
+ */
+interface ScheduledJobData {
+  rpcName: string
+  data?: any
+  session?: CoreUserSession
+}
+
+/**
+ * pg-boss scheduler service implementation
+ * Uses pg-boss's schedule() API to store recurring jobs in PostgreSQL
+ */
+export class PgBossSchedulerService extends SchedulerService {
+  constructor(private pgBoss: PgBoss) {
+    super()
+  }
+
+  /**
+   * Initialize - no-op as pg-boss is already initialized by factory
+   */
+  async init(): Promise<void> {
+    // No-op - pg-boss is already initialized by factory
+  }
+
+  /**
+   * Schedule a one-off delayed RPC call
+   * Uses pg-boss send() with startAfter for one-time execution
+   */
+  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 send() with startAfter for one-off delayed execution
+    const taskId = await this.pgBoss.send(
+      'pikku-remote-internal-rpc',
+      jobData,
+      {
+        startAfter: new Date(Date.now() + delayMs),
+        singletonKey: `${rpcName}-${Date.now()}`, // Ensure uniqueness
+      }
+    )
+
+    if (!taskId) {
+      throw new Error('Failed to schedule RPC')
+    }
+
+    return taskId
+  }
+
+  /**
+   * Unschedule (cancel) a task by ID
+   */
+  async unschedule(taskId: string): Promise<boolean> {
+    await this.pgBoss.cancel('pikku-remote-internal-rpc', taskId)
+    return true
+  }
+
+  /**
+   * Get a scheduled task by ID with full details
+   */
+  async getTask(taskId: string): Promise<ScheduledTaskInfo | null> {
+    const job = await this.pgBoss.getJobById(
+      'pikku-remote-internal-rpc',
+      taskId
+    )
+
+    if (!job) {
+      return null
+    }
+
+    const jobData = job.data as ScheduledJobData
+
+    return {
+      taskId: job.id,
+      rpcName: jobData.rpcName,
+      scheduledFor: job.startAfter || job.createdOn,
+      data: jobData.data,
+      session: jobData.session,
+      status: job.state as any,
+    }
+  }
+
+  /**
+   * Get all scheduled tasks with minimal info
+   */
+  async getAllTasks(): Promise<ScheduledTaskSummary[]> {
+    // pg-boss doesn't have a simple way to list all pending jobs
+    // This would require querying the database directly or maintaining a separate index
+    // For now, return empty array - can be implemented if needed
+    return []
+  }
+
+  /**
+   * Close - no-op as pg-boss lifecycle is managed by factory
+   */
+  async close(): Promise<void> {
+    // No-op - pg-boss lifecycle is managed by factory
+  }
+}

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

@@ -0,0 +1,94 @@
+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'
+
+/**
+ * Factory class for pg-boss services
+ * Manages a single PgBoss instance shared across queue, worker, and scheduler services
+ */
+export class PgBossServiceFactory {
+  private pgBoss: PgBoss
+  private queueService?: PgBossQueueService
+  private queueWorkers?: PgBossQueueWorkers
+  private schedulerService?: PgBossSchedulerService
+  private initialized = false
+
+  constructor(optionsOrInstance: ConstructorOptions | string | PgBoss) {
+    if (optionsOrInstance instanceof PgBoss) {
+      this.pgBoss = optionsOrInstance
+    } else {
+      const options =
+        typeof optionsOrInstance === 'string'
+          ? { connectionString: optionsOrInstance }
+          : optionsOrInstance
+      this.pgBoss = new PgBoss(options)
+    }
+  }
+
+  /**
+   * Initialize the pg-boss instance
+   */
+  async init(): Promise<void> {
+    if (!this.initialized) {
+      await this.pgBoss.start()
+      this.initialized = true
+    }
+  }
+
+  /**
+   * Get the queue service for publishing jobs
+   */
+  getQueueService(): PgBossQueueService {
+    if (!this.queueService) {
+      this.queueService = new PgBossQueueService(this.pgBoss)
+    }
+    return this.queueService
+  }
+
+  /**
+   * Get the queue workers for processing jobs
+   */
+  getQueueWorkers(
+    singletonServices: CoreSingletonServices,
+    createWireServices?: CreateWireServices<
+      CoreSingletonServices,
+      CoreServices,
+      any
+    >
+  ): PgBossQueueWorkers {
+    if (!this.queueWorkers) {
+      this.queueWorkers = new PgBossQueueWorkers(
+        this.pgBoss,
+        singletonServices,
+        createWireServices
+      )
+    }
+    return this.queueWorkers
+  }
+
+  /**
+   * Get the scheduler service for managing recurring tasks
+   */
+  getSchedulerService(): PgBossSchedulerService {
+    if (!this.schedulerService) {
+      this.schedulerService = new PgBossSchedulerService(this.pgBoss)
+    }
+    return this.schedulerService
+  }
+
+  /**
+   * Close all services and the pg-boss connection
+   */
+  async close(): Promise<void> {
+    if (this.initialized) {
+      await this.pgBoss.stop()
+      this.initialized = false
+    }
+  }
+}

package/src/utils.ts

@@ -1,5 +1,5 @@
 import { QueueJob, QueueJobStatus } from '@pikku/core/queue'
-import PgBoss from 'pg-boss'
+import { PgBoss, type JobWithMetadata } from 'pg-boss'
 
 /**
  * Map pg-boss job state to our queue job status
@@ -26,7 +26,7 @@ const mapPgBossStateToStatus = (state: string): QueueJobStatus => {
  * Map pg-boss job to QueueJob interface
  */
 export const mapPgBossJobToQueueJob = <In, Out>(
-  pgBossJob: PgBoss.JobWithMetadata<In>,
+  pgBossJob: JobWithMetadata<In>,
   pgBossInstance: PgBoss
 ): QueueJob<In, Out> => {
   return {

package/tsconfig.tsbuildinfo

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