@lucaapp/service-utils 5.13.1 → 5.14.1

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

@@ -11,6 +11,8 @@ interface AtomicAuditLogOptions {
     attributeRevisionModelTableName?: string;
     primaryKeyType?: typeof DataTypes.UUID | typeof DataTypes.INTEGER;
     viewPartitionCount?: number;
+    getContext?: () => Record<string, unknown> | null | undefined;
+    getCorrelationId?: () => string | null | undefined;
 }
 export interface PartitionResult {
     archiveTableName: string;
@@ -21,7 +23,11 @@ export declare class AtomicAuditLog {
     private tableName;
     private primaryKeyType;
     private viewPartitionCount;
+    private getContext?;
+    private getCorrelationId?;
+    private knownColumnsCache?;
     constructor(sequelize: Sequelize, options?: AtomicAuditLogOptions);
+    private getKnownColumns;
     getTableName(): string;
     getViewName(): string;
     addHistory<T extends Model>(model: ModelStatic<T>, options?: AddHistoryOptions): void;

package/dist/lib/atomicAuditLog/index.js

@@ -63,6 +63,21 @@ class AtomicAuditLog {
         this.tableName = options.attributeRevisionModelTableName ?? 'AuditLogs';
         this.primaryKeyType = options.primaryKeyType ?? sequelize_1.DataTypes.INTEGER;
         this.viewPartitionCount = options.viewPartitionCount ?? 6;
+        this.getContext = options.getContext;
+        this.getCorrelationId = options.getCorrelationId;
+    }
+    async getKnownColumns() {
+        if (!this.knownColumnsCache) {
+            this.knownColumnsCache = this.sequelize
+                .query(`SELECT column_name FROM information_schema.columns
+           WHERE table_name = :tableName AND table_schema = current_schema()`, {
+                replacements: { tableName: this.tableName },
+                type: sequelize_1.QueryTypes.SELECT,
+            })
+                .then(rows => new Set(rows.map(row => row.column_name)))
+                .catch(() => new Set());
+        }
+        return this.knownColumnsCache;
     }
     getTableName() {
         return this.tableName;
@@ -86,31 +101,45 @@ class AtomicAuditLog {
         if (dialect !== 'postgres') {
             return;
         }
-        const lockKey = `hashtext('${this.tableName}:${modelId}')`;
-        await this.sequelize.query(`SELECT pg_advisory_xact_lock(${lockKey})`, {
-            transaction,
-            type: sequelize_1.QueryTypes.SELECT,
-        });
-        const query = `
-      INSERT INTO "${this.tableName}" ("modelId", "model", "operation", "diff", "revision", "createdAt")
-      SELECT
-        :modelId,
-        :modelName,
-        :operation,
-        :diff::jsonb,
-        COALESCE(
-          (SELECT MAX("revision") + 1 FROM "${this.tableName}" WHERE "modelId" = :modelId),
-          0
-        ),
-        NOW()
-    `;
+        const knownColumns = await this.getKnownColumns();
+        const useRevision = knownColumns.has('revision');
+        if (useRevision) {
+            const lockKey = `hashtext('${this.tableName}:${modelId}')`;
+            await this.sequelize.query(`SELECT pg_advisory_xact_lock(${lockKey})`, {
+                transaction,
+                type: sequelize_1.QueryTypes.SELECT,
+            });
+        }
+        const replacements = {
+            modelId,
+            modelName,
+            operation,
+            diff: JSON.stringify(diff),
+        };
+        const columns = ['"modelId"', '"model"', '"operation"', '"diff"'];
+        const values = [':modelId', ':modelName', ':operation', ':diff::jsonb'];
+        if (this.getContext && knownColumns.has('context')) {
+            const context = this.getContext() ?? null;
+            columns.push('"context"');
+            values.push(':context::jsonb');
+            replacements.context = context === null ? null : JSON.stringify(context);
+        }
+        if (this.getCorrelationId && knownColumns.has('correlationId')) {
+            columns.push('"correlationId"');
+            values.push(':correlationId');
+            replacements.correlationId = this.getCorrelationId() ?? null;
+        }
+        if (useRevision) {
+            columns.push('"revision"');
+            values.push(`COALESCE((SELECT MAX("revision") + 1 FROM "${this.tableName}" WHERE "modelId" = :modelId), 0)`);
+        }
+        columns.push('"createdAt"');
+        values.push('NOW()');
+        const query = useRevision
+            ? `INSERT INTO "${this.tableName}" (${columns.join(', ')})\n      SELECT ${values.join(', ')}`
+            : `INSERT INTO "${this.tableName}" (${columns.join(', ')}) VALUES (${values.join(', ')})`;
         await this.sequelize.query(query, {
-            replacements: {
-                modelId,
-                modelName,
-                operation,
-                diff: JSON.stringify(diff),
-            },
+            replacements,
             type: sequelize_1.QueryTypes.INSERT,
             transaction,
         });

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

@@ -2,8 +2,9 @@ import { PgBoss } from 'pg-boss';
 /**
  * List jobs in a queue with mandatory pagination.
  *
- * pg-boss `findJobs` does not support limit/offset directly, so we slice
- * client-side. Callers must pass `limit` (clamped to MAX_LIMIT) and
- * `offset` to avoid loading 1M rows into memory.
+ * pg-boss `findJobs` does not support limit/offset or ORDER BY directly, so we
+ * sort client-side (actionable states first, then newest-first within each
+ * group) before slicing. Without this, active/created jobs in queues with
+ * >100 completed entries would never appear in the default page.
  */
 export declare const listJobs: (boss: PgBoss, queueName: string, limit?: number, offset?: number) => Promise<Record<string, unknown>[]>;

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

@@ -3,18 +3,37 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.listJobs = void 0;
 const DEFAULT_LIMIT = 100;
 const MAX_LIMIT = 1000;
+// Actionable states surface first so they are never buried by completed volume.
+// pg-boss ENUM order: created < retry < active < completed < cancelled < failed
+const STATE_PRIORITY = {
+    active: 0,
+    created: 1,
+    retry: 2,
+    failed: 3,
+    cancelled: 4,
+    completed: 5,
+};
 /**
  * List jobs in a queue with mandatory pagination.
  *
- * pg-boss `findJobs` does not support limit/offset directly, so we slice
- * client-side. Callers must pass `limit` (clamped to MAX_LIMIT) and
- * `offset` to avoid loading 1M rows into memory.
+ * pg-boss `findJobs` does not support limit/offset or ORDER BY directly, so we
+ * sort client-side (actionable states first, then newest-first within each
+ * group) before slicing. Without this, active/created jobs in queues with
+ * >100 completed entries would never appear in the default page.
  */
 const listJobs = async (boss, queueName, limit = DEFAULT_LIMIT, offset = 0) => {
     const cappedLimit = Math.min(Math.max(limit, 1), MAX_LIMIT);
     const safeOffset = Math.max(offset, 0);
     const jobs = await boss.findJobs(queueName);
     return jobs
+        .sort((a, b) => {
+        const pa = STATE_PRIORITY[a.state] ?? 99;
+        const pb = STATE_PRIORITY[b.state] ?? 99;
+        if (pa !== pb)
+            return pa - pb;
+        return (new Date(b.createdOn).getTime() -
+            new Date(a.createdOn).getTime());
+    })
         .slice(safeOffset, safeOffset + cappedLimit)
         .map(job => ({ ...job }));
 };

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

@@ -38,7 +38,7 @@ declare class ServiceIdentity {
     private readonly jwksCache;
     private readonly keyCache;
     private readonly axiosClient;
-    constructor(identityName: string, identityKid: string, identityPrivateKey: string, identityPublicKey: string, debug?: boolean);
+    constructor(identityName: string, identityKid: string, identityPrivateKey: string, identityPublicKey: string, debug?: boolean, timeoutMs?: number);
     getRemoteJWKS: (service: string) => RemoteJWKS;
     private getJwtVerifyOptions;
     getIdentityPublicKey: () => Promise<jose.KeyLike>;

package/dist/lib/serviceIdentity/serviceIdentity.js

@@ -68,7 +68,7 @@ class ServiceIdentityError extends Error {
 }
 exports.ServiceIdentityError = ServiceIdentityError;
 class ServiceIdentity {
-    constructor(identityName, identityKid, identityPrivateKey, identityPublicKey, debug = false) {
+    constructor(identityName, identityKid, identityPrivateKey, identityPublicKey, debug = false, timeoutMs = 60_000) {
         this.jwksCache = {};
         this.keyCache = {};
         this.getRemoteJWKS = (service) => {
@@ -199,7 +199,7 @@ class ServiceIdentity {
         this.identityKid = identityKid;
         this.identityPrivateKey = identityPrivateKey;
         this.identityPublicKey = identityPublicKey;
-        this.axiosClient = axios_1.default.create({ proxy: false });
+        this.axiosClient = axios_1.default.create({ proxy: false, timeout: timeoutMs });
         // Configure axios-retry to handle 429 and respect Retry-After header
         (0, axios_retry_1.default)(this.axiosClient, {
             retries: 3,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucaapp/service-utils",
-  "version": "5.13.1",
+  "version": "5.14.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [