@tstdl/base 0.93.141 → 0.93.143

package/orm/server/repository.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);
@@ -26,7 +27,7 @@ import { millisecondsPerSecond } from '../../utils/units.js';
 import { Entity } from '../entity.js';
 import { distance, isSimilar, isStrictWordSimilar, isWordSimilar, TRANSACTION_TIMESTAMP, tsHeadline, tsRankCd } from '../sqls/index.js';
 import { getInheritanceMetadata, isChildEntity } from '../utils.js';
-import { getColumnDefinitions, getColumnDefinitionsMap, getDrizzleTableFromType, getTableColumnDefinitions, isTableOwning } from './drizzle/schema-converter.js';
+import { getColumnDefinitions, getColumnDefinitionsMap, getDrizzleTableFromType, getPrimaryKeyColumnDefinitions, getPrimaryKeyColumns, getTableColumnDefinitions, isTableOwning } from './drizzle/schema-converter.js';
 import { convertQuery, getTsQuery, getTsVector, resolveTargetColumn } from './query-converter.js';
 import { EntityRepositoryConfig } from './repository-config.js';
 import { ENCRYPTION_SECRET } from './tokens.js';
@@ -54,6 +55,8 @@ let EntityRepository = class EntityRepository extends Transactional {
     #baseTableWithMetadata = this.#baseTable;
     #columnDefinitions = this.#context.columnDefinitions ?? getColumnDefinitions(this.#table);
     #columnDefinitionsMap = this.#context.columnDefinitionsMap ?? getColumnDefinitionsMap(this.#table);
+    #primaryKeyColumns = getPrimaryKeyColumns(this.type, this.#table);
+    #primaryKeyColumnNames = this.#primaryKeyColumns.map((column) => column.name);
     #joinedTables = this.#tablesChain.filter((info) => info.table != this.#table).map((info) => info.table);
     #inheritanceMetadata = getInheritanceMetadata(this.type);
     #subclasses = this.#inheritanceMetadata?.subclasses ?? [];
@@ -64,6 +67,7 @@ let EntityRepository = class EntityRepository extends Transactional {
             type: subclass,
             table,
             tablesChain,
+            primaryKeyColumns: getPrimaryKeyColumns(subclass, table),
             columnDefinitions: getColumnDefinitions(table),
             discriminatorValue: reflectionRegistry.getMetadata(subclass)?.data.tryGet('orm')?.childEntity?.discriminatorValue, // eslint-disable-line @typescript-eslint/no-non-null-asserted-optional-chain
         };
@@ -84,7 +88,7 @@ let EntityRepository = class EntityRepository extends Transactional {
     })();
     #defaultSelection = fromEntries(this.#columnDefinitions.map((column) => [column.name, this.resolveTargetColumn(column)]));
     #upsertManyExcludedMapping = fromEntries(this.#tableColumnDefinitions
