@tstdl/base 0.93.87 → 0.93.89

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

@@ -14,7 +14,7 @@ import { injectionToken } from '../../../injector/token.js';
 import { Logger } from '../../../logger/logger.js';
 import { getEntityIds } from '../../../orm/index.js';
 import { injectRepository } from '../../../orm/server/index.js';
-import { Queue } from '../../../queue/queue.js';
+import { TaskQueue, TaskResult } from '../../../task-queue/task-queue.js';
 import { currentTimestamp } from '../../../utils/date-time.js';
 import { isNull, isUndefined } from '../../../utils/type-guards.js';
 import { millisecondsPerMinute } from '../../../utils/units.js';
@@ -37,7 +37,7 @@ let DocumentValidationService = DocumentValidationService_1 = class DocumentVali
     #validationExecutionService = injectRepository(DocumentValidationExecution);
     #validationExecutionRelatedDocumentService = injectRepository(DocumentValidationExecutionRelatedDocument);
     #documentTypeValidationService = injectRepository(DocumentTypeValidation);
-    #queue = inject((Queue), { name: 'DocumentManagement: validation', processTimeout: 5 * millisecondsPerMinute, maxTries: 3 });
+    #taskQueue = inject((TaskQueue), { namespace: 'DocumentManagement:validation', visibilityTimeout: 5 * millisecondsPerMinute, maxTries: 3 });
     #executors = injectAll(DOCUMENT_VALIDATION_EXECUTORS);
     #logger = inject(Logger, DocumentValidationService_1.name);
     #executorMap = new Map(this.#executors.map((executor) => [executor.identifier, executor]));
@@ -45,10 +45,11 @@ let DocumentValidationService = DocumentValidationService_1 = class DocumentVali
         this.processQueue(cancellationSignal);
     }
     processQueue(cancellationSignal) {
-        this.#queue.process({ concurrency: 5, cancellationSignal }, async (job) => {
+        this.#taskQueue.process({ concurrency: 5, cancellationSignal }, async (job) => {
             this.#logger.verbose(`Processing validation execution "${job.data.executionId}"`);
             await this.processValidationExecution(job.data.tenantId, job.data.executionId);
-        }, this.#logger);
+            return TaskResult.Complete();
+        });
     }
     async startValidationWorkflow(tenantId, documentId) {
         const document = await this.#documentService.loadByQuery({ tenantId, id: documentId });
@@ -69,7 +70,7 @@ let DocumentValidationService = DocumentValidationService_1 = class DocumentVali
                 startedAt: null,
                 completedAt: null,
             });
-            await this.#queue.enqueue({ tenantId, executionId: execution.id });
+            await this.#taskQueue.enqueue('validate', { tenantId, executionId: execution.id });
         }
     }
     async setExecutionRunning(tenantId, executionId) {

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

@@ -13,7 +13,7 @@ import { inject } from '../../../injector/inject.js';
 import { afterResolve } from '../../../injector/interfaces.js';
 import { Logger } from '../../../logger/index.js';
 import { injectRepository, injectTransactional, Transactional } from '../../../orm/server/index.js';
-import { Queue } from '../../../queue/queue.js';
+import { TaskQueue, TaskResult } from '../../../task-queue/task-queue.js';
 import { toArray } from '../../../utils/array/array.js';
 import { currentTimestamp } from '../../../utils/date-time.js';
 import { _throw } from '../../../utils/throw.js';
@@ -37,7 +37,7 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
     #documentAssignmentTaskRepository = injectRepository(DocumentAssignmentTask);
     #documentAssignmentScopeRepository = injectRepository(DocumentAssignmentScope);
     #observationService = inject(DocumentManagementObservationService);
-    #queue = inject((Queue), { name: 'DocumentWorkflow', processTimeout: 5 * 60 * 1000, maxTries: 3 });
+    #taskQueue = inject((TaskQueue), { namespace: 'DocumentManagement:DocumentWorkflow', visibilityTimeout: 5 * 60 * 1000, maxTries: 3 });
     #logger = inject(Logger, DocumentWorkflowService_1.name);
     documentService = inject(DocumentService, undefined, { forwardRef: true });
     repository = injectRepository(DocumentWorkflow);
@@ -45,7 +45,7 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
         if (this.isInTransaction) {
             return;
         }
-        this.#queue.process({ concurrency: 5, cancellationSignal }, async (taskContext) => await this.processWorkflowJob(taskContext), this.#logger);
+        this.#taskQueue.process({ concurrency: 5, cancellationSignal }, async (taskContext) => await this.processWorkflowJob(taskContext));
     }
     async loadLatestWorkflow(tenantId, documentId) {
         return await this.repository.loadByQuery({ tenantId, documentId }, { order: { 'metadata.createTimestamp': 'desc' } });
@@ -82,7 +82,7 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
     }
     async initiateWorkflow(tenantId, documentId, step) {
         const workflow = await this.repository.insert({ tenantId, documentId, step, state: 'pending', failReason: null, completeTimestamp: null, completeUserId: null });
-        await this.#queue.enqueue({ workflowId: workflow.id });
+        await this.#taskQueue.enqueue('workflow', { workflowId: workflow.id });
         this.#observationService.documentChange(workflow.id, this.session);
         return workflow;
     }
