@tstdl/base 0.93.155 → 0.93.157

package/document-management/server/services/document-workflow.service.js

@@ -42,7 +42,7 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
     documentService = inject(forwardRef(() => DocumentService));
     repository = injectRepository(DocumentWorkflow);
     [afterResolve](_, { cancellationSignal }) {
-        if (this.isInTransaction) {
+        if (this.isFork) {
             return;
         }
         this.#taskQueue.process({ concurrency: 5, cancellationSignal }, async (taskContext) => await this.processWorkflowJob(taskContext));

package/orm/server/repository.js

@@ -101,7 +101,7 @@ let EntityRepository = class EntityRepository extends Transactional {
         return this.#table;
     }
     [afterResolve]() {
-        if (!this.isInTransaction) {
+        if (!this.isFork) {
             void this.expirationLoop();
         }
     }

package/orm/server/transactional.d.ts

@@ -11,6 +11,7 @@ export type TransactionInitOptions = TransactionConfig & {
 };
 export type TransactionHandler<R> = (transaction: Transaction) => Promise<R>;
 type TransactionalContext<ContextData = unknown> = {
+    isFork: boolean;
     session: Database | PgTransaction;
     instances: WeakMap<Type, WeakMap<Database | PgTransaction, any>>;
     data: ContextData;
@@ -26,6 +27,7 @@ export declare abstract class Transactional<ContextData = unknown> {
     protected transactionalContextData: ContextData | undefined;
     readonly session: Database | PgTransaction;
     readonly isInTransaction: boolean;
+    readonly isFork: boolean;
     constructor();
     /**
      * Starts a new database transaction.

package/orm/server/transactional.js

@@ -42,6 +42,7 @@ export class Transactional {
     transactionalContextData = this.#context.data;
     session = this.#context.session ?? inject(Database);
     isInTransaction = this.session instanceof DrizzlePgTransaction;
+    isFork = (this.#context.isFork ?? false) || this.isInTransaction;
     constructor() {
         this.#classConstructor = new.target;
     }
@@ -77,6 +78,7 @@ export class Transactional {
             return this;
         }
         const context = {
+            isFork: true,
             session,
             instances: this.#instances,
             data: this.getTransactionalContextData(),
@@ -119,6 +121,7 @@ export class Transactional {
             return await this.transaction(handler);
         }
         const context = {
+            isFork: true,
             session: existingTransaction.pgTransaction,
             instances: this.#instances,
             data: this.getTransactionalContextData(),
@@ -139,6 +142,7 @@ export class Transactional {
     async transaction(handler, config) {
         const transaction = await this.startTransaction(config);
         const context = {
+            isFork: true,
             session: transaction.pgTransaction,
             instances: this.#instances,
             data: this.getTransactionalContextData(),

package/orm/sqls/sqls.d.ts

@@ -13,7 +13,6 @@ import type { Uuid } from '../types.js';
 /** Represents valid units for PostgreSQL interval values. */
 export type IntervalUnit = 'millennium' | 'millenniums' | 'millennia' | 'century' | 'centuries' | 'decade' | 'decades' | 'year' | 'years' | 'day' | 'days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds' | 'millisecond' | 'milliseconds' | 'microsecond' | 'microseconds';
 export type ExclusiveColumnCondition = Column | boolean | SQL;
-export declare const simpleJsonKeyPattern: RegExp;
 export type TsHeadlineOptions = {
     /**
      * The longest headline to output.
@@ -64,6 +63,7 @@ export declare const RANDOM_UUID_V4: SQL<Uuid>;
 export declare const RANDOM_UUID_V7: SQL<Uuid>;
 export declare const SQL_TRUE: SQL<boolean>;
 export declare const SQL_FALSE: SQL<boolean>;
+export declare const SQL_NULL: SQL<null>;
 export declare function enumValue<T extends EnumerationObject>(enumeration: T, dbEnum: PgEnumFromEnumeration<T> | string | null, value: EnumerationValue<T>): SQL<string>;
 /**
  * Generates a SQL `CASE` expression to enforce strict, mutually exclusive column usage based on a discriminator value.
@@ -114,7 +114,7 @@ export declare function exclusiveNotNull(...columns: Column[]): SQL;
  *   that defines the default condition to apply when a `Column` is provided in `conditionMapping`.
  *   By default, it generates an `IS NOT NULL` check.
  */
-export declare function enumerationCaseWhen<T extends EnumerationObject>(enumeration: T, discriminator: Column, conditionMapping: Record<EnumerationValue<T>, Column | [Column, ...Column[]] | boolean | SQL>, defaultColumnCondition?: (column: [Column, ...Column[]]) => SQL<unknown> | undefined): SQL;
+export declare function enumerationCaseWhen<T extends EnumerationObject>(enumeration: T, discriminator: Column, conditionMapping: Record<EnumerationValue<T>, Column | [Column, ...Column[]] | boolean | SQL>, defaultColumnCondition?: (columns: Column | [Column, ...Column[]]) => SQL<unknown>): SQL;
 export declare function array<T>(values: readonly (SQL<T> | SQLChunk | T)[]): SQL<T[]>;
 export declare function autoAlias<T>(column: AnyColumn<{
     data: T;

package/orm/sqls/sqls.js

@@ -8,7 +8,7 @@ import { and, Column, eq, isSQLWrapper, sql, isNotNull as sqlIsNotNull, isNull a
 import { match, P } from 'ts-pattern';
 import { distinct, toArray } from '../../utils/array/array.js';
 import { objectEntries, objectValues } from '../../utils/object/object.js';
-import { assertDefined, isArray, isBoolean, isDefined, isInstanceOf, isNotNull, isNull, isNullOrUndefined, isNumber, isObject, isString } from '../../utils/type-guards.js';
+import { assertDefined, isArray, isBoolean, isDefined, isInstanceOf, isLiteralObject, isNotNull, isNull, isNullOrUndefined, isNumber, isString } from '../../utils/type-guards.js';
 import { getEnumName } from '../enums.js';
 import { caseWhen } from './case-when.js';
 const isJsonbSymbol = Symbol('isJsonb');
@@ -25,7 +25,6 @@ function isJsonb(value) {
     }
     return false;
 }
-export const simpleJsonKeyPattern = /^[a-zA-Z0-9_-]+$/u;
 /** Drizzle SQL helper for getting the current transaction's timestamp. Returns a Date object. */
 export const TRANSACTION_TIMESTAMP = sql `transaction_timestamp()`;
 /** Drizzle SQL helper for generating a random UUID (v4). Returns a Uuid string. */
@@ -34,6 +33,7 @@ export const RANDOM_UUID_V4 = sql `gen_random_uuid()`;
 export const RANDOM_UUID_V7 = sql `uuidv7()`;
 export const SQL_TRUE = sql `TRUE`;
 export const SQL_FALSE = sql `FALSE`;
+export const SQL_NULL = sql `NULL`;
 export function enumValue(enumeration, dbEnum, value) {
     if (isNull(dbEnum)) {
         const enumName = getEnumName(enumeration);
@@ -69,25 +69,45 @@ export function enumValue(enumeration, dbEnum, value) {
  * @returns A SQL object representing the complete `CASE discriminator WHEN ... THEN ... ELSE FALSE` statement.
  */
 export function exclusiveColumn(enumeration, discriminator, conditionMapping) {
+    // 1. Gather all unique columns across the entire mapping
     const allColumns = objectValues(conditionMapping)
         .filter(isNotNull)
-        .flatMap((value) => toArray(value).filter((value) => isInstanceOf(value, Column)));
+        .flatMap((value) => toArray(value).filter((item) => isInstanceOf(item, Column)));
     const participatingColumns = distinct(allColumns);
-    const mapping = objectEntries(conditionMapping).map(([key, value]) => {
+    const kaseWhen = caseWhen(discriminator);
+    // 2. Iterate and build conditions safely
+    for (const [key, value] of objectEntries(conditionMapping)) {
         if (isNull(value)) {
-            return [key, SQL_FALSE];
+            kaseWhen.when(enumValue(enumeration, null, key), SQL_FALSE);
+            continue;
         }
-        const requiredColumns = toArray(value).filter((value) => isInstanceOf(value, Column));
+        const conditions = [];
+        const items = toArray(value);
+        // Identify required vs null columns
+        const requiredColumns = items.filter((item) => isInstanceOf(item, Column));
         const nullColumns = participatingColumns.filter((column) => !requiredColumns.includes(column));
-        const customConditions = toArray(value)
-            .filter((val) => !isInstanceOf(val, Column) && (val !== true))
-            .map((condition) => isBoolean(condition) ? (condition ? SQL_TRUE : SQL_FALSE) : condition);
-        const condition = and(...requiredColumns.map((col) => sqlIsNotNull(col)), ...nullColumns.map((col) => sqlIsNull(col)), ...customConditions);
-        return [key, condition];
-    });
-    const kaseWhen = caseWhen(discriminator);
-    for (const [key, condition] of mapping) {
-        kaseWhen.when(enumValue(enumeration, null, key), condition);
+        // Push column constraints
+        for (const col of requiredColumns) {
+            conditions.push(sqlIsNotNull(col));
+        }
+        for (const col of nullColumns) {
+            conditions.push(sqlIsNull(col));
+        }
+        // Handle custom conditions (SQL or booleans)
+        for (const item of items) {
+            if (!isInstanceOf(item, Column)) {
+                if (isBoolean(item)) {
+                    if (!item) {
+                        conditions.push(SQL_FALSE);
+                    }
+                }
+                else {
+                    conditions.push(item);
+                }
+            }
+        }
+        const finalCondition = and(...conditions) ?? SQL_TRUE;
+        kaseWhen.when(enumValue(enumeration, null, key), finalCondition);
     }
     return kaseWhen.else(SQL_FALSE);
 }
@@ -116,20 +136,17 @@ export function exclusiveNotNull(...columns) {
  *   that defines the default condition to apply when a `Column` is provided in `conditionMapping`.
  *   By default, it generates an `IS NOT NULL` check.
  */
-export function enumerationCaseWhen(enumeration, discriminator, conditionMapping, defaultColumnCondition = (column) => isArray(column) ? and(...column.map((col) => sqlIsNotNull(col))) : sqlIsNotNull(column)) {
-    const whens = [];
+export function enumerationCaseWhen(enumeration, discriminator, conditionMapping, defaultColumnCondition = (columns) => isArray(columns) ? and(...columns.map((col) => sqlIsNotNull(col))) : sqlIsNotNull(columns)) {
+    const kaseWhen = caseWhen(discriminator);
     for (const [key, value] of objectEntries(conditionMapping)) {
         const condition = match(value)
-            .with(P.boolean, (bool) => bool ? SQL_TRUE : SQL_FALSE)
-            .when((value) => isInstanceOf(value, Column), (col) => defaultColumnCondition(col))
+            .with(P.boolean, (bool) => (bool ? SQL_TRUE : SQL_FALSE))
+            // Check for both a single Column OR an Array of Columns
+            .when((val) => isInstanceOf(val, Column) || (isArray(val) && val.every((v) => isInstanceOf(v, Column))), (cols) => defaultColumnCondition(cols))
             .otherwise((rawSql) => rawSql);
-        whens.push(sql `    WHEN ${enumValue(enumeration, null, key)} THEN ${condition}`);
+        kaseWhen.when(enumValue(enumeration, null, key), condition);
     }
-    return sql `
-  CASE ${discriminator}
-${sql.join(whens, sql `\n`)}
-    ELSE FALSE
-  END`;
+    return kaseWhen.else(SQL_FALSE);
 }
 export function array(values) {
     const chunks = values.map((value) => isSQLWrapper(value) ? value : sql `${value}`);
@@ -411,9 +428,7 @@ export function jsonbBuildObject(properties) {
     const chunks = [];
     for (const [key, value] of entries) {
         if (isDefined(value)) {
-            const isSimpleKey = simpleJsonKeyPattern.test(key);
-            const sqlKey = isSimpleKey ? sql.raw(`'${key}'`) : sql `${key}`;
-            chunks.push(sqlKey, buildJsonb(value));
+            chunks.push(sql `${key}::text`, buildJsonb(value));
         }
     }
     if (chunks.length == 0) {
@@ -439,8 +454,17 @@ export function buildJsonb(value) {
         const elements = value.map((inner) => buildJsonb(inner));
         return markAsJsonb(sql `jsonb_build_array(${sql.join(elements, sql `, `)})`);
     }
-    if (isObject(value)) {
+    if (isLiteralObject(value)) {
         return jsonbBuildObject(value);
     }
-    return markAsJsonb(sql `${JSON.stringify(value)}::jsonb`);
+    if (isString(value)) {
+        return markAsJsonb(sql `to_jsonb(${value}::text)`);
+    }
+    if (isNumber(value)) {
+        return markAsJsonb(sql `to_jsonb(${value}::numeric)`);
+    }
+    if (isBoolean(value)) {
+        return markAsJsonb(sql `to_jsonb(${value}::boolean)`);
+    }
+    return markAsJsonb(sql `to_jsonb(${value})`);
 }

package/orm/tests/build-jsonb.test.d.ts

@@ -0,0 +1 @@
+export {};

package/orm/tests/build-jsonb.test.js

@@ -0,0 +1,39 @@
+import { PgDialect } from 'drizzle-orm/pg-core';
+import { describe, expect, test } from 'vitest';
+import { buildJsonb } from '../sqls/sqls.js';
+describe('buildJsonb', () => {
+    const dialect = new PgDialect();
+    test('should build jsonb from simple object', () => {
+        const query = buildJsonb({ a: 1, b: 'foo' });
+        const { sql, params } = dialect.sqlToQuery(query);
+        expect(sql).toBe('jsonb_build_object($1::text, to_jsonb($2), $3::text, to_jsonb($4))');
+        expect(params).toEqual(['a', 1, 'b', 'foo']);
+    });
+    test('should build jsonb from object with non-simple keys', () => {
+        const query = buildJsonb({ 'Betriebs-Nr.': '18182952' });
+        const { sql, params } = dialect.sqlToQuery(query);
+        // This is what failed before: it lacked the ::text cast
+        expect(sql).toBe('jsonb_build_object($1::text, to_jsonb($2))');
+        expect(params).toEqual(['Betriebs-Nr.', '18182952']);
+    });
+    test('should build jsonb from nested structures', () => {
+        const query = buildJsonb({
+            additionalData: { 'Betriebs-Nr.': '18182952' },
+            tags: ['a', 'b']
+        });
+        const { sql, params } = dialect.sqlToQuery(query);
+        expect(sql).toBe('jsonb_build_object($1::text, jsonb_build_object($2::text, to_jsonb($3)), $4::text, jsonb_build_array(to_jsonb($5), to_jsonb($6)))');
+        expect(params).toEqual(['additionalData', 'Betriebs-Nr.', '18182952', 'tags', 'a', 'b']);
+    });
+    test('should handle numbers correctly', () => {
+        const query = buildJsonb({ score: 0.5 });
+        const { sql, params } = dialect.sqlToQuery(query);
+        expect(sql).toBe('jsonb_build_object($1::text, to_jsonb($2))');
+        expect(params).toEqual(['score', 0.5]);
+    });
+    test('should handle null and empty structures', () => {
+        expect(dialect.sqlToQuery(buildJsonb(null)).sql).toBe('\'null\'::jsonb');
+        expect(dialect.sqlToQuery(buildJsonb({})).sql).toBe('\'{}\'::jsonb');
+        expect(dialect.sqlToQuery(buildJsonb([])).sql).toBe('\'[]\'::jsonb');
+    });
+});

package/orm/tests/query-converter-complex.test.js

@@ -7,13 +7,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { describe, expect, test } from 'vitest';
-import { sql } from 'drizzle-orm';
 import { PgDialect } from 'drizzle-orm/pg-core';
-import { StringProperty, Integer } from '../../schema/index.js';
+import { Integer, StringProperty } from '../../schema/index.js';
+import { describe, expect, test } from 'vitest';
+import { Table } from '../decorators.js';
 import { Entity } from '../entity.js';
-import { Column, Table } from '../decorators.js';
-import { getDrizzleTableFromType, getColumnDefinitionsMap } from '../server/drizzle/schema-converter.js';
+import { getColumnDefinitionsMap, getDrizzleTableFromType } from '../server/drizzle/schema-converter.js';
 import { convertQuery } from '../server/query-converter.js';
 describe('ORM Query Converter Complex', () => {
     const dialect = new PgDialect();
@@ -49,10 +48,11 @@ describe('ORM Query Converter Complex', () => {
             },
         };
         const condition = convertQuery(q, table, colMap);
-        const sqlStr = dialect.sqlToQuery(condition).sql;
-        expect(sqlStr).toContain('setweight(to_tsvector($1, "test"."complex_items"."name"), \'A\')');
-        expect(sqlStr).toContain('setweight(to_tsvector($2, "test"."complex_items"."description"), \'B\')');
-        expect(sqlStr).toContain('websearch_to_tsquery($3, $4)');
+        const { sql, params } = dialect.sqlToQuery(condition);
+        expect(sql).toContain('setweight(to_tsvector($1, "test"."complex_items"."name"), \'A\')');
+        expect(sql).toContain('setweight(to_tsvector($2, "test"."complex_items"."description"), \'B\')');
+        expect(sql).toContain('websearch_to_tsquery($3, $4)');
+        expect(params).toEqual(['english', 'english', 'english', 'search term']);
     });
     test('should handle ParadeDB $parade match with tokenizer', () => {
         const q = {
@@ -66,9 +66,10 @@ describe('ORM Query Converter Complex', () => {
             },
         };
         const condition = convertQuery(q, table, colMap);
-        const sqlStr = dialect.sqlToQuery(condition).sql;
+        const { sql, params } = dialect.sqlToQuery(condition);
         // Tokenizer is supported via JSON object syntax
-        expect(sqlStr).toContain('"test"."complex_items"."name" @@@ jsonb_build_object(\'match\', jsonb_build_object(\'value\', $1::jsonb, \'tokenizer\', jsonb_build_object(\'type\', $2::jsonb, \'min_gram\', $3::jsonb, \'max_gram\', $4::jsonb)))::pdb.query');
+        expect(sql).toContain('"test"."complex_items"."name" @@@ jsonb_build_object($1::text, jsonb_build_object($2::text, to_jsonb($3), $4::text, jsonb_build_object($5::text, to_jsonb($6), $7::text, to_jsonb($8), $9::text, to_jsonb($10))))::pdb.query');
+        expect(params).toEqual(['match', 'value', 'test', 'tokenizer', 'type', 'ngram', 'min_gram', 3, 'max_gram', 3]);
     });
     test('should handle ParadeDB $parade range', () => {
         const q = {
@@ -82,9 +83,10 @@ describe('ORM Query Converter Complex', () => {
             },
         };
         const condition = convertQuery(q, table, colMap);
-        const sqlStr = dialect.sqlToQuery(condition).sql;
+        const { sql, params } = dialect.sqlToQuery(condition);
         // This should fall back to convertParadeComparisonQuery with recursive jsonb build
-        expect(sqlStr).toContain('"test"."complex_items"."value" @@@ jsonb_build_object(\'range\', jsonb_build_object(\'lower_bound\', jsonb_build_object(\'included\', $1::jsonb), \'upper_bound\', jsonb_build_object(\'excluded\', $2::jsonb)))::pdb.query');
+        expect(sql).toContain('"test"."complex_items"."value" @@@ jsonb_build_object($1::text, jsonb_build_object($2::text, jsonb_build_object($3::text, to_jsonb($4)), $5::text, jsonb_build_object($6::text, to_jsonb($7))))::pdb.query');
+        expect(params).toEqual(['range', 'lower_bound', 'included', 10, 'upper_bound', 'excluded', 20]);
     });
     test('should handle ParadeDB $parade phrasePrefix', () => {
         const q = {
@@ -95,8 +97,9 @@ describe('ORM Query Converter Complex', () => {
             },
         };
         const condition = convertQuery(q, table, colMap);
-        const sqlStr = dialect.sqlToQuery(condition).sql;
-        expect(sqlStr).toContain('"test"."complex_items"."name" @@@ jsonb_build_object(\'phrase_prefix\', jsonb_build_object(\'phrases\', jsonb_build_array($1::jsonb, $2::jsonb), \'max_expansions\', $3::jsonb))::pdb.query');
+        const { sql, params } = dialect.sqlToQuery(condition);
+        expect(sql).toContain('"test"."complex_items"."name" @@@ jsonb_build_object($1::text, jsonb_build_object($2::text, jsonb_build_array(to_jsonb($3), to_jsonb($4)), $5::text, to_jsonb($6)))::pdb.query');
+        expect(params).toEqual(['phrase_prefix', 'phrases', 'hello', 'wor', 'max_expansions', 10]);
     });
     test('should handle ParadeDB $parade regexPhrase', () => {
         const q = {
@@ -107,8 +110,9 @@ describe('ORM Query Converter Complex', () => {
             },
         };
         const condition = convertQuery(q, table, colMap);
-        const sqlStr = dialect.sqlToQuery(condition).sql;
-        expect(sqlStr).toContain('"test"."complex_items"."name" @@@ jsonb_build_object(\'regex_phrase\', jsonb_build_object(\'regexes\', jsonb_build_array($1::jsonb, $2::jsonb), \'slop\', $3::jsonb))::pdb.query');
+        const { sql, params } = dialect.sqlToQuery(condition);
+        expect(sql).toContain('"test"."complex_items"."name" @@@ jsonb_build_object($1::text, jsonb_build_object($2::text, jsonb_build_array(to_jsonb($3), to_jsonb($4)), $5::text, to_jsonb($6)))::pdb.query');
+        expect(params).toEqual(['regex_phrase', 'regexes', 'he.*', 'wo.*', 'slop', 1]);
     });
     test('should handle ParadeDB top-level moreLikeThis', () => {
         const q = {
@@ -120,7 +124,8 @@ describe('ORM Query Converter Complex', () => {
             },
         };
         const condition = convertQuery(q, table, colMap);
-        const sqlStr = dialect.sqlToQuery(condition).sql;
-        expect(sqlStr).toContain('"test"."complex_items"."id" @@@ jsonb_build_object(\'more_like_this\', jsonb_build_object(\'key_value\', $1::jsonb, \'fields\', to_jsonb(ARRAY[$2, $3])))::pdb.query');
+        const { sql, params } = dialect.sqlToQuery(condition);
+        expect(sql).toContain('"test"."complex_items"."id" @@@ jsonb_build_object($1::text, jsonb_build_object($2::text, to_jsonb($3), $4::text, to_jsonb(ARRAY[$5, $6])))::pdb.query');
+        expect(params).toEqual(['more_like_this', 'key_value', '123', 'fields', 'name', 'description']);
     });
 });

package/orm/tests/sql-helpers.test.js

@@ -42,7 +42,7 @@ describe('ORM SQL Helpers', () => {
     test('interval should generate postgres interval syntax', () => {
         const i = interval(5, 'days');
         const sqlStr = dialect.sqlToQuery(i).sql;
-        expect(sqlStr).toContain("||' days')::interval");
+        expect(sqlStr).toContain("|| ' days')::interval");
     });
     test('coalesce should join multiple columns', () => {
         const c = coalesce(testTable.colA, testTable.colB, sql `'default'`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.155",
+  "version": "0.93.157",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/task-queue/postgres/task-queue.d.ts

@@ -135,6 +135,7 @@ export declare class PostgresTaskQueue<Definitions extends TaskDefinitionMap = T
     private lowFrequencyMaintenanceLoop;
     private mediumFrequencyMaintenanceLoop;
     private highFrequencyMaintenanceLoop;
+    private logPromiseAllSettledErrors;
     getBatchConsumer<Type extends TaskTypes<Definitions>>(size: number, cancellationSignal: CancellationSignal, options?: {
         forceDequeue?: boolean;
         types?: Type[];

package/task-queue/postgres/task-queue.js

@@ -137,7 +137,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         result: null,
     };
     [afterResolve]() {
-        if (!this.isInTransaction) {
+        if (!this.isFork) {
             this.maintenanceLoop();
         }
     }
@@ -1311,10 +1311,11 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
     async lowFrequencyMaintenanceLoop() {
         while (this.#cancellationSignal.isUnset) {
             try {
-                await Promise.allSettled([
+                const results = await Promise.allSettled([
                     this.performArchival(),
                     this.performArchivePurge(),
                 ]);
+                this.logPromiseAllSettledErrors(results, 'low frequency maintenance loop');
             }
             catch (error) {
                 this.#logger.error('Error during low frequency maintenance loop', error);
@@ -1327,10 +1328,11 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
     async mediumFrequencyMaintenanceLoop() {
         while (this.#cancellationSignal.isUnset) {
             try {
-                await Promise.allSettled([
+                const results = await Promise.allSettled([
                     this.processExpirations(),
                     this.processPriorityAging(),
                 ]);
+                this.logPromiseAllSettledErrors(results, 'medium frequency maintenance loop');
             }
             catch (error) {
                 this.#logger.error('Error during medium frequency maintenance loop', error);
@@ -1343,11 +1345,12 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
     async highFrequencyMaintenanceLoop() {
         while (this.#cancellationSignal.isUnset) {
             try {
-                await Promise.allSettled([
+                const results = await Promise.allSettled([
                     this.processZombieRetries(),
                     this.processZombieExhaustions(),
                     this.processHardTimeouts(),
                 ]);
+                this.logPromiseAllSettledErrors(results, 'high frequency maintenance loop');
             }
             catch (error) {
                 this.#logger.error('Error during high frequency maintenance loop', error);
@@ -1357,6 +1360,13 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             }
         }
     }
+    logPromiseAllSettledErrors(results, context) {
+        for (const result of results) {
+            if (result.status == 'rejected') {
+                this.#logger.error(`Error during ${context}`, result.reason);
+            }
+        }
+    }
     async *getBatchConsumer(size, cancellationSignal, options) {
         const continue$ = merge(this.#messageBus.allMessages$).pipe(filter((namespace) => namespace == this.#namespace));
         const mergedContinue$ = merge(continue$, cancellationSignal);

package/test4.js

@@ -23,7 +23,7 @@ const config = {
         },
     },
     s3: {
-        endpoint: string('S3_ENDPOINT', 'http://localhost:9000'),
+        endpoint: string('S3_ENDPOINT', 'http://localhost:19552'),
         accessKey: string('S3_ACCESS_KEY', 'tstdl-dev'),
         secretKey: string('S3_SECRET_KEY', 'tstdl-dev'),
         bucket: string('S3_BUCKET', undefined),

package/testing/integration-setup.js

@@ -125,7 +125,7 @@ export async function setupIntegrationTest(options = {}) {
         if (options.modules?.objectStorage) {
             const bucketPerModule = options.s3?.bucketPerModule ?? configParser.boolean('S3_BUCKET_PER_MODULE', true);
             configureS3ObjectStorage({
-                endpoint: options.s3?.endpoint ?? configParser.string('S3_ENDPOINT', 'http://127.0.0.1:9000'),
+                endpoint: options.s3?.endpoint ?? configParser.string('S3_ENDPOINT', 'http://127.0.0.1:19552'),
                 accessKey: options.s3?.accessKey ?? configParser.string('S3_ACCESS_KEY', 'tstdl-dev'),
                 secretKey: options.s3?.secretKey ?? configParser.string('S3_SECRET_KEY', 'tstdl-dev'),
                 bucket: bucketPerModule ? undefined : (options.s3?.bucket ?? configParser.string('S3_BUCKET', 'test-bucket')),