@lucaapp/service-utils 5.6.1 → 5.7.0

package/dist/index.d.ts

@@ -21,4 +21,5 @@ export * from './lib/jobs';
 export * from './lib/validation';
 export * from './lib/s3';
 export * from './lib/iso3166';
+export * from './lib/pgBoss';
 export * from './types';

package/dist/index.js

@@ -37,4 +37,5 @@ __exportStar(require("./lib/jobs"), exports);
 __exportStar(require("./lib/validation"), exports);
 __exportStar(require("./lib/s3"), exports);
 __exportStar(require("./lib/iso3166"), exports);
+__exportStar(require("./lib/pgBoss"), exports);
 __exportStar(require("./types"), exports);

package/dist/lib/api/api.d.ts

@@ -37,7 +37,7 @@ export declare class Api {
     patch<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBodySchema extends ZodObjectSchemaOrUndefined = undefined, TRequestParamsSchema extends ZodObjectSchemaOrUndefined = undefined, TRequestQuerySchema extends ZodObjectSchemaOrUndefined = undefined, TRequestHeadersSchema extends ZodObjectSchemaOrUndefined = undefined, TMiddlewares extends ReadonlyArray<Middleware<any, any, any, any, any, any>> | undefined = undefined>(path: string, summary: string, options: EndpointOptions<TResponseSchemas, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TMiddlewares>, handler: EndpointHandler<TResponseSchemas, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TMiddlewares>): void;
     put<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBodySchema extends ZodObjectSchemaOrUndefined = undefined, TRequestParamsSchema extends ZodObjectSchemaOrUndefined = undefined, TRequestQuerySchema extends ZodObjectSchemaOrUndefined = undefined, TRequestHeadersSchema extends ZodObjectSchemaOrUndefined = undefined, TMiddlewares extends ReadonlyArray<Middleware<any, any, any, any, any, any>> | undefined = undefined>(path: string, summary: string, options: EndpointOptions<TResponseSchemas, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TMiddlewares>, handler: EndpointHandler<TResponseSchemas, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TMiddlewares>): void;
     delete<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBodySchema extends ZodObjectSchemaOrUndefined = undefined, TRequestParamsSchema extends ZodObjectSchemaOrUndefined = undefined, TRequestQuerySchema extends ZodObjectSchemaOrUndefined = undefined, TRequestHeadersSchema extends ZodObjectSchemaOrUndefined = undefined, TMiddlewares extends ReadonlyArray<Middleware<any, any, any, any, any, any>> | undefined = undefined>(path: string, summary: string, options: EndpointOptions<TResponseSchemas, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TMiddlewares>, handler: EndpointHandler<TResponseSchemas, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TMiddlewares>): void;
-    generateOpenAPISpec(): import("openapi3-ts/oas30").OpenAPIObject | import("openapi3-ts/oas31").OpenAPIObject;
+    generateOpenAPISpec(): import('openapi3-ts/oas30').OpenAPIObject | import('openapi3-ts/oas31').OpenAPIObject;
     mountSwaggerMiddlewares(): void;
 }
 export {};

package/dist/lib/lifecycle/index.d.ts

@@ -6,12 +6,12 @@ declare class Lifecycle {
     private readonly shutdownDelay;
     private readonly logger;
     constructor(shutdownDelay: number, logger: Logger);
-    shutdownHandlers: Array<() => void>;
+    shutdownHandlers: Array<() => void | Promise<void>>;
     gracefulShutdown: (isImmediate?: boolean) => Promise<void>;
     private sigtermHandler;
     unhandledRejectionHandler: (error: unknown) => void;
     uncaughtExceptionHandler: (error: unknown) => void;
-    registerShutdownHandler: (shutdownHandler: () => void) => void;
+    registerShutdownHandler: (shutdownHandler: () => void | Promise<void>) => void;
     registerHooks: () => void;
 }
 export { Lifecycle };

package/dist/lib/lifecycle/index.js

@@ -22,7 +22,7 @@ class Lifecycle {
             }
             this.logger.info('starting shutdown');
             for (const shutdownHandler of this.shutdownHandlers) {
-                shutdownHandler();
+                await shutdownHandler();
             }
             this.logger.info('shutdown complete');
         };

package/dist/lib/pgBoss/config.d.ts

@@ -0,0 +1,7 @@
+import type { PgBossConfig } from './types';
+export declare const PG_BOSS_DEFAULTS: {
+    readonly maxConnectionPoolSize: 3;
+    readonly deleteAfterDays: 30;
+    readonly applicationName: "pgboss";
+};
+export declare const buildPgBossDefaults: (config: PgBossConfig) => Required<PgBossConfig>;

package/dist/lib/pgBoss/config.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPgBossDefaults = exports.PG_BOSS_DEFAULTS = void 0;
+exports.PG_BOSS_DEFAULTS = {
+    maxConnectionPoolSize: 3,
+    deleteAfterDays: 30,
+    applicationName: 'pgboss',
+};
+const buildPgBossDefaults = (config) => ({
+    maxConnectionPoolSize: exports.PG_BOSS_DEFAULTS.maxConnectionPoolSize,
+    deleteAfterDays: exports.PG_BOSS_DEFAULTS.deleteAfterDays,
+    applicationName: exports.PG_BOSS_DEFAULTS.applicationName,
+    mattermostWebhookUrl: '',
+    ...config,
+});
+exports.buildPgBossDefaults = buildPgBossDefaults;

package/dist/lib/pgBoss/controller/routes.d.ts

@@ -0,0 +1,20 @@
+import { Api } from '../../api/api';
+import { PgBossService } from '../service';
+/**
+ * Mounts pg-boss dashboard API routes onto an Api instance.
+ *
+ * Endpoints:
+ * - GET  /queues                          — list queues with stats
+ * - GET  /queues/:name/jobs               — list jobs in a queue
+ * - GET  /queues/:queue/jobs/:id          — job detail
+ * - POST /queues/:queue/jobs/:id/retry    — retry a job
+ * - POST /queues/:queue/jobs/:id/cancel   — cancel a job
+ * - DELETE /queues/:queue/jobs/:id        — delete a job
+ * - GET  /schedules                       — list cron schedules
+ * - POST /schedules                       — create a schedule
+ * - PUT  /schedules/:name                 — update a schedule
+ * - DELETE /schedules/:name               — delete a schedule
+ * - POST /queues/:name/jobs               — enqueue a new job
+ * - GET  /warnings                        — recent warnings
+ */
+export declare const mountPgBossApiRoutes: (api: Api, service: PgBossService) => void;

