@tstdl/base 0.93.140 → 0.93.141

package/task-queue/tests/worker.test.js

@@ -59,7 +59,7 @@ describe('Worker & Base Class Tests', () => {
         // Wait until task is processed (error recorded and status is Pending)
         for (let i = 0; i < 50; i++) {
             const updated = await queue.getTask(task.id);
-            if (updated?.tries == 1) {
+            if (updated?.tries == 1 && updated.status == TaskStatus.Pending) {
                 break;
             }
             await timeout(20);
@@ -134,16 +134,31 @@ describe('Worker & Base Class Tests', () => {
             // Other queue spawn
             const otherQueue = injector.resolve(TaskQueueProvider).get('other-queue');
             const otherChild = await context.spawn(otherQueue, 'other', { x: 1 });
-            expect(otherChild.parentId).toBe(task.id);
             expect(otherChild.namespace).toBe('other-queue');
-            const otherChildren = await context.spawnMany(otherQueue, [{ type: 'other', data: { x: 2 } }]);
-            expect(otherChildren[0]?.parentId).toBe(task.id);
+            await context.spawnMany(otherQueue, [{ type: 'other', data: { x: 2 } }]);
             executed = true;
             return TaskProcessResult.Complete();
         });
-        await queue.waitForTasks([task.id], { interval: 50, timeout: 1000 });
+        // Complete children so parent can finalize
+        void (async () => {
+            while (!executed) {
+                await timeout(50);
+            }
+            // At this point parent should be WaitingChildren if children are not done
+            const midTask = await queue.getTask(task.id);
+            expect(midTask?.status).toBe(TaskStatus.WaitingChildren);
+            while (true) {
+                const dChild = await queue.dequeue({ types: ['child'] });
+                if (!dChild)
+                    break;
+                await queue.complete(dChild);
+            }
+        })();
+        await queue.waitForTasks([task.id], { interval: 50, timeout: 5000 });
         token.set();
         expect(executed).toBe(true);
+        const finalTask = await queue.getTask(task.id);
+        expect(finalTask?.status).toBe(TaskStatus.Completed);
     });
     it('should correctly report isFinalAttempt in TaskContext', async () => {
         const queueProvider = injector.resolve(TaskQueueProvider);

package/task-queue/tests/zombie-parent.test.d.ts

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

package/task-queue/tests/zombie-parent.test.js

@@ -0,0 +1,45 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
+import { timeout } from '../../utils/timing.js';
+describe('Zombie Parent Deadlock', () => {
+    let injector;
+    let queue;
+    beforeAll(async () => {
+        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
+    });
+    beforeEach(() => {
+        const queueProvider = injector.resolve(TaskQueueProvider);
+        const queueName = `zombie-queue-${Date.now()}-${Math.random()}`;
+        queue = queueProvider.get(queueName, {
+            visibilityTimeout: 1000,
+        });
+    });
+    afterEach(async () => {
+        await queue.clear();
+    });
+    afterAll(async () => {
+        await injector?.dispose();
+    });
+    it('should resolve parent even if child fails (failFast: false)', async () => {
+        const parent = await queue.enqueue('parent', {});
+        const dParent = await queue.dequeue();
+        // Spawn a child that will fail. Parent has failFast: false by default.
+        const [child] = await queue.enqueueMany([{ type: 'child', data: {}, parentId: parent.id, failFast: false }], { returnTasks: true });
+        await queue.complete(dParent);
+        // Parent should be WaitingChildren
+        const uParent = await queue.getTask(parent.id);
+        expect(uParent?.status).toBe(TaskStatus.WaitingChildren);
+        // Fail the child fatally
+        const dChild = await queue.dequeue();
+        await queue.fail(dChild, new Error('child failed'), { fatal: true });
+        // Verify child is Dead
+        const uChild = await queue.getTask(child.id);
+        expect(uChild?.status).toBe(TaskStatus.Dead);
+        // Wait a bit for dependency resolution
+        await timeout(200);
+        // Parent should NOT be stuck. It should transition to Completed because the child is terminal.
+        const fParent = await queue.getTask(parent.id);
+        expect(fParent?.status).toBe(TaskStatus.Completed);
+    });
+});

package/task-queue/tests/zombie-recovery.test.d.ts

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

package/task-queue/tests/zombie-recovery.test.js

@@ -0,0 +1,51 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
+import { timeout } from '../../utils/timing.js';
+describe('Zombie Recovery Race Condition', () => {
+    let injector;
+    let queue;
+    beforeAll(async () => {
+        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
+    });
+    beforeEach(() => {
+        const queueProvider = injector.resolve(TaskQueueProvider);
+        const queueName = `zombie-recovery-queue-${Date.now()}-${Math.random()}`;
+        queue = queueProvider.get(queueName, {
+            visibilityTimeout: 100, // Very short visibility timeout
+            retryDelayMinimum: 0,
+        });
+    });
+    afterEach(async () => {
+        await queue.clear();
+    });
+    afterAll(async () => {
+        await injector?.dispose();
+    });
+    it('should NOT prematurely complete a recovered parent when children finish', async () => {
+        // 1. Enqueue parent
+        const parent = await queue.enqueue('parent', {});
+        // 2. Dequeue parent (it is now Running, startTimestamp is set)
+        const dParent = await queue.dequeue();
+        expect(dParent?.id).toBe(parent.id);
+        expect(dParent?.startTimestamp).not.toBeNull();
+        // 3. Parent spawns a child that it waits for
+        const [child] = await queue.enqueueMany([{ type: 'child', data: {}, parentId: parent.id }], { returnTasks: true });
+        // 4. Simulate crash: Wait for visibility timeout so it becomes a zombie
+        await timeout(200);
+        // 5. Run maintenance to recover the zombie parent
+        await queue.maintenance();
+        // Verify it was recovered to Pending
+        const recoveredParent = await queue.getTask(parent.id);
+        expect(recoveredParent?.status).toBe(TaskStatus.Pending);
+        // If the bug exists, startTimestamp is still set here.
+        // 6. Complete the child while parent is still Pending
+        const dChild = await queue.dequeue({ types: ['child'] });
+        await queue.complete(dChild);
+        // 7. Verify parent status
+        // BUG: evaluateTaskStatus will see unresolvedCompleteDependencies=0 and startTimestamp != null,
+        // and incorrectly transition the Pending parent to Completed.
+        const finalParent = await queue.getTask(parent.id);
+        expect(finalParent?.status).toBe(TaskStatus.Pending); // It should still be pending execution!
+    });
+});

package/test5.js

@@ -1,14 +1,14 @@
 import './polyfills.js';
-import { promptBuilder } from './ai/index.js';
 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';
 async function main(_cancellationSignal) {
-    const x = promptBuilder();
-    console.log(x.buildSystemPrompt()[0].text);
-    console.log('\n\n---\n\n');
-    console.log(x.buildUserPrompt()[0].text);
+    const arr = [1, 2, 3, 4, 5];
+    for (const item of arr) {
+        console.log(item);
+        arr.push(arr.at(-1) + 1);
+    }
 }
 Application.run('Test', [
     provideConsoleLogTransport(PrettyPrintLogFormatter),

package/testing/integration-setup.d.ts

@@ -3,6 +3,7 @@ import { type AuthenticationAncillaryService } from '../authentication/server/in
 import { Injector } from '../injector/index.js';
 import { LogLevel } from '../logger/index.js';
 import { type S3ObjectStorageProviderConfig } from '../object-storage/s3/index.js';
+import type { EntityType } from '../orm/entity.js';
 import { Database } from '../orm/server/index.js';
 import type { Type } from '../types/index.js';
 export type IntegrationTestOptions = {
@@ -30,7 +31,6 @@ export type IntegrationTestOptions = {
         rateLimiter?: boolean;
         signals?: boolean;
         taskQueue?: boolean;
-        test?: boolean;
         webServer?: boolean;
     };
     authenticationAncillaryService?: Type<AuthenticationAncillaryService>;
@@ -47,14 +47,14 @@ export declare function setupIntegrationTest(options?: IntegrationTestOptions):
  * Helper to truncate specific tables in a schema.
  * Useful in beforeEach() to reset state.
  */
-export declare function truncateTables(database: Database, schema: string, tables: string[]): Promise<void>;
+export declare function truncateTables(database: Database, schema: string, tables: (string | EntityType)[]): Promise<void>;
 /**
  * Helper to delete data for a specific tenant from specific tables.
  * Useful for parallel tests to avoid interference.
  */
-export declare function clearTenantData(database: Database, schema: string, tables: string[], tenantId: string): Promise<void>;
+export declare function clearTenantData(database: Database, schema: string | undefined, tables: (string | EntityType)[], tenantId: string): Promise<void>;
 /**
  * Helper to drop specific tables.
  * Useful in beforeAll() cleanups.
  */
-export declare function dropTables(database: Database, schema: string, tables: string[]): Promise<void>;
+export declare function dropTables(database: Database, schema: string | undefined, tables: (string | EntityType)[]): Promise<void>;

package/testing/integration-setup.js

@@ -1,30 +1,31 @@
 import { sql } from 'drizzle-orm';
 import { configureApiServer } from '../api/server/index.js';
-import { configureAudit, migrateAuditSchema } from '../audit/index.js';
+import { configureAudit } from '../audit/index.js';
 import { AuthenticationApiClient } from '../authentication/client/api.client.js';
 import { configureAuthenticationClient } from '../authentication/client/index.js';
-import { AuthenticationApiController, configureAuthenticationServer, migrateAuthenticationSchema } from '../authentication/server/index.js';
-import { configurePostgresCircuitBreaker, migratePostgresCircuitBreaker } from '../circuit-breaker/postgres/module.js';
-import { configureDocumentManagement, migrateDocumentManagementSchema } from '../document-management/server/index.js';
+import { AuthenticationApiController, configureAuthenticationServer } from '../authentication/server/index.js';
+import { configurePostgresCircuitBreaker } from '../circuit-breaker/postgres/module.js';
+import { configureDocumentManagement } from '../document-management/server/index.js';
 import { configureUndiciHttpClientAdapter } from '../http/client/adapters/undici.adapter.js';
 import { configureHttpClient } from '../http/client/index.js';
 import { HttpServer } from '../http/server/index.js';
 import { configureNodeHttpServer } from '../http/server/node/module.js';
 import { Injector, runInInjectionContext } from '../injector/index.js';
-import { configurePostgresKeyValueStore, migratePostgresKeyValueStoreSchema } from '../key-value-store/postgres/module.js';
-import { configurePostgresLock, migratePostgresLockSchema } from '../lock/postgres/module.js';
+import { configurePostgresKeyValueStore } from '../key-value-store/postgres/module.js';
+import { configurePostgresLock } from '../lock/postgres/module.js';
 import { ConsoleLogTransport, DEFAULT_LOG_LEVEL, LogFormatter, LogLevel, LogManager, LogTransport, PrettyPrintLogFormatter } from '../logger/index.js';
 import { configureLocalMessageBus } from '../message-bus/index.js';
 import { configureWebServerModule, WebServerModule } from '../module/modules/web-server.module.js';
-import { configureNotification, migrateNotificationSchema } from '../notification/server/index.js';
+import { configureNotification } from '../notification/server/index.js';
 import { configureS3ObjectStorage } from '../object-storage/s3/index.js';
-import { configureOrm, Database } from '../orm/server/index.js';
-import { configurePostgresRateLimiter, migratePostgresRateLimiterSchema } from '../rate-limit/postgres/module.js';
+import { configureOrm, Database, runDatabaseMigrations } from '../orm/server/index.js';
+import { getEntitySchema, getEntityTableName } from '../orm/utils.js';
+import { configurePostgresRateLimiter } from '../rate-limit/postgres/module.js';
 import { configureDefaultSignalsImplementation } from '../signals/implementation/configure.js';
-import { configurePostgresTaskQueue, migratePostgresTaskQueueSchema } from '../task-queue/postgres/index.js';
+import { configurePostgresTaskQueue } from '../task-queue/postgres/index.js';
 import * as configParser from '../utils/config-parser.js';
 import { objectEntries } from '../utils/object/object.js';
-import { isDefined, isNotNull } from '../utils/type-guards.js';
+import { assertDefinedPass, isDefined, isNotNull, isString } from '../utils/type-guards.js';
 /**
  * Standard setup for integration tests.
  */
@@ -51,6 +52,8 @@ export async function setupIntegrationTest(options = {}) {
         ...options.dbConfig,
     };
     // 4. Configure ORM
+    // We disable autoMigrate here because APPLICATION_INITIALIZER is not used in integration tests
+    // We manually run migrations via runDatabaseMigrations below
     configureOrm({
         repositoryConfig: { schema: options.orm?.schema ?? 'test' },
         connection: dbConfig,
@@ -66,35 +69,29 @@ export async function setupIntegrationTest(options = {}) {
             await database.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(options.orm.schema)}`);
         }
         // 7. Optional Modules
-        if (options.modules?.messageBus ?? options.modules?.taskQueue ?? options.modules?.authentication ?? options.modules?.test ?? options.modules?.notification) {
+        if (options.modules?.messageBus ?? options.modules?.taskQueue ?? options.modules?.authentication ?? options.modules?.notification) {
             configureLocalMessageBus({ injector });
         }
         if (options.modules?.taskQueue) {
             configurePostgresTaskQueue({ injector });
-            await runInInjectionContext(injector, migratePostgresTaskQueueSchema);
         }
         if (options.modules?.circuitBreaker ?? options.modules?.taskQueue) {
             configurePostgresCircuitBreaker({ injector });
-            await runInInjectionContext(injector, migratePostgresCircuitBreaker);
         }
         if (options.modules?.rateLimiter ?? options.modules?.taskQueue) {
             configurePostgresRateLimiter({ injector });
-            await runInInjectionContext(injector, migratePostgresRateLimiterSchema);
         }
         if (options.modules?.keyValueStore ?? options.modules?.authentication) {
             configurePostgresKeyValueStore({ injector });
-            await runInInjectionContext(injector, migratePostgresKeyValueStoreSchema);
         }
         if (options.modules?.lock ?? options.modules?.authentication) {
             configurePostgresLock({ injector });
-            await runInInjectionContext(injector, migratePostgresLockSchema);
         }
-        if (options.modules?.signals ?? options.modules?.authentication ?? options.modules?.test ?? options.modules?.notification) {
+        if (options.modules?.signals ?? options.modules?.authentication ?? options.modules?.notification) {
             configureDefaultSignalsImplementation();
         }
         if (options.modules?.audit ?? options.modules?.authentication) {
             configureAudit({ injector });
-            await runInInjectionContext(injector, migrateAuditSchema);
         }
         if (options.modules?.authentication) {
             configureAuthenticationServer({
@@ -106,11 +103,9 @@ export async function setupIntegrationTest(options = {}) {
                 authenticationAncillaryService: options.authenticationAncillaryService,
                 injector,
             });
-            await runInInjectionContext(injector, migrateAuthenticationSchema);
         }
         if (options.modules?.notification) {
             configureNotification({ injector });
-            await runInInjectionContext(injector, migrateNotificationSchema);
         }
         if (options.modules?.documentManagement) {
             configureDocumentManagement({
@@ -122,8 +117,8 @@ export async function setupIntegrationTest(options = {}) {
                 skipAi: true,
                 injector,
             });
-            await runInInjectionContext(injector, migrateDocumentManagementSchema);
         }
+        await runInInjectionContext(injector, runDatabaseMigrations);
         if (options.modules?.objectStorage) {
             const bucketPerModule = options.s3?.bucketPerModule ?? configParser.boolean('S3_BUCKET_PER_MODULE', true);
             configureS3ObjectStorage({
@@ -190,9 +185,18 @@ export async function truncateTables(database, schema, tables) {
     if (tables.length == 0) {
         return;
     }
-    // Using CASCADE to handle foreign keys automatically
-    for (const table of tables) {
-        await database.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier(table)} CASCADE`);
+    const lockId = 987654321; // Different lock ID for table maintenance
+    await database.execute(sql `SELECT pg_advisory_lock(${lockId})`);
+    try {
+        // Using CASCADE to handle foreign keys automatically
+        for (const table of tables) {
+            const tableName = isString(table) ? table : getEntityTableName(table);
+            const tableSchema = isString(table) ? schema : getEntitySchema(table, schema);
+            await database.execute(sql `TRUNCATE TABLE ${sql.identifier(tableSchema)}.${sql.identifier(tableName)} CASCADE`);
+        }
+    }
+    finally {
+        await database.execute(sql `SELECT pg_advisory_unlock(${lockId})`);
     }
 }
 /**
@@ -203,8 +207,17 @@ export async function clearTenantData(database, schema, tables, tenantId) {
     if (tables.length == 0) {
         return;
     }
-    for (const table of tables) {
-        await database.execute(sql `DELETE FROM ${sql.identifier(schema)}.${sql.identifier(table)} WHERE tenant_id = ${tenantId}`);
+    const lockId = 987654321;
+    await database.execute(sql `SELECT pg_advisory_lock(${lockId})`);
+    try {
+        for (const table of tables) {
+            const tableName = isString(table) ? table : getEntityTableName(table);
+            const tableSchema = isString(table) ? assertDefinedPass(schema, 'Schema not provided') : getEntitySchema(table, schema);
+            await database.execute(sql `DELETE FROM ${sql.identifier(tableSchema)}.${sql.identifier(tableName)} WHERE tenant_id = ${tenantId}`);
+        }
+    }
+    finally {
+        await database.execute(sql `SELECT pg_advisory_unlock(${lockId})`);
     }
 }
 /**
@@ -212,7 +225,19 @@ export async function clearTenantData(database, schema, tables, tenantId) {
  * Useful in beforeAll() cleanups.
  */
 export async function dropTables(database, schema, tables) {
-    for (const table of tables) {
-        await database.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier(table)} CASCADE`);
+    if (tables.length == 0) {
+        return;
+    }
+    const lockId = 987654321;
+    await database.execute(sql `SELECT pg_advisory_lock(${lockId})`);
+    try {
+        for (const table of tables) {
+            const tableName = isString(table) ? table : getEntityTableName(table);
+            const tableSchema = isString(table) ? assertDefinedPass(schema, 'Schema not provided') : getEntitySchema(table, schema);
+            await database.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(tableSchema)}.${sql.identifier(tableName)} CASCADE`);
+        }
+    }
+    finally {
+        await database.execute(sql `SELECT pg_advisory_unlock(${lockId})`);
     }
 }

package/text/localization.service.js

@@ -192,7 +192,7 @@ function buildMappedLocalization({ language, keys, enums }) {
     const mappedLocalization = {
         language,
         keys: new Map(deepObjectEntries(keys)),
-        enums: new Map(enumsEntries)
+        enums: new Map(enumsEntries),
     };
     return mappedLocalization;
 }
@@ -215,7 +215,7 @@ function mergeMappedLocalization(a, b, force = false) {
     return {
         language: b.language,
         keys: new Map([...a.keys, ...b.keys]),
-        enums: new Map([...a.enums, ...b.enums])
+        enums: new Map([...a.enums, ...b.enums]),
     };
 }
 export function isLocalizeItem(value) {

package/utils/file-reader.js

@@ -1,4 +1,3 @@
-import { DetailsError } from '../errors/details.error.js';
 export async function readAsText(blob, encoding) {
     return await setup((reader) => reader.readAsText(blob, encoding));
 }
@@ -12,7 +11,7 @@ async function setup(dispatcher) {
     return await new Promise((resolve, reject) => {
         const reader = new FileReader();
         reader.onload = () => resolve(reader.result);
-        reader.onerror = () => reject(new DetailsError(reader.error.message, reader.error));
+        reader.onerror = () => reject(new Error('FileReader error', { cause: reader.error }));
         dispatcher(reader);
     });
 }