@tstdl/base 0.93.154 → 0.93.156

package/orm/sqls/sqls.d.ts

@@ -4,7 +4,7 @@
  * simplifying common SQL operations like generating UUIDs, working with intervals,
  * and aggregating data.
  */
-import { Column, SQL, type AnyColumn, type SQLChunk, type SQLWrapper } from 'drizzle-orm';
+import { Column, type AnyColumn, type SQL, type SQLChunk, type SQLWrapper } from 'drizzle-orm';
 import type { GetSelectTableSelection, SelectResultField, TableLike } from 'drizzle-orm/query-builders/select.types';
 import type { EnumerationObject, EnumerationValue, Record } from '../../types/types.js';
 import { type PgEnumFromEnumeration } from '../enums.js';
@@ -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;
@@ -125,7 +125,7 @@ export declare function autoAlias<T>(column: AnyColumn<{
  * @param unit - The unit of the interval (e.g., 'day', 'hour').
  * @returns A Drizzle SQL object representing the interval.
  */
-export declare function interval(value: number, unit: IntervalUnit): SQL;
+export declare function interval(value: number | SQL<number>, unit: IntervalUnit): SQL;
 /**
  * Creates a PostgreSQL `array_agg` aggregate function call.
  * Aggregates values from a column into a PostgreSQL array.
@@ -183,6 +183,7 @@ export declare function greatest<T extends (Column | SQL | SQL.Aliased | number)
     [P in keyof T]: T[P] extends number ? Exclude<T[P], number> | SQL<number> : T[P];
 }[number]>>;
 export declare function greatest<T>(...values: T[]): SQL<SelectResultField<T>>;
+export declare function power(base: number | SQLChunk, exponent: number | SQLChunk): SQL<number>;
 export declare function unnest<T>(array: SQL<readonly T[]> | SQL.Aliased<readonly T[]> | Column): SQL<T>;
 /**
  * Creates a PostgreSQL array contains operator expression (@>).

package/orm/sqls/sqls.js

@@ -4,7 +4,7 @@
  * simplifying common SQL operations like generating UUIDs, working with intervals,
  * and aggregating data.
  */
-import { and, Column, eq, isSQLWrapper, sql, SQL, isNotNull as sqlIsNotNull, isNull as sqlIsNull, Table } from 'drizzle-orm';
+import { and, Column, eq, isSQLWrapper, sql, isNotNull as sqlIsNotNull, isNull as sqlIsNull, Table } from 'drizzle-orm';
 import { match, P } from 'ts-pattern';
 import { distinct, toArray } from '../../utils/array/array.js';
 import { objectEntries, objectValues } from '../../utils/object/object.js';
@@ -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}`);
@@ -146,7 +163,7 @@ export function autoAlias(column) {
  * @returns A Drizzle SQL object representing the interval.
  */
 export function interval(value, unit) {
-    return sql `(${value} ||' ${sql.raw(unit)}')::interval`;
+    return sql `(${value} || ' ${sql.raw(unit)}')::interval`;
 }
 /**
  * Creates a PostgreSQL `array_agg` aggregate function call.
@@ -224,6 +241,9 @@ export function greatest(...values) {
     const sqlValues = values.map((value) => isNumber(value) ? sql.raw(String(value)) : value);
     return sql `greatest(${sql.join(sqlValues, sql.raw(', '))})`;
 }
+export function power(base, exponent) {
+    return sql `power(${base}, ${exponent})`;
+}
 export function unnest(array) {
     return sql `unnest(${array})`;
 }
@@ -408,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,5 +457,5 @@ export function buildJsonb(value) {
     if (isObject(value)) {
         return jsonbBuildObject(value);
     }
-    return markAsJsonb(sql `${JSON.stringify(value)}::jsonb`);
+    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.154",
+  "version": "0.93.156",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -152,8 +152,8 @@
     "type-fest": "^5.4"
   },
   "peerDependencies": {
-    "@aws-sdk/client-s3": "^3.1001",
-    "@aws-sdk/s3-request-presigner": "^3.1001",
+    "@aws-sdk/client-s3": "^3.1002",
+    "@aws-sdk/s3-request-presigner": "^3.1002",
     "@genkit-ai/google-genai": "^1.29",
     "@google-cloud/storage": "^7.19",
     "@toon-format/toon": "^2.1.0",
@@ -168,7 +168,7 @@
     "handlebars": "^4.7",
     "mjml": "^4.18",
     "nodemailer": "^8.0",
-    "pg": "^8.19",
+    "pg": "^8.20",
     "playwright": "^1.58",
     "preact": "^10.28",
     "preact-render-to-string": "^6.6",

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

@@ -60,15 +60,14 @@ import { aliasedTable, and, asc, count, eq, gt, gte, inArray, lt, lte, notExists
 import { filter, merge, throttleTime } from 'rxjs';
 import { CancellationSignal } from '../../cancellation/index.js';
 import { CircuitBreaker, CircuitBreakerState } from '../../circuit-breaker/index.js';
-import { serializeError, TimeoutError } from '../../errors/index.js';
+import { NotFoundError, serializeError, TimeoutError } from '../../errors/index.js';
 import { afterResolve, inject, provide, Singleton } from '../../injector/index.js';
 import { Logger } from '../../logger/index.js';
 import { MessageBus } from '../../message-bus/index.js';
-import { arrayOverlaps, caseWhen, coalesce, enumValue, getEntityIds, greatest, interval, jsonbBuildObject, RANDOM_UUID_V4, TRANSACTION_TIMESTAMP } from '../../orm/index.js';
-import { Database, DatabaseConfig, injectRepository } from '../../orm/server/index.js';
+import { arrayOverlaps, caseWhen, coalesce, enumValue, greatest, interval, jsonbBuildObject, least, power, RANDOM_UUID_V4, TRANSACTION_TIMESTAMP } from '../../orm/index.js';
+import { DatabaseConfig, injectRepository } from '../../orm/server/index.js';
 import { RateLimiter } from '../../rate-limit/index.js';
 import { distinct, toArray } from '../../utils/array/array.js';
-import { currentTimestamp } from '../../utils/date-time.js';
 import { Timer } from '../../utils/timer.js';
 import { cancelableTimeout } from '../../utils/timing.js';
 import { isArray, isDefined, isNotNull, isNull, isNumber, isString, isUndefined } from '../../utils/type-guards.js';
@@ -76,10 +75,9 @@ import { millisecondsPerMinute, millisecondsPerSecond } from '../../utils/units.
 import { defaultQueueConfig, queueableOrWaitableStatuses, queueableStatuses, TaskDependencyType, TaskQueue, TaskStatus, terminalStatuses } from '../task-queue.js';
 import { ensureTaskError } from '../task.error.js';
 import { PostgresTaskQueueModuleConfig } from './module.js';
-import { taskArchive as taskArchiveTable, taskDependency as taskDependencyTable, taskDependencyType, taskStatus, task as taskTable } from './schemas.js';
+import { taskArchive as taskArchiveTable, taskDependency as taskDependencyTable, taskStatus, task as taskTable } from './schemas.js';
 import { PostgresTask, PostgresTaskArchive } from './task.model.js';
 let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
-    #database = inject(Database);
     #repository = injectRepository(PostgresTask);
     #archiveRepository = injectRepository(PostgresTaskArchive);
     #config = this.config;
@@ -399,13 +397,17 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             .set({
             unresolvedScheduleDependencies: sql `${taskTable.unresolvedScheduleDependencies} + ${updates.scheduleIncrement}`,
             unresolvedCompleteDependencies: sql `${taskTable.unresolvedCompleteDependencies} + ${updates.completeIncrement}`,
-            status: caseWhen(and(eq(taskTable.status, TaskStatus.Pending), gt(sql `${taskTable.unresolvedScheduleDependencies} + ${updates.scheduleIncrement}`, 0)), enumValue(TaskStatus, taskStatus, TaskStatus.Waiting)).else(taskTable.status),
+            status: caseWhen(and(eq(taskTable.status, TaskStatus.Pending), gt(sql `${taskTable.unresolvedScheduleDependencies} + ${updates.scheduleIncrement}`, 0)), TaskStatus.Waiting).else(taskTable.status),
         })
             .from(updates)
             .where(eq(taskTable.id, updates.taskId))
             .returning({ id: taskTable.id, status: taskTable.status, namespace: taskTable.namespace });
+        const notifiedNamespaces = new Set();
         for (const row of updatedRows) {
-            this.notify(row.namespace);
+            if (!notifiedNamespaces.has(row.namespace)) {
+                this.notify(row.namespace);
+                notifiedNamespaces.add(row.namespace);
+            }
         }
     }
     async has(id, options) {
@@ -535,23 +537,29 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         await this.cancelMany([id], options);
     }
     async cancelMany(ids, options) {
+        if (ids.length == 0) {
+            return;
+        }
         await this.#repository.useTransaction(options?.transaction, async (tx) => {
-            const tree = await this.getTree(ids, { transaction: tx });
-            const treeIds = tree.map((task) => task.id);
-            if (treeIds.length == 0) {
-                return;
-            }
-            const cancelledRows = await tx.pgTransaction
-                .update(taskTable)
-                .set({
-                status: TaskStatus.Cancelled,
-                token: null,
-                completeTimestamp: TRANSACTION_TIMESTAMP,
-            })
-                .where(and(inArray(taskTable.id, treeIds), notInArray(taskTable.status, terminalStatuses)))
-                .returning({ id: taskTable.id, namespace: taskTable.namespace });
-            if (cancelledRows.length > 0) {
-                await this.resolveDependenciesMany(cancelledRows.map((row) => ({ id: row.id, status: TaskStatus.Cancelled, namespace: row.namespace })), { transaction: tx });
+            const cancelledRows = await tx.pgTransaction.execute(sql `
+        WITH RECURSIVE task_tree AS (
+          SELECT id FROM ${taskTable} WHERE ${inArray(taskTable.id, ids)}
+          UNION ALL
+          SELECT child.id FROM ${taskTable} child JOIN task_tree parent ON child.parent_id = parent.id
+        )
+        UPDATE ${taskTable}
+        SET
+          status = ${enumValue(TaskStatus, taskStatus, TaskStatus.Cancelled)},
+          token = NULL,
+          complete_timestamp = ${TRANSACTION_TIMESTAMP}
+        FROM task_tree
+        WHERE
+          ${taskTable.id} = task_tree.id
+          AND ${taskTable.status} NOT IN (${sql.join(terminalStatuses.map((s) => enumValue(TaskStatus, taskStatus, s)), sql `, `)})
+        RETURNING ${taskTable.id} as id, ${taskTable.namespace} as namespace
+      `);
+            if (cancelledRows.rows.length > 0) {
+                await this.resolveDependenciesMany(cancelledRows.rows.map((row) => ({ id: row.id, status: TaskStatus.Cancelled, namespace: row.namespace })), { transaction: tx });
             }
         });
     }
@@ -705,42 +713,29 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         if (isNull(task.token)) {
             return undefined;
         }
-        return await this.#repository.useTransaction(options?.transaction, async (tx) => {
-            const update = {
-                visibilityDeadline: sql `${TRANSACTION_TIMESTAMP} + ${interval(this.visibilityTimeout, 'milliseconds')}`,
-            };
-            if (isDefined(options?.progress)) {
-                update.progress = options.progress;
-            }
-            if (isDefined(options?.state)) {
-                update.state = options.state;
-            }
-            const [updatedRow] = await tx.pgTransaction
-                .update(taskTable)
-                .set(update)
-                .where(and(eq(taskTable.id, task.id), eq(taskTable.status, TaskStatus.Running), isNull(task.token) ? sqlIsNull(taskTable.token) : eq(taskTable.token, task.token), gt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`)))
-                .returning();
-            if (isDefined(updatedRow)) {
-                return await this.#repository.mapToEntity(updatedRow);
-            }
-            const [existingRow] = await tx.pgTransaction
-                .select({ startTimestamp: taskTable.startTimestamp })
-                .from(taskTable)
-                .where(and(eq(taskTable.id, task.id), eq(taskTable.status, TaskStatus.Running), isNull(task.token) ? sqlIsNull(taskTable.token) : eq(taskTable.token, task.token)));
-            if (isDefined(existingRow) && isNotNull(existingRow.startTimestamp) && (currentTimestamp() - existingRow.startTimestamp) > this.maxExecutionTime) {
-                await tx.pgTransaction
-                    .update(taskTable)
-                    .set({
-                    status: TaskStatus.TimedOut,
-                    completeTimestamp: TRANSACTION_TIMESTAMP,
-                    error: { code: 'MaxTimeExceeded', message: 'Hard Execution Timeout' },
-                })
-                    .where(eq(taskTable.id, task.id));
-                await this.resolveDependenciesMany([{ id: task.id, status: TaskStatus.TimedOut, namespace: task.namespace }], { transaction: tx });
-                this.notify();
-            }
+        const session = options?.transaction?.pgTransaction ?? this.#repository.session;
+        const exceededMaxExecutionTime = lt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`);
+        const [updatedRow] = await session
+            .update(taskTable)
+            .set({
+            status: caseWhen(exceededMaxExecutionTime, enumValue(TaskStatus, taskStatus, TaskStatus.TimedOut)).else(taskTable.status),
+            visibilityDeadline: caseWhen(exceededMaxExecutionTime, null).else(sql `${TRANSACTION_TIMESTAMP} + ${interval(this.visibilityTimeout, 'milliseconds')}`),
+            completeTimestamp: caseWhen(exceededMaxExecutionTime, TRANSACTION_TIMESTAMP).else(taskTable.completeTimestamp),
+            error: caseWhen(exceededMaxExecutionTime, jsonbBuildObject({ code: 'MaxTimeExceeded', message: 'Hard Execution Timeout' })).else(taskTable.error),
+            progress: caseWhen(exceededMaxExecutionTime, taskTable.progress).else(isDefined(options?.progress) ? options.progress : taskTable.progress),
+            state: caseWhen(exceededMaxExecutionTime, taskTable.state).else(isDefined(options?.state) ? options.state : taskTable.state),
+        })
+            .where(and(eq(taskTable.id, task.id), eq(taskTable.status, TaskStatus.Running), isNull(task.token) ? sqlIsNull(taskTable.token) : eq(taskTable.token, task.token)))
+            .returning();
+        if (isUndefined(updatedRow)) {
             return undefined;
-        });
+        }
+        if (updatedRow.status == TaskStatus.TimedOut) {
+            await this.resolveDependencies(task.id, TaskStatus.TimedOut, { namespace: task.namespace, transaction: options?.transaction });
+            this.notify();
+            return undefined;
+        }
+        return await this.#repository.mapToEntity(updatedRow);
     }
     async touchMany(tasks, options) {
         if (tasks.length == 0) {
@@ -778,34 +773,24 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
     }
     async complete(task, options) {
         await this.#repository.useTransaction(options?.transaction, async (tx) => {
-            const [freshTask] = await tx.pgTransaction
-                .select({ unresolvedCompleteDependencies: taskTable.unresolvedCompleteDependencies })
-                .from(taskTable)
-                .where(eq(taskTable.id, task.id))
-                .for('update');
-            if (isUndefined(freshTask)) {
-                return;
-            }
-            const hasActiveChildren = freshTask.unresolvedCompleteDependencies > 0;
-            const nextStatus = hasActiveChildren ? TaskStatus.WaitingChildren : TaskStatus.Completed;
             const [updatedTask] = await tx.pgTransaction.update(taskTable)
                 .set({
-                status: nextStatus,
+                status: caseWhen(gt(taskTable.unresolvedCompleteDependencies, 0), enumValue(TaskStatus, taskStatus, TaskStatus.WaitingChildren)).else(enumValue(TaskStatus, taskStatus, TaskStatus.Completed)),
                 token: null,
                 result: options?.result,
-                progress: hasActiveChildren ? task.progress : 1,
-                completeTimestamp: (nextStatus == TaskStatus.Completed) ? TRANSACTION_TIMESTAMP : null,
+                progress: caseWhen(gt(taskTable.unresolvedCompleteDependencies, 0), task.progress).else(sql.raw('1')),
+                completeTimestamp: caseWhen(gt(taskTable.unresolvedCompleteDependencies, 0), null).else(TRANSACTION_TIMESTAMP),
                 visibilityDeadline: null,
             })
                 .where(and(eq(taskTable.id, task.id), isNull(task.token) ? sqlIsNull(taskTable.token) : eq(taskTable.token, task.token)))
-                .returning({ id: taskTable.id });
+                .returning({ id: taskTable.id, status: taskTable.status });
             if (isUndefined(updatedTask)) {
                 return;
             }
-            if (nextStatus == TaskStatus.Completed) {
+            if (updatedTask.status == TaskStatus.Completed) {
                 await this.#circuitBreaker.recordSuccess();
             }
-            await this.resolveDependencies(task.id, nextStatus, { namespace: task.namespace, transaction: tx });
+            await this.resolveDependencies(task.id, updatedTask.status, { namespace: task.namespace, transaction: tx });
         });
     }
     async completeMany(tasks, options) {
@@ -855,9 +840,9 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         const isRetryable = (options?.fatal != true) && (task.tries < this.maxTries);
         const nextStatus = isRetryable ? TaskStatus.Retrying : TaskStatus.Dead;
         const delay = isRetryable
-            ? Math.min(this.retryDelayMaximum, this.retryDelayMinimum * (this.retryDelayGrowth ** task.tries))
+            ? Math.min(this.retryDelayMaximum, this.retryDelayMinimum * (this.retryDelayGrowth ** (task.tries - 1)))
             : 0;
-        const nextSchedule = currentTimestamp() + delay;
+        const nextSchedule = sql `${TRANSACTION_TIMESTAMP} + ${interval(delay, 'milliseconds')}`;
         await this.#repository.useTransaction(options?.transaction, async (tx) => {
             const [updatedRow] = await tx.pgTransaction
                 .update(taskTable)
@@ -866,7 +851,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 token: null,
                 error: serializeError(error),
                 visibilityDeadline: null,
-                scheduleTimestamp: nextSchedule,
+                scheduleTimestamp: isRetryable ? nextSchedule : taskTable.scheduleTimestamp,
                 startTimestamp: null,
                 completeTimestamp: (nextStatus == TaskStatus.Dead) ? TRANSACTION_TIMESTAMP : null,
             })
@@ -889,31 +874,31 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 const isRetryable = (task.tries < this.maxTries);
                 const nextStatus = isRetryable ? TaskStatus.Retrying : TaskStatus.Dead;
                 const delay = isRetryable
-                    ? Math.min(this.retryDelayMaximum, this.retryDelayMinimum * (this.retryDelayGrowth ** task.tries))
+                    ? Math.min(this.retryDelayMaximum, this.retryDelayMinimum * (this.retryDelayGrowth ** (task.tries - 1)))
                     : 0;
-                const nextSchedule = new Date(currentTimestamp() + delay);
-                const completeTimestamp = (nextStatus == TaskStatus.Dead) ? new Date() : null;
-                return sql `(${task.id}::uuid, ${task.token}::uuid, ${task.tries}::int, ${nextStatus}::text, ${serializeError(error)}::jsonb, ${nextSchedule}::timestamptz, ${completeTimestamp}::timestamptz)`;
+                const nextSchedule = sql `(${TRANSACTION_TIMESTAMP} + ${interval(delay, 'milliseconds')})`;
+                const completeTimestamp = (nextStatus == TaskStatus.Dead) ? TRANSACTION_TIMESTAMP : null;
+                return sql `(${task.id}::uuid, ${task.token}::uuid, ${task.tries}::int, ${nextStatus}::${taskStatus}, ${serializeError(error)}::jsonb, ${nextSchedule}::timestamptz, ${completeTimestamp}::timestamptz)`;
             });
             const updates = tx.pgTransaction.$with('updates').as((qb) => qb
                 .select({
-                updateId: sql `(id)::uuid`.as('update_id'),
-                updateToken: sql `(token)::uuid`.as('update_token'),
-                updateTries: sql `(tries)::int`.as('update_tries'),
-                updateStatus: sql `(status)::text`.as('update_status'),
-                updateError: sql `(error)::jsonb`.as('update_error'),
-                updateSchedule: sql `(schedule_timestamp)::timestamptz`.as('update_schedule'),
-                updateComplete: sql `(complete_timestamp)::timestamptz`.as('update_complete'),
+                updateId: sql `(id)`.as('update_id'),
+                updateToken: sql `(token)`.as('update_token'),
+                updateTries: sql `(tries)`.as('update_tries'),
+                updateStatus: sql `(status)`.as('update_status'),
+                updateError: sql `(error)`.as('update_error'),
+                updateSchedule: sql `(schedule_timestamp)`.as('update_schedule'),
+                updateComplete: sql `(complete_timestamp)`.as('update_complete'),
             })
                 .from(sql `(VALUES ${sql.join(rows, sql `, `)}) AS t(id, token, tries, status, error, schedule_timestamp, complete_timestamp)`));
             const updated = tx.pgTransaction.$with('updated').as(() => tx.pgTransaction
                 .update(taskTable)
                 .set({
-                status: sql `${updates.updateStatus}::${taskStatus}`,
+                status: sql `${updates.updateStatus}`,
                 token: null,
                 error: sql `${updates.updateError}`,
                 visibilityDeadline: null,
-                scheduleTimestamp: sql `${updates.updateSchedule}`,
+                scheduleTimestamp: caseWhen(eq(updates.updateStatus, TaskStatus.Retrying), updates.updateSchedule).else(taskTable.scheduleTimestamp),
                 startTimestamp: null,
                 completeTimestamp: sql `${updates.updateComplete}`,
             })
@@ -934,41 +919,41 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         await this.resolveDependenciesMany([{ id, status, namespace: options?.namespace }], options);
     }
     async resolveDependenciesMany(tasks, options) {
-        if (tasks.length == 0) {
+        const tasksToResolve = tasks.filter((t) => terminalStatuses.includes(t.status));
+        if (tasksToResolve.length == 0) {
             return;
         }
-        const taskStatusMap = new Map(tasks.map((t) => [t.id, t.status]));
         const notifiedNamespaces = new Set();
         await this.#repository.useTransaction(options?.transaction, async (tx) => {
-            const taskIds = tasks.map((t) => t.id);
-            const dependents = await tx.pgTransaction
+            const taskValues = tasksToResolve.map((t) => sql `(${t.id}::uuid, ${t.status}::${taskStatus})`);
+            // 1. CTE: Load the incoming terminal tasks into a memory table
+            const resolvedTasks = tx.pgTransaction.$with('resolved_tasks').as((qb) => qb
                 .select({
-                taskId: taskDependencyTable.taskId,
-                dependencyTaskId: taskDependencyTable.dependencyTaskId,
-                type: taskDependencyTable.type,
-                requiredStatuses: taskDependencyTable.requiredStatuses,
+                resolvedId: sql `(id)`.as('resolved_id'),
+                resolvedStatus: sql `(status)`.as('resolved_status'),
             })
-                .from(taskDependencyTable)
-                .where(inArray(taskDependencyTable.dependencyTaskId, taskIds));
-            if (dependents.length == 0) {
-                return;
-            }
-            const resolvedEdges = [];
-            const abortOnDependencyFailureTaskIds = new Set();
-            for (const dep of dependents) {
-                const status = taskStatusMap.get(dep.dependencyTaskId);
-                const isMatched = dep.requiredStatuses.includes(status);
-                const isTerminal = terminalStatuses.includes(status);
-                if (isMatched || isTerminal) {
-                    resolvedEdges.push(dep);
-                    if (!isMatched) {
-                        abortOnDependencyFailureTaskIds.add(dep.taskId);
-                    }
-                }
-            }
+                .from(sql `(VALUES ${sql.join(taskValues, sql `, `)}) AS t(id, status)`));
+            // 2. CTE: Atomically delete all edges pointing to these terminal tasks and return them
+            const deletedEdges = tx.pgTransaction.$with('deleted_edges').as(() => tx.pgTransaction
+                .delete(taskDependencyTable)
+                .where(inArray(taskDependencyTable.dependencyTaskId, tx.pgTransaction.select({ id: resolvedTasks.resolvedId }).from(resolvedTasks)))
+                .returning());
+            // 3. Execute: Join deleted edges with their resolving status to determine if they matched the required status
+            const resolvedEdges = await tx.pgTransaction
+                .with(resolvedTasks, deletedEdges)
+                .select({
+                taskId: deletedEdges.taskId,
+                dependencyTaskId: deletedEdges.dependencyTaskId,
+                type: deletedEdges.type,
+                isMatched: sql `${resolvedTasks.resolvedStatus} = ANY(${deletedEdges.requiredStatuses})`.as('is_matched'),
+            })
+                .from(deletedEdges)
+                .innerJoin(resolvedTasks, eq(deletedEdges.dependencyTaskId, resolvedTasks.resolvedId));
             if (resolvedEdges.length == 0) {
                 return;
             }
+            // Extract skipped dependencies (terminal status but not a matched status)
+            const abortOnDependencyFailureTaskIds = distinct(resolvedEdges.filter((d) => !d.isMatched).map((d) => d.taskId));
             const sortedResolvedEdges = resolvedEdges.toSorted((a, b) => {
                 const idCompare = a.taskId.localeCompare(b.taskId);
                 if (idCompare != 0) {
@@ -980,18 +965,10 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 }
                 return a.type.localeCompare(b.type);
             });
-            const edgeValues = sortedResolvedEdges.map((e) => sql `(${e.taskId}::uuid, ${e.dependencyTaskId}::uuid, ${e.type}::text)`);
-            await tx.pgTransaction.execute(sql `
-        DELETE FROM ${taskDependencyTable}
-        WHERE (task_id, dependency_task_id, type) IN (
-          SELECT t.task_id, t.dependency_task_id, t.type::${taskDependencyType}
-          FROM (VALUES ${sql.join(edgeValues, sql `, `)}) AS t(task_id, dependency_task_id, type)
-        )
-      `);
             const terminalTasks = [];
             const skippedTaskIds = new Set();
-            if (abortOnDependencyFailureTaskIds.size > 0) {
-                const sortedAbortIds = [...abortOnDependencyFailureTaskIds].toSorted();
+            if (abortOnDependencyFailureTaskIds.length > 0) {
+                const sortedAbortIds = abortOnDependencyFailureTaskIds.toSorted();
                 const dependentTasks = await tx.pgTransaction
                     .select({ id: taskTable.id, namespace: taskTable.namespace, abortOnDependencyFailure: taskTable.abortOnDependencyFailure, status: taskTable.status })
                     .from(taskTable)
@@ -1054,7 +1031,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                     .set({
                     unresolvedScheduleDependencies: greatest(0, sql `${taskTable.unresolvedScheduleDependencies} - ${updates.scheduleDecrement}`),
                     unresolvedCompleteDependencies: greatest(0, sql `${taskTable.unresolvedCompleteDependencies} - ${updates.completeDecrement}`),
-                    status: caseWhen(and(eq(taskTable.status, TaskStatus.Waiting), eq(greatest(0, sql `${taskTable.unresolvedScheduleDependencies} - ${updates.scheduleDecrement}`), 0)), enumValue(TaskStatus, taskStatus, TaskStatus.Pending)).else(caseWhen(and(eq(taskTable.status, TaskStatus.WaitingChildren), eq(greatest(0, sql `${taskTable.unresolvedCompleteDependencies} - ${updates.completeDecrement}`), 0)), enumValue(TaskStatus, taskStatus, TaskStatus.Completed)).else(taskTable.status)),
+                    status: caseWhen(and(eq(taskTable.status, TaskStatus.Waiting), eq(greatest(0, sql `${taskTable.unresolvedScheduleDependencies} - ${updates.scheduleDecrement}`), 0)), TaskStatus.Pending).else(caseWhen(and(eq(taskTable.status, TaskStatus.WaitingChildren), eq(greatest(0, sql `${taskTable.unresolvedCompleteDependencies} - ${updates.completeDecrement}`), 0)), TaskStatus.Completed).else(taskTable.status)),
                     progress: caseWhen(and(eq(taskTable.status, TaskStatus.WaitingChildren), eq(greatest(0, sql `${taskTable.unresolvedCompleteDependencies} - ${updates.completeDecrement}`), 0)), 1).else(taskTable.progress),
                     completeTimestamp: caseWhen(and(eq(taskTable.status, TaskStatus.WaitingChildren), eq(greatest(0, sql `${taskTable.unresolvedCompleteDependencies} - ${updates.completeDecrement}`), 0)), TRANSACTION_TIMESTAMP).else(taskTable.completeTimestamp),
                     token: caseWhen(and(eq(taskTable.status, TaskStatus.WaitingChildren), eq(greatest(0, sql `${taskTable.unresolvedCompleteDependencies} - ${updates.completeDecrement}`), 0)), null).else(taskTable.token),
@@ -1086,47 +1063,50 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         }
     }
     async maintenance(options) {
-        await Promise.allSettled([
-            this.processExpirations(options),
-            this.processZombieRetries(options),
-            this.processZombieExhaustions(options),
-            this.processHardTimeouts(options),
-            this.processPriorityAging(options),
-        ]);
+        await this.processExpirations(options);
+        await this.processZombieRetries(options);
+        await this.processZombieExhaustions(options);
+        await this.processHardTimeouts(options);
+        await this.processPriorityAging(options);
         await this.performArchival(options);
         await this.performArchivePurge(options);
     }
     async performArchival(options) {
+        const session = options?.transaction?.pgTransaction ?? this.#repository.session;
         while (true) {
-            const archivedCount = await this.#repository.useTransaction(options?.transaction, async (tx) => {
-                const childTaskTable = aliasedTable(taskTable, 'childTask');
-                const rowsToArchive = await tx.pgTransaction
-                    .select()
-                    .from(taskTable)
-                    .where(and(eq(taskTable.namespace, this.#namespace), inArray(taskTable.status, terminalStatuses), lte(taskTable.completeTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.retention, 'milliseconds')}`), notExists(tx.pgTransaction
-                    .select({ id: childTaskTable.id })
-                    .from(childTaskTable)
-                    .where(eq(childTaskTable.parentId, taskTable.id))), notExists(tx.pgTransaction
-                    .select({ taskId: taskDependencyTable.taskId })
-                    .from(taskDependencyTable)
-                    .where(eq(taskDependencyTable.dependencyTaskId, taskTable.id)))))
-                    .limit(1000)
-                    .for('update', { skipLocked: true });
-                if (rowsToArchive.length > 0) {
-                    const rowsToArchiveIds = getEntityIds(rowsToArchive);
-                    await tx.pgTransaction.insert(taskArchiveTable).values(rowsToArchive);
-                    await tx.pgTransaction.delete(taskTable).where(inArray(taskTable.id, rowsToArchiveIds));
-                }
-                return rowsToArchive.length;
-            });
-            if (archivedCount < 1000) {
+            const childTaskTable = aliasedTable(taskTable, 'childTask');
+            const selection = session.$with('selection').as((qb) => qb
+                .select({ id: taskTable.id })
+                .from(taskTable)
+                .where(and(eq(taskTable.namespace, this.#namespace), inArray(taskTable.status, terminalStatuses), lte(taskTable.completeTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.retention, 'milliseconds')}`), notExists(session
+                .select({ id: childTaskTable.id })
+                .from(childTaskTable)
+                .where(eq(childTaskTable.parentId, taskTable.id))), notExists(session
+                .select({ taskId: taskDependencyTable.taskId })
+                .from(taskDependencyTable)
+                .where(eq(taskDependencyTable.dependencyTaskId, taskTable.id)))))
+                .limit(1000)
+                .for('update', { skipLocked: true }));
+            const deleted = session.$with('deleted').as(() => session
+                .delete(taskTable)
+                .where(inArray(taskTable.id, session.select().from(selection)))
+                .returning());
+            const inserted = session.$with('inserted').as(() => session
+                .insert(taskArchiveTable)
+                .select(session.select().from(deleted))
+                .returning({ id: taskArchiveTable.id }));
+            const [result] = await session
+                .with(selection, deleted, inserted)
+                .select({ count: count() })
+                .from(inserted);
+            if ((result?.count ?? 0) < 1000) {
                 break;
             }
         }
     }
     async performArchivePurge(options) {
-        const session = options?.transaction?.pgTransaction ?? this.#database;
-        const selection = session.$with('archive_purge_selection').as((qb) => qb
+        const session = options?.transaction?.pgTransaction ?? this.#repository.session;
+        const selection = session.$with('selection').as((qb) => qb
             .select({ id: taskArchiveTable.id })
             .from(taskArchiveTable)
             .where(and(eq(taskArchiveTable.namespace, this.#namespace), lte(taskArchiveTable.completeTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.archiveRetention, 'milliseconds')}`)))
@@ -1143,7 +1123,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         }
     }
     async processExpirations(options) {
-        const expiredSelection = this.#database.$with('expired_selection').as((qb) => qb
+        const expiredSelection = this.#repository.session.$with('expired_selection').as((qb) => qb
             .select({ id: taskTable.id })
             .from(taskTable)
             .where(and(eq(taskTable.namespace, this.#namespace), inArray(taskTable.status, queueableOrWaitableStatuses), lt(taskTable.timeToLive, TRANSACTION_TIMESTAMP)))
@@ -1173,7 +1153,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         }
     }
     async processZombieRetries(options) {
-        const session = options?.transaction?.pgTransaction ?? this.#database;
+        const session = options?.transaction?.pgTransaction ?? this.#repository.session;
         const zombieRetrySelection = session.$with('zombie_retry_selection').as((qb) => qb
             .select({ id: taskTable.id })
             .from(taskTable)
@@ -1189,7 +1169,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 token: null,
                 visibilityDeadline: null,
                 startTimestamp: null,
-                scheduleTimestamp: sql `${TRANSACTION_TIMESTAMP} + ${interval(this.retryDelayMinimum, 'milliseconds')}`, // Simple backoff for zombies
+                scheduleTimestamp: sql `${TRANSACTION_TIMESTAMP} + ${interval(least(this.retryDelayMaximum, sql `${this.retryDelayMinimum} * ${power(this.retryDelayGrowth, sql `${taskTable.tries} - 1`)}`), 'milliseconds')}`,
                 error: jsonbBuildObject({ code: 'VisibilityTimeout', message: 'Worker Lost', lastError: taskTable.error }),
             })
                 .where(inArray(taskTable.id, session.select().from(zombieRetrySelection)))
@@ -1200,7 +1180,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         }
     }
     async processZombieExhaustions(options) {
-        const zombieExhaustionSelection = this.#database.$with('zombie_exhaustion_selection').as((qb) => qb
+        const zombieExhaustionSelection = this.#repository.session.$with('selection').as((qb) => qb
             .select({ id: taskTable.id })
             .from(taskTable)
             .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Running), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP), gte(taskTable.tries, this.maxTries)))
@@ -1231,7 +1211,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         }
     }
     async processHardTimeouts(options) {
-        const timeoutSelection = this.#database.$with('timeout_selection').as((qb) => qb
+        const timeoutSelection = this.#repository.session.$with('selection').as((qb) => qb
             .select({ id: taskTable.id })
             .from(taskTable)
             .where(and(eq(taskTable.namespace, this.#namespace), eq(taskTable.status, TaskStatus.Running), lt(taskTable.startTimestamp, sql `${TRANSACTION_TIMESTAMP} - ${interval(this.maxExecutionTime, 'milliseconds')}`)))
@@ -1262,7 +1242,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         }
     }
     async processPriorityAging(options) {
-        const session = options?.transaction?.pgTransaction ?? this.#database;
+        const session = options?.transaction?.pgTransaction ?? this.#repository.session;
         const agingSelection = session.$with('aging_selection').as((qb) => qb
             .select({ id: taskTable.id })
             .from(taskTable)
@@ -1285,8 +1265,8 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         }
     }
     async restart(id, options) {
-        const repository = this.#repository.withOptionalTransaction(options?.transaction);
-        await repository.session
+        const session = options?.transaction?.pgTransaction ?? this.#repository.session;
+        const [updatedTask] = await session
             .update(taskTable)
             .set({
             status: TaskStatus.Pending,
@@ -1301,7 +1281,12 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             priorityAgeTimestamp: TRANSACTION_TIMESTAMP,
             state: (options?.resetState == true) ? null : undefined,
         })
-            .where(and(eq(taskTable.id, id), or(inArray(taskTable.status, queueableStatuses), inArray(taskTable.status, terminalStatuses), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP))));
+            .where(and(eq(taskTable.id, id), or(inArray(taskTable.status, queueableStatuses), inArray(taskTable.status, terminalStatuses), lt(taskTable.visibilityDeadline, TRANSACTION_TIMESTAMP))))
+            .returning();
+        if (isUndefined(updatedTask)) {
+            throw new NotFoundError('Task not found or not in a restartable state.');
+        }
+        this.notify(updatedTask.namespace);
     }
     notify(namespace = this.#namespace) {
         this.#messageBus.publishAndForget(namespace);

package/task-queue/tests/optimization-edge-cases.test.d.ts

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

package/task-queue/tests/optimization-edge-cases.test.js

@@ -0,0 +1,127 @@
+import { and, eq, sql } from 'drizzle-orm';
+import { beforeAll, describe, expect, vi } from 'vitest';
+import { inject } from '../../injector/index.js';
+import { TRANSACTION_TIMESTAMP } from '../../orm/index.js';
+import { injectRepository } from '../../orm/server/index.js';
+import { setupIntegrationTest, testInInjector } from '../../testing/index.js';
+import { timeout } from '../../utils/timing.js';
+import { taskArchive as taskArchiveTable, taskDependency as taskDependencyTable, task as taskTable } from '../postgres/schemas.js';
+import { PostgresTaskQueue } from '../postgres/task-queue.js';
+import { PostgresTask, PostgresTaskArchive } from '../postgres/task.model.js';
+import { TaskDependencyType, TaskStatus } from '../task-queue.js';
+describe('Task Queue Optimization Edge Cases', () => {
+    let context;
+    beforeAll(async () => {
+        context = await setupIntegrationTest({ modules: { taskQueue: true } });
+    });
+    testInInjector('should notify unique namespaces exactly once in incrementCounters', () => context.injector, async () => {
+        const q1 = inject(PostgresTaskQueue, 'ns-1');
+        const q2 = inject(PostgresTaskQueue, 'ns-2');
+        const notifySpy = vi.spyOn(PostgresTaskQueue.prototype, 'notify');
+        const [t1] = await q1.enqueueMany([{ type: 't1', data: {} }], { returnTasks: true });
+        const [t2] = await q2.enqueueMany([{ type: 't2', data: {} }], { returnTasks: true });
+        notifySpy.mockClear();
+        await q1.incrementCounters([
+            { taskId: t1.id, dependencyTaskId: 'some-dep', type: TaskDependencyType.Schedule },
+            { taskId: t2.id, dependencyTaskId: 'some-dep', type: TaskDependencyType.Schedule },
+            { taskId: t1.id, dependencyTaskId: 'other-dep', type: TaskDependencyType.Schedule },
+        ]);
+        const notifiedNamespaces = notifySpy.mock.calls.map(call => call[0]);
+        expect(notifiedNamespaces).toContain('ns-1');
+        expect(notifiedNamespaces).toContain('ns-2');
+        expect(notifiedNamespaces.filter(n => n == 'ns-1').length).toBe(1);
+        expect(notifiedNamespaces.filter(n => n == 'ns-2').length).toBe(1);
+    });
+    testInInjector('should resolve edge and abort on unmatched terminal status in resolveDependenciesMany', () => context.injector, async () => {
+        const queue = inject(PostgresTaskQueue, 'test-namespace');
+        const repository = injectRepository(PostgresTask);
+        const [parent] = await queue.enqueueMany([{ type: 'parent', data: {}, abortOnDependencyFailure: true }], { returnTasks: true });
+        const [child] = await queue.enqueueMany([{ type: 'child', data: {} }], { returnTasks: true });
+        await repository.session.insert(taskDependencyTable).values({
+            taskId: parent.id,
+            dependencyTaskId: child.id,
+            type: TaskDependencyType.Schedule,
+            requiredStatuses: [TaskStatus.Completed],
+        });
+        await repository.session.update(taskTable).set({ unresolvedScheduleDependencies: 1, status: TaskStatus.Waiting }).where(eq(taskTable.id, parent.id));
+        await queue.resolveDependenciesMany([{ id: child.id, status: TaskStatus.Dead, namespace: 'test-namespace' }]);
+        const updatedParent = await queue.getTask(parent.id);
+        expect(updatedParent.status).toBe(TaskStatus.Skipped);
+    });
+    testInInjector('should handle hard timeout during touch', () => context.injector, async () => {
+        // Configure with small maxExecutionTime
+        const queue = inject(PostgresTaskQueue, { namespace: 'timeout-test', maxExecutionTime: 10 });
+        const [task] = await queue.enqueueMany([{ type: 'test', data: {} }], { returnTasks: true });
+        const [runningTask] = await queue.dequeueMany(1);
+        await timeout(50);
+        const result = await queue.touch(runningTask);
+        expect(result).toBeUndefined();
+        const updated = await queue.getTask(runningTask.id);
+        expect(updated.status).toBe(TaskStatus.TimedOut);
+    });
+    testInInjector('should handle non-existent tasks in complete and fail', () => context.injector, async () => {
+        const queue = inject(PostgresTaskQueue, 'missing-test');
+        const fakeTask = { id: crypto.randomUUID(), token: crypto.randomUUID(), tries: 0 };
+        await expect(queue.complete(fakeTask)).resolves.toBeUndefined();
+        await expect(queue.fail(fakeTask, new Error('fail'))).resolves.toBeUndefined();
+    });
+    testInInjector('should handle terminal tasks with no dependents in resolveDependenciesMany', () => context.injector, async () => {
+        const queue = inject(PostgresTaskQueue, 'no-deps-test');
+        const [task] = await queue.enqueueMany([{ type: 'test', data: {} }], { returnTasks: true });
+        await queue.resolveDependenciesMany([{ id: task.id, status: TaskStatus.Completed }]);
+    });
+    testInInjector('should handle archival and purge in maintenance', () => context.injector, async () => {
+        const namespace = `archival-test-${crypto.randomUUID()}`;
+        // Configure with small retention
+        const queue = inject(PostgresTaskQueue, { namespace, retention: 1000, archiveRetention: 1000 });
+        const repository = injectRepository(PostgresTask);
+        const archiveRepository = injectRepository(PostgresTaskArchive);
+        const [task] = await queue.enqueueMany([{ type: 'test', data: {} }], { returnTasks: true });
+        await repository.session.update(taskTable)
+            .set({
+            status: TaskStatus.Completed,
+            completeTimestamp: sql `${TRANSACTION_TIMESTAMP} - interval '2 seconds'`,
+        })
+            .where(and(eq(taskTable.id, task.id), eq(taskTable.namespace, namespace)));
+        await queue.performArchival();
+        const archived = await archiveRepository.load(task.id);
+        expect(archived).toBeDefined();
+        await repository.session.update(taskArchiveTable)
+            .set({ completeTimestamp: sql `${TRANSACTION_TIMESTAMP} - interval '2 seconds'` })
+            .where(and(eq(taskArchiveTable.id, task.id), eq(taskArchiveTable.namespace, namespace)));
+        await queue.performArchivePurge();
+        const purged = await archiveRepository.load(task.id).catch(() => undefined);
+        expect(purged).toBeUndefined();
+    });
+    testInInjector('should notify on restart', () => context.injector, async () => {
+        const namespace = `restart-test-${crypto.randomUUID()}`;
+        const queue = inject(PostgresTaskQueue, namespace);
+        const notifySpy = vi.spyOn(PostgresTaskQueue.prototype, 'notify');
+        const [task] = await queue.enqueueMany([{ type: 'test', data: {} }], { returnTasks: true });
+        await queue.cancelMany([task.id]);
+        notifySpy.mockClear();
+        await queue.restart(task.id);
+        expect(notifySpy).toHaveBeenCalledWith(namespace);
+    });
+    testInInjector('should use exponential backoff for zombies', () => context.injector, async () => {
+        const namespace = `zombie-backoff-${crypto.randomUUID()}`;
+        // Configure with standard growth
+        const queue = inject(PostgresTaskQueue, { namespace, retryDelayMinimum: 1000, retryDelayGrowth: 2 });
+        const repository = injectRepository(PostgresTask);
+        const [task] = await queue.enqueueMany([{ type: 'test', data: {} }], { returnTasks: true });
+        await queue.dequeueMany(1);
+        await repository.session.update(taskTable)
+            .set({
+            status: TaskStatus.Running,
+            visibilityDeadline: sql `${TRANSACTION_TIMESTAMP} - interval '1 minute'`,
+            tries: 2,
+        })
+            .where(and(eq(taskTable.id, task.id), eq(taskTable.namespace, namespace)));
+        await queue.processZombieRetries();
+        const updated = await queue.getTask(task.id);
+        expect(updated.status).toBe(TaskStatus.Retrying);
+        const delay = updated.scheduleTimestamp - Date.now();
+        expect(delay).toBeGreaterThan(1000);
+        expect(delay).toBeLessThan(3000);
+    });
+});

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/test5.js

@@ -3,12 +3,18 @@ import { Application } from './application/application.js';
 import { provideModule, provideSignalHandler } from './application/index.js';
 import { PrettyPrintLogFormatter } from './logger/index.js';
 import { provideConsoleLogTransport } from './logger/transports/console.js';
+import { TaskQueue } from './task-queue/task-queue.js';
+import { setupIntegrationTest } from './testing/integration-setup.js';
+import { createArray } from './utils/array/array.js';
+import { timedBenchmarkAsync } from './utils/benchmark.js';
 async function main(_cancellationSignal) {
-    const arr = [1, 2, 3, 4, 5];
-    for (const item of arr) {
-        console.log(item);
-        arr.push(arr.at(-1) + 1);
-    }
+    const { injector } = await setupIntegrationTest({ modules: { taskQueue: true } });
+    const queue1 = injector.resolve(TaskQueue, 'namespace-1');
+    const batch = createArray(1000, (i) => ({ type: 'test', data: { index: i } }));
+    const enqueueResult = await timedBenchmarkAsync(1000, async () => {
+        await queue1.enqueueMany(batch);
+    });
+    console.log(enqueueResult.operationsPerMillisecond * batch.length * 1000, 'items/s');
 }
 Application.run('Test', [
     provideConsoleLogTransport(PrettyPrintLogFormatter),

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')),