package/dist/lib/pgBoss/controller/routes.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mountPgBossApiRoutes = void 0;
+const send_1 = require("../../api/send");
+const response_1 = require("../../api/response");
+const routes_schema_1 = require("./routes.schema");
+/**
+ * Mounts pg-boss dashboard API routes onto an Api instance.
+ *
+ * Endpoints:
+ * - GET  /queues                          — list queues with stats
+ * - GET  /queues/:name/jobs               — list jobs in a queue
+ * - GET  /queues/:queue/jobs/:id          — job detail
+ * - POST /queues/:queue/jobs/:id/retry    — retry a job
+ * - POST /queues/:queue/jobs/:id/cancel   — cancel a job
+ * - DELETE /queues/:queue/jobs/:id        — delete a job
+ * - GET  /schedules                       — list cron schedules
+ * - POST /schedules                       — create a schedule
+ * - PUT  /schedules/:name                 — update a schedule
+ * - DELETE /schedules/:name               — delete a schedule
+ * - POST /queues/:name/jobs               — enqueue a new job
+ * - GET  /warnings                        — recent warnings
+ */
+const mountPgBossApiRoutes = (api, service) => {
+    const pgBossApi = api.child({ tags: ['PgBoss'] });
+    // GET /queues — list queues with stats
+    pgBossApi.get('/queues', 'List all queues with stats', {
+        responses: [(0, response_1.okResponse)(routes_schema_1.queueStatsArraySchema)],
+    }, async (_request, _context, respond) => {
+        const stats = await service.getQueueStats();
+        return respond((0, send_1.ok)(stats));
+    });
+    // GET /queues/:name/jobs — list jobs in a queue
+    pgBossApi.get('/queues/:name/jobs', 'List jobs in a queue', {
+        responses: [(0, response_1.okResponse)(routes_schema_1.jobArraySchema)],
+        schemas: {
+            params: routes_schema_1.queueNameParamsSchema,
+        },
+    }, async (request, _context, respond) => {
+        const jobs = await service.listJobs(request.params.name);
+        return respond((0, send_1.ok)(jobs));
+    });
+    // GET /queues/:queue/jobs/:id — job detail
+    pgBossApi.get('/queues/:queue/jobs/:id', 'Get job details', {
+        responses: [(0, response_1.okResponse)(routes_schema_1.jobDetailSchema)],
+        schemas: {
+            params: routes_schema_1.queueJobParamsSchema,
+        },
+    }, async (request, _context, respond) => {
+        const { queue, id } = request.params;
+        const job = await service.getJob(queue, id);
+        if (!job) {
+            throw new Error('Job not found');
+        }
+        return respond((0, send_1.ok)(job));
+    });
+    // POST /queues/:queue/jobs/:id/retry — retry a failed job
+    pgBossApi.post('/queues/:queue/jobs/:id/retry', 'Retry a failed job', {
+        responses: [(0, response_1.okResponse)(routes_schema_1.successResponseSchema)],
+        schemas: {
+            params: routes_schema_1.queueJobParamsSchema,
+        },
+    }, async (request, _context, respond) => {
+        const { queue, id } = request.params;
+        await service.retryJob(queue, id);
+        return respond((0, send_1.ok)({ success: true, jobId: id }));
+    });
+    // POST /queues/:queue/jobs/:id/cancel — cancel a job
+    pgBossApi.post('/queues/:queue/jobs/:id/cancel', 'Cancel a job', {
+        responses: [(0, response_1.okResponse)(routes_schema_1.successResponseSchema)],
+        schemas: {
+            params: routes_schema_1.queueJobParamsSchema,
+        },
+    }, async (request, _context, respond) => {
+        const { queue, id } = request.params;
+        await service.cancelJob(queue, id);
+        return respond((0, send_1.ok)({ success: true, jobId: id }));
+    });
+    // DELETE /queues/:queue/jobs/:id — delete a job
+    pgBossApi.delete('/queues/:queue/jobs/:id', 'Delete a job', {
+        responses: [(0, response_1.okResponse)(routes_schema_1.successResponseSchema)],
+        schemas: {
+            params: routes_schema_1.queueJobParamsSchema,
+        },
+    }, async (request, _context, respond) => {
+        const { queue, id } = request.params;
+        await service.deleteJob(queue, id);
+        return respond((0, send_1.ok)({ success: true, deleted: id }));
+    });
+    // GET /schedules — list cron schedules
+    pgBossApi.get('/schedules', 'List all cron schedules', {
+        responses: [(0, response_1.okResponse)(routes_schema_1.scheduleArraySchema)],
+    }, async (_request, _context, respond) => {
+        const schedules = await service.getSchedules();
+        return respond((0, send_1.ok)(schedules));
+    });
+    // POST /schedules — create a cron schedule
+    pgBossApi.post('/schedules', 'Create a cron schedule', {
+        responses: [(0, response_1.createdResponse)(routes_schema_1.successResponseSchema)],
+        schemas: {
+            body: routes_schema_1.scheduleBodySchema,
+        },
+    }, async (request, _context, respond) => {
+        const { name, cron, data, options } = request.body;
+        await service.createSchedule(name, cron, data, options);
+        return respond((0, send_1.created)({ success: true, name }));
+    });
+    // PUT /schedules/:name — update a cron schedule
+    pgBossApi.put('/schedules/:name', 'Update a cron schedule', {
+        responses: [(0, response_1.okResponse)(routes_schema_1.successResponseSchema)],
+        schemas: {
+            params: routes_schema_1.scheduleNameParamsSchema,
+            body: routes_schema_1.updateScheduleBodySchema,
+        },
+    }, async (request, _context, respond) => {
+        const { cron, data, options } = request.body;
+        await service.updateSchedule(request.params.name, cron, data, options);
+        return respond((0, send_1.ok)({ success: true, name: request.params.name }));
+    });
+    // DELETE /schedules/:name — delete a cron schedule
+    pgBossApi.delete('/schedules/:name', 'Delete a cron schedule', {
+        responses: [(0, response_1.okResponse)(routes_schema_1.successResponseSchema)],
+        schemas: {
+            params: routes_schema_1.scheduleNameParamsSchema,
+        },
+    }, async (request, _context, respond) => {
+        await service.deleteSchedule(request.params.name);
+        return respond((0, send_1.ok)({ success: true, deleted: request.params.name }));
+    });
+    // POST /queues/:name/jobs — enqueue a new job
+    pgBossApi.post('/queues/:name/jobs', 'Enqueue a new job', {
+        responses: [(0, response_1.createdResponse)(routes_schema_1.successResponseSchema)],
+        schemas: {
+            params: routes_schema_1.queueNameParamsSchema,
+            body: routes_schema_1.enqueueBodySchema,
+        },
+    }, async (request, _context, respond) => {
+        const { data, options } = request.body;
+        const jobId = await service.enqueueJob(request.params.name, data, options);
+        return respond((0, send_1.created)({ success: true, jobId: jobId ?? undefined }));
+    });
+    // GET /warnings — recent warnings
+    pgBossApi.get('/warnings', 'List recent warnings', {
+        responses: [(0, response_1.okResponse)(routes_schema_1.warningArraySchema)],
+        schemas: {
+            query: routes_schema_1.warningsQuerySchema,
+        },
+    }, async (request, _context, respond) => {
+        const warnings = await service.getWarnings(request.query.limit);
+        return respond((0, send_1.ok)(warnings));
+    });
+};
+exports.mountPgBossApiRoutes = mountPgBossApiRoutes;

