@tstdl/base 0.93.140 → 0.93.142

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/orm/utils.d.ts

@@ -4,8 +4,8 @@
  */
 import { type PropertyMetadata } from '../reflection/registry.js';
 import type { AbstractConstructor } from '../types/index.js';
-import type { InheritanceMetadata } from './decorators.js';
-import type { BaseEntity, Entity } from './entity.js';
+import type { InheritanceMetadata, OrmTableReflectionData } from './decorators.js';
+import type { BaseEntity, Entity, EntityType } from './entity.js';
 /**
  * Converts an array of entities into a Map keyed by entity ID.
  * @template T - The entity type, must extend `Entity` (i.e., have an `id` property).
@@ -24,3 +24,18 @@ export declare function getEntityIds(entities: (Entity | BaseEntity)[]): string[
 export declare function isChildEntity(type: AbstractConstructor): boolean;
 export declare function getInheritanceMetadata(type: AbstractConstructor): InheritanceMetadata | undefined;
 export declare function getOwnProperties(type: AbstractConstructor): PropertyMetadata[];
+/**
+ * Gets the database schema name for a given entity type, traversing the inheritance hierarchy.
+ * @param type The entity class.
+ * @param fallback Optional fallback schema name if none is defined in metadata.
+ * @returns The resolved schema name.
+ */
+export declare function getEntitySchema(type: AbstractConstructor, fallback?: string): string;
+/**
+ * Gets the database table name for a given entity type, traversing the inheritance hierarchy.
+ * @param type The entity class.
+ * @returns The resolved table name.
+ */
+export declare function getEntityTableName(type: AbstractConstructor): string;
+export declare function getDefaultTableName(type: EntityType): string;
+export declare function getTableReflectionDatas(type: EntityType): OrmTableReflectionData[];

package/orm/utils.js

@@ -3,7 +3,8 @@
  * Provides utility functions for working with ORM entities.
  */
 import { reflectionRegistry } from '../reflection/registry.js';
-import { isDefined, isNotNullOrUndefined, isUndefined } from '../utils/type-guards.js';
+import { toSnakeCase } from '../utils/string/index.js';
+import { assertDefined, isDefined, isNotNullOrUndefined, isString, isUndefined } from '../utils/type-guards.js';
 export function getEntityMap(entities, selector = (entity) => entity.id) {
     const entries = entities.map((entity) => [selector(entity), entity]);
     return new Map(entries);
@@ -36,3 +37,50 @@ export function getOwnProperties(type) {
     }
     return [...metadata.properties.values()].filter((property) => !property.inherited || (property.key == 'id'));
 }