@@ -109,7 +109,7 @@ let DocumentWorkflowService = DocumentWorkflowService_1 = class DocumentWorkflow
             else {
                 await this.setWorkflowState(workflow.id, DocumentWorkflowState.Review);
             }
-            await task.acknowledge();
+            return TaskResult.Complete();
         }
         catch (error) {
             if (task.triesLeft == 0) {

package/document-management/service-models/document-folders.view-model.d.ts

@@ -1,9 +1,12 @@
 import type { EnrichedDocumentManagementData } from './enriched/enriched-document-management-data.view.js';
 export type DocumentManagementFolder = {
     id: string;
-    type: 'collection' | 'category' | 'virtual';
+    type: 'collection' | 'category' | 'collection-group';
     label: string;
     subFolders: DocumentManagementFolder[];
 };
-export declare function getDocumentManagementFolders(data: EnrichedDocumentManagementData): DocumentManagementFolder[];
+export type GetDocumentManagementFoldersOptions = {
+    wrapCollections?: boolean;
+};
+export declare function getDocumentManagementFolders(data: EnrichedDocumentManagementData, options?: GetDocumentManagementFoldersOptions): DocumentManagementFolder[];
 export declare function getFlatFolders(folders: DocumentManagementFolder[]): DocumentManagementFolder[];

package/document-management/service-models/document-folders.view-model.js

@@ -1,19 +1,52 @@
 import { isNotNull } from '../../utils/type-guards.js';
-export function getDocumentManagementFolders(data) {
-    function getCategoryFolder(category) {
-        const subFolders = category.children.map(getCategoryFolder).filter(isNotNull);
-        const categoryFolder = {
+export function getDocumentManagementFolders(data, options = {}) {
+    const { wrapCollections = (data.collections.length > 1) } = options;
+    function getCategoryFolder(category, collectionId) {
+        const subFolders = category.children.map((child) => getCategoryFolder(child, collectionId)).filter(isNotNull);
+        const documents = (collectionId == null)
+            ? category.documents
+            : category.documents.filter((document) => document.assignments.collections.some((assignment) => assignment.collection.id == collectionId));
+        if ((documents.length + subFolders.length) == 0) {
+            return null;
+        }
+        return {
             id: category.id,
             type: 'category',
             label: category.label,
             subFolders,
         };
-        if ((category.documents.length + categoryFolder.subFolders.length) == 0) {
-            return null;
-        }
-        return categoryFolder;
     }
-    return data.rootCategories.map(getCategoryFolder).filter(isNotNull);
+    if (wrapCollections) {
+        return data.collectionGroups.flatMap((group) => {
+            const collectionFolders = group.collections.map((collection) => {
+                const subFolders = data.rootCategories.map((category) => getCategoryFolder(category, collection.id)).filter(isNotNull);
+                if (subFolders.length == 0) {
+                    return null;
+                }
+                return {
+                    id: collection.id,
+                    type: 'collection',
+                    label: collection.name,
+                    subFolders,
+                };
+            }).filter(isNotNull);
+            if (collectionFolders.length == 0) {
+                return [];
+            }
+            if (group.group == null) {
+                return collectionFolders;
+            }
+            return [
+                {
+                    id: `group:${group.group}`,
+                    type: 'collection-group',
+                    label: group.group,
+                    subFolders: collectionFolders,
+                },
+            ];
+        });
+    }
+    return data.rootCategories.map((category) => getCategoryFolder(category)).filter(isNotNull);
 }
 export function getFlatFolders(folders) {
     return [...folders, ...folders.flatMap((folder) => getFlatFolders(folder.subFolders))];

package/document-management/service-models/enriched/enriched-document-management-data.view.js

@@ -56,7 +56,7 @@ export class EnrichedDocumentManagementData {
         return this.rawData.collections.map((collection) => collection.id);
     }
     get rootCollections() {
-        return this.rootCollections.filter((collection) => isNull(collection.parent));
+        return this.collections.filter((collection) => isNull(collection.parentId));
     }
     get collections() {
         return this.rawData.collections.map((collection) => new EnrichedDocumentCollection(this, collection));

package/examples/document-management/main.js

@@ -11,6 +11,7 @@ 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 { 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';
@@ -24,11 +25,10 @@ import { configureLocalMessageBus } from '../../message-bus/index.js';
 import { WebServerModule } from '../../module/index.js';
 import { configureS3ObjectStorage } from '../../object-storage/index.js';
 import { configureOrm } from '../../orm/server/index.js';
-import { configurePostgresQueue, migratePostgresQueueSchema } from '../../queue/postgres/index.js';
 import { configureDefaultSignalsImplementation } from '../../signals/implementation/configure.js';
+import { configurePostgresTaskQueue, migratePostgresTaskQueueSchema } from '../../task-queue/postgres/index.js';
 import { boolean, positiveInteger, string } from '../../utils/config-parser.js';
 import { TstdlCategoryParents, TstdlDocumentCategoryLabels, TstdlDocumentPropertyConfiguration, TstdlDocumentTypeCategories, TstdlDocumentTypeLabels, TstdlDocumentTypeProperties } from './categories-and-types.js';
-import { configurePostgresCircuitBreaker, migratePostgresCircuitBreaker } from '../../circuit-breaker/postgres/module.js';
 const config = {
     database: {
         host: string('DATABASE_HOST', '127.0.0.1'),
@@ -87,7 +87,7 @@ export { AllowAllDocumentManagementAuthorizationService };
 async function bootstrap() {
     const injector = inject(Injector);
     configureNodeHttpServer();
-    configurePostgresQueue();
+    configurePostgresTaskQueue();
     configurePostgresCircuitBreaker();
     configureLocalMessageBus();
     configureDefaultSignalsImplementation();
@@ -138,7 +138,7 @@ async function bootstrap() {
     });
     await runInInjectionContext(injector, migrateDocumentManagementSchema);
     await runInInjectionContext(injector, migratePostgresCircuitBreaker);
-    await runInInjectionContext(injector, migratePostgresQueueSchema);
+    await runInInjectionContext(injector, migratePostgresTaskQueueSchema);
 }
 async function main() {
     const tenantId = '00000000-0000-0000-0000-000000000000';

package/http/client/adapters/undici.adapter.d.ts

@@ -1,20 +1,22 @@
 import type { Dispatcher } from 'undici';
 import type { Resolvable } from '../../../injector/index.js';
 import { resolveArgumentType } from '../../../injector/index.js';
+import { Injector } from '../../../injector/injector.js';
 import type { HttpClientRequest } from '../http-client-request.js';
 import { HttpClientResponse } from '../http-client-response.js';
 import { HttpClientAdapter } from '../http-client.adapter.js';
-export type UndiciHttpClientAdapterOptions = {
+export declare class UndiciHttpClientAdapterOptions {
     dispatcher?: Dispatcher;
-};
+}
 export declare class UndiciHttpClientAdapter extends HttpClientAdapter implements Resolvable<UndiciHttpClientAdapterOptions> {
     private readonly options;
     readonly [resolveArgumentType]: UndiciHttpClientAdapterOptions;
     call(httpClientRequest: HttpClientRequest): Promise<HttpClientResponse>;
 }
 /**
- * @param register whether to register for {@link HttpClientAdapter}
+ * configure undici http client adapter module
+ * @param options adapter configuration
  */
-export declare function configureUndiciHttpClientAdapter(options?: UndiciHttpClientAdapterOptions & {
-    register?: boolean;
+export declare function configureUndiciHttpClientAdapter({ injector, ...options }?: UndiciHttpClientAdapterOptions & {
+    injector?: Injector;
 }): void;

package/http/client/adapters/undici.adapter.js

@@ -8,15 +8,18 @@ import { Readable } from 'node:stream';
 import { request, errors as undiciErrors } from 'undici';
 import { HttpHeaders } from '../../../http/http-headers.js';
 import { HttpError, HttpErrorReason } from '../../../http/http.error.js';
-import { Singleton, injectArgument, resolveArgumentType } from '../../../injector/index.js';
+import { Singleton, inject, resolveArgumentType } from '../../../injector/index.js';
 import { Injector } from '../../../injector/injector.js';
 import { toArray } from '../../../utils/array/array.js';
 import { isBlob, isDefined, isUint8Array } from '../../../utils/type-guards.js';
 import { HttpClientResponse } from '../http-client-response.js';
 import { HttpClientAdapter } from '../http-client.adapter.js';
-let defaultOptions = {};
+export class UndiciHttpClientAdapterOptions {
+    dispatcher;
+}
+;
 let UndiciHttpClientAdapter = class UndiciHttpClientAdapter extends HttpClientAdapter {
-    options = injectArgument(this);
+    options = inject(UndiciHttpClientAdapterOptions, undefined, { optional: true }) ?? {};
     // eslint-disable-next-line max-lines-per-function, max-statements
     async call(httpClientRequest) {
         let body;
@@ -78,17 +81,17 @@ let UndiciHttpClientAdapter = class UndiciHttpClientAdapter extends HttpClientAd
     }
 };
 UndiciHttpClientAdapter = __decorate([
-    Singleton({ defaultArgumentProvider: () => defaultOptions })
+    Singleton()
 ], UndiciHttpClientAdapter);
 export { UndiciHttpClientAdapter };
 /**
- * @param register whether to register for {@link HttpClientAdapter}
+ * configure undici http client adapter module
+ * @param options adapter configuration
  */
-export function configureUndiciHttpClientAdapter(options = {}) {
-    defaultOptions = options;
-    if (options.register ?? true) {
-        Injector.register(HttpClientAdapter, { useToken: UndiciHttpClientAdapter });
-    }
+export function configureUndiciHttpClientAdapter({ injector, ...options } = {}) {
+    const targetInjector = injector ?? Injector;
+    targetInjector.register(UndiciHttpClientAdapterOptions, { useValue: options });
+    targetInjector.register(HttpClientAdapter, { useToken: UndiciHttpClientAdapter });
 }
 function getHttpErrorReason(error) {
     switch (error.code) {

package/http/client/module.d.ts

@@ -1,3 +1,4 @@
+import { Injector } from '../../injector/injector.js';
 import type { OneOrMany, Type } from '../../types/index.js';
 import { HttpClientOptions } from './http-client-options.js';
 import { HttpClientAdapter } from './http-client.adapter.js';
@@ -8,5 +9,6 @@ export type HttpClientModuleConfig = HttpClientOptions & {
      * Middlewares to add
      */
     middleware?: OneOrMany<HttpClientMiddleware>;
+    injector?: Injector;
 };
-export declare function configureHttpClient({ adapter, middleware, ...rest }: HttpClientModuleConfig): void;
+export declare function configureHttpClient({ adapter, middleware, injector, ...rest }?: HttpClientModuleConfig): void;

package/http/client/module.js

@@ -4,20 +4,19 @@ import { isDefined } from '../../utils/type-guards.js';
 import { HttpClientOptions } from './http-client-options.js';
 import { HttpClientAdapter } from './http-client.adapter.js';
 import { HTTP_CLIENT_MIDDLEWARE } from './tokens.js';
-let options = {};
-export function configureHttpClient({ adapter, middleware, ...rest }) {
+export function configureHttpClient({ adapter, middleware, injector, ...rest } = {}) {
+    const targetInjector = injector ?? Injector;
     if (isDefined(adapter)) {
-        Injector.register(HttpClientAdapter, { useToken: adapter });
+        targetInjector.register(HttpClientAdapter, { useToken: adapter });
     }
-    options = {
-        ...options,
-        baseUrl: rest.baseUrl ?? options.baseUrl,
-        enableErrorHandling: rest.enableErrorHandling ?? options.enableErrorHandling
+    const options = {
+        baseUrl: rest.baseUrl,
+        enableErrorHandling: rest.enableErrorHandling,
     };
     if (isDefined(middleware)) {
         for (const m of toArray(middleware)) {
-            Injector.register(HTTP_CLIENT_MIDDLEWARE, { useValue: m }, { multi: true });
+            targetInjector.register(HTTP_CLIENT_MIDDLEWARE, { useValue: m }, { multi: true });
         }
     }
-    Injector.register(HttpClientOptions, { useValue: options });
+    targetInjector.register(HttpClientOptions, { useValue: options });
 }

package/http/server/http-server.d.ts

@@ -7,6 +7,8 @@ export type HttpServerRequestContext<Context = unknown> = {
 };
 export declare abstract class HttpServer<Context = unknown> implements AsyncIterable<HttpServerRequestContext<Context>>, AsyncDisposable {
     abstract readonly connectedSocketsCount: number;
+    abstract readonly port: number;
+    abstract readonly address: string;
     abstract listen(port: number): Promise<void>;
     abstract close(timeout: number): Promise<void>;
     abstract [Symbol.asyncIterator](): AsyncIterator<HttpServerRequestContext<Context>>;

package/http/server/node/module.d.ts

@@ -1,7 +1,11 @@
+import { Injector } from '../../../injector/injector.js';
 export declare class NodeHttpServerConfiguration {
     trustedProxiesCount: number;
 }
 /**
- * registers {@link HttpServer} in global container
+ * registers {@link HttpServer} in container
+ * @param configuration server configuration
  */
-export declare function configureNodeHttpServer(configuration?: Partial<NodeHttpServerConfiguration>): void;
+export declare function configureNodeHttpServer({ injector, ...configuration }?: Partial<NodeHttpServerConfiguration> & {
+    injector?: Injector;
+}): void;

package/http/server/node/module.js

@@ -6,13 +6,15 @@ export class NodeHttpServerConfiguration {
 }
 ;
 /**
- * registers {@link HttpServer} in global container
+ * registers {@link HttpServer} in container
+ * @param configuration server configuration
  */
-export function configureNodeHttpServer(configuration = {}) {
-    Injector.register(NodeHttpServerConfiguration, {
+export function configureNodeHttpServer({ injector, ...configuration } = {}) {
+    const targetInjector = injector ?? Injector;
+    targetInjector.register(NodeHttpServerConfiguration, {
         useValue: {
             trustedProxiesCount: configuration.trustedProxiesCount ?? 0,
         },
     });
-    Injector.registerSingleton(HttpServer, { useToken: NodeHttpServer });
+    targetInjector.registerSingleton(HttpServer, { useToken: NodeHttpServer });
 }

package/http/server/node/node-http-server.d.ts

@@ -9,6 +9,8 @@ export declare class NodeHttpServer extends HttpServer<NodeHttpServerContext> im
     #private;
     private untrackConnectedSockets?;
     get connectedSocketsCount(): number;
+    get port(): number;
+    get address(): string;
     [afterResolve](): void;
     [Symbol.asyncDispose](): Promise<void>;
     listen(port: number): Promise<void>;

package/http/server/node/node-http-server.js

@@ -34,6 +34,12 @@ let NodeHttpServer = NodeHttpServer_1 = class NodeHttpServer extends HttpServer
     get connectedSocketsCount() {
         return this.#sockets.size;
     }
+    get port() {
+        return this.#httpServer.address().port;
+    }
+    get address() {
+        return this.#httpServer.address().address;
+    }
     [afterResolve]() {
         this.#httpServer.on('request', (request, response) => this.#requestIterable.feed({ request, response }));
     }
@@ -85,6 +91,7 @@ let NodeHttpServer = NodeHttpServer_1 = class NodeHttpServer extends HttpServer
                 await cancelableTimeout(250, CancellationToken.from(close$));
             }
         }
+        this.#requestIterable.end();
         this.untrackConnectedSockets?.();
         this.untrackConnectedSockets = undefined;
     }

package/http/types.d.ts

@@ -3,7 +3,7 @@ export type HttpValue = string | number | boolean | null;
 export type NormalizedHttpValue = string;
 export type HttpValueObject = Record<string, OneOrMany<HttpValue>>;
 export type NormalizedHttpValueObject = Record<string, WritableOneOrMany<string>>;
-export type HttpMethod = 'HEAD' | 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS';
+export type HttpMethod = 'HEAD' | 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'TRACE';
 export declare function normalizeHttpValue(value: OneOrMany<HttpValue>): WritableOneOrMany<string>;
 export declare function normalizeSingleHttpValue(value: HttpValue): string;
 export declare function denormalizeHttpValue(value: OneOrMany<HttpValue>): OneOrMany<HttpValue>;

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

@@ -1,6 +1,12 @@
+import { Injector } from '../../injector/index.js';
 import { type DatabaseConfig } from '../../orm/server/index.js';
 export declare class PostgresKeyValueStoreModuleConfig {
     database?: DatabaseConfig;
 }
-export declare function configurePostgresKeyValueStore(config?: PostgresKeyValueStoreModuleConfig): void;
+/**
+ * configure key-value store module
+ */
+export declare function configurePostgresKeyValueStore({ injector, ...config }?: PostgresKeyValueStoreModuleConfig & {
+    injector?: Injector;
+}): void;
 export declare function migratePostgresKeyValueStoreSchema(): Promise<void>;

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

@@ -6,11 +6,15 @@ import { PostgresKeyValueStore } from './key-value-store.service.js';
 export class PostgresKeyValueStoreModuleConfig {
     database;
 }
-export function configurePostgresKeyValueStore(config) {
+/**
+ * configure key-value store module
+ */
+export function configurePostgresKeyValueStore({ injector, ...config } = {}) {
+    const targetInjector = injector ?? Injector;
     if (isDefined(config)) {
-        Injector.register(PostgresKeyValueStoreModuleConfig, { useValue: config });
+        targetInjector.register(PostgresKeyValueStoreModuleConfig, { useValue: config });
     }
-    Injector.registerSingleton(KeyValueStore, { useToken: PostgresKeyValueStore });
+    targetInjector.registerSingleton(KeyValueStore, { useToken: PostgresKeyValueStore });
 }
 export async function migratePostgresKeyValueStoreSchema() {
     const connection = inject(PostgresKeyValueStoreModuleConfig, undefined, { optional: true })?.database?.connection;

package/lock/postgres/lock.js

@@ -84,7 +84,6 @@ let PostgresLockAdapter = class PostgresLockAdapter extends Lock {
             setWhere: lte(lock.expiration, TRANSACTION_TIMESTAMP),
         })
             .returning({ expiration: lock.expiration });
-        console.log(upsertQuery.toSQL());
         const [result] = await upsertQuery;
         if (isUndefined(result)) {
             return false;

package/lock/postgres/module.d.ts

@@ -1,6 +1,12 @@
+import { Injector } from '../../injector/index.js';
 import { type DatabaseConfig } from '../../orm/server/index.js';
 export declare class PostgresLockModuleConfig {
     database?: DatabaseConfig;
 }
-export declare function configurePostgresLock(config?: PostgresLockModuleConfig): void;
+/**
+ * configure lock module
+ */
+export declare function configurePostgresLock({ injector, ...config }?: PostgresLockModuleConfig & {
+    injector?: Injector;
+}): void;
 export declare function migratePostgresLockSchema(): Promise<void>;

package/lock/postgres/module.js

@@ -3,17 +3,21 @@ import { Database, migrate } from '../../orm/server/index.js';
 import { isDefined } from '../../utils/type-guards.js';
 import { Lock } from '../lock.js';
 import { LockProvider } from '../provider.js';
-import { PostgresLockProvider } from './provider.js';
 import { PostgresLockAdapter } from './lock.js';
+import { PostgresLockProvider } from './provider.js';
 export class PostgresLockModuleConfig {
     database;
 }
-export function configurePostgresLock(config) {
+/**
+ * configure lock module
+ */
+export function configurePostgresLock({ injector, ...config } = {}) {
+    const targetInjector = injector ?? Injector;
     if (isDefined(config)) {
-        Injector.register(PostgresLockModuleConfig, { useValue: config });
+        targetInjector.register(PostgresLockModuleConfig, { useValue: config });
     }
-    Injector.registerSingleton(LockProvider, { useToken: PostgresLockProvider });
-    Injector.registerSingleton(Lock, { useToken: PostgresLockAdapter });
+    targetInjector.registerSingleton(LockProvider, { useToken: PostgresLockProvider });
+    targetInjector.registerSingleton(Lock, { useToken: PostgresLockAdapter });
 }
 export async function migratePostgresLockSchema() {
     const connection = inject(PostgresLockModuleConfig, undefined, { optional: true })?.database?.connection;

package/logger/formatter.d.ts

@@ -5,7 +5,9 @@ export type LogPayload = {
     level: LogLevel;
     module: string[];
     message: string;
+    interpolationKeys: string[];
     context: Record<string>;
+    error?: unknown;
 };
 /** Formats a log payload for a transport. */
 export declare abstract class LogFormatter {

package/logger/formatters/json.js

@@ -21,8 +21,8 @@ let JsonLogFormatter = class JsonLogFormatter extends LogFormatter {
             ...payload.context,
         };
         // Special handling for error objects to make them serializable
-        if (isNotNullOrUndefined(logObject['error'])) {
-            logObject['error'] = formatError(logObject['error'], { includeStack: true });
+        if (isNotNullOrUndefined(payload.error)) {
+            logObject['error'] = formatError(payload.error, { includeStack: true });
         }
         return JSON.stringify(logObject);
     }

package/logger/formatters/pretty-print.js

@@ -8,6 +8,7 @@ import { Singleton } from '../../injector/decorators.js';
 import { supportsColoredStdout } from '../../supports.js';
 import { enumValueName } from '../../utils/enum.js';
 import { formatError } from '../../utils/format-error.js';
+import { objectKeys } from '../../utils/object/object.js';
 import { isNotNullOrUndefined } from '../../utils/type-guards.js';
 import { LogFormatter } from '../formatter.js';
 import { LogLevel } from '../level.js';
@@ -28,23 +29,20 @@ let PrettyPrintLogFormatter = class PrettyPrintLogFormatter extends LogFormatter
         const levelName = enumValueName(LogLevel, payload.level).toUpperCase();
         const levelString = `${levelName}:`.padEnd(8);
         const moduleString = payload.module.map((m) => `[${m}]`).join(' ');
-        const metadata = { ...payload.context };
         let metadataString = '';
         let errorString = '';
-        if (Object.keys(metadata).length > 0) {
+        if (objectKeys(payload.context).length > 0) {
             const displayMeta = {};
-            // Don't display metadata used in interpolation
-            const interpolationKeys = Array.from(payload.message.matchAll(/{([^{}]+)}/g)).map((match) => match[1]);
-            for (const key in metadata) {
-                if (!interpolationKeys.includes(key)) {
-                    displayMeta[key] = metadata[key];
+            for (const key in payload.context) {
+                if (!payload.interpolationKeys.includes(key)) {
+                    displayMeta[key] = payload.context[key];
                 }
             }
-            if (Object.keys(displayMeta).length > 0) {
+            if (objectKeys(displayMeta).length > 0) {
                 metadataString = ` ${dimColor}${JSON.stringify(displayMeta)}${resetColor}`;
             }
-            if (isNotNullOrUndefined(metadata['error'])) {
-                errorString += `\n${formatError(metadata['error'], { includeStack: true })}`;
+            if (isNotNullOrUndefined(payload.error)) {
+                errorString += `\n${formatError(payload.error, { includeStack: true })}`;
             }
         }
         return `${dimColor}${payload.timestamp.toISOString()}${resetColor} ${color}${levelString}${resetColor} ${moduleString}${moduleString.length > 0 ? ' ' : ''}${payload.message}${metadataString}${errorString}`;

package/logger/logger.d.ts

@@ -18,7 +18,7 @@ export declare class Logger implements Resolvable<LoggerArgument> {
     readonly context: Record<string>;
     readonly level: LogLevel | undefined;
     readonly [resolveArgumentType]: LoggerArgument;
-    error(message: string, context?: Record<string>): void;
+    error(message: string, error: unknown, context?: Record<string>): void;
     error(error: unknown, context?: Record<string>): void;
     warn(message: string, context?: Record<string>): void;
     info(message: string, context?: Record<string>): void;