-        .filter((column) => column.name != this.#table.id.name)
+        .filter((column) => !this.#primaryKeyColumnNames.includes(column.name))
         .map((column) => [column.name, sql `excluded.${sql.identifier(this.getColumn(column).name)}`]));
     #expirationColumns = this.#columnDefinitions.filter((column) => isDefined(column.reflectionData?.expirationField));
     #softExpirationColumns = this.#expirationColumns.filter((column) => column.reflectionData.expirationField.mode == 'soft');
@@ -679,7 +683,7 @@ let EntityRepository = class EntityRepository extends Transactional {
             const transformContext = await this.getTransformContext();
             const results = {};
             let generatedId = entity.id;
-            for (const { table, columnDefinitions } of this.#tablesChain) {
+            for (const { table, columnDefinitions, primaryKeyColumns } of this.#tablesChain) {
                 const tableColumnNames = columnDefinitions.map((def) => def.name);
                 const tableColumnNamesSet = new Set(tableColumnNames);
                 const filteredTarget = isDefined(wheres?.target) ? this.filterQuery(wheres.target, tableColumnNamesSet) : undefined;
@@ -695,7 +699,7 @@ let EntityRepository = class EntityRepository extends Transactional {
                 });
                 const tableTarget = isTargetInTable
                     ? targetPaths.map((path) => resolveTargetColumn(path, table, this.#columnDefinitionsMap))
-                    : [table.id];
+                    : primaryKeyColumns;
                 const [row] = await transaction.pgTransaction
                     .insert(table)
                     .values({ ...columns, ...(isDefined(generatedId) ? { id: generatedId } : {}) })
@@ -758,7 +762,7 @@ let EntityRepository = class EntityRepository extends Transactional {
             if (generatedIds.length != entities.length) {
                 generatedIds = undefined;
             }
-            for (const { table, columnDefinitions } of this.#tablesChain) {
+            for (const { table, columnDefinitions, primaryKeyColumns } of this.#tablesChain) {
                 const tableColumnNames = columnDefinitions.map((def) => def.name);
                 const tableColumnNamesSet = new Set(tableColumnNames);
                 const filteredTarget = isDefined(wheres?.target) ? this.filterQuery(wheres.target, tableColumnNamesSet) : undefined;
@@ -772,10 +776,11 @@ let EntityRepository = class EntityRepository extends Transactional {
                     }
                     return columns;
                 }));
+                const primaryKeyColumnNames = primaryKeyColumns.map((pk) => pk.name);
                 const mappedUpdate = isDefined(update)
                     ? await this._mapToTableUpdate(update, transformContext, table, columnDefinitions)
                     : {
-                        ...fromEntries(columnDefinitions.filter((column) => column.name != table.id.name).map((column) => [column.name, sql `excluded.${sql.identifier(resolveTargetColumn(column, table, this.#columnDefinitionsMap).name)}`])),
+                        ...fromEntries(columnDefinitions.filter((column) => !primaryKeyColumnNames.includes(column.name)).map((column) => [column.name, sql `excluded.${sql.identifier(resolveTargetColumn(column, table, this.#columnDefinitionsMap).name)}`])),
                         ...((table == this.#baseTable) ? this._getMetadataUpdate(update) : undefined),
                     };
                 const targetPaths = toArray(target);
@@ -785,7 +790,7 @@ let EntityRepository = class EntityRepository extends Transactional {
                 });
                 const tableTarget = isTargetInTable
                     ? targetPaths.map((path) => resolveTargetColumn(path, table, this.#columnDefinitionsMap))
-                    : [table.id];
+                    : primaryKeyColumns;
                 const rows = await transaction.pgTransaction
                     .insert(table)
                     .values(values)
@@ -1455,7 +1460,10 @@ let EntityRepository = class EntityRepository extends Transactional {
         return sql `${this.#baseTableWithMetadata.attributes} || ${JSON.stringify(attributes)}::jsonb`;
     }
     applyJoins(dbQuery) {
-        return this.#joinedTables.reduce((query, joinedTable) => query.innerJoin(joinedTable, eq(this.#table.id, joinedTable.id)), dbQuery);
+        return this.#tablesChain.filter((info) => info.table != this.#table).reduce((query, info) => {
+            const conditions = info.primaryKeyColumnDefinitions.map((def) => eq(this.#table[def.name], info.table[def.name]));
+            return query.innerJoin(info.table, and(...conditions));
+        }, dbQuery);
     }
     getTablesChain(type) {
         const chain = [];
@@ -1463,7 +1471,9 @@ let EntityRepository = class EntityRepository extends Transactional {
         while (true) {
             const table = getDrizzleTableFromType(currentType, this.#schema);
             const columnDefinitions = getTableColumnDefinitions(table);
-            chain.unshift({ table, type: currentType, columnDefinitions });
+            const primaryKeyColumnDefinitions = getPrimaryKeyColumnDefinitions(currentType, table);
+            const primaryKeyColumns = getPrimaryKeyColumns(currentType, table, primaryKeyColumnDefinitions);
+            chain.unshift({ table, type: currentType, columnDefinitions, primaryKeyColumnDefinitions, primaryKeyColumns });
             const parentType = reflectionRegistry.getMetadata(currentType)?.parent;
             if (isNullOrUndefined(parentType) || !isTableOwning(parentType)) {
                 break;

package/orm/server/transaction.d.ts

@@ -11,6 +11,7 @@ export declare class Transaction implements AsyncDisposable {
     readonly afterCommit: import("../../utils/async-hook/index.js").AsyncHook<never, never, unknown>;
     readonly parent?: Transaction;
     manualCommit: boolean;
+    get isDone(): boolean;
     constructor(pgTransaction: PgTransaction, parent?: Transaction);
     static create(session: Database | PgTransaction, config?: TransactionConfig, parent?: Transaction): Promise<Transaction>;
     [Symbol.asyncDispose](): Promise<void>;

package/orm/server/transaction.js

@@ -12,6 +12,9 @@ export class Transaction {
     afterCommit = asyncHook();
     parent;
     manualCommit = false;
+    get isDone() {
+        return this.#done;
+    }
     constructor(pgTransaction, parent) {
         this.pgTransaction = pgTransaction;
         this.parent = parent;

package/orm/tests/database-extension.test.js

@@ -0,0 +1,63 @@
+import { sql } from 'drizzle-orm';
+import { describe, expect, it, vi } from 'vitest';
+import { APPLICATION_INITIALIZER } from '../../application/application.js';
+import { runInInjectionContext } from '../../injector/inject.js';
+import { bootstrapOrm, provideOrm } from '../../orm/server/bootstrap.js';
+import { Database } from '../../orm/server/database.js';
+import { DATABASE_EXTENSION, registerDatabaseExtension, runDatabaseExtensions } from '../../orm/server/extension.js';
+import { DATABASE_MIGRATION } from '../../orm/server/migration.js';
+import { setupIntegrationTest } from '../../testing/index.js';
+describe('Database Extension Registration', () => {
+    it('should have DATABASE_EXTENSION token defined', () => {
+        expect(DATABASE_EXTENSION).toBeDefined();
+    });
+    it('should provide ORM bootstrap as application initializer', () => {
+        const provider = provideOrm();
+        expect(provider.provide).toBe(APPLICATION_INITIALIZER);
+        expect(provider.useValue).toBe(bootstrapOrm);
+        expect(provider.multi).toBe(true);
+    });
+    it('should register an extension', async () => {
+        const { injector } = await setupIntegrationTest();
+        registerDatabaseExtension('btree_gin', { injector });
+        const extensions = injector.resolveAll(DATABASE_EXTENSION);
+        expect(extensions).toHaveLength(1);
+        expect(extensions[0].name).toBe('btree_gin');
+    });
+    it('should run extensions', async () => {
+        const { injector } = await setupIntegrationTest();
+        const database = injector.resolve(Database);
+        const executeSpy = vi.spyOn(database, 'execute').mockResolvedValue({});
+        registerDatabaseExtension('btree_gin', { injector });
+        registerDatabaseExtension('uuid-ossp', { injector });
+        await runInInjectionContext(injector, async () => {
+            await runDatabaseExtensions();
+        });
+        expect(executeSpy).toHaveBeenCalledWith(sql.raw('CREATE EXTENSION IF NOT EXISTS "btree_gin"'));
+        expect(executeSpy).toHaveBeenCalledWith(sql.raw('CREATE EXTENSION IF NOT EXISTS "uuid-ossp"'));
+    });
+    it('should bootstrap ORM (extensions and migrations)', async () => {
+        const { injector } = await setupIntegrationTest();
+        const database = injector.resolve(Database);
+        const executeSpy = vi.spyOn(database, 'execute').mockResolvedValue({});
+        registerDatabaseExtension('btree_gin', { injector });
+        let migrated = false;
+        const migration = {
+            name: 'test-migration',
+            migrate: async () => {
+                migrated = true;
+            },
+        };
+        injector.register(DATABASE_MIGRATION, { useValue: migration }, { multi: true });
+        await runInInjectionContext(injector, async () => {
+            await bootstrapOrm();
+        });
+        // Check extension call
+        expect(executeSpy).toHaveBeenCalledWith(sql.raw('CREATE EXTENSION IF NOT EXISTS "btree_gin"'));
+        // Check migration ran
+        expect(migrated).toBe(true);
+        // Check locking
+        expect(executeSpy).toHaveBeenCalledWith(sql `SELECT pg_advisory_lock(${123456789})`);
+        expect(executeSpy).toHaveBeenCalledWith(sql `SELECT pg_advisory_unlock(${123456789})`);
+    });
+});

package/orm/tests/database-migration.test.js

@@ -1,16 +1,17 @@
 import { APPLICATION_INITIALIZER } from '../../application/application.js';
 import { runInInjectionContext } from '../../injector/inject.js';
-import { DATABASE_MIGRATION, provideDatabaseMigrator, runDatabaseMigrations } from '../../orm/server/migration.js';
+import { bootstrapOrm, provideOrm } from '../../orm/server/bootstrap.js';
+import { DATABASE_MIGRATION } from '../../orm/server/migration.js';
 import { setupIntegrationTest } from '../../testing/index.js';
 import { describe, expect, it } from 'vitest';
 describe('Database Migration Orchestration', () => {
     it('should have DATABASE_MIGRATION token defined', () => {
         expect(DATABASE_MIGRATION).toBeDefined();
     });
-    it('should provide database migrator as application initializer', () => {
-        const provider = provideDatabaseMigrator();
+    it('should provide ORM bootstrap as application initializer', () => {
+        const provider = provideOrm();
         expect(provider.provide).toBe(APPLICATION_INITIALIZER);
-        expect(provider.useValue).toBe(runDatabaseMigrations);
+        expect(provider.useValue).toBe(bootstrapOrm);
         expect(provider.multi).toBe(true);
     });
     it('should register and resolve a migration', async () => {
@@ -57,7 +58,7 @@ describe('Database Migration Orchestration', () => {
         injector.register(DATABASE_MIGRATION, { useValue: migrationB }, { multi: true });
         injector.register(DATABASE_MIGRATION, { useValue: migrationC }, { multi: true });
         await runInInjectionContext(injector, async () => {
-            await runDatabaseMigrations();
+            await bootstrapOrm();
         });
         expect(executionOrder).toEqual(['b', 'a', 'c']);
     });
@@ -76,7 +77,7 @@ describe('Database Migration Orchestration', () => {
         injector.register(DATABASE_MIGRATION, { useValue: migrationA }, { multi: true });
         injector.register(DATABASE_MIGRATION, { useValue: migrationB }, { multi: true });
         await runInInjectionContext(injector, async () => {
-            await expect(runDatabaseMigrations()).rejects.toThrow('Circular dependency detected');
+            await expect(bootstrapOrm()).rejects.toThrow('Circular dependency detected');
         });
     });
 });

package/orm/tests/repository-compound-primary-key.test.d.ts

@@ -0,0 +1,2 @@
+/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
+export {};

package/orm/tests/repository-compound-primary-key.test.js

@@ -0,0 +1,234 @@
+/** 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);
+    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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Injector, runInInjectionContext } from '../../injector/index.js';
+import { StringProperty } from '../../schema/index.js';
+import { dropTables, setupIntegrationTest } from '../../testing/index.js';
+import { sql } from 'drizzle-orm';
+import { getTableConfig } from 'drizzle-orm/pg-core';
+import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
+import { ChildEntity, Inheritance, PrimaryKey, Table } from '../decorators.js';
+import { Entity } from '../entity.js';
+import { getDrizzleTableFromType } from '../server/drizzle/index.js';
+import { Database, injectRepository } from '../server/index.js';
+describe('ORM Repository Compound Primary Key (Integration)', () => {
+    let injector;
+    let database;
+    const schema = 'test_orm_compound_pk';
+    let CompoundEntity = class CompoundEntity extends Entity {
+        namespace;
+        data;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], CompoundEntity.prototype, "namespace", void 0);
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], CompoundEntity.prototype, "data", void 0);
+    CompoundEntity = __decorate([
+        Table('compound_entities', { schema }),
+        PrimaryKey(['namespace', 'id'])
+    ], CompoundEntity);
+    let ParentEntity = class ParentEntity extends Entity {
+        namespace;
+        type;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], ParentEntity.prototype, "namespace", void 0);
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], ParentEntity.prototype, "type", void 0);
+    ParentEntity = __decorate([
+        Table('parent_entities', { schema }),
+        PrimaryKey(['namespace', 'id']),
+        Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
+    ], ParentEntity);
+    let ChildEntityModel = class ChildEntityModel extends ParentEntity {
+        childData;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], ChildEntityModel.prototype, "childData", void 0);
+    ChildEntityModel = __decorate([
+        Table('child_entities', { schema }),
+        ChildEntity('child')
+    ], ChildEntityModel);
+    let GrandchildEntity = class GrandchildEntity extends ChildEntityModel {
+        grandchildData;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], GrandchildEntity.prototype, "grandchildData", void 0);
+    GrandchildEntity = __decorate([
+        Table('grandchild_entities', { schema }),
+        ChildEntity('grandchild')
+    ], GrandchildEntity);
+    beforeAll(async () => {
+        ({ injector, database } = await setupIntegrationTest({ orm: { schema } }));
+        await database.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
+        await dropTables(database, schema, ['grandchild_entities', 'child_entities', 'parent_entities', 'compound_entities']);
+        await database.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('compound_entities')} (
+        namespace TEXT NOT NULL,
+        id UUID NOT NULL,
+        data TEXT NOT NULL,
+        revision INTEGER NOT NULL,
+        revision_timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
+        create_timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
+        delete_timestamp TIMESTAMP WITH TIME ZONE,
+        attributes JSONB NOT NULL DEFAULT '{}',
+        PRIMARY KEY (namespace, id)
+      )
+    `);
+        await database.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('parent_entities')} (
+        namespace TEXT NOT NULL,
+        id UUID NOT NULL,
+        type TEXT NOT NULL,
+        revision INTEGER NOT NULL,
+        revision_timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
+        create_timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
+        delete_timestamp TIMESTAMP WITH TIME ZONE,
+        attributes JSONB NOT NULL DEFAULT '{}',
+        PRIMARY KEY (namespace, id),
+        UNIQUE (namespace, id, type)
+      )
+    `);
+        await database.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('child_entities')} (
+        namespace TEXT NOT NULL,
+        id UUID NOT NULL,
+        type TEXT NOT NULL CHECK (type IN ('child', 'grandchild')),
+        child_data TEXT NOT NULL,
+        PRIMARY KEY (namespace, id),
+        FOREIGN KEY (namespace, id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('parent_entities')} (namespace, id, type) ON DELETE CASCADE,
+        UNIQUE (namespace, id, type)
+      )
+    `);
+        await database.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('grandchild_entities')} (
+        namespace TEXT NOT NULL,
+        id UUID NOT NULL,
+        type TEXT NOT NULL CHECK (type = 'grandchild'),
+        grandchild_data TEXT NOT NULL,
+        PRIMARY KEY (namespace, id),
+        FOREIGN KEY (namespace, id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('child_entities')} (namespace, id, type) ON DELETE CASCADE
+      )
+    `);
+    });
+    beforeEach(async () => {
+        await database.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('grandchild_entities')}, ${sql.identifier(schema)}.${sql.identifier('child_entities')}, ${sql.identifier(schema)}.${sql.identifier('parent_entities')}, ${sql.identifier(schema)}.${sql.identifier('compound_entities')} CASCADE`);
+    });
+    test('should insert and load compound entity', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(CompoundEntity);
+            const entity = new CompoundEntity();
+            entity.id = '00000000-0000-0000-0000-000000000001';
+            entity.namespace = 'ns1';
+            entity.data = 'test data';
+            await repository.insert(entity);
+            const loaded = await repository.loadByQuery({ namespace: 'ns1', id: '00000000-0000-0000-0000-000000000001' });
+            expect(loaded.data).toBe('test data');
+            expect(loaded.namespace).toBe('ns1');
+            expect(loaded.id).toBe('00000000-0000-0000-0000-000000000001');
+        });
+    });
+    test('should upsert compound entity', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(CompoundEntity);
+            const entity = new CompoundEntity();
+            entity.id = '00000000-0000-0000-0000-000000000010';
+            entity.namespace = 'ns1';
+            entity.data = 'initial data';
+            await repository.insert(entity);
+            const updateEntity = new CompoundEntity();
+            updateEntity.id = '00000000-0000-0000-0000-000000000010';
+            updateEntity.namespace = 'ns1';
+            updateEntity.data = 'updated data';
+            await repository.upsert(['namespace', 'id'], updateEntity);
+            const loaded = await repository.loadByQuery({ namespace: 'ns1', id: '00000000-0000-0000-0000-000000000010' });
+            expect(loaded.data).toBe('updated data');
+        });
+    });
+    test('should insert and load child entity with compound PK', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(ChildEntityModel);
+            const entity = new ChildEntityModel();
+            entity.id = '00000000-0000-0000-0000-000000000020';
+            entity.namespace = 'ns2';
+            entity.type = 'child';
+            entity.childData = 'child specific data';
+            await repository.insert(entity);
+            const loaded = await repository.loadByQuery({ namespace: 'ns2', id: '00000000-0000-0000-0000-000000000020' });
+            expect(loaded.childData).toBe('child specific data');
+            expect(loaded.namespace).toBe('ns2');
+            expect(loaded.id).toBe('00000000-0000-0000-0000-000000000020');
+        });
+    });
+    test('should insert and load grandchild entity with compound PK', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(GrandchildEntity);
+            const entity = new GrandchildEntity();
+            entity.id = '00000000-0000-0000-0000-000000000050';
+            entity.namespace = 'ns5';
+            entity.type = 'grandchild';
+            entity.childData = 'child part';
+            entity.grandchildData = 'grandchild part';
+            await repository.insert(entity);
+            const loaded = await repository.loadByQuery({ namespace: 'ns5', id: '00000000-0000-0000-0000-000000000050' });
+            expect(loaded.grandchildData).toBe('grandchild part');
+            expect(loaded.childData).toBe('child part');
+            expect(loaded.namespace).toBe('ns5');
+            expect(loaded.id).toBe('00000000-0000-0000-0000-000000000050');
+        });
+    });
+    test('should updateManyByQuery with compound PK', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(CompoundEntity);
+            const entity1 = new CompoundEntity();
+            entity1.id = '00000000-0000-0000-0000-000000000030';
+            entity1.namespace = 'ns3';
+            entity1.data = 'data 1';
+            const entity2 = new CompoundEntity();
+            entity2.id = '00000000-0000-0000-0000-000000000040';
+            entity2.namespace = 'ns3';
+            entity2.data = 'data 2';
+            await repository.insertMany([entity1, entity2]);
+            await repository.updateManyByQuery({ namespace: 'ns3' }, { data: 'batch updated' });
+            const entities = await repository.loadManyByQuery({ namespace: 'ns3' });
+            expect(entities).toHaveLength(2);
+            expect(entities.every(e => e.data === 'batch updated')).toBe(true);
+        });
+    });
+    test('should respect custom primary key name', () => {
+        let CustomPkEntity = class CustomPkEntity extends Entity {
+            namespace;
+        };
+        __decorate([
+            StringProperty(),
+            __metadata("design:type", String)
+        ], CustomPkEntity.prototype, "namespace", void 0);
+        CustomPkEntity = __decorate([
+            Table('custom_pk_table', { schema: 'test' }),
+            PrimaryKey(['namespace', 'id'], { name: 'my_custom_pk' })
+        ], CustomPkEntity);
+        const table = getDrizzleTableFromType(CustomPkEntity);
+        const config = getTableConfig(table);
+        expect(config.primaryKeys).toHaveLength(1);
+        expect(config.primaryKeys[0].name).toBe('my_custom_pk');
+    });
+});

package/orm/tests/schema-generation.test.d.ts

@@ -1 +1,2 @@
+/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
 export {};

package/orm/tests/schema-generation.test.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);
@@ -7,11 +8,11 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { describe, expect, test } from 'vitest';
 import { getTableConfig } from 'drizzle-orm/pg-core';
+import { describe, expect, test } from 'vitest';
 import { StringProperty } from '../../schema/index.js';
-import { Entity } from '../entity.js';
-import { Column, Inheritance, ChildEntity, Table, ParadeIndex } from '../decorators.js';
+import { ChildEntity, Column, Inheritance, ParadeIndex, Table } from '../decorators.js';
+import { Entity, TenantEntity } from '../entity.js';
 import { getDrizzleTableFromType } from '../server/drizzle/schema-converter.js';
 describe('ORM Schema Generation (CTI)', () => {
     test('should generate correct parent table with discriminator and unique constraint', () => {
@@ -95,6 +96,52 @@ describe('ORM Schema Generation (CTI)', () => {
         expect(compositeFk).toBeDefined();
         expect(compositeFk?.reference().columns.map(c => c.name).sort()).toEqual(['id', 'type']);
     });
+    test('should generate correct parent and child table for TenantEntity with joined inheritance', () => {
+        let BaseTenantUser = class BaseTenantUser extends TenantEntity {
+            type;
+        };
+        __decorate([
+            StringProperty(),
+            Column({ name: 'type' }),
+            __metadata("design:type", String)
+        ], BaseTenantUser.prototype, "type", void 0);
+        BaseTenantUser = __decorate([
+            Table('tenant_users', { schema: 'test' }),
+            Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
+        ], BaseTenantUser);
+        let TenantAdmin = class TenantAdmin extends BaseTenantUser {
+            role;
+        };
+        __decorate([
+            StringProperty(),
+            __metadata("design:type", String)
+        ], TenantAdmin.prototype, "role", void 0);
+        TenantAdmin = __decorate([
+            Table('tenant_admins', { schema: 'test' }),
+            ChildEntity('admin')
+        ], TenantAdmin);
+        // Test Parent Table
+        const parentTable = getDrizzleTableFromType(BaseTenantUser);
+        const parentConfig = getTableConfig(parentTable);
+        const parentUnique = parentConfig.uniqueConstraints.find((uc) => uc.columns.some((c) => c.name === 'type'));
+        expect(parentUnique).toBeDefined();
+        // Should be tenant_id, type, id (no duplicates)
+        expect(parentUnique.columns.map((c) => c.name)).toEqual(['tenant_id', 'type', 'id']);
+        // UNIQUE identifier should use snake_case column names
+        expect(parentUnique.name).toBe('tenant_users_tenant_id_type_id_unique');
+        // Test Child Table
+        const childTable = getDrizzleTableFromType(TenantAdmin);
+        const childConfig = getTableConfig(childTable);
+        // Child should have tenant_id and id from parent PK, plus type discriminator
+        const childColumnNames = childConfig.columns.map((c) => c.name);
+        expect(childColumnNames).toContain('tenant_id');
+        expect(childColumnNames).toContain('id');
+        expect(childColumnNames).toContain('type');
+        // Child Foreign Key should link correctly with all 3 columns
+        const childFk = childConfig.foreignKeys.find((fk) => fk.reference().columns.length === 3);
+        expect(childFk).toBeDefined();
+        expect(childFk.reference().columns.map((c) => c.name)).toEqual(['tenant_id', 'type', 'id']);
+    });
     test('should generate BM25 index with correct config', () => {
         let SearchableItem = class SearchableItem extends Entity {
             title;
@@ -112,7 +159,7 @@ describe('ORM Schema Generation (CTI)', () => {
             Table('searchable', { schema: 'test' }),
             ParadeIndex({
                 columns: ['title', ['body', { tokenizer: 'simple' }]],
-                naming: 'abbreviated-table'
+                naming: 'abbreviated-table',
             })
         ], SearchableItem);
         const table = getDrizzleTableFromType(SearchableItem);
@@ -122,6 +169,6 @@ describe('ORM Schema Generation (CTI)', () => {
         expect(paradeIdx).toBeDefined();
         const extraConfig = paradeIdx.config.with;
         expect(extraConfig).toBeDefined();
-        expect(extraConfig.key_field).toBe("'id'");
+        expect(extraConfig.key_field).toBe(`'id'`);
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.141",
+  "version": "0.93.143",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -152,8 +152,8 @@
     "type-fest": "^5.4"
   },
   "peerDependencies": {
-    "@aws-sdk/client-s3": "^3.996",
-    "@aws-sdk/s3-request-presigner": "^3.996",
+    "@aws-sdk/client-s3": "^3.997",
+    "@aws-sdk/s3-request-presigner": "^3.997",
     "@genkit-ai/google-genai": "^1.29",
     "@google-cloud/storage": "^7.19",
     "@toon-format/toon": "^2.1.0",
@@ -168,7 +168,7 @@
     "handlebars": "^4.7",
     "mjml": "^4.18",
     "nodemailer": "^8.0",
-    "pg": "^8.18",
+    "pg": "^8.19",
     "playwright": "^1.58",
     "preact": "^10.28",
     "preact-render-to-string": "^6.6",

package/task-queue/README.md

@@ -285,7 +285,6 @@ Passed to the worker handler.
 | `maxExecutionTime`        | `60m`   | Hard limit for `Running` state.                    |
 | `maxTries`                | `3`     | Maximum dequeue attempts allowed.                  |
 | `retention`               | `30d`   | Duration to retain terminal tasks before archival. |
-| `globalConcurrency`       | `null`  | Max simultaneous running tasks across all workers. |
 | `circuitBreakerThreshold` | `5`     | Failures before tripping the circuit breaker.      |
 | `retryDelayMinimum`       | `5s`    | Floor for exponential backoff delay.               |
 | `retryDelayMaximum`       | `5m`    | Ceiling for exponential backoff delay.             |