package/dist/lib/pgBoss/controller/routes.schema.d.ts

@@ -0,0 +1,161 @@
+import { z } from 'zod';
+export declare const queueNameParamsSchema: z.ZodObject<{
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+}, {
+    name: string;
+}>;
+export declare const queueJobParamsSchema: z.ZodObject<{
+    queue: z.ZodString;
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    queue: string;
+}, {
+    id: string;
+    queue: string;
+}>;
+export declare const scheduleNameParamsSchema: z.ZodObject<{
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+}, {
+    name: string;
+}>;
+export declare const warningsQuerySchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+}, {
+    limit?: number | undefined;
+}>;
+export declare const enqueueBodySchema: z.ZodObject<{
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    options?: Record<string, unknown> | undefined;
+    data?: Record<string, unknown> | undefined;
+}, {
+    options?: Record<string, unknown> | undefined;
+    data?: Record<string, unknown> | undefined;
+}>;
+export declare const scheduleBodySchema: z.ZodObject<{
+    name: z.ZodString;
+    cron: z.ZodString;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    cron: string;
+    options?: Record<string, unknown> | undefined;
+    data?: Record<string, unknown> | undefined;
+}, {
+    name: string;
+    cron: string;
+    options?: Record<string, unknown> | undefined;
+    data?: Record<string, unknown> | undefined;
+}>;
+export declare const updateScheduleBodySchema: z.ZodObject<{
+    cron: z.ZodString;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    cron: string;
+    options?: Record<string, unknown> | undefined;
+    data?: Record<string, unknown> | undefined;
+}, {
+    cron: string;
+    options?: Record<string, unknown> | undefined;
+    data?: Record<string, unknown> | undefined;
+}>;
+export declare const queueStatsSchema: z.ZodObject<{
+    name: z.ZodString;
+    policy: z.ZodOptional<z.ZodString>;
+    retryLimit: z.ZodOptional<z.ZodNumber>;
+    retryDelay: z.ZodOptional<z.ZodNumber>;
+    retryBackoff: z.ZodOptional<z.ZodBoolean>;
+    expireInSeconds: z.ZodOptional<z.ZodNumber>;
+    deadLetter: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    queuedCount: z.ZodNumber;
+    activeCount: z.ZodNumber;
+    totalCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    queuedCount: number;
+    activeCount: number;
+    totalCount: number;
+    retryDelay?: number | undefined;
+    policy?: string | undefined;
+    retryLimit?: number | undefined;
+    retryBackoff?: boolean | undefined;
+    expireInSeconds?: number | undefined;
+    deadLetter?: string | null | undefined;
+}, {
+    name: string;
+    queuedCount: number;
+    activeCount: number;
+    totalCount: number;
+    retryDelay?: number | undefined;
+    policy?: string | undefined;
+    retryLimit?: number | undefined;
+    retryBackoff?: boolean | undefined;
+    expireInSeconds?: number | undefined;
+    deadLetter?: string | null | undefined;
+}>;
+export declare const queueStatsArraySchema: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    policy: z.ZodOptional<z.ZodString>;
+    retryLimit: z.ZodOptional<z.ZodNumber>;
+    retryDelay: z.ZodOptional<z.ZodNumber>;
+    retryBackoff: z.ZodOptional<z.ZodBoolean>;
+    expireInSeconds: z.ZodOptional<z.ZodNumber>;
+    deadLetter: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    queuedCount: z.ZodNumber;
+    activeCount: z.ZodNumber;
+    totalCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    queuedCount: number;
+    activeCount: number;
+    totalCount: number;
+    retryDelay?: number | undefined;
+    policy?: string | undefined;
+    retryLimit?: number | undefined;
+    retryBackoff?: boolean | undefined;
+    expireInSeconds?: number | undefined;
+    deadLetter?: string | null | undefined;
+}, {
+    name: string;
+    queuedCount: number;
+    activeCount: number;
+    totalCount: number;
+    retryDelay?: number | undefined;
+    policy?: string | undefined;
+    retryLimit?: number | undefined;
+    retryBackoff?: boolean | undefined;
+    expireInSeconds?: number | undefined;
+    deadLetter?: string | null | undefined;
+}>, "many">;
+export declare const jobDetailSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export declare const jobArraySchema: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+export declare const scheduleSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export declare const scheduleArraySchema: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+export declare const warningSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export declare const warningArraySchema: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+export declare const successResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    jobId: z.ZodOptional<z.ZodString>;
+    deleted: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    name?: string | undefined;
+    jobId?: string | undefined;
+    deleted?: string | undefined;
+}, {
+    success: boolean;
+    name?: string | undefined;
+    jobId?: string | undefined;
+    deleted?: string | undefined;
+}>;

