@tstdl/base 0.93.162 → 0.93.164

package/api/server/gateway.d.ts

@@ -1,3 +1,4 @@
+/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
 import 'urlpattern-polyfill';
 import type { HttpServerRequestContext } from '../../http/server/http-server.js';
 import { HttpServerResponse, type HttpServerRequest } from '../../http/server/index.js';

package/api/server/gateway.js

@@ -1,3 +1,4 @@
+/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -14,9 +15,7 @@ import 'urlpattern-polyfill';
 import { Auditor } from '../../audit/auditor.js';
 import { ActorType } from '../../audit/types.js';
 import { NIL_UUID } from '../../constants.js';
-import { BadRequestError } from '../../errors/bad-request.error.js';
-import { NotFoundError } from '../../errors/not-found.error.js';
-import { NotImplementedError } from '../../errors/not-implemented.error.js';
+import { BadRequestError, InvalidTokenError, NotFoundError, NotImplementedError } from '../../errors/index.js';
 import { HttpServerResponse } from '../../http/server/index.js';
 import { inject, injectArgument, resolveArgumentType, Singleton } from '../../injector/index.js';
 import { Logger } from '../../logger/index.js';
@@ -213,7 +212,15 @@ let ApiGateway = ApiGateway_1 = class ApiGateway {
                 return await requestTokenProvider.getToken(requestContext);
             },
             getAuditor: async () => {
-                const token = await requestContext.tryGetToken();
+                let token = null;
+                try {
+                    token = await requestContext.tryGetToken();
+                }
+                catch (error) {
+                    if (!(error instanceof InvalidTokenError)) {
+                        throw error;
+                    }
+                }
                 return auditor.fork(context.api.resource)
                     .withCorrelation()
                     .with({

package/authentication/tests/authentication.api-controller.test.js

@@ -55,6 +55,30 @@ describe('AuthenticationApiController Integration', () => {
             expect(service.subjectId()).toBe(user.id);
         });
     });
+    test('login should work even if an expired token is present in the Authorization header', async () => {
+        await runInInjectionContext(injector, async () => {
+            const user = await subjectService.createUser({ tenantId, email: 'expired-token-login@example.com', firstName: 'E', lastName: 'L' });
+            await serverService.setCredentials(user, 'Strong-Password-2026!');
+            // Create an expired token
+            const now = Math.floor(Date.now() / 1000);
+            const expiredTokenResult = await serverService.createToken({
+                subject: user,
+                sessionId: crypto.randomUUID(),
+                impersonator: undefined,
+                additionalTokenPayload: {},
+                refreshTokenExpiration: now - 3600,
+                expiration: now - 3600, // Expired 1 hour ago
+                issuedAt: now - 7200,
+                timestamp: (now - 7200) * 1000,
+            });
+            // Inject the expired token into the client service
+            service.updateRawTokens(expiredTokenResult.token);
+            // Now try to login
+            await service.login({ tenantId, subject: user.id }, 'Strong-Password-2026!');
+            expect(service.isLoggedIn()).toBe(true);
+            expect(service.subjectId()).toBe(user.id);
+        });
+    });
     test('checkSecret should work via API client', async () => {
         const result = await service.checkSecret('abc');
         expect(result.strength).toBeLessThan(2);

package/circuit-breaker/postgres/circuit-breaker.d.ts

@@ -1,9 +1,6 @@
-import { afterResolve } from '../../injector/index.js';
 import { CircuitBreaker, type CircuitBreakerCheckResult } from '../circuit-breaker.js';
 export declare class PostgresCircuitBreakerService extends CircuitBreaker {
     #private;
-    private static checkStatement;
-    [afterResolve](): void;
     check(): Promise<CircuitBreakerCheckResult>;
     recordSuccess(): Promise<void>;
     recordFailure(): Promise<void>;

package/circuit-breaker/postgres/circuit-breaker.js

@@ -4,9 +4,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var PostgresCircuitBreakerService_1;
 import { and, eq, lte, sql, isNotNull as sqlIsNotNull } from 'drizzle-orm';
-import { afterResolve, injectArgument, provide, Singleton } from '../../injector/index.js';
+import { injectArgument, provide, Singleton } from '../../injector/index.js';
 import { coalesce, interval, TRANSACTION_TIMESTAMP } from '../../orm/index.js';
 import { DatabaseConfig, injectRepository } from '../../orm/server/index.js';
 import { isString, isUndefined } from '../../utils/type-guards.js';
@@ -16,18 +15,14 @@ import { PostgresCircuitBreaker } from './model.js';
 import { PostgresCircuitBreakerModuleConfig } from './module.js';
 import { circuitBreaker } from './schemas.js';
 let PostgresCircuitBreakerService = class PostgresCircuitBreakerService extends CircuitBreaker {
-    static { PostgresCircuitBreakerService_1 = this; }
-    static checkStatement;
     #repository = injectRepository(PostgresCircuitBreaker);
     #arg = injectArgument(this);
     #key = isString(this.#arg) ? this.#arg : this.#arg.key;
     #threshold = (isString(this.#arg) ? undefined : this.#arg.threshold) ?? 5;
     #resetTimeout = (isString(this.#arg) ? undefined : this.#arg.resetTimeout) ?? 30 * millisecondsPerSecond;
-    [afterResolve]() {
-        PostgresCircuitBreakerService_1.checkStatement ??= this.getPreparedCheckStatement();
-    }
+    #checkStatement = this.getPreparedCheckStatement();
     async check() {
-        const [result] = await PostgresCircuitBreakerService_1.checkStatement.execute({ key: this.#key });
+        const [result] = await this.#checkStatement.execute({ key: this.#key });
         // 1. Breaker doesn't exist or is Closed
         if (isUndefined(result) || (result.state === CircuitBreakerState.Closed)) {
             return { allowed: true, state: CircuitBreakerState.Closed, isProbe: false };
@@ -36,9 +31,11 @@ let PostgresCircuitBreakerService = class PostgresCircuitBreakerService extends
         if (result.isProbe) {
             return { allowed: true, state: CircuitBreakerState.HalfOpen, isProbe: true };
         }
-        // 3. Fallback: Catch-all for failed transitions.
-        // - If state is HalfOpen, someone else is probing. Reject.
-        // - If state is Open, timeout hasn't expired. Reject
+        // 3. If it's already HalfOpen, allow it but it's not the primary probe (others must handle concurrency)
+        if (result.state === CircuitBreakerState.HalfOpen) {
+            return { allowed: true, state: CircuitBreakerState.HalfOpen, isProbe: false };
+        }
+        // 4. Fallback: Catch-all for Open state where timeout hasn't expired. Reject
         return { allowed: false, state: result.state, isProbe: false };
     }
     async recordSuccess() {
@@ -92,7 +89,7 @@ let PostgresCircuitBreakerService = class PostgresCircuitBreakerService extends
             .prepare('circuit_breaker_check');
     }
 };
-PostgresCircuitBreakerService = PostgresCircuitBreakerService_1 = __decorate([
+PostgresCircuitBreakerService = __decorate([
     Singleton({
         argumentIdentityProvider: (arg) => isString(arg) ? arg : arg.key,
         providers: [

package/circuit-breaker/tests/circuit-breaker.test.js

@@ -56,11 +56,16 @@ describe('Circuit Breaker (Standalone) Tests', () => {
         expect(probe.allowed).toBe(true);
         expect(probe.state).toBe(CircuitBreakerState.HalfOpen);
         expect(probe.isProbe).toBe(true);
-        // Subsequent check should be denied (Half-Open wait)
+        // Subsequent check should be allowed but not the probe
         const subsequent = await breaker.check();
-        expect(subsequent.allowed).toBe(false);
+        expect(subsequent.allowed).toBe(true);
         expect(subsequent.state).toBe(CircuitBreakerState.HalfOpen);
         expect(subsequent.isProbe).toBe(false);
+        // Another check should also be allowed
+        const third = await breaker.check();
+        expect(third.allowed).toBe(true);
+        expect(third.state).toBe(CircuitBreakerState.HalfOpen);
+        expect(third.isProbe).toBe(false);
     });
     it('should close if Probe succeeds', async () => {
         const timeoutMs = 100;

package/object-storage/s3/tests/s3.object-storage.integration.test.js

@@ -73,7 +73,7 @@ describe('S3ObjectStorage Integration', () => {
         const key = 'signed-download.txt';
         await storage.uploadObject(key, new TextEncoder().encode('signed download'));
         const url = await storage.getDownloadUrl(key, Date.now() + 60000);
-        expect(url).toMatch(/http:\/\/(127\.0\.0\.1|localhost):9000/);
+        expect(url).toMatch(/http:\/\/(127\.0\.0\.1|localhost):19552/);
         const response = await fetch(url);
         expect(response.status).toBe(200);
         expect(await response.text()).toBe('signed download');
@@ -230,7 +230,7 @@ describe('S3ObjectStorage Integration', () => {
         const url = await storage.getDownloadUrl(key, Date.now() + 60000, {
             Expires: new Date(Date.now() + 60000).toUTCString(),
         });
-        expect(url).toMatch(/http:\/\/(127\.0\.0\.1|localhost):9000/);
+        expect(url).toMatch(/http:\/\/(127\.0\.0\.1|localhost):19552/);
         const response = await fetch(url);
         expect(response.status).toBe(200);
     });

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

@@ -6,29 +6,29 @@ describe('buildJsonb', () => {
     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(sql).toBe('jsonb_build_object($1::text, to_jsonb($2::numeric), $3::text, to_jsonb($4::text))');
         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(sql).toBe('jsonb_build_object($1::text, to_jsonb($2::text))');
         expect(params).toEqual(['Betriebs-Nr.', '18182952']);
     });
     test('should build jsonb from nested structures', () => {
         const query = buildJsonb({
             additionalData: { 'Betriebs-Nr.': '18182952' },
-            tags: ['a', 'b']
+            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(sql).toBe('jsonb_build_object($1::text, jsonb_build_object($2::text, to_jsonb($3::text)), $4::text, jsonb_build_array(to_jsonb($5::text), to_jsonb($6::text)))');
         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(sql).toBe('jsonb_build_object($1::text, to_jsonb($2::numeric))');
         expect(params).toEqual(['score', 0.5]);
     });
     test('should handle null and empty structures', () => {

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

@@ -68,7 +68,7 @@ describe('ORM Query Converter Complex', () => {
         const condition = convertQuery(q, table, colMap);
         const { sql, params } = dialect.sqlToQuery(condition);
         // Tokenizer is supported via JSON object syntax
-        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(sql).toContain('"test"."complex_items"."name" @@@ jsonb_build_object($1::text, jsonb_build_object($2::text, to_jsonb($3::text), $4::text, jsonb_build_object($5::text, to_jsonb($6::text), $7::text, to_jsonb($8::numeric), $9::text, to_jsonb($10::numeric))))::pdb.query');
         expect(params).toEqual(['match', 'value', 'test', 'tokenizer', 'type', 'ngram', 'min_gram', 3, 'max_gram', 3]);
     });
     test('should handle ParadeDB $parade range', () => {
@@ -85,7 +85,7 @@ describe('ORM Query Converter Complex', () => {
         const condition = convertQuery(q, table, colMap);
         const { sql, params } = dialect.sqlToQuery(condition);
         // This should fall back to convertParadeComparisonQuery with recursive jsonb build
-        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(sql).toContain('"test"."complex_items"."value" @@@ jsonb_build_object($1::text, jsonb_build_object($2::text, jsonb_build_object($3::text, to_jsonb($4::numeric)), $5::text, jsonb_build_object($6::text, to_jsonb($7::numeric))))::pdb.query');
         expect(params).toEqual(['range', 'lower_bound', 'included', 10, 'upper_bound', 'excluded', 20]);
     });
     test('should handle ParadeDB $parade phrasePrefix', () => {
@@ -98,7 +98,7 @@ describe('ORM Query Converter Complex', () => {
         };
         const condition = convertQuery(q, table, colMap);
         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(sql).toContain('"test"."complex_items"."name" @@@ jsonb_build_object($1::text, jsonb_build_object($2::text, jsonb_build_array(to_jsonb($3::text), to_jsonb($4::text)), $5::text, to_jsonb($6::numeric)))::pdb.query');
         expect(params).toEqual(['phrase_prefix', 'phrases', 'hello', 'wor', 'max_expansions', 10]);
     });
     test('should handle ParadeDB $parade regexPhrase', () => {
@@ -111,7 +111,7 @@ describe('ORM Query Converter Complex', () => {
         };
         const condition = convertQuery(q, table, colMap);
         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(sql).toContain('"test"."complex_items"."name" @@@ jsonb_build_object($1::text, jsonb_build_object($2::text, jsonb_build_array(to_jsonb($3::text), to_jsonb($4::text)), $5::text, to_jsonb($6::numeric)))::pdb.query');
         expect(params).toEqual(['regex_phrase', 'regexes', 'he.*', 'wo.*', 'slop', 1]);
     });
     test('should handle ParadeDB top-level moreLikeThis', () => {
@@ -125,7 +125,7 @@ describe('ORM Query Converter Complex', () => {
         };
         const condition = convertQuery(q, table, colMap);
         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(sql).toContain('"test"."complex_items"."id" @@@ jsonb_build_object($1::text, jsonb_build_object($2::text, to_jsonb($3::text), $4::text, to_jsonb(ARRAY[$5, $6])))::pdb.query');
         expect(params).toEqual(['more_like_this', 'key_value', '123', 'fields', 'name', 'description']);
     });
 });

package/orm/tests/repository-cti-complex.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 { ChildEntity, Inheritance, 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_cti_complex';
+const test = getIntegrationTest({ orm: { schema } });
 describe('ORM Repository CTI Complex', () => {
-    let injector;
-    let db;
-    const schema = 'test_orm_cti_complex';
     let BaseEntity = class BaseEntity extends Entity {
         type;
         baseName;
@@ -57,15 +55,7 @@ describe('ORM Repository CTI Complex', () => {
         Table('leaf_entities', { schema }),
         ChildEntity('leaf')
     ], LeafEntity);
-    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('leaf_entities')} CASCADE`);
         await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('middle_entities')} CASCADE`);
@@ -102,69 +92,60 @@ describe('ORM Repository CTI Complex', () => {
     `);
     });
     test('should support deep inheritance (3 levels)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(LeafEntity);
-            const leaf = Object.assign(new LeafEntity(), {
-                baseName: 'Base',
-                middleName: 'Middle',
-                leafName: 'Leaf',
-            });
-            const inserted = await repository.insert(leaf);
-            expect(inserted.id).toBeDefined();
-            expect(inserted.baseName).toBe('Base');
-            expect(inserted.middleName).toBe('Middle');
-            expect(inserted.leafName).toBe('Leaf');
-            const loaded = await repository.load(inserted.id);
-            expect(loaded).toBeInstanceOf(LeafEntity);
-            expect(loaded.baseName).toBe('Base');
-            expect(loaded.middleName).toBe('Middle');
-            expect(loaded.leafName).toBe('Leaf');
+        const repository = injectRepository(LeafEntity);
+        const leaf = Object.assign(new LeafEntity(), {
+            baseName: 'Base',
+            middleName: 'Middle',
+            leafName: 'Leaf',
         });
+        const inserted = await repository.insert(leaf);
+        expect(inserted.id).toBeDefined();
+        expect(inserted.baseName).toBe('Base');
+        expect(inserted.middleName).toBe('Middle');
+        expect(inserted.leafName).toBe('Leaf');
+        const loaded = await repository.load(inserted.id);
+        expect(loaded).toBeInstanceOf(LeafEntity);
+        expect(loaded.baseName).toBe('Base');
+        expect(loaded.middleName).toBe('Middle');
+        expect(loaded.leafName).toBe('Leaf');
     });
     test('should throw error on discriminator mismatch', async () => {
-        await runInInjectionContext(injector, async () => {
-            const middleRepository = injectRepository(MiddleEntity);
-            const leafRepository = injectRepository(LeafEntity);
-            const middle = await middleRepository.insert(Object.assign(new MiddleEntity(), {
-                baseName: 'B',
-                middleName: 'M',
-            }));
-            // Try to load middle as leaf
-            await expect(leafRepository.load(middle.id)).rejects.toThrow();
-        });
+        const middleRepository = injectRepository(MiddleEntity);
+        const leafRepository = injectRepository(LeafEntity);
+        const middle = await middleRepository.insert(Object.assign(new MiddleEntity(), {
+            baseName: 'B',
+            middleName: 'M',
+        }));
+        // Try to load middle as leaf
+        await expect(leafRepository.load(middle.id)).rejects.toThrow();
     });
     test('should upsert correctly on child entities', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(MiddleEntity);
-            const e1 = Object.assign(new MiddleEntity(), { baseName: 'B1', middleName: 'M1' });
-            const inserted = await repository.insert(e1);
-            const update = Object.assign(new MiddleEntity(), { id: inserted.id, baseName: 'B1_Updated', middleName: 'M1_Updated' });
-            const upserted = await repository.upsert('id', update);
-            expect(upserted.id).toBe(inserted.id);
-            expect(upserted.baseName).toBe('B1_Updated');
-            expect(upserted.middleName).toBe('M1_Updated');
-        });
+        const repository = injectRepository(MiddleEntity);
+        const e1 = Object.assign(new MiddleEntity(), { baseName: 'B1', middleName: 'M1' });
+        const inserted = await repository.insert(e1);
+        const update = Object.assign(new MiddleEntity(), { id: inserted.id, baseName: 'B1_Updated', middleName: 'M1_Updated' });
+        const upserted = await repository.upsert('id', update);
+        expect(upserted.id).toBe(inserted.id);
+        expect(upserted.baseName).toBe('B1_Updated');
+        expect(upserted.middleName).toBe('M1_Updated');
     });
-    test('should handle upsert when parent exists but child does not', async () => {
-        await runInInjectionContext(injector, async () => {
-            const baseRepository = injectRepository(BaseEntity);
-            const middleRepository = injectRepository(MiddleEntity);
-            // Manually insert into base table only
-            const id = '00000000-0000-0000-0000-000000000001';
-            await db.execute(sql `
-        INSERT INTO ${sql.identifier(schema)}.${sql.identifier('base_entities')} (id, type, base_name, revision, revision_timestamp, create_timestamp, attributes)
-        VALUES (${id}, 'middle', 'OnlyBase', 1, now(), now(), '{}')
-      `);
-            // Now upsert via middle repository
-            const update = Object.assign(new MiddleEntity(), { id, baseName: 'Updated', middleName: 'NewMiddle' });
-            // This is expected to fail or behave unexpectedly if not handled, 
-            // because upsert (onConflictDoUpdate) usually targets one table.
-            // In CTI, we might need special handling.
-            const upserted = await middleRepository.upsert('id', update);
-            expect(upserted.id).toBe(id);
-            expect(upserted.middleName).toBe('NewMiddle');
-            const loaded = await middleRepository.load(id);
-            expect(loaded.middleName).toBe('NewMiddle');
-        });
+    test('should handle upsert when parent exists but child does not', async ({ database: db }) => {
+        const middleRepository = injectRepository(MiddleEntity);
+        // Manually insert into base table only
+        const id = '00000000-0000-0000-0000-000000000001';
+        await db.execute(sql `
+      INSERT INTO ${sql.identifier(schema)}.${sql.identifier('base_entities')} (id, type, base_name, revision, revision_timestamp, create_timestamp, attributes)
+      VALUES (${id}, 'middle', 'OnlyBase', 1, now(), now(), '{}')
+    `);
+        // Now upsert via middle repository
+        const update = Object.assign(new MiddleEntity(), { id, baseName: 'Updated', middleName: 'NewMiddle' });
+        // This is expected to fail or behave unexpectedly if not handled,
+        // because upsert (onConflictDoUpdate) usually targets one table.
+        // In CTI, we might need special handling.
+        const upserted = await middleRepository.upsert('id', update);
+        expect(upserted.id).toBe(id);
+        expect(upserted.middleName).toBe('NewMiddle');
+        const loaded = await middleRepository.load(id);
+        expect(loaded.middleName).toBe('NewMiddle');
     });
 });

package/orm/tests/repository-cti-embedded.test.js

@@ -9,15 +9,16 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { Injector, runInInjectionContext } from '../../injector/index.js';
 import { StringProperty } from '../../schema/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { sql } from 'drizzle-orm';
 import { beforeAll, describe, expect, test } from 'vitest';
 import { ChildEntity, Column, EmbeddedProperty, Inheritance, Table } from '../decorators.js';
 import { Entity } from '../entity.js';
-import { configureOrm, Database } from '../server/index.js';
+import { Database } from '../server/index.js';
 import { injectRepository } from '../server/repository.js';
 describe('ORM Repository CTI Embedded (Integration)', () => {
     let injector;
-    let db;
+    let database;
     const schema = 'test_orm_cti_embedded';
     class Address {
         street;
@@ -77,22 +78,11 @@ describe('ORM Repository CTI Embedded (Integration)', () => {
         ChildEntity('user')
     ], UserWithContact);
     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);
-        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('users_with_contact')} CASCADE`);
-        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('entities_with_address')} CASCADE`);
-        await db.execute(sql `
+        ({ injector, database } = await setupIntegrationTest({ orm: { schema } }));
+        await database.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
+        await database.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('users_with_contact')} CASCADE`);
+        await database.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('entities_with_address')} CASCADE`);
+        await database.execute(sql `
       CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('entities_with_address')} (
         id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
         type TEXT NOT NULL,
@@ -106,7 +96,7 @@ describe('ORM Repository CTI Embedded (Integration)', () => {
         UNIQUE (id, type)
       )
     `);
-        await db.execute(sql `
+        await database.execute(sql `
       CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('users_with_contact')} (
         id UUID PRIMARY KEY,
         type TEXT NOT NULL CHECK (type = 'user'),

package/orm/tests/repository-cti-search.test.js

@@ -11,13 +11,13 @@ import { sql } from 'drizzle-orm';
 import { beforeAll, describe, expect, test } from 'vitest';
 import { Injector, runInInjectionContext } from '../../injector/index.js';
 import { StringProperty } from '../../schema/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { ChildEntity, Column, GeneratedTsVector, Inheritance, Table } from '../decorators.js';
 import { Entity } from '../entity.js';
-import { configureOrm, Database } from '../server/index.js';
-import { injectRepository } from '../server/repository.js';
+import { injectRepository } from '../server/index.js';
 describe('ORM Repository CTI Search (Integration)', () => {
     let injector;
-    let db;
+    let database;
     const schema = 'test_orm_cti_search';
     let Item = class Item extends Entity {
         type;
@@ -70,23 +70,12 @@ describe('ORM Repository CTI Search (Integration)', () => {
         ChildEntity('electronic')
     ], Electronic);
     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);
-        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('books')} CASCADE`);
-        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('electronics')} CASCADE`);
-        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('items')} CASCADE`);
-        await db.execute(sql `
+        ({ injector, database } = await setupIntegrationTest({ orm: { schema } }));
+        await database.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
+        await database.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('books')} CASCADE`);
+        await database.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('electronics')} CASCADE`);
+        await database.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('items')} CASCADE`);
+        await database.execute(sql `
       CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('items')} (
         id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
         type TEXT NOT NULL,
@@ -101,8 +90,8 @@ describe('ORM Repository CTI Search (Integration)', () => {
         UNIQUE (id, type)
       )
     `);
-        await db.execute(sql `CREATE INDEX items_search_idx ON ${sql.identifier(schema)}.${sql.identifier('items')} USING GIN (search_vector)`);
-        await db.execute(sql `
+        await database.execute(sql `CREATE INDEX items_search_idx ON ${sql.identifier(schema)}.${sql.identifier('items')} USING GIN (search_vector)`);
+        await database.execute(sql `
       CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('books')} (
         id UUID PRIMARY KEY,
         type TEXT NOT NULL CHECK (type = 'book'),
@@ -110,7 +99,7 @@ describe('ORM Repository CTI Search (Integration)', () => {
         FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('items')} (id, type) ON DELETE CASCADE
       )
     `);
-        await db.execute(sql `
+        await database.execute(sql `
       CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('electronics')} (
         id UUID PRIMARY KEY,
         type TEXT NOT NULL CHECK (type = 'electronic'),