@tstdl/base 0.93.140 → 0.93.142

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

@@ -1,18 +1,23 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 import { CancellationToken } from '../../cancellation/index.js';
+import { runInInjectionContext } from '../../injector/index.js';
+import { injectRepository } from '../../orm/server/index.js';
 import { TaskProcessResult, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
+import { PostgresTask } from '../../task-queue/postgres/index.js';
 import { setupIntegrationTest } from '../../testing/index.js';
 import { timeout } from '../../utils/timing.js';
 describe('Worker & Base Class Tests', () => {
     let injector;
     let queue;
     let token;
+    let otherQueueName;
     beforeAll(async () => {
         ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
+        otherQueueName = `other-queue-${crypto.randomUUID()}`;
     });
     beforeEach(() => {
         const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `worker-queue-${Date.now()}-${Math.random()}`;
+        const queueName = `worker-queue-${crypto.randomUUID()}`;
         queue = queueProvider.get(queueName, {
             visibilityTimeout: 200, // Short visibility for testing lease loss
         });
@@ -20,9 +25,14 @@ describe('Worker & Base Class Tests', () => {
     });
     afterEach(async () => {
         token.set();
+        const repository = runInInjectionContext(injector, () => injectRepository(PostgresTask));
+        const namespace = queue.getTransactionalContextData().namespace;
+        // Clear foreign keys
+        await repository.updateManyByQuery({ namespace }, { parentId: null });
+        await repository.updateManyByQuery({ namespace: otherQueueName }, { parentId: null });
         await queue.clear();
         const queueProvider = injector.resolve(TaskQueueProvider);
-        await queueProvider.get('other-queue').clear();
+        await queueProvider.get(otherQueueName).clear();
     });
     afterAll(async () => {
         await injector?.dispose();
@@ -39,6 +49,7 @@ describe('Worker & Base Class Tests', () => {
         for (let i = 0; i < 50; i++) {
             if (processed.length == 2)
                 break;
+            queue.notify();
             await timeout(20);
         }
         token.set(); // Stop worker
@@ -56,17 +67,18 @@ describe('Worker & Base Class Tests', () => {
         queue.process({ cancellationSignal: token }, async () => {
             throw new Error('worker error');
         });
-        // Wait until task is processed (error recorded and status is Pending)
+        // Wait until task is processed (error recorded and status is Retrying)
         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.Retrying) {
                 break;
             }
+            queue.notify();
             await timeout(20);
         }
         token.set();
         const updated = await queue.getTask(task.id);
-        expect(updated?.status).toBe(TaskStatus.Pending); // Should retry
+        expect(updated?.status).toBe(TaskStatus.Retrying); // Should retry
         expect(updated?.tries).toBe(1);
         expect(updated?.error?.message).toBe('worker error');
     });
@@ -79,6 +91,7 @@ describe('Worker & Base Class Tests', () => {
             executed = true;
             return TaskProcessResult.Complete();
         });
+        queue.notify();
         await queue.waitForTasks([task.id], { timeout: 5000 });
         token.set();
         expect(executed).toBe(true);
@@ -99,18 +112,19 @@ describe('Worker & Base Class Tests', () => {
             }
             return TaskProcessResult.Complete();
         });
-        // Wait until tasks are processed (error/reschedule recorded and status is Pending)
+        // Wait until tasks are processed (error/reschedule recorded and status is Retrying/Pending)
         for (let i = 0; i < 50; i++) {
             const uFail = await queue.getTask(tFail.id);
             const uResched = await queue.getTask(tResched.id);
-            if (uFail?.tries == 1 && uResched?.status == TaskStatus.Pending && (uResched?.scheduleTimestamp ?? 0) > Date.now()) {
+            if (uFail?.tries == 1 && uFail.status == TaskStatus.Retrying && uResched?.status == TaskStatus.Pending && (uResched?.scheduleTimestamp ?? 0) > Date.now()) {
                 break;
             }
+            queue.notify();
             await timeout(20);
         }
         token.set();
         const uFail = await queue.getTask(tFail.id);
-        expect(uFail?.status).toBe(TaskStatus.Pending); // Retry
+        expect(uFail?.status).toBe(TaskStatus.Retrying); // Retry
         expect(uFail?.error?.message).toBe('explicit fail');
         const uResched = await queue.getTask(tResched.id);
         expect(uResched?.status).toBe(TaskStatus.Pending);
@@ -132,22 +146,48 @@ describe('Worker & Base Class Tests', () => {
             const children = await context.spawnMany([{ type: 'child', data: { c: 2 } }]);
             expect(children[0]?.parentId).toBe(task.id);
             // Other queue spawn
-            const otherQueue = injector.resolve(TaskQueueProvider).get('other-queue');
+            const otherQueue = injector.resolve(TaskQueueProvider).get(otherQueueName);
             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);
+            expect(otherChild.namespace).toBe(otherQueueName);
+            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);
+                queue.notify();
+            }
+            // At this point parent should be WaitingChildren if children are not done
+            await queue.waitForTasks([task.id], { statuses: [TaskStatus.WaitingChildren], timeout: 2000 });
+            const midTask = await queue.getTask(task.id);
+            expect(midTask?.status).toBe(TaskStatus.WaitingChildren);
+            while (true) {
+                const dChild = await queue.dequeue({ types: ['child'] });
+                if (!dChild) {
+                    // Check other-queue as well
+                    const otherQueue = injector.resolve(TaskQueueProvider).get(otherQueueName);
+                    const dOther = await otherQueue.dequeue();
+                    if (dOther) {
+                        await otherQueue.complete(dOther);
+                        continue;
+                    }
+                    break;
+                }
+                await queue.complete(dChild);
+            }
+        })();
+        queue.notify();
+        await queue.waitForTasks([task.id], { interval: 50, timeout: 2000 });
         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);
-        const queueName = `final-try-test-${Date.now()}`;
+        const queueName = `final-try-test-${crypto.randomUUID()}`;
         const testQueue = queueProvider.get(queueName, {
             maxTries: 2,
             retryDelayMinimum: 0,
@@ -173,4 +213,12 @@ describe('Worker & Base Class Tests', () => {
         expect(finalAttemptValues).toEqual([false, true]);
         await testQueue.clear();
     });
+    it('should handle unsupported task result action', async () => {
+        const task = await queue.enqueue('unsupported-action', {});
+        const workerPromise = queue.processWorker(token, () => ({ payload: { action: 'magic' } }));
+        await expect(workerPromise).rejects.toThrow('Unsupported task result action');
+        const updated = await queue.getTask(task.id);
+        expect(updated?.status).toBe(TaskStatus.Retrying);
+        expect(updated?.error?.message).toContain('Unsupported task result action');
+    });
 });

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-${crypto.randomUUID()}`;
+        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-${crypto.randomUUID()}`;
+        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.Retrying);
+        // 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.Retrying); // 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,32 @@
 import { sql } from 'drizzle-orm';
+import { afterAll } from 'vitest';
 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 { bootstrapOrm, configureOrm, Database } 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 +53,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 bootstrapOrm below
     configureOrm({
         repositoryConfig: { schema: options.orm?.schema ?? 'test' },
         connection: dbConfig,
@@ -66,35 +70,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 +104,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 +118,8 @@ export async function setupIntegrationTest(options = {}) {
                 skipAi: true,
                 injector,
             });
-            await runInInjectionContext(injector, migrateDocumentManagementSchema);
         }
+        await runInInjectionContext(injector, bootstrapOrm);
         if (options.modules?.objectStorage) {
             const bucketPerModule = options.s3?.bucketPerModule ?? configParser.boolean('S3_BUCKET_PER_MODULE', true);
             configureS3ObjectStorage({
@@ -167,6 +163,7 @@ export async function setupIntegrationTest(options = {}) {
             }
         }
     });
+    afterAll(async () => await injector.dispose());
     return { injector, database };
 }
 /**
@@ -190,9 +187,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 +209,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 +227,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);
     });
 }

package/utils/timing.d.ts

@@ -8,9 +8,9 @@ export declare function timeout(milliseconds?: number, options?: {
 /** Timeout until specified time */
 export declare function timeoutUntil(timestamp: number | Date): Promise<void>;
 /** Timeout for specified duration */
-export declare function cancelableTimeout(milliseconds: number, cancelSignal: Observable<void> | CancellationSignal): Promise<'timeout' | 'canceled'>;
+export declare function cancelableTimeout(milliseconds: number, cancelSignal: Observable<unknown> | CancellationSignal): Promise<'timeout' | 'canceled'>;
 /** Timeout until specified time */
-export declare function cancelableTimeoutUntil(timestamp: number | Date, cancelSignal: Observable<void> | CancellationSignal): Promise<'timeout' | 'canceled'>;
+export declare function cancelableTimeoutUntil(timestamp: number | Date, cancelSignal: Observable<unknown> | CancellationSignal): Promise<'timeout' | 'canceled'>;
 export declare function withTimeout<T>(milliseconds: number, promiseOrProvider: ValueOrProvider<Promise<T>>, options?: {
     errorMessage?: string;
 }): Promise<T>;

package/task-queue/postgres/drizzle/0000_simple_invisible_woman.sql

@@ -1,74 +0,0 @@
-CREATE TYPE "task_queue"."dependency_join_mode" AS ENUM('and', 'or');--> statement-breakpoint
-CREATE TYPE "task_queue"."task_status" AS ENUM('pending', 'running', 'completed', 'cancelled', 'waiting', 'dead');--> statement-breakpoint
-CREATE TABLE "task_queue"."task" (
-	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
-	"namespace" text NOT NULL,
-	"type" text NOT NULL,
-	"status" "task_queue"."task_status" NOT NULL,
-	"idempotency_key" text,
-	"trace_id" text,
-	"tags" text[] NOT NULL,
-	"complete_after_tags" text[] NOT NULL,
-	"schedule_after_tags" text[] NOT NULL,
-	"fail_fast" boolean NOT NULL,
-	"dependency_join_mode" "task_queue"."dependency_join_mode" NOT NULL,
-	"dependency_trigger_statuses" "task_queue"."task_status"[] NOT NULL,
-	"priority" integer NOT NULL,
-	"token" uuid,
-	"creation_timestamp" timestamp with time zone NOT NULL,
-	"priority_age_timestamp" timestamp with time zone NOT NULL,
-	"schedule_timestamp" timestamp with time zone NOT NULL,
-	"start_timestamp" timestamp with time zone,
-	"time_to_live" timestamp with time zone,
-	"visibility_deadline" timestamp with time zone,
-	"complete_timestamp" timestamp with time zone,
-	"tries" integer NOT NULL,
-	"progress" double precision NOT NULL,
-	"data" jsonb,
-	"state" jsonb,
-	"result" jsonb,
-	"error" jsonb,
-	"parent_id" uuid,
-	CONSTRAINT "task_namespace_idempotency_key_unique" UNIQUE("namespace","idempotency_key")
-);
---> statement-breakpoint
-CREATE TABLE "task_queue"."task_archive" (
-	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
-	"namespace" text NOT NULL,
-	"type" text NOT NULL,
-	"status" "task_queue"."task_status" NOT NULL,
-	"idempotency_key" text,
-	"trace_id" text,
-	"tags" text[] NOT NULL,
-	"complete_after_tags" text[] NOT NULL,
-	"schedule_after_tags" text[] NOT NULL,
-	"fail_fast" boolean NOT NULL,
-	"dependency_join_mode" "task_queue"."dependency_join_mode" NOT NULL,
-	"dependency_trigger_statuses" "task_queue"."task_status"[] NOT NULL,
-	"priority" integer NOT NULL,
-	"token" uuid,
-	"creation_timestamp" timestamp with time zone NOT NULL,
-	"priority_age_timestamp" timestamp with time zone NOT NULL,
-	"schedule_timestamp" timestamp with time zone NOT NULL,
-	"start_timestamp" timestamp with time zone,
-	"time_to_live" timestamp with time zone,
-	"visibility_deadline" timestamp with time zone,
-	"complete_timestamp" timestamp with time zone,
-	"tries" integer NOT NULL,
-	"progress" double precision NOT NULL,
-	"data" jsonb,
-	"state" jsonb,
-	"result" jsonb,
-	"error" jsonb,
-	"parent_id" uuid
-);
---> statement-breakpoint
-ALTER TABLE "task_queue"."task" ADD CONSTRAINT "task_parent_id_task_id_fk" FOREIGN KEY ("parent_id") REFERENCES "task_queue"."task"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-CREATE INDEX "task_parent_id_idx" ON "task_queue"."task" USING btree ("parent_id");--> statement-breakpoint
-CREATE INDEX "task_status_visibility_deadline_idx" ON "task_queue"."task" USING btree ("status","visibility_deadline");--> statement-breakpoint
-CREATE INDEX "task_status_complete_timestamp_idx" ON "task_queue"."task" USING btree ("status","complete_timestamp");--> statement-breakpoint
-CREATE INDEX "task_schedule_after_tags_idx" ON "task_queue"."task" USING gin ("schedule_after_tags");--> statement-breakpoint
-CREATE INDEX "task_complete_after_tags_idx" ON "task_queue"."task" USING gin ("complete_after_tags");--> statement-breakpoint
-CREATE INDEX "task_tags_idx" ON "task_queue"."task" USING gin ("tags");--> statement-breakpoint
-CREATE INDEX "task_namespace_status_schedule_timestamp_priority_idx" ON "task_queue"."task" USING btree ("namespace","status","schedule_timestamp","priority");--> statement-breakpoint
-CREATE INDEX "task_archive_namespace_complete_timestamp_idx" ON "task_queue"."task_archive" USING btree ("namespace","complete_timestamp");