package/dist/lib/pgBoss/controller/routes.schema.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.successResponseSchema = exports.warningArraySchema = exports.warningSchema = exports.scheduleArraySchema = exports.scheduleSchema = exports.jobArraySchema = exports.jobDetailSchema = exports.queueStatsArraySchema = exports.queueStatsSchema = exports.updateScheduleBodySchema = exports.scheduleBodySchema = exports.enqueueBodySchema = exports.warningsQuerySchema = exports.scheduleNameParamsSchema = exports.queueJobParamsSchema = exports.queueNameParamsSchema = void 0;
+const zod_1 = require("zod");
+// ── Param schemas ────────────────────────────────────────────────────
+exports.queueNameParamsSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+});
+exports.queueJobParamsSchema = zod_1.z.object({
+    queue: zod_1.z.string(),
+    id: zod_1.z.string(),
+});
+exports.scheduleNameParamsSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+});
+// ── Query schemas ────────────────────────────────────────────────────
+exports.warningsQuerySchema = zod_1.z.object({
+    limit: zod_1.z.coerce.number().int().positive().optional().default(100),
+});
+// ── Body schemas ─────────────────────────────────────────────────────
+exports.enqueueBodySchema = zod_1.z.object({
+    data: zod_1.z.record(zod_1.z.unknown()).optional(),
+    options: zod_1.z.record(zod_1.z.unknown()).optional(),
+});
+exports.scheduleBodySchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    cron: zod_1.z.string(),
+    data: zod_1.z.record(zod_1.z.unknown()).optional(),
+    options: zod_1.z.record(zod_1.z.unknown()).optional(),
+});
+exports.updateScheduleBodySchema = zod_1.z.object({
+    cron: zod_1.z.string(),
+    data: zod_1.z.record(zod_1.z.unknown()).optional(),
+    options: zod_1.z.record(zod_1.z.unknown()).optional(),
+});
+// ── Response schemas ─────────────────────────────────────────────────
+exports.queueStatsSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    policy: zod_1.z.string().optional(),
+    retryLimit: zod_1.z.number().optional(),
+    retryDelay: zod_1.z.number().optional(),
+    retryBackoff: zod_1.z.boolean().optional(),
+    expireInSeconds: zod_1.z.number().optional(),
+    deadLetter: zod_1.z.string().nullable().optional(),
+    queuedCount: zod_1.z.number(),
+    activeCount: zod_1.z.number(),
+    totalCount: zod_1.z.number(),
+});
+exports.queueStatsArraySchema = zod_1.z.array(exports.queueStatsSchema);
+exports.jobDetailSchema = zod_1.z.record(zod_1.z.unknown());
+exports.jobArraySchema = zod_1.z.array(exports.jobDetailSchema);
+exports.scheduleSchema = zod_1.z.record(zod_1.z.unknown());
+exports.scheduleArraySchema = zod_1.z.array(exports.scheduleSchema);
+exports.warningSchema = zod_1.z.record(zod_1.z.unknown());
+exports.warningArraySchema = zod_1.z.array(exports.warningSchema);
+exports.successResponseSchema = zod_1.z.object({
+    success: zod_1.z.boolean(),
+    jobId: zod_1.z.string().optional(),
+    deleted: zod_1.z.string().optional(),
+    name: zod_1.z.string().optional(),
+});

package/dist/lib/pgBoss/helpers.d.ts

@@ -0,0 +1,15 @@
+import { PgBoss } from 'pg-boss';
+import type { SendOptions } from 'pg-boss';
+import type { Logger } from 'pino';
+import type { Sequelize, Transaction } from 'sequelize';
+/**
+ * Enqueue a job via pg-boss with logging.
+ */
+export declare const enqueueJob: (boss: PgBoss, queueName: string, data: object, options: SendOptions | undefined, logger: Logger) => Promise<string | null>;
+/**
+ * Enqueue a job inside an existing Sequelize transaction.
+ *
+ * Uses pg-boss's public `send()` API with a transactional database adapter
+ * instead of calling internal SQL functions directly.
+ */
+export declare const enqueueInTransaction: (boss: PgBoss, queueName: string, data: object, options: SendOptions, transaction: Transaction, sequelize: Sequelize) => Promise<string | null>;

package/dist/lib/pgBoss/helpers.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enqueueInTransaction = exports.enqueueJob = void 0;
+/**
+ * Enqueue a job via pg-boss with logging.
+ */
+const enqueueJob = async (boss, queueName, data, options = {}, logger) => {
+    const jobId = await boss.send(queueName, data, options);
+    logger.info({ queueName, jobId }, 'Job enqueued via pg-boss');
+    return jobId;
+};
+exports.enqueueJob = enqueueJob;
+/**
+ * Create a pg-boss–compatible database adapter backed by a Sequelize transaction.
+ *
+ * Bridges Sequelize's transaction with pg-boss's `ConnectionOptions.db`
+ * so that `boss.send()` executes within the same database transaction
+ * as surrounding Sequelize operations.
+ */
+const createTransactionalDb = (sequelize, transaction) => ({
+    executeSql: async (text, values) => {
+        const [results] = await sequelize.query(text, {
+            bind: values,
+            transaction,
+            raw: true,
+        });
+        return {
+            rows: Array.isArray(results)
+                ? results
+                : [],
+        };
+    },
+});
+/**
+ * Enqueue a job inside an existing Sequelize transaction.
+ *
+ * Uses pg-boss's public `send()` API with a transactional database adapter
+ * instead of calling internal SQL functions directly.
+ */
+const enqueueInTransaction = async (boss, queueName, data, options, transaction, sequelize) => {
+    const db = createTransactionalDb(sequelize, transaction);
+    return boss.send(queueName, data, { ...options, db });
+};
+exports.enqueueInTransaction = enqueueInTransaction;

package/dist/lib/pgBoss/index.d.ts