+/**
+ * Gets the database schema name for a given entity type, traversing the inheritance hierarchy.
+ * @param type The entity class.
+ * @param fallback Optional fallback schema name if none is defined in metadata.
+ * @returns The resolved schema name.
+ */
+export function getEntitySchema(type, fallback) {
+    for (let currentMetadata = reflectionRegistry.getMetadata(type); isNotNullOrUndefined(currentMetadata); currentMetadata = isNotNullOrUndefined(currentMetadata.parent) ? reflectionRegistry.getMetadata(currentMetadata.parent) : undefined) {
+        const schema = currentMetadata.data.tryGet('orm')?.schema;
+        if (isDefined(schema)) {
+            return schema;
+        }
+    }
+    if (isDefined(fallback)) {
+        return fallback;
+    }
+    throw new Error(`Schema not found for entity ${type.name} and no fallback provided.`);
+}
+/**
+ * Gets the database table name for a given entity type, traversing the inheritance hierarchy.
+ * @param type The entity class.
+ * @returns The resolved table name.
+ */
+export function getEntityTableName(type) {
+    for (let currentMetadata = reflectionRegistry.getMetadata(type); isNotNullOrUndefined(currentMetadata); currentMetadata = isNotNullOrUndefined(currentMetadata.parent) ? reflectionRegistry.getMetadata(currentMetadata.parent) : undefined) {
+        const name = currentMetadata.data.tryGet('orm')?.name;
+        if (isDefined(name)) {
+            return name;
+        }
+    }
+    return getDefaultTableName(type);
+}
+export function getDefaultTableName(type) {
+    return toSnakeCase(isString(type.entityName) ? type.entityName : type.name.replace(/\d+$/u, ''));
+}
+export function getTableReflectionDatas(type) {
+    const metadata = reflectionRegistry.getMetadata(type);
+    assertDefined(metadata, `Type ${type.name} does not have reflection metadata.`);
+    const tableReflectionDatas = [];
+    for (let currentMetadata = metadata; isNotNullOrUndefined(currentMetadata?.parent); currentMetadata = reflectionRegistry.getMetadata(currentMetadata.parent)) {
+        const tableReflectionData = currentMetadata.data.tryGet('orm');
+        if (isDefined(tableReflectionData)) {
+            tableReflectionDatas.push(tableReflectionData);
+        }
+    }
+    return tableReflectionDatas;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.140",
+  "version": "0.93.142",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -17,6 +17,7 @@
     "lint": "eslint --cache source/",
     "pub": "npm run build:production && npm run cleanup:dist && npm publish dist/",
     "test": "vitest run",
+    "test:coverage": "f() { vitest run --coverage --coverage.include=\"source/$1/**/*.ts\" source/$1; }; f",
     "tsc:watch": "tsc --watch",
     "tsc-alias:watch": "tsc-alias --watch",
     "cleanup:dist": "rm -vrf dist/tools/",
@@ -151,8 +152,8 @@
     "type-fest": "^5.4"
   },
   "peerDependencies": {
-    "@aws-sdk/client-s3": "^3.994",
-    "@aws-sdk/s3-request-presigner": "^3.994",
+    "@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",
@@ -167,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/rate-limit/postgres/module.d.ts

@@ -2,6 +2,7 @@ import { Injector } from '../../injector/injector.js';
 import { type DatabaseConfig } from '../../orm/server/index.js';
 export declare class PostgresRateLimiterModuleConfig {
     database?: DatabaseConfig;
+    autoMigrate?: boolean;
 }
 /**
  * configure rate limit module

package/rate-limit/postgres/module.js

@@ -1,12 +1,13 @@
 import { inject } from '../../injector/index.js';
 import { Injector } from '../../injector/injector.js';
-import { Database, migrate } from '../../orm/server/index.js';
+import { Database, migrate, registerDatabaseMigration } from '../../orm/server/index.js';
 import { RateLimiterProvider } from '../provider.js';
 import { RateLimiter } from '../rate-limiter.js';
 import { PostgresRateLimiter } from './postgres-rate-limiter.js';
 import { PostgresRateLimiterProvider } from './rate-limiter.provider.js';
 export class PostgresRateLimiterModuleConfig {
     database;
+    autoMigrate;
 }
 /**
  * configure rate limit module
@@ -16,6 +17,9 @@ export function configurePostgresRateLimiter({ injector, ...config } = {}) {
     targetInjector.register(PostgresRateLimiterModuleConfig, { useValue: config });
     targetInjector.registerSingleton(RateLimiterProvider, { useToken: PostgresRateLimiterProvider });
     targetInjector.registerSingleton(RateLimiter, { useToken: PostgresRateLimiter });
+    if (config.autoMigrate != false) {
+        registerDatabaseMigration('PostgresRateLimiter', migratePostgresRateLimiterSchema, { injector });
+    }
 }
 export async function migratePostgresRateLimiterSchema() {
     const connection = inject(PostgresRateLimiterModuleConfig, undefined, { optional: true })?.database?.connection;

package/reflection/decorator-data.js

@@ -1,7 +1,6 @@
 import { DetailsError } from '../errors/details.error.js';
 import { isDefined, isFunction, isNumber, isObject, isUndefined } from '../utils/type-guards.js';
 import { getConstructor } from './utils.js';
-// eslint-disable-next-line max-lines-per-function
 export function getDecoratorData(target, propertyKey, descriptorOrParameterIndex) {
     const constructor = getConstructor(target);
     const prototype = constructor.prototype;
@@ -10,54 +9,54 @@ export function getDecoratorData(target, propertyKey, descriptorOrParameterIndex
         return {
             type: 'class',
             constructor,
-            prototype
+            prototype,
         };
     }
-    else if (isDefined(propertyKey) && isUndefined(descriptorOrParameterIndex)) {
+    if (isDefined(propertyKey) && isUndefined(descriptorOrParameterIndex)) {
         return {
             type: 'property',
             constructor,
             prototype,
             static: isStatic,
-            propertyKey
+            propertyKey,
         };
     }
-    else if (isDefined(propertyKey) && isObject(descriptorOrParameterIndex) && (isFunction(descriptorOrParameterIndex.get ?? descriptorOrParameterIndex.set))) { // eslint-disable-line @typescript-eslint/unbound-method
+    if (isDefined(propertyKey) && isObject(descriptorOrParameterIndex) && (isFunction(descriptorOrParameterIndex.get ?? descriptorOrParameterIndex.set))) { // eslint-disable-line @typescript-eslint/unbound-method
         return {
             type: 'accessor',
             constructor,
             prototype,
             static: isStatic,
             propertyKey,
-            descriptor: descriptorOrParameterIndex
+            descriptor: descriptorOrParameterIndex,
         };
     }
-    else if (isDefined(propertyKey) && isObject(descriptorOrParameterIndex) && isFunction(descriptorOrParameterIndex.value)) {
+    if (isDefined(propertyKey) && isObject(descriptorOrParameterIndex) && isFunction(descriptorOrParameterIndex.value)) {
         return {
             type: 'method',
             constructor,
             prototype,
             static: isStatic,
             methodKey: propertyKey,
-            descriptor: descriptorOrParameterIndex
+            descriptor: descriptorOrParameterIndex,
         };
     }
-    else if (isDefined(propertyKey) && isNumber(descriptorOrParameterIndex)) {
+    if (isDefined(propertyKey) && isNumber(descriptorOrParameterIndex)) {
         return {
             type: 'method-parameter',
             constructor,
             prototype,
             static: isStatic,
             methodKey: propertyKey,
-            index: descriptorOrParameterIndex
+            index: descriptorOrParameterIndex,
         };
     }
-    else if (isNumber(descriptorOrParameterIndex)) {
+    if (isNumber(descriptorOrParameterIndex)) {
         return {
             type: 'constructor-parameter',
             constructor,
             prototype,
-            index: descriptorOrParameterIndex
+            index: descriptorOrParameterIndex,
         };
     }
     throw new DetailsError('unknown type', { type: constructor, isStatic, propertyKey, descriptorOrParameterIndex });

package/task-queue/README.md

@@ -60,18 +60,11 @@ A function that processes tasks. The `TaskQueue` provides a managed loop (`proce
 Register the PostgreSQL backend in your application bootstrap.
 
 ```typescript
-import { configurePostgresTaskQueue, migratePostgresTaskQueueSchema } from '@tstdl/base/task-queue/postgres';
-import { runInInjectionContext, inject } from '@tstdl/base/injector';
-import { Injector } from '@tstdl/base/injector';
+import { configurePostgresTaskQueue } from '@tstdl/base/task-queue/postgres';
 
 export async function bootstrap() {
-  const injector = inject(Injector);
-
-  // Configure the module (uses default DatabaseConfig from context)
+  // Configure the module
   configurePostgresTaskQueue();
-
-  // Run migrations to create the 'task_queue.task' table
-  await runInInjectionContext(injector, migratePostgresTaskQueueSchema);
 }
 ```
 
@@ -292,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.             |