@tstdl/base 0.93.162 → 0.93.164

package/orm/tests/repository-transactions-nested.test.js

@@ -8,17 +8,15 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { sql } from 'drizzle-orm';
-import { beforeAll, describe, expect, test } from 'vitest';
-import { Injector, runInInjectionContext } from '../../injector/index.js';
+import { describe, expect } from 'vitest';
 import { StringProperty } from '../../schema/index.js';
+import { getIntegrationTest } from '../../testing/index.js';
 import { Table } from '../decorators.js';
 import { Entity } from '../entity.js';
-import { configureOrm, Database } from '../server/index.js';
 import { injectRepository } from '../server/repository.js';
+const schema = 'test_orm_tx_nested';
+const test = getIntegrationTest({ orm: { schema } });
 describe('ORM Repository Transactions Nested (Integration)', () => {
-    let injector;
-    let db;
-    const schema = 'test_orm_tx_nested';
     let TxEntity = class TxEntity extends Entity {
         name;
     };
@@ -29,15 +27,7 @@ describe('ORM Repository Transactions Nested (Integration)', () => {
     TxEntity = __decorate([
         Table('tx_entities', { schema })
     ], TxEntity);
-    beforeAll(async () => {
-        injector = new Injector('Test');
-        configureOrm({
-            repositoryConfig: { schema },
-            connection: {
-                host: '127.0.0.1', port: 5432, user: 'tstdl', password: 'wf7rq6glrk5jykne', database: 'tstdl',
-            },
-        });
-        db = injector.resolve(Database);
+    test.beforeEach(async ({ database: db }) => {
         await db.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
         await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
         await db.execute(sql `
@@ -52,113 +42,121 @@ describe('ORM Repository Transactions Nested (Integration)', () => {
       )
     `);
     });
-    test('should commit nested transaction', async () => {
+    test('should commit nested transaction', async ({ database: db }) => {
+        const repo = injectRepository(TxEntity);
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
+        await repo.transaction(async (tx1) => {
+            const repo1 = repo.withTransaction(tx1);
+            await repo1.insert(Object.assign(new TxEntity(), { name: 'Outer' }));
+            await repo1.transaction(async (tx2) => {
+                const repo2 = repo1.withTransaction(tx2);
+                await repo2.insert(Object.assign(new TxEntity(), { name: 'Inner' }));
+            });
+        });
+        const count = await repo.count();
+        expect(count).toBe(2);
+    });
+    test('should rollback nested transaction (inner fails)', async ({ database: db }) => {
+        const repo = injectRepository(TxEntity);
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(TxEntity);
+        try {
             await repo.transaction(async (tx1) => {
                 const repo1 = repo.withTransaction(tx1);
                 await repo1.insert(Object.assign(new TxEntity(), { name: 'Outer' }));
                 await repo1.transaction(async (tx2) => {
                     const repo2 = repo1.withTransaction(tx2);
                     await repo2.insert(Object.assign(new TxEntity(), { name: 'Inner' }));
+                    throw new Error('Fail Inner');
                 });
             });
-            const count = await repo.count();
-            expect(count).toBe(2);
-        });
+        }
+        catch (e) {
+            expect(e.message).toBe('Fail Inner');
+        }
+        const count = await repo.count();
+        expect(count).toBe(0); // Outer should rollback too if error propagates
     });
-    test('should rollback nested transaction (inner fails)', async () => {
+    test('should rollback nested transaction but keep outer if caught', async ({ database: db }) => {
+        const repo = injectRepository(TxEntity);
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(TxEntity);
+        await repo.transaction(async (tx1) => {
+            const repo1 = repo.withTransaction(tx1);
+            await repo1.insert(Object.assign(new TxEntity(), { name: 'Outer' }));
             try {
-                await repo.transaction(async (tx1) => {
-                    const repo1 = repo.withTransaction(tx1);
-                    await repo1.insert(Object.assign(new TxEntity(), { name: 'Outer' }));
-                    await repo1.transaction(async (tx2) => {
-                        const repo2 = repo1.withTransaction(tx2);
-                        await repo2.insert(Object.assign(new TxEntity(), { name: 'Inner' }));
-                        throw new Error('Fail Inner');
-                    });
+                await repo1.transaction(async (tx2) => {
+                    const repo2 = repo1.withTransaction(tx2);
+                    await repo2.insert(Object.assign(new TxEntity(), { name: 'Inner' }));
+                    throw new Error('Fail Inner');
                 });
             }
-            catch (e) {
-                expect(e.message).toBe('Fail Inner');
+            catch {
+                // Swallow error to keep outer alive
             }
-            const count = await repo.count();
-            expect(count).toBe(0); // Outer should rollback too if error propagates
         });
+        const all = await repo.loadAll();
+        expect(all).toHaveLength(1);
+        expect(all[0].name).toBe('Outer');
     });
-    test('should rollback nested transaction but keep outer if caught', async () => {
+    test('should rollback outer transaction (outer fails after inner commit)', async ({ database: db }) => {
+        const repo = injectRepository(TxEntity);
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(TxEntity);
+        try {
             await repo.transaction(async (tx1) => {
                 const repo1 = repo.withTransaction(tx1);
                 await repo1.insert(Object.assign(new TxEntity(), { name: 'Outer' }));
-                try {
-                    await repo1.transaction(async (tx2) => {
-                        const repo2 = repo1.withTransaction(tx2);
-                        await repo2.insert(Object.assign(new TxEntity(), { name: 'Inner' }));
-                        throw new Error('Fail Inner');
-                    });
-                }
-                catch {
-                    // Swallow error to keep outer alive
-                }
+                await repo1.transaction(async (tx2) => {
+                    const repo2 = repo1.withTransaction(tx2);
+                    await repo2.insert(Object.assign(new TxEntity(), { name: 'Inner' }));
+                });
+                throw new Error('Fail Outer');
             });
-            const all = await repo.loadAll();
-            expect(all).toHaveLength(1);
-            expect(all[0].name).toBe('Outer');
-        });
+        }
+        catch {
+            // Expected
+        }
+        const count = await repo.count();
+        expect(count).toBe(0);
     });
-    test('should rollback outer transaction (outer fails after inner commit)', async () => {
+    test('should support multiple nested transactions sequentially', async ({ database: db }) => {
+        const repo = injectRepository(TxEntity);
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(TxEntity);
-            try {
-                await repo.transaction(async (tx1) => {
-                    const repo1 = repo.withTransaction(tx1);
-                    await repo1.insert(Object.assign(new TxEntity(), { name: 'Outer' }));
-                    await repo1.transaction(async (tx2) => {
-                        const repo2 = repo1.withTransaction(tx2);
-                        await repo2.insert(Object.assign(new TxEntity(), { name: 'Inner' }));
-                    });
-                    throw new Error('Fail Outer');
-                });
-            }
-            catch {
-                // Expected
-            }
-            const count = await repo.count();
-            expect(count).toBe(0);
+        await repo.transaction(async (tx1) => {
+            const repo1 = repo.withTransaction(tx1);
+            await repo1.transaction(async (tx2) => {
+                await repo1.withTransaction(tx2).insert(Object.assign(new TxEntity(), { name: 'Inner1' }));
+            });
+            await repo1.transaction(async (tx3) => {
+                await repo1.withTransaction(tx3).insert(Object.assign(new TxEntity(), { name: 'Inner2' }));
+            });
         });
+        const count = await repo.count();
+        expect(count).toBe(2);
     });
-    test('should support multiple nested transactions sequentially', async () => {
+    test('should support deep nesting (3 levels)', async ({ database: db }) => {
+        const repo = injectRepository(TxEntity);
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(TxEntity);
-            await repo.transaction(async (tx1) => {
-                const repo1 = repo.withTransaction(tx1);
-                await repo1.transaction(async (tx2) => {
-                    await repo1.withTransaction(tx2).insert(Object.assign(new TxEntity(), { name: 'Inner1' }));
-                });
-                await repo1.transaction(async (tx3) => {
-                    await repo1.withTransaction(tx3).insert(Object.assign(new TxEntity(), { name: 'Inner2' }));
+        await repo.transaction(async (tx1) => {
+            const r1 = repo.withTransaction(tx1);
+            await r1.insert(Object.assign(new TxEntity(), { name: 'L1' }));
+            await r1.transaction(async (tx2) => {
+                const r2 = r1.withTransaction(tx2);
+                await r2.insert(Object.assign(new TxEntity(), { name: 'L2' }));
+                await r2.transaction(async (tx3) => {
+                    const r3 = r2.withTransaction(tx3);
+                    await r3.insert(Object.assign(new TxEntity(), { name: 'L3' }));
                 });
             });
-            const count = await repo.count();
-            expect(count).toBe(2);
         });
+        const count = await repo.count();
+        expect(count).toBe(3);
     });
-    test('should support deep nesting (3 levels)', async () => {
+    test('should rollback deep nesting middle layer', async ({ database: db }) => {
+        const repo = injectRepository(TxEntity);
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(TxEntity);
-            await repo.transaction(async (tx1) => {
-                const r1 = repo.withTransaction(tx1);
-                await r1.insert(Object.assign(new TxEntity(), { name: 'L1' }));
+        await repo.transaction(async (tx1) => {
+            const r1 = repo.withTransaction(tx1);
+            await r1.insert(Object.assign(new TxEntity(), { name: 'L1' }));
+            try {
                 await r1.transaction(async (tx2) => {
                     const r2 = r1.withTransaction(tx2);
                     await r2.insert(Object.assign(new TxEntity(), { name: 'L2' }));
@@ -166,37 +164,15 @@ describe('ORM Repository Transactions Nested (Integration)', () => {
                         const r3 = r2.withTransaction(tx3);
                         await r3.insert(Object.assign(new TxEntity(), { name: 'L3' }));
                     });
+                    throw new Error('Fail L2');
                 });
-            });
-            const count = await repo.count();
-            expect(count).toBe(3);
-        });
-    });
-    test('should rollback deep nesting middle layer', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(TxEntity);
-            await repo.transaction(async (tx1) => {
-                const r1 = repo.withTransaction(tx1);
-                await r1.insert(Object.assign(new TxEntity(), { name: 'L1' }));
-                try {
-                    await r1.transaction(async (tx2) => {
-                        const r2 = r1.withTransaction(tx2);
-                        await r2.insert(Object.assign(new TxEntity(), { name: 'L2' }));
-                        await r2.transaction(async (tx3) => {
-                            const r3 = r2.withTransaction(tx3);
-                            await r3.insert(Object.assign(new TxEntity(), { name: 'L3' }));
-                        });
-                        throw new Error('Fail L2');
-                    });
-                }
-                catch {
-                    // Catch L2 failure
-                }
-            });
-            const all = await repo.loadAll();
-            expect(all).toHaveLength(1);
-            expect(all[0].name).toBe('L1');
+            }
+            catch {
+                // Catch L2 failure
+            }
         });
+        const all = await repo.loadAll();
+        expect(all).toHaveLength(1);
+        expect(all[0].name).toBe('L1');
     });
 });

package/orm/tests/transactional.test.js

@@ -10,10 +10,11 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 import { sql } from 'drizzle-orm';
 import { Injector, runInInjectionContext, Singleton } from '../../injector/index.js';
 import { StringProperty } from '../../schema/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { beforeAll, describe, expect, test } from 'vitest';
 import { Table } from '../decorators.js';
 import { Entity } from '../entity.js';
-import { configureOrm, Database } from '../server/index.js';
+import { Database } from '../server/index.js';
 import { getRepository } from '../server/repository.js';
 import { Transactional } from '../server/transactional.js';
 describe('ORM Transactional (Integration)', () => {
@@ -47,20 +48,10 @@ describe('ORM Transactional (Integration)', () => {
         Singleton()
     ], TransactionalService);
     beforeAll(async () => {
-        injector = new Injector('Test');
         const encryptionSecret = new Uint8Array(32).fill(1);
-        configureOrm({
-            repositoryConfig: { schema },
-            connection: {
-                host: '127.0.0.1',
-                port: 5432,
-                user: 'tstdl',
-                password: 'wf7rq6glrk5jykne',
-                database: 'tstdl',
-            },
-            encryptionSecret,
-        });
-        db = injector.resolve(Database);
+        const context = await setupIntegrationTest({ orm: { schema, encryptionSecret } });
+        injector = context.injector;
+        db = context.database;
         await db.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
         await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('transactional_items')} CASCADE`);
         await db.execute(sql `

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.162",
+  "version": "0.93.164",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -152,9 +152,9 @@
     "type-fest": "^5.4"
   },
   "peerDependencies": {
-    "@aws-sdk/client-s3": "^3.1003",
-    "@aws-sdk/s3-request-presigner": "^3.1003",
-    "@genkit-ai/google-genai": "^1.29",
+    "@aws-sdk/client-s3": "^3.1010",
+    "@aws-sdk/s3-request-presigner": "^3.1010",
+    "@genkit-ai/google-genai": "^1.30",
     "@google-cloud/storage": "^7.19",
     "@toon-format/toon": "^2.1.0",
     "@tstdl/angular": "^0.93",
@@ -164,16 +164,16 @@
     "@zxcvbn-ts/language-en": "^3.0",
     "drizzle-orm": "^0.45",
     "file-type": "^21.3",
-    "genkit": "^1.29",
+    "genkit": "^1.30",
     "handlebars": "^4.7",
     "mjml": "^4.18",
     "nodemailer": "^8.0",
     "pg": "^8.20",
     "playwright": "^1.58",
-    "preact": "^10.28",
+    "preact": "^10.29",
     "preact-render-to-string": "^6.6",
     "sharp": "^0.34",
-    "undici": "^7.22",
+    "undici": "^7.24",
     "urlpattern-polyfill": "^10.1",
     "zod": "^3.25"
   },
@@ -191,8 +191,8 @@
     "@types/node": "25",
     "@types/nodemailer": "7.0",
     "@types/pg": "8.18",
-    "@vitest/coverage-v8": "4.0",
-    "@vitest/ui": "4.0",
+    "@vitest/coverage-v8": "4.1",
+    "@vitest/ui": "4.1",
     "concurrently": "9.2",
     "drizzle-kit": "0.31",
     "eslint": "9.39",
@@ -202,9 +202,9 @@
     "typedoc-plugin-markdown": "4.10",
     "typedoc-plugin-missing-exports": "4.1",
     "typescript": "5.9",
-    "typescript-eslint": "8.56",
+    "typescript-eslint": "8.57",
     "vite-tsconfig-paths": "6.1",
-    "vitest": "4.0"
+    "vitest": "4.1"
   },
   "overrides": {
     "drizzle-kit": {

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

@@ -1,20 +1,17 @@
 import { and, eq, sql } from 'drizzle-orm';
-import { beforeAll, describe, expect, vi } from 'vitest';
+import { 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 { getIntegrationTest } 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';
+const test = getIntegrationTest({ modules: { taskQueue: true } });
 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 () => {
+    test('should notify unique namespaces exactly once in incrementCounters', async () => {
         const q1 = inject(PostgresTaskQueue, 'ns-1');
         const q2 = inject(PostgresTaskQueue, 'ns-2');
         const notifySpy = vi.spyOn(PostgresTaskQueue.prototype, 'notify');
@@ -32,7 +29,7 @@ describe('Task Queue Optimization Edge Cases', () => {
         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 () => {
+    test('should resolve edge and abort on unmatched terminal status in resolveDependenciesMany', async () => {
         const queue = inject(PostgresTaskQueue, 'test-namespace');
         const repository = injectRepository(PostgresTask);
         const [parent] = await queue.enqueueMany([{ type: 'parent', data: {}, abortOnDependencyFailure: true }], { returnTasks: true });
@@ -48,7 +45,7 @@ describe('Task Queue Optimization Edge Cases', () => {
         const updatedParent = await queue.getTask(parent.id);
         expect(updatedParent.status).toBe(TaskStatus.Skipped);
     });
-    testInInjector('should handle hard timeout during touch', () => context.injector, async () => {
+    test('should handle hard timeout during touch', async () => {
         // Configure with small maxExecutionTime
         const queue = inject(PostgresTaskQueue, { namespace: 'timeout-test', maxExecutionTime: 10 });
         const [task] = await queue.enqueueMany([{ type: 'test', data: {} }], { returnTasks: true });
@@ -59,18 +56,18 @@ describe('Task Queue Optimization Edge Cases', () => {
         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 () => {
+    test('should handle non-existent tasks in complete and fail', 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 () => {
+    test('should handle terminal tasks with no dependents in resolveDependenciesMany', 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 () => {
+    test('should handle archival and purge in maintenance', async () => {
         const namespace = `archival-test-${crypto.randomUUID()}`;
         // Configure with small retention
         const queue = inject(PostgresTaskQueue, { namespace, retention: 1000, archiveRetention: 1000 });
@@ -93,7 +90,7 @@ describe('Task Queue Optimization Edge Cases', () => {
         const purged = await archiveRepository.load(task.id).catch(() => undefined);
         expect(purged).toBeUndefined();
     });
-    testInInjector('should notify on restart', () => context.injector, async () => {
+    test('should notify on restart', async () => {
         const namespace = `restart-test-${crypto.randomUUID()}`;
         const queue = inject(PostgresTaskQueue, namespace);
         const notifySpy = vi.spyOn(PostgresTaskQueue.prototype, 'notify');
@@ -103,7 +100,7 @@ describe('Task Queue Optimization Edge Cases', () => {
         await queue.restart(task.id);
         expect(notifySpy).toHaveBeenCalledWith(namespace);
     });
-    testInInjector('should use exponential backoff for zombies', () => context.injector, async () => {
+    test('should use exponential backoff for zombies', async () => {
         const namespace = `zombie-backoff-${crypto.randomUUID()}`;
         // Configure with standard growth
         const queue = inject(PostgresTaskQueue, { namespace, retryDelayMinimum: 1000, retryDelayGrowth: 2 });

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

@@ -1,6 +1,7 @@
 import { eq, or } from 'drizzle-orm';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 import { CancellationToken } from '../../cancellation/index.js';
+import { CircuitBreaker, CircuitBreakerState } from '../../circuit-breaker/index.js';
 import { Database } from '../../orm/server/index.js';
 import { TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
 import { task as taskTable } from '../../task-queue/postgres/schemas.js';
@@ -356,7 +357,7 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
             const t3Attempt = await queue.dequeue();
             expect(t3Attempt).toBeUndefined();
         });
-        it('should allow a single probe in Half-Open state', async () => {
+        it('should only allow a single active task in Half-Open state', async () => {
             await queue.enqueueMany([
                 { type: 'foo', data: { foo: '1' } },
                 { type: 'foo', data: { foo: '2' } },
@@ -368,7 +369,33 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
             const probe = await queue.dequeue();
             expect(probe).toBeDefined();
             const secondAttempt = await queue.dequeue();
-            expect(secondAttempt).toBeUndefined(); // Only 1 probe allowed in Half-Open
+            expect(secondAttempt).toBeUndefined(); // Only 1 task allowed to RUN in Half-Open
+        });
+        it('should not stall forever when circuit breaker is Half-Open and no tasks are found', async () => {
+            // 1. Trip the breaker
+            await queue.enqueue('foo', { foo: '1' });
+            await queue.enqueue('foo', { foo: '2' });
+            await queue.fail((await queue.dequeue()), 'err', { fatal: true });
+            await queue.fail((await queue.dequeue()), 'err', { fatal: true });
+            const cb = injector.resolve(CircuitBreaker, queue.namespace);
+            let status = await cb.check();
+            expect(status.state).toBe(CircuitBreakerState.Open);
+            expect(status.allowed).toBe(false);
+            // 2. Wait for timeout (50ms)
+            await timeout(75);
+            // 3. First dequeue - should be the probe, but find nothing (we enqueued and failed the only task)
+            const tasks1 = await queue.dequeueMany(1);
+            expect(tasks1).toHaveLength(0);
+            status = await cb.check();
+            expect(status.state).toBe(CircuitBreakerState.HalfOpen);
+            // 4. Second dequeue - should still be allowed (but find nothing)
+            const tasks2 = await queue.dequeueMany(1);
+            expect(tasks2).toHaveLength(0);
+            // 5. Add a task
+            await queue.enqueue('foo', { foo: 'new' });
+            // 6. Third dequeue - should find the task now!
+            const tasks3 = await queue.dequeueMany(1);
+            expect(tasks3).toHaveLength(1);
         });
     });
     describe('Timeouts and Maintenance (Pruning)', () => {

package/testing/README.md

@@ -80,51 +80,40 @@ The `setupIntegrationTest` utility (found in `source/testing/integration-setup.t
 4.  **Schema Isolation**: Automatically creates and uses PostgreSQL schemas for isolation.
 5.  **Modules**: Optional configuration for `taskQueue`, `authentication`, `objectStorage`, `notification`, etc.
 
-### Injection Context: `testInInjector`
+### Injection Context: `getIntegrationTest`
 
-Integration tests may require an injection context to resolve services and repositories. You can use the `testInInjector` (or `itInInjector`) helper to automatically wrap your test body.
-
-> [!IMPORTANT]
-> `testInInjector` is **only required** for code that uses `inject()` or `injectRepository()` outside of a class constructor/initializer (e.g. ad-hoc repository injection in a test body).
->
-> If you resolve your services in `beforeAll` or `beforeEach`, calling their methods usually does **not** require `testInInjector`.
-
-> [!TIP]
-> **Performance & Reusability**: For most integration tests, resolve services once in `beforeAll` and reuse the variables in your tests.
+Integration tests often require an injection context to resolve services and repositories using `inject()`. You can use the `getIntegrationTest` helper to create a specialized `test` function that automatically manages this context and simplifies setup.
 
 ```typescript
-import { beforeAll, describe, expect, test } from 'vitest';
-import { setupIntegrationTest, testInInjector } from '#/testing/index.js';
+import { describe, expect } from 'vitest';
+import { inject } from '#/injector/index.js';
+import { getIntegrationTest } from '#/testing/index.js';
 import { MyService } from '../my-service.js';
 
-describe('MyService Integration', () => {
-  let injector: Injector;
-  let myService: MyService;
-
-  beforeAll(async () => {
-    ({ injector } = await setupIntegrationTest({
-      modules: { taskQueue: true },
-    }));
-
-    // Resolve reused services once
-    myService = injector.resolve(MyService);
-  });
+// 1. Create a specialized test function with your required modules
+const test = getIntegrationTest({
+  modules: { taskQueue: true },
+});
 
-  // Calling methods on resolved services does NOT require testInInjector
+describe('MyService Integration', () => {
+  // 2. Use the returned 'test' function - it automatically runs in an injection context
   test('should process data', async () => {
+    // You can use inject() directly in the test body!
+    const myService = inject(MyService);
     const result = await myService.process();
+
     expect(result.success).toBe(true);
   });
-
-  // testInInjector is ONLY needed if you use inject() directly in the test body
-  testInInjector('should work with ad-hoc injection', () => injector, async () => {
-      const repo = injectRepository(SomeEntity);
-      // ...
-    },
-  );
 });
 ```
 
+> [!IMPORTANT]
+> **Async Context Limitation**: Due to how asynchronous execution works in Node.js, `inject()` calls **must** occur before any `await` statements in your test function. If you need to inject something after an `await`, resolve it at the beginning of the test.
+
+> [!TIP]
+> **Fixtures**: The `test` function provided by `getIntegrationTest` is an extended Vitest test. You can access `injector`, `database`, and `context` as fixtures if needed:
+> `test('example', async ({ injector, database }) => { ... })`
+
 ## Best Practices & Guidelines
 
 ### 1. Isolation & Performance
@@ -154,7 +143,7 @@ describe('MyService Integration', () => {
   injector.register(MailService, { useValue: mailServiceMock });
   ```
 - **Injection Context**: Any code that uses repositories or services relying on `inject()` outside of a class constructor/initializer **must** be wrapped in an injection context.
-  - **Preferred**: Use `testInInjector` (or `itInInjector`) for the entire test body.
+  - **Preferred**: Use the test function returned by `getIntegrationTest`.
   - **Alternative**: Use `runInInjectionContext(injector, async () => { ... })` for specific blocks within a test or hook.
 - **Mock Reset**: Always call `vi.clearAllMocks()` in `beforeEach` if using spys or mocks to ensure test independence.
 
@@ -183,8 +172,7 @@ describe('MyService Integration', () => {
 ### 5. Common Helpers (from `source/testing/`)
 
 - `setupIntegrationTest(options)`: Main entry point for integration tests.
-- `testInInjector(name, injector, fn, options)`: Runs a test within an injection context.
-- `itInInjector`: Alias for `testInInjector`.
+- `getIntegrationTest(options)`: Returns a Vitest test function pre-configured with the given options and an injection context.
 - `truncateTables(database, schema, tables)`: Clears data from specified tables.
 - `dropTables(database, schema, tables)`: Drops specified tables.
 - `clearTenantData(database, schema, tables, tenantId)`: Deletes data for a specific tenant.