@@ -0,0 +1,29 @@
+import { PgBoss } from 'pg-boss';
+import type { Logger } from 'pino';
+import type { PgBossConfig } from './types';
+export { PgBoss };
+export type { PgBossConfig, QueueDefinition, WorkerRegistration, PgBossInstance, } from './types';
+export { PG_BOSS_DEFAULTS, buildPgBossDefaults } from './config';
+export { mountPgBossApiRoutes } from './controller/routes';
+export { PgBossService } from './service';
+export { registerPgBossMetrics } from './metrics';
+export { enqueueJob, enqueueInTransaction } from './helpers';
+export { sendDlqAlert } from './metrics';
+export interface PgBossContext {
+    boss: PgBoss;
+    logger: Logger;
+    config: Required<PgBossConfig>;
+}
+/**
+ * Creates a pg-boss instance with error recovery (auto-restart on connection loss).
+ * Issue #510 mitigation: on error, waits 5s then restarts.
+ */
+export declare const createPgBoss: (config: PgBossConfig, logger: Logger) => PgBossContext;
+/**
+ * Starts the pg-boss instance. Call after database is connected.
+ */
+export declare const startBoss: (ctx: PgBossContext) => Promise<void>;
+/**
+ * Gracefully stops the pg-boss instance. Suitable as a shutdown handler.
+ */
+export declare const stopBoss: (ctx: PgBossContext) => Promise<void>;

package/dist/lib/pgBoss/index.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopBoss = exports.startBoss = exports.createPgBoss = exports.sendDlqAlert = exports.enqueueInTransaction = exports.enqueueJob = exports.registerPgBossMetrics = exports.PgBossService = exports.mountPgBossApiRoutes = exports.buildPgBossDefaults = exports.PG_BOSS_DEFAULTS = exports.PgBoss = void 0;
+const pg_boss_1 = require("pg-boss");
+Object.defineProperty(exports, "PgBoss", { enumerable: true, get: function () { return pg_boss_1.PgBoss; } });
+const config_1 = require("./config");
+var config_2 = require("./config");
+Object.defineProperty(exports, "PG_BOSS_DEFAULTS", { enumerable: true, get: function () { return config_2.PG_BOSS_DEFAULTS; } });
+Object.defineProperty(exports, "buildPgBossDefaults", { enumerable: true, get: function () { return config_2.buildPgBossDefaults; } });
+var routes_1 = require("./controller/routes");
+Object.defineProperty(exports, "mountPgBossApiRoutes", { enumerable: true, get: function () { return routes_1.mountPgBossApiRoutes; } });
+var service_1 = require("./service");
+Object.defineProperty(exports, "PgBossService", { enumerable: true, get: function () { return service_1.PgBossService; } });
+var metrics_1 = require("./metrics");
+Object.defineProperty(exports, "registerPgBossMetrics", { enumerable: true, get: function () { return metrics_1.registerPgBossMetrics; } });
+var helpers_1 = require("./helpers");
+Object.defineProperty(exports, "enqueueJob", { enumerable: true, get: function () { return helpers_1.enqueueJob; } });
+Object.defineProperty(exports, "enqueueInTransaction", { enumerable: true, get: function () { return helpers_1.enqueueInTransaction; } });
+var metrics_2 = require("./metrics");
+Object.defineProperty(exports, "sendDlqAlert", { enumerable: true, get: function () { return metrics_2.sendDlqAlert; } });
+const RESTART_DELAY_MS = 5000;
+/**
+ * Creates a pg-boss instance with error recovery (auto-restart on connection loss).
+ * Issue #510 mitigation: on error, waits 5s then restarts.
+ */
+const createPgBoss = (config, logger) => {
+    const resolvedConfig = (0, config_1.buildPgBossDefaults)(config);
+    const boss = new pg_boss_1.PgBoss({
+        connectionString: resolvedConfig.connectionString,
+        schema: resolvedConfig.schema,
+        application_name: resolvedConfig.applicationName,
+        migrate: true,
+    });
+    boss.on('error', (error) => {
+        logger.error({ error }, 'pg-boss error — will attempt restart');
+        scheduleRestart(boss, logger);
+    });
+    boss.on('warning', warning => {
+        logger.warn({ warning }, 'pg-boss warning');
+    });
+    return { boss, logger, config: resolvedConfig };
+};
+exports.createPgBoss = createPgBoss;
+/**
+ * Starts the pg-boss instance. Call after database is connected.
+ */
+const startBoss = async (ctx) => {
+    ctx.logger.info({ schema: ctx.config.schema }, 'Starting pg-boss');
+    await ctx.boss.start();
+    ctx.logger.info({ schema: ctx.config.schema }, 'pg-boss started successfully');
+};
+exports.startBoss = startBoss;
+/**
+ * Gracefully stops the pg-boss instance. Suitable as a shutdown handler.
+ */
+const stopBoss = async (ctx) => {
+    ctx.logger.info({ schema: ctx.config.schema }, 'Stopping pg-boss');
+    await ctx.boss.stop({ graceful: true, timeout: 30_000 });
+    ctx.logger.info({ schema: ctx.config.schema }, 'pg-boss stopped');
+};
+exports.stopBoss = stopBoss;
+const scheduleRestart = (boss, logger) => {
+    setTimeout(async () => {
+        try {
+            logger.info('Attempting pg-boss restart after error');
+            await boss.start();
+            logger.info('pg-boss restarted successfully');
+        }
+        catch (restartError) {
+            logger.error({ error: restartError }, 'pg-boss restart failed — will retry');
+            scheduleRestart(boss, logger);
+        }
+    }, RESTART_DELAY_MS);
+};

package/dist/lib/pgBoss/metrics.d.ts

@@ -0,0 +1,15 @@
+import { PgBoss } from 'pg-boss';
+import type { Logger } from 'pino';
+/**
+ * Register Prometheus metrics by polling pg-boss queue stats.
+ *
+ * pg-boss v12 removed the `monitor-states` event, so we poll
+ * `getQueues()` + `getQueueStats()` on a timer instead.
+ *
+ * Returns the interval handle so callers can clear it on shutdown.
+ */
+export declare const registerPgBossMetrics: (boss: PgBoss, serviceName: string, logger: Logger, mattermostWebhookUrl?: string) => NodeJS.Timeout;
+/**
+ * Send a Mattermost alert for a dead-letter job.
+ */
+export declare const sendDlqAlert: (webhookUrl: string, queueName: string, jobId: string, error: string, logger: Logger) => Promise<void>;

