@tstdl/base 0.93.140 → 0.93.142

package/application/application.d.ts

@@ -4,7 +4,7 @@ import { Module } from '../module/index.js';
 import type { OneOrMany, Type } from '../types/index.js';
 export type InitializerFn = () => void | Promise<void>;
 export type DestructorFn = () => void | Promise<void>;
-export declare const APPLICATION_MODULE: import("../injector/token.js").InjectionToken<Module, never>;
+export declare const APPLICATION_MODULE: import("../injector/token.js").InjectionToken<Module | Type<Module>, never>;
 export declare const APPLICATION_INITIALIZER: import("../injector/token.js").InjectionToken<InitializerFn, never>;
 export declare const APPLICATION_DESTRUCTOR: import("../injector/token.js").InjectionToken<DestructorFn, never>;
 export declare const APPLICATION_INSTANCE_ID: import("../injector/token.js").InjectionToken<string, never>;

package/application/application.js

@@ -79,7 +79,7 @@ let Application = Application_1 = class Application {
         try {
             const initializers = await this.#injector.resolveAllAsync(APPLICATION_INITIALIZER, undefined, { optional: true });
             for (const initializer of initializers) {
-                await runInInjectionContext(this.#injector, initializer);
+                await runInInjectionContext(this.#injector, async () => await initializer());
             }
             modules = await toArrayAsync(mapAsync(this.#moduleTypesAndInstances, async (instanceOrType) => (isFunction(instanceOrType) ? await this.#injector.resolveAsync(instanceOrType) : instanceOrType)));
             await Promise.race([

package/application/providers.d.ts

@@ -1,9 +1,27 @@
 import { CancellationSignal } from '../cancellation/index.js';
-import { type ProvidersItem } from '../injector/index.js';
+import { Injector, type ProvidersItem } from '../injector/index.js';
 import { Module, type FunctionModuleFunction } from '../module/index.js';
 import type { OneOrMany, Type } from '../types/index.js';
 import { type DestructorFn, type InitializerFn } from './application.js';
-export declare function provideModule(...functionsAndModules: OneOrMany<FunctionModuleFunction | Type<Module>>[]): ProvidersItem[];
+/**
+ * Registers an application initializer function that will be executed during application startup.
+ */
+export declare function registerInitializer(fn: InitializerFn, options?: {
+    injector?: Injector;
+}): void;
+/**
+ * Registers an application destructor function that will be executed during application shutdown.
+ */
+export declare function registerDestructor(fn: DestructorFn, options?: {
+    injector?: Injector;
+}): void;
+/**
+ * Registers a module or a function-based module in the application. If a class extending Module is provided, it will be registered directly. If a function is provided, it will be wrapped in a FunctionModule.
+ */
+export declare function registerModule(fnOrModule: FunctionModuleFunction | Type<Module>, options?: {
+    injector?: Injector;
+}): void;
+export declare function provideModule(...functionsAndModules: OneOrMany<FunctionModuleFunction | Type<Module>>[]): ProvidersItem<Module | Type<Module>>[];
 export declare function provideInitializer(fn: InitializerFn): ProvidersItem;
 export declare function provideDestructor(fn: DestructorFn): ProvidersItem;
 export declare function provideShutdownSignal(signal: CancellationSignal): ProvidersItem;

package/application/providers.js

@@ -1,5 +1,5 @@
 import { CancellationSignal } from '../cancellation/index.js';
-import { inject } from '../injector/index.js';
+import { inject, Injector, provide } from '../injector/index.js';
 import { Logger } from '../logger/index.js';
 import { FunctionModule, Module } from '../module/index.js';
 import { isFunction } from '../utils/type-guards.js';
@@ -7,17 +7,44 @@ import { typeExtends } from '../utils/type/index.js';
 import { Application, APPLICATION_DESTRUCTOR, APPLICATION_INITIALIZER, APPLICATION_MODULE } from './application.js';
 const quitSignals = ['SIGTERM', 'SIGINT', 'SIGHUP', 'SIGBREAK'];
 const quitEvents = ['uncaughtException', 'unhandledRejection', 'rejectionHandled'];
+/**
+ * Registers an application initializer function that will be executed during application startup.
+ */
+export function registerInitializer(fn, options) {
+    const targetInjector = options?.injector ?? Injector;
+    targetInjector.register(APPLICATION_INITIALIZER, { useValue: fn }, { multi: true });
+}
+/**
+ * Registers an application destructor function that will be executed during application shutdown.
+ */
+export function registerDestructor(fn, options) {
+    const targetInjector = options?.injector ?? Injector;
+    targetInjector.register(APPLICATION_DESTRUCTOR, { useValue: fn }, { multi: true });
+}
+/**
+ * Registers a module or a function-based module in the application. If a class extending Module is provided, it will be registered directly. If a function is provided, it will be wrapped in a FunctionModule.
+ */
+export function registerModule(fnOrModule, options) {
+    const targetInjector = options?.injector ?? Injector;
+    if (typeExtends(fnOrModule, Module)) {
+        targetInjector.register(APPLICATION_MODULE, { useValue: fnOrModule }, { multi: true });
+    }
+    else if (isFunction(fnOrModule)) {
+        targetInjector.register(APPLICATION_MODULE, { useToken: FunctionModule, defaultArgument: fnOrModule }, { multi: true });
+    }
+    else {
+        throw new TypeError('Invalid module or function provided to registerModule');
+    }
+}
 export function provideModule(...functionsAndModules) {
     return functionsAndModules.flat().map((fnOrModule) => {
         if (typeExtends(fnOrModule, Module)) {
-            return { provide: APPLICATION_MODULE, useValue: fnOrModule, multi: true };
-        }
-        else if (isFunction(fnOrModule)) {
-            return { provide: APPLICATION_MODULE, useToken: FunctionModule, defaultArgument: fnOrModule, multi: true };
+            return provide(APPLICATION_MODULE, { useValue: fnOrModule, multi: true });
         }
-        else {
-            throw new TypeError('Invalid module or function provided to provideModules');
+        if (isFunction(fnOrModule)) {
+            return provide(APPLICATION_MODULE, { useToken: FunctionModule, defaultArgument: fnOrModule, multi: true });
         }
+        throw new TypeError('Invalid module or function provided to provideModule');
     });
 }
 export function provideInitializer(fn) {

package/audit/module.d.ts

@@ -9,6 +9,11 @@ export declare class AuditModuleConfig {
      * If not provided, the global database configuration is used.
      */
     database?: DatabaseConfig;
+    /**
+     * Whether to automatically run database migrations when the application starts.
+     * Defaults to `true`.
+     */
+    autoMigrate?: boolean;
 }
 /**
  * Configures audit server services.

package/audit/module.js

@@ -1,5 +1,5 @@
 import { inject, Injector } from '../injector/index.js';
-import { Database, migrate } from '../orm/server/index.js';
+import { Database, migrate, registerDatabaseMigration } from '../orm/server/index.js';
 /**
  * Configuration for {@link configureAudit}.
  */
@@ -9,6 +9,11 @@ export class AuditModuleConfig {
      * If not provided, the global database configuration is used.
      */
     database;
+    /**
+     * Whether to automatically run database migrations when the application starts.
+     * Defaults to `true`.
+     */
+    autoMigrate;
 }
 /**
  * Configures audit server services.
@@ -17,6 +22,9 @@ export class AuditModuleConfig {
 export function configureAudit({ injector, ...config } = {}) {
     const targetInjector = injector ?? Injector;
     targetInjector.register(AuditModuleConfig, { useValue: config });
+    if (config.autoMigrate != false) {
+        registerDatabaseMigration('Audit', migrateAuditSchema, { injector });
+    }
 }
 /**
  * Migrates the audit database schema to the latest version.

package/authentication/client/authentication.service.d.ts

@@ -27,6 +27,7 @@ export declare class AuthenticationClientService<AdditionalTokenPayload extends
     private readonly logger;
     private readonly disposeSignal;
     private readonly forceRefreshRequested;
+    private readonly forceRefreshRequested$;
     private clockOffset;
     private initialized;
     private refreshLoopPromise;

package/authentication/client/authentication.service.js

@@ -70,6 +70,7 @@ let AuthenticationClientService = class AuthenticationClientService {
     logger = inject(Logger, 'AuthenticationService');
     disposeSignal = inject(CancellationSignal).fork();
     forceRefreshRequested = signal(false);
+    forceRefreshRequested$ = toObservable(this.forceRefreshRequested);
     clockOffset = 0;
     initialized = false;
     refreshLoopPromise;
@@ -435,7 +436,7 @@ let AuthenticationClientService = class AuthenticationClientService {
                     this.token$.pipe(filter((t) => t != currentToken)),
                 ];
                 if (!forceRefresh) {
-                    wakeUpSignals.push(toObservable(this.forceRefreshRequested).pipe(filter((v) => v)));
+                    wakeUpSignals.push(this.forceRefreshRequested$.pipe(filter((requested) => requested)));
                 }
                 if (delay > 0) {
                     await firstValueFrom(race([timer(delay), ...wakeUpSignals]), { defaultValue: undefined });
@@ -451,7 +452,7 @@ let AuthenticationClientService = class AuthenticationClientService {
                     timer(2500),
                     from(this.disposeSignal),
                     this.token$.pipe(filter((t) => t != currentToken)),
-                    toObservable(this.forceRefreshRequested).pipe(filter((requested) => requested), skip(this.forceRefreshRequested() ? 1 : 0)),
+                    this.forceRefreshRequested$.pipe(filter((requested) => requested), skip(this.forceRefreshRequested() ? 1 : 0)),
                 ]), { defaultValue: undefined });
             }
         }

package/authentication/server/module.d.ts

@@ -25,6 +25,11 @@ export declare class AuthenticationModuleConfig {
      * Override default {@link AuthenticationAncillaryService}.
      */
     authenticationAncillaryService?: InjectionToken<AuthenticationAncillaryService<any, any, any>>;
+    /**
+     * Whether to automatically run database migrations when the application starts.
+     * Defaults to `true`.
+     */
+    autoMigrate?: boolean;
 }
 /**
  * Configures authentication server services.

package/authentication/server/module.js

@@ -2,7 +2,7 @@ import { ApiRequestTokenProvider } from '../../api/server/api-request-token.prov
 import { inject } from '../../injector/index.js';
 import { Injector } from '../../injector/injector.js';
 import { isProvider } from '../../injector/provider.js';
-import { Database, migrate } from '../../orm/server/index.js';
+import { Database, migrate, registerDatabaseMigration } from '../../orm/server/index.js';
 import { isDefined } from '../../utils/type-guards.js';
 import { AuthenticationAncillaryService } from './authentication-ancillary.service.js';
 import { AuthenticationApiRequestTokenProvider } from './authentication-api-request-token.provider.js';
@@ -28,6 +28,11 @@ export class AuthenticationModuleConfig {
      * Override default {@link AuthenticationAncillaryService}.
      */
     authenticationAncillaryService;
+    /**
+     * Whether to automatically run database migrations when the application starts.
+     * Defaults to `true`.
+     */
+    autoMigrate;
 }
 /**
  * Configures authentication server services.
@@ -44,6 +49,9 @@ export function configureAuthenticationServer({ injector, ...config }) {
     if (isDefined(config.authenticationAncillaryService)) {
         targetInjector.registerSingleton(AuthenticationAncillaryService, { useToken: config.authenticationAncillaryService });
     }
+    if (config.autoMigrate != false) {
+        registerDatabaseMigration('Authentication', migrateAuthenticationSchema, { injector });
+    }
 }
 /**
  * Migrates the authentication schema.

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

@@ -25,7 +25,7 @@ describe('AuthenticationApiController Integration', () => {
             clear: vi.fn(() => storage.clear()),
         };
         ({ injector, database } = await setupIntegrationTest({
-            modules: { authentication: true, audit: true, keyValueStore: true, test: true, api: true, webServer: true },
+            modules: { authentication: true, audit: true, keyValueStore: true, signals: true, api: true, webServer: true },
             authenticationAncillaryService: DefaultAuthenticationAncillaryService,
         }));
         await runInInjectionContext(injector, async () => {

package/authentication/tests/authentication.api-request-token.provider.test.js

@@ -11,7 +11,7 @@ describe('AuthenticationApiRequestTokenProvider', () => {
     let tokenProvider;
     const tenantId = crypto.randomUUID();
     beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({ modules: { authentication: true, test: true } }));
+        ({ injector } = await setupIntegrationTest({ modules: { authentication: true, signals: true } }));
         authenticationService = await injector.resolveAsync(AuthenticationService);
         subjectService = await injector.resolveAsync(SubjectService);
         tokenProvider = injector.resolve(AuthenticationApiRequestTokenProvider);

package/authentication/tests/authentication.client-service.test.js

@@ -25,7 +25,7 @@ describe('AuthenticationClientService Integration', () => {
             clear: vi.fn(() => storage.clear()),
         };
         ({ injector, database } = await setupIntegrationTest({
-            modules: { authentication: true, audit: true, keyValueStore: true, test: true, api: true, webServer: true },
+            modules: { authentication: true, audit: true, keyValueStore: true, signals: true, api: true, webServer: true },
             authenticationAncillaryService: DefaultAuthenticationAncillaryService,
         }));
         await runInInjectionContext(injector, async () => {

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

@@ -6,15 +6,15 @@ export declare const CircuitBreakerState: {
     readonly HalfOpen: "half-open";
 };
 export type CircuitBreakerState = EnumType<typeof CircuitBreakerState>;
-export interface CircuitBreakerConfig {
+export type CircuitBreakerConfig = {
     threshold: number;
     resetTimeout: number;
-}
-export interface CircuitBreakerCheckResult {
+};
+export type CircuitBreakerCheckResult = {
     allowed: boolean;
     state: CircuitBreakerState;
     isProbe?: boolean;
-}
+};
 export type CircuitBreakerArgument = string | (CircuitBreakerConfig & {
     key: string;
 });
@@ -29,4 +29,6 @@ export declare abstract class CircuitBreaker implements Resolvable<CircuitBreake
     abstract recordSuccess(): Promise<void>;
     /** Records a failure, potentially tripping the breaker to Open. */
     abstract recordFailure(): Promise<void>;
+    /** Records multiple failures at once. */
+    abstract recordFailures(count: number): Promise<void>;
 }

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

@@ -4,4 +4,5 @@ export declare class PostgresCircuitBreakerService extends CircuitBreaker {
     check(): Promise<CircuitBreakerCheckResult>;
     recordSuccess(): Promise<void>;
     recordFailure(): Promise<void>;
+    recordFailures(count: number): Promise<void>;
 }

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

@@ -43,8 +43,11 @@ let PostgresCircuitBreakerService = class PostgresCircuitBreakerService extends
         await this.#repository.tryDeleteByQuery({ key: this.#key });
     }
     async recordFailure() {
+        await this.recordFailures(1);
+    }
+    async recordFailures(count) {
         const table = this.#repository.table;
-        const initialTrip = 1 >= this.#threshold;
+        const initialTrip = count >= this.#threshold;
         const initialState = initialTrip ? CircuitBreakerState.Open : CircuitBreakerState.Closed;
         const initialResetTimestamp = initialTrip
             ? sql `${TRANSACTION_TIMESTAMP} + ${interval(this.#resetTimeout, 'milliseconds')}`
@@ -52,16 +55,16 @@ let PostgresCircuitBreakerService = class PostgresCircuitBreakerService extends
         await this.#repository.upsert(['key'], {
             key: this.#key,
             state: initialState,
-            failureCount: 1,
+            failureCount: count,
             resetTimestamp: initialResetTimestamp,
         }, {
-            failureCount: sql `${table.failureCount} + 1`,
+            failureCount: sql `${table.failureCount} + ${count}`,
             state: sql `CASE
-          WHEN ${table.failureCount} + 1 >= ${this.#threshold} THEN ${CircuitBreakerState.Open}
+          WHEN ${table.failureCount} + ${count} >= ${this.#threshold} THEN ${CircuitBreakerState.Open}
           ELSE ${table.state}
         END`,
             resetTimestamp: sql `CASE
-          WHEN ${table.failureCount} + 1 >= ${this.#threshold} THEN ${TRANSACTION_TIMESTAMP} + ${interval(this.#resetTimeout, 'milliseconds')}
+          WHEN ${table.failureCount} + ${count} >= ${this.#threshold} THEN ${TRANSACTION_TIMESTAMP} + ${interval(this.#resetTimeout, 'milliseconds')}
           ELSE ${table.resetTimestamp}
         END`,
         });

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

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

package/circuit-breaker/postgres/module.js

@@ -1,11 +1,12 @@
 import { inject, Injector } from '../../injector/index.js';
-import { Database, migrate } from '../../orm/server/index.js';
+import { Database, migrate, registerDatabaseMigration } from '../../orm/server/index.js';
 import { CircuitBreaker } from '../circuit-breaker.js';
 import { CircuitBreakerProvider } from '../provider.js';
 import { PostgresCircuitBreakerService } from './circuit-breaker.js';
 import { PostgresCircuitBreakerProvider } from './provider.js';
 export class PostgresCircuitBreakerModuleConfig {
     database;
+    autoMigrate;
 }
 /**
  * configure circuit breaker module
@@ -15,6 +16,9 @@ export function configurePostgresCircuitBreaker({ injector, ...config } = {}) {
     targetInjector.register(PostgresCircuitBreakerModuleConfig, { useValue: config });
     targetInjector.registerSingleton(CircuitBreakerProvider, { useToken: PostgresCircuitBreakerProvider });
     targetInjector.registerSingleton(CircuitBreaker, { useToken: PostgresCircuitBreakerService });
+    if (config.autoMigrate != false) {
+        registerDatabaseMigration('PostgresCircuitBreaker', migratePostgresCircuitBreaker, { injector });
+    }
 }
 export async function migratePostgresCircuitBreaker() {
     const connection = inject(PostgresCircuitBreakerModuleConfig, undefined, { optional: true })?.database?.connection;

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

@@ -90,4 +90,24 @@ describe('Circuit Breaker (Standalone) Tests', () => {
         expect(result.allowed).toBe(false);
         expect(result.state).toBe(CircuitBreakerState.Open);
     });
+    it('should trip to Open after threshold failures via recordFailures', async () => {
+        const breaker = provider.provide(`cb-bulk-trip-${Date.now()}`, { threshold: 5, resetTimeout: 1000 });
+        // 1. Bulk Failure (Threshold Not Reached)
+        await breaker.recordFailures(3);
+        let result = await breaker.check();
+        expect(result.state).toBe(CircuitBreakerState.Closed);
+        // 2. Bulk Failure (Threshold Reached)
+        await breaker.recordFailures(2);
+        result = await breaker.check();
+        expect(result.allowed).toBe(false);
+        expect(result.state).toBe(CircuitBreakerState.Open);
+    });
+    it('should trip to Open after threshold failures via single large recordFailures', async () => {
+        const breaker = provider.provide(`cb-single-bulk-trip-${Date.now()}`, { threshold: 5, resetTimeout: 1000 });
+        // Single large bulk failure exceeding threshold
+        await breaker.recordFailures(10);
+        const result = await breaker.check();
+        expect(result.allowed).toBe(false);
+        expect(result.state).toBe(CircuitBreakerState.Open);
+    });
 });

package/document-management/server/configure.js

@@ -1,7 +1,8 @@
 import { Injector } from '../../injector/injector.js';
+import { registerDatabaseMigration } from '../../orm/server/index.js';
 import { isDefined } from '../../utils/type-guards.js';
 import { DocumentManagementAuthorizationService } from '../authorization/document-management-authorization.service.js';
-import { DocumentManagementConfiguration } from './module.js';
+import { DocumentManagementConfiguration, migrateDocumentManagementSchema } from './module.js';
 import { DocumentManagementAiProviderService, DocumentManagementAncillaryService } from './services/index.js';
 export function configureDocumentManagement(configuration) {
     const targetInjector = configuration.injector ?? Injector;
@@ -11,4 +12,7 @@ export function configureDocumentManagement(configuration) {
     if (isDefined(configuration.aiProvider)) {
         targetInjector.register(DocumentManagementAiProviderService, { useToken: configuration.aiProvider });
     }
+    if (configuration.autoMigrate != false) {
+        registerDatabaseMigration('DocumentManagement', migrateDocumentManagementSchema, { injector: configuration.injector });
+    }
 }

package/document-management/server/module.d.ts

@@ -1,4 +1,3 @@
-import './schemas.js';
 import { type InjectionToken } from '../../injector/index.js';
 import { type DatabaseConfig } from '../../orm/server/index.js';
 import type { DocumentManagementAuthorizationService } from '../authorization/document-management-authorization.service.js';
@@ -14,5 +13,6 @@ export declare class DocumentManagementConfiguration {
     database?: DatabaseConfig;
     maxFileSize?: number;
     skipAi?: boolean;
+    autoMigrate?: boolean;
 }
 export declare function migrateDocumentManagementSchema(): Promise<void>;

package/document-management/server/module.js

@@ -1,4 +1,3 @@
-import './schemas.js';
 import { inject } from '../../injector/index.js';
 import { Database, migrate } from '../../orm/server/index.js';
 export class DocumentManagementConfiguration {
@@ -11,6 +10,7 @@ export class DocumentManagementConfiguration {
     database;
     maxFileSize;
     skipAi;
+    autoMigrate;
 }
 ;
 export async function migrateDocumentManagementSchema() {

package/document-management/server/services/document-management-ancillary.service.js

@@ -6,6 +6,6 @@ export class DocumentManagementAncillaryService {
      * @returns The resolved file name for the document, without the file extension.
      */
     getDocumentFilename(document) {
-        return document.title ?? document.originalFileName ?? document.id;
+        return document.title ?? document.originalFileName?.slice(0, document.originalFileName.lastIndexOf('.')) ?? document.id;
     }
 }

package/document-management/tests/ai-config-hierarchy.test.js

@@ -8,7 +8,6 @@ import { TestDocumentManagementAncillaryService } from './helper.js';
 describe('DocumentManagementAiService Hierarchy', () => {
     let injector;
     let aiService;
-    let flashModel;
     const tenantId = crypto.randomUUID();
     const mockAiProvider = {
         getGlobalConfiguration: vi.fn(),
@@ -20,12 +19,8 @@ describe('DocumentManagementAiService Hierarchy', () => {
     };
     beforeAll(async () => {
         ({ injector } = await setupIntegrationTest({
-            orm: { schema: 'document_management' },
             modules: { messageBus: true, signals: true, objectStorage: true, documentManagement: true },
         }));
-        runInInjectionContext(injector, () => {
-            flashModel = injectModel('gemini-2.5-flash');
-        });
         injector.register(DocumentManagementAiProviderService, { useValue: mockAiProvider });
         // Ancillary and configuration are already registered by setupIntegrationTest, but we can override if needed
         injector.register(DocumentManagementAncillaryService, { useToken: TestDocumentManagementAncillaryService });

package/document-management/tests/document-management-ai-overrides.test.js

@@ -22,7 +22,6 @@ describe('DocumentManagementAiService Overrides', () => {
     };
     beforeAll(async () => {
         ({ injector } = await setupIntegrationTest({
-            orm: { schema: 'document_management' },
             modules: { messageBus: true, signals: true, objectStorage: true },
         }));
         runInInjectionContext(injector, () => {

package/document-management/tests/document-validation-ai-overrides.test.js

@@ -32,7 +32,6 @@ describe('AiValidationExecutor Overrides', () => {
     };
     beforeAll(async () => {
         ({ injector } = await setupIntegrationTest({
-            orm: { schema: 'document_management' },
             modules: { messageBus: true, signals: true, objectStorage: true },
         }));
         runInInjectionContext(injector, () => {

package/examples/document-management/main.d.ts

@@ -1,3 +1,4 @@
+/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
 import '../../polyfills.js';
 import { DocumentManagementAuthorizationService, type DocumentCollection, type DocumentCollectionMetadata } from '../../document-management/index.js';
 import { DocumentManagementAncillaryService } from '../../document-management/server/index.js';

package/examples/document-management/main.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);
@@ -10,22 +11,23 @@ import { MockApiRequestTokenProvider } from '../../api/server/api-request-token.
 import { configureApiServer } from '../../api/server/module.js';
 import { Application } from '../../application/application.js';
 import { provideInitializer, provideModule, provideSignalHandler } from '../../application/index.js';
-import { configurePostgresCircuitBreaker, migratePostgresCircuitBreaker } from '../../circuit-breaker/postgres/module.js';
+import { configureAudit } from '../../audit/module.js';
+import { configurePostgresCircuitBreaker } from '../../circuit-breaker/postgres/module.js';
 import { DocumentManagementAuthorizationService } from '../../document-management/index.js';
 import { configureDocumentManagement } from '../../document-management/server/configure.js';
 import { DocumentCategoryTypeService, DocumentCollectionService, DocumentManagementAncillaryService, DocumentManagementApiController, DocumentRequestService } from '../../document-management/server/index.js';
-import { migrateDocumentManagementSchema } from '../../document-management/server/module.js';
 import { DocumentManagementService } from '../../document-management/server/services/document-management.service.js';
 import { configureNodeHttpServer } from '../../http/server/node/module.js';
-import { Injector, Singleton } from '../../injector/index.js';
-import { inject, injectManyAsync, runInInjectionContext } from '../../injector/inject.js';
+import { Singleton } from '../../injector/index.js';
+import { injectManyAsync } from '../../injector/inject.js';
 import { PrettyPrintLogFormatter, provideConsoleLogTransport } from '../../logger/index.js';
 import { configureLocalMessageBus } from '../../message-bus/index.js';
 import { WebServerModule } from '../../module/index.js';
 import { configureS3ObjectStorage } from '../../object-storage/s3/index.js';
-import { configureOrm } from '../../orm/server/index.js';
+import { configureOrm, provideOrm } from '../../orm/server/index.js';
+import { configurePostgresRateLimiter } from '../../rate-limit/postgres/module.js';
 import { configureDefaultSignalsImplementation } from '../../signals/implementation/configure.js';
-import { configurePostgresTaskQueue, migratePostgresTaskQueueSchema } from '../../task-queue/postgres/index.js';
+import { configurePostgresTaskQueue } from '../../task-queue/postgres/index.js';
 import { boolean, positiveInteger, string } from '../../utils/config-parser.js';
 import { ExampleAiProviderService } from './ai-provider.js';
 import { TstdlCategoryParents, TstdlDocumentCategoryLabels, TstdlDocumentPropertyConfiguration, TstdlDocumentTypeCategories, TstdlDocumentTypeLabels, TstdlDocumentTypeProperties } from './categories-and-types.js';
@@ -84,11 +86,13 @@ AllowAllDocumentManagementAuthorizationService = __decorate([
     Singleton()
 ], AllowAllDocumentManagementAuthorizationService);
 export { AllowAllDocumentManagementAuthorizationService };
-async function bootstrap() {
-    const injector = inject(Injector);
+function bootstrap() {
+    configureAudit();
     configureNodeHttpServer();
     configurePostgresTaskQueue();
     configurePostgresCircuitBreaker();
+    configurePostgresTaskQueue();
+    configurePostgresRateLimiter();
     configureLocalMessageBus();
     configureDefaultSignalsImplementation();
     configureGenkit({
@@ -119,6 +123,7 @@ async function bootstrap() {
         bucketPerModule: config.s3.bucketPerModule,
         accessKey: config.s3.accessKey,
         secretKey: config.s3.secretKey,
+        forcePathStyle: true,
     });
     configureApiServer({
         controllers: [DocumentManagementApiController],
@@ -139,9 +144,6 @@ async function bootstrap() {
             location: config.ai.vertex.location,
         },
     });
-    await runInInjectionContext(injector, migrateDocumentManagementSchema);
-    await runInInjectionContext(injector, migratePostgresCircuitBreaker);
-    await runInInjectionContext(injector, migratePostgresTaskQueueSchema);
 }
 async function main() {
     const tenantId = '00000000-0000-0000-0000-000000000000';
@@ -171,4 +173,5 @@ Application.run('DocumentManagementTest', [
     provideModule(main, WebServerModule),
     provideSignalHandler(),
     provideConsoleLogTransport(PrettyPrintLogFormatter),
+    provideOrm(),
 ]);

package/key-value-store/postgres/module.d.ts

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

package/key-value-store/postgres/module.js

@@ -1,10 +1,11 @@
 import { inject, Injector } from '../../injector/index.js';
-import { Database, migrate } from '../../orm/server/index.js';
+import { Database, migrate, registerDatabaseMigration } from '../../orm/server/index.js';
 import { isDefined } from '../../utils/type-guards.js';
 import { KeyValueStore } from '../key-value.store.js';
 import { PostgresKeyValueStore } from './key-value-store.service.js';
 export class PostgresKeyValueStoreModuleConfig {
     database;
+    autoMigrate;
 }
 /**
  * configure key-value store module
@@ -15,6 +16,9 @@ export function configurePostgresKeyValueStore({ injector, ...config } = {}) {
         targetInjector.register(PostgresKeyValueStoreModuleConfig, { useValue: config });
     }
     targetInjector.registerSingleton(KeyValueStore, { useToken: PostgresKeyValueStore });
+    if (config.autoMigrate != false) {
+        registerDatabaseMigration('PostgresKeyValueStore', migratePostgresKeyValueStoreSchema, { injector });
+    }
 }
 export async function migratePostgresKeyValueStoreSchema() {
     const connection = inject(PostgresKeyValueStoreModuleConfig, undefined, { optional: true })?.database?.connection;

package/lock/postgres/module.d.ts

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

package/lock/postgres/module.js

@@ -1,5 +1,5 @@
 import { inject, Injector } from '../../injector/index.js';
-import { Database, migrate } from '../../orm/server/index.js';
+import { Database, migrate, registerDatabaseMigration } from '../../orm/server/index.js';
 import { isDefined } from '../../utils/type-guards.js';
 import { Lock } from '../lock.js';
 import { LockProvider } from '../provider.js';
@@ -7,6 +7,7 @@ import { PostgresLockAdapter } from './lock.js';
 import { PostgresLockProvider } from './provider.js';
 export class PostgresLockModuleConfig {
     database;
+    autoMigrate;
 }
 /**
  * configure lock module
@@ -18,6 +19,9 @@ export function configurePostgresLock({ injector, ...config } = {}) {
     }
     targetInjector.registerSingleton(LockProvider, { useToken: PostgresLockProvider });
     targetInjector.registerSingleton(Lock, { useToken: PostgresLockAdapter });
+    if (config.autoMigrate != false) {
+        registerDatabaseMigration('PostgresLock', migratePostgresLockSchema, { injector });
+    }
 }
 export async function migratePostgresLockSchema() {
     const connection = inject(PostgresLockModuleConfig, undefined, { optional: true })?.database?.connection;