package/dist/lib/pgBoss/metrics.js

@@ -0,0 +1,93 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendDlqAlert = exports.registerPgBossMetrics = void 0;
+const promClient = __importStar(require("prom-client"));
+const axios_1 = __importDefault(require("axios"));
+const queueDepth = new promClient.Gauge({
+    name: 'pgboss_queue_created_total',
+    help: 'Number of queued (pending) jobs per queue',
+    labelNames: ['queue', 'service'],
+});
+const queueActive = new promClient.Gauge({
+    name: 'pgboss_queue_active_total',
+    help: 'Number of active jobs per queue',
+    labelNames: ['queue', 'service'],
+});
+const queueTotal = new promClient.Gauge({
+    name: 'pgboss_queue_total',
+    help: 'Total number of jobs per queue (all states)',
+    labelNames: ['queue', 'service'],
+});
+const POLL_INTERVAL_MS = 30_000;
+/**
+ * Register Prometheus metrics by polling pg-boss queue stats.
+ *
+ * pg-boss v12 removed the `monitor-states` event, so we poll
+ * `getQueues()` + `getQueueStats()` on a timer instead.
+ *
+ * Returns the interval handle so callers can clear it on shutdown.
+ */
+const registerPgBossMetrics = (boss, serviceName, logger, mattermostWebhookUrl) => {
+    const collectMetrics = async () => {
+        try {
+            const queues = await boss.getQueues();
+            for (const queue of queues) {
+                const stats = await boss.getQueueStats(queue.name);
+                const labels = { queue: queue.name, service: serviceName };
+                queueDepth.set(labels, stats.queuedCount ?? 0);
+                queueActive.set(labels, stats.activeCount ?? 0);
+                queueTotal.set(labels, stats.totalCount ?? 0);
+            }
+        }
+        catch (error) {
+            logger.error({ error }, 'Failed to collect pg-boss metrics');
+        }
+    };
+    if (mattermostWebhookUrl) {
+        logger.info('Mattermost DLQ alerting enabled');
+    }
+    // Initial collection + interval
+    void collectMetrics();
+    return setInterval(collectMetrics, POLL_INTERVAL_MS);
+};
+exports.registerPgBossMetrics = registerPgBossMetrics;
+/**
+ * Send a Mattermost alert for a dead-letter job.
+ */
+const sendDlqAlert = async (webhookUrl, queueName, jobId, error, logger) => {
+    try {
+        await axios_1.default.post(webhookUrl, {
+            text: `🚨 **pg-boss DLQ Alert**\n**Queue:** \`${queueName}\`\n**Job ID:** \`${jobId}\`\n**Error:** ${error}`,
+        });
+    }
+    catch (webhookError) {
+        logger.error({ error: webhookError }, 'Failed to send Mattermost DLQ alert');
+    }
+};
+exports.sendDlqAlert = sendDlqAlert;

package/dist/lib/pgBoss/service/enqueue.d.ts

@@ -0,0 +1,3 @@
+import { PgBoss } from 'pg-boss';
+import type { Logger } from 'pino';
+export declare const enqueue: (boss: PgBoss, logger: Logger, queueName: string, data?: Record<string, unknown>, options?: Record<string, unknown>) => Promise<string | null>;

package/dist/lib/pgBoss/service/enqueue.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enqueue = void 0;
+const enqueue = async (boss, logger, queueName, data, options) => {
+    const jobId = await boss.send(queueName, data || {}, options || {});
+    logger.info({ queue: queueName, jobId }, 'Job enqueued');
+    return jobId;
+};
+exports.enqueue = enqueue;

package/dist/lib/pgBoss/service/getJob.d.ts

@@ -0,0 +1,2 @@
+import { PgBoss } from 'pg-boss';
+export declare const getJob: (boss: PgBoss, queueName: string, jobId: string) => Promise<Record<string, unknown> | null>;

package/dist/lib/pgBoss/service/getJob.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJob = void 0;
+const getJob = async (boss, queueName, jobId) => {
+    const jobs = await boss.findJobs(queueName, { id: jobId });
+    return jobs.length > 0 ? { ...jobs[0] } : null;
+};
+exports.getJob = getJob;

package/dist/lib/pgBoss/service/getQueueStats.d.ts

@@ -0,0 +1,14 @@
+import { PgBoss } from 'pg-boss';
+export interface QueueStats {
+    name: string;
+    policy?: string;
+    retryLimit?: number;
+    retryDelay?: number;
+    retryBackoff?: boolean;
+    expireInSeconds?: number;
+    deadLetter?: string | null;
+    queuedCount: number;
+    activeCount: number;
+    totalCount: number;
+}
+export declare const getQueueStats: (boss: PgBoss) => Promise<QueueStats[]>;

package/dist/lib/pgBoss/service/getQueueStats.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQueueStats = void 0;
+const getQueueStats = async (boss) => {
+    const queues = await boss.getQueues();
+    return Promise.all(queues.map(async (q) => {
+        const stats = await boss.getQueueStats(q.name);
+        return {
+            name: q.name,
+            policy: q.policy,
+            retryLimit: q.retryLimit,
+            retryDelay: q.retryDelay,
+            retryBackoff: q.retryBackoff,
+            expireInSeconds: q.expireInSeconds,
+            deadLetter: q.deadLetter,
+            queuedCount: stats.queuedCount,
+            activeCount: stats.activeCount,
+            totalCount: stats.totalCount,
+        };
+    }));
+};
+exports.getQueueStats = getQueueStats;

package/dist/lib/pgBoss/service/getWarnings.d.ts

@@ -0,0 +1,9 @@
+import { PgBoss } from 'pg-boss';
+/**
+ * Retrieve persisted warnings from the pg-boss warning table.
+ *
+ * pg-boss v12 persists warnings (slow queries, queue backlogs, clock skew)
+ * when `persistWarnings: true` is set. There is no public class method,
+ * so we query the warning table via `getDb()`.
+ */
+export declare const getWarnings: (boss: PgBoss, schema: string, limit?: number) => Promise<Record<string, unknown>[]>;

package/dist/lib/pgBoss/service/getWarnings.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWarnings = void 0;
+/**
+ * Retrieve persisted warnings from the pg-boss warning table.
+ *
+ * pg-boss v12 persists warnings (slow queries, queue backlogs, clock skew)
+ * when `persistWarnings: true` is set. There is no public class method,
+ * so we query the warning table via `getDb()`.
+ */
+const getWarnings = async (boss, schema, limit = 100) => {
+    const db = boss.getDb();
+    const result = await db.executeSql(`SELECT id, type, message, data, created_on
+     FROM "${schema}".warning
+     ORDER BY created_on DESC
+     LIMIT $1`, [limit]);
+    return result.rows;
+};
+exports.getWarnings = getWarnings;

package/dist/lib/pgBoss/service/listJobs.d.ts

@@ -0,0 +1,2 @@
+import { PgBoss } from 'pg-boss';
+export declare const listJobs: (boss: PgBoss, queueName: string) => Promise<Record<string, unknown>[]>;

package/dist/lib/pgBoss/service/listJobs.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listJobs = void 0;
+const listJobs = async (boss, queueName) => {
+    const jobs = await boss.findJobs(queueName);
+    return jobs.map(j => ({ ...j }));
+};
+exports.listJobs = listJobs;

package/dist/lib/pgBoss/service/manageJob.d.ts

@@ -0,0 +1,3 @@
+import { PgBoss } from 'pg-boss';
+import type { Logger } from 'pino';
+export declare const manageJob: (boss: PgBoss, logger: Logger, action: "retry" | "cancel" | "delete", queueName: string, jobId: string) => Promise<void>;

package/dist/lib/pgBoss/service/manageJob.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageJob = void 0;
+const manageJob = async (boss, logger, action, queueName, jobId) => {
+    switch (action) {
+        case 'retry':
+            await boss.resume(queueName, jobId);
+            break;
+        case 'cancel':
+            await boss.cancel(queueName, jobId);
+            break;
+        case 'delete':
+            await boss.deleteJob(queueName, jobId);
+            break;
+    }
+    logger.info({ queue: queueName, jobId, action }, `Job ${action} completed`);
+};
+exports.manageJob = manageJob;

package/dist/lib/pgBoss/service/schedules.d.ts

@@ -0,0 +1,6 @@
+import { PgBoss } from 'pg-boss';
+import type { Logger } from 'pino';
+export declare const getSchedules: (boss: PgBoss) => Promise<Record<string, unknown>[]>;
+export declare const createSchedule: (boss: PgBoss, logger: Logger, name: string, cron: string, data?: Record<string, unknown>, options?: Record<string, unknown>) => Promise<void>;
+export declare const updateSchedule: (boss: PgBoss, logger: Logger, name: string, cron: string, data?: Record<string, unknown>, options?: Record<string, unknown>) => Promise<void>;
+export declare const deleteSchedule: (boss: PgBoss, logger: Logger, name: string) => Promise<void>;

package/dist/lib/pgBoss/service/schedules.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteSchedule = exports.updateSchedule = exports.createSchedule = exports.getSchedules = void 0;
+const getSchedules = async (boss) => {
+    const schedules = await boss.getSchedules();
+    return schedules.map(s => ({ ...s }));
+};
+exports.getSchedules = getSchedules;
+const createSchedule = async (boss, logger, name, cron, data, options) => {
+    await boss.schedule(name, cron, data || {}, options || {});
+    logger.info({ name, cron }, 'Schedule created');
+};
+exports.createSchedule = createSchedule;
+const updateSchedule = async (boss, logger, name, cron, data, options) => {
+    await boss.unschedule(name);
+    await boss.schedule(name, cron, data || {}, options || {});
+    logger.info({ name, cron }, 'Schedule updated');
+};
+exports.updateSchedule = updateSchedule;
+const deleteSchedule = async (boss, logger, name) => {
+    await boss.unschedule(name);
+    logger.info({ name }, 'Schedule deleted');
+};
+exports.deleteSchedule = deleteSchedule;

package/dist/lib/pgBoss/service.d.ts

@@ -0,0 +1,20 @@
+import { PgBoss } from 'pg-boss';
+import type { Logger } from 'pino';
+export declare class PgBossService {
+    private readonly boss;
+    private readonly logger;
+    private readonly schema;
+    constructor(boss: PgBoss, logger: Logger, schema?: string);
+    getQueueStats: () => Promise<import("./service/getQueueStats").QueueStats[]>;
+    listJobs: (queueName: string) => Promise<Record<string, unknown>[]>;
+    getJob: (queueName: string, jobId: string) => Promise<Record<string, unknown> | null>;
+    retryJob: (queueName: string, jobId: string) => Promise<void>;
+    cancelJob: (queueName: string, jobId: string) => Promise<void>;
+    deleteJob: (queueName: string, jobId: string) => Promise<void>;
+    getSchedules: () => Promise<Record<string, unknown>[]>;
+    createSchedule: (name: string, cron: string, data?: Record<string, unknown>, options?: Record<string, unknown>) => Promise<void>;
+    updateSchedule: (name: string, cron: string, data?: Record<string, unknown>, options?: Record<string, unknown>) => Promise<void>;
+    deleteSchedule: (name: string) => Promise<void>;
+    enqueueJob: (queueName: string, data?: Record<string, unknown>, options?: Record<string, unknown>) => Promise<string | null>;
+    getWarnings: (limit?: number) => Promise<Record<string, unknown>[]>;
+}

package/dist/lib/pgBoss/service.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgBossService = void 0;
+const getQueueStats_1 = require("./service/getQueueStats");
+const listJobs_1 = require("./service/listJobs");
+const getJob_1 = require("./service/getJob");
+const manageJob_1 = require("./service/manageJob");
+const schedules_1 = require("./service/schedules");
+const enqueue_1 = require("./service/enqueue");
+const getWarnings_1 = require("./service/getWarnings");
+class PgBossService {
+    constructor(boss, logger, schema = 'pgboss') {
+        this.boss = boss;
+        this.logger = logger;
+        this.schema = schema;
+        this.getQueueStats = () => (0, getQueueStats_1.getQueueStats)(this.boss);
+        this.listJobs = (queueName) => (0, listJobs_1.listJobs)(this.boss, queueName);
+        this.getJob = (queueName, jobId) => (0, getJob_1.getJob)(this.boss, queueName, jobId);
+        this.retryJob = (queueName, jobId) => (0, manageJob_1.manageJob)(this.boss, this.logger, 'retry', queueName, jobId);
+        this.cancelJob = (queueName, jobId) => (0, manageJob_1.manageJob)(this.boss, this.logger, 'cancel', queueName, jobId);
+        this.deleteJob = (queueName, jobId) => (0, manageJob_1.manageJob)(this.boss, this.logger, 'delete', queueName, jobId);
+        this.getSchedules = () => (0, schedules_1.getSchedules)(this.boss);
+        this.createSchedule = (name, cron, data, options) => (0, schedules_1.createSchedule)(this.boss, this.logger, name, cron, data, options);
+        this.updateSchedule = (name, cron, data, options) => (0, schedules_1.updateSchedule)(this.boss, this.logger, name, cron, data, options);
+        this.deleteSchedule = (name) => (0, schedules_1.deleteSchedule)(this.boss, this.logger, name);
+        this.enqueueJob = (queueName, data, options) => (0, enqueue_1.enqueue)(this.boss, this.logger, queueName, data, options);
+        this.getWarnings = (limit) => (0, getWarnings_1.getWarnings)(this.boss, this.schema, limit);
+    }
+}
+exports.PgBossService = PgBossService;

package/dist/lib/pgBoss/types.d.ts

@@ -0,0 +1,26 @@
+import type { QueueOptions, Job, WorkOptions } from 'pg-boss';
+import type { PgBoss } from 'pg-boss';
+export type { SendOptions, QueueOptions, WorkOptions, Job } from 'pg-boss';
+export interface PgBossConfig {
+    enabled: boolean;
+    connectionString: string;
+    schema: string;
+    /** Max connections in the pg-boss pool. Default: 3 */
+    maxConnectionPoolSize?: number;
+    /** Days to keep completed/failed jobs. Default: 30 (GDPR-aligned) */
+    deleteAfterDays?: number;
+    /** Application name for PG connections. Default: "pgboss" */
+    applicationName?: string;
+    /** Mattermost webhook URL for DLQ alerts (optional) */
+    mattermostWebhookUrl?: string;
+}
+export interface QueueDefinition {
+    name: string;
+    options?: QueueOptions;
+}
+export interface WorkerRegistration<T = object> {
+    queue: string;
+    handler: (job: Job<T>[]) => Promise<void>;
+    options?: WorkOptions;
+}
+export type PgBossInstance = PgBoss;

package/dist/lib/pgBoss/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/serviceIdentity/environment.d.ts

@@ -10,6 +10,7 @@ declare enum Environment {
     P4 = "p4",
     P5 = "p5",
     P6 = "p6",
+    P7 = "p7",
     PREPROD = "preprod",
     PROD = "prod"
 }

package/dist/lib/serviceIdentity/environment.js

@@ -14,6 +14,7 @@ var Environment;
     Environment["P4"] = "p4";
     Environment["P5"] = "p5";
     Environment["P6"] = "p6";
+    Environment["P7"] = "p7";
     Environment["PREPROD"] = "preprod";
     Environment["PROD"] = "prod";
 })(Environment || (exports.Environment = Environment = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucaapp/service-utils",
-  "version": "5.6.1",
+  "version": "5.7.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -15,11 +15,11 @@
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "test:ci": "VITEST_JUNIT_SUITE_NAME=service-utils CI=true vitest run --coverage",
-    "audit": "improved-yarn-audit --ignore-dev-deps"
+    "audit": "sh ../../scripts/cached-audit.sh improved-yarn-audit --ignore-dev-deps"
   },
   "dependencies": {
     "@apidevtools/swagger-parser": "10.0.3",
-    "@asteasolutions/zod-to-openapi": "6.1.0",
+    "@asteasolutions/zod-to-openapi": "7.3.4",
     "@aws-sdk/client-s3": "^3.993.0",
     "@aws-sdk/lib-storage": "^3.993.0",
     "@hapi/boom": "^10.0.1",
@@ -57,7 +57,8 @@
     "url-value-parser": "^2.2.0",
     "uuid": "^9.0.0",
     "validator": "13.15.23",
-    "zod": "3.24.1"
+    "zod": "3.24.1",
+    "pg-boss": "12.14.0"
   },
   "devDependencies": {
     "@types/busboy": "^1.5.4",
@@ -68,25 +69,31 @@
     "@types/uuid": "^8.3.4",
     "@typescript-eslint/eslint-plugin": "^7.15.0",
     "@typescript-eslint/parser": "^7.15.0",
-    "@vitest/coverage-v8": "3.2.4",
+    "@vitest/coverage-v8": "4.1.1",
     "conventional-changelog-conventionalcommits": "^8.0.0",
     "eslint": "8.57.0",
     "eslint-plugin-prettier": "4.2.1",
     "eslint-plugin-vitest": "0.4.1",
     "improved-yarn-audit": "^3.0.4",
     "prettier": "2.7.1",
-    "semantic-release": "^19.0.5",
+    "semantic-release": "^25.0.3",
     "semantic-release-monorepo": "8.0.2",
     "supertest": "^6.3.3",
     "typescript": "5.5.3",
     "vite-tsconfig-paths": "4.3.2",
-    "vitest": "3.2.4"
+    "vitest": "4.1.1"
   },
   "resolutions": {
     "tar": "^7.5.11",
     "lodash": "^4.17.23",
     "qs": "^6.14.2",
     "dottie": "2.0.7",
-    "fast-xml-parser": "^5.5.6"
+    "fast-xml-parser": "^5.5.6",
+    "yaml": "^2.8.3",
+    "openapi3-ts": "4.5.0",
+    "**/micromatch/picomatch": "2.3.2",
+    "**/tinyglobby/picomatch": "4.0.4",
+    "picomatch": "2.3.2",
+    "node-forge": "1.4.0"
   }
 }