@tstdl/base 0.92.166 → 0.92.168

package/logger/manager.js

@@ -0,0 +1,77 @@
+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;
+};
+import { Singleton } from '../injector/decorators.js';
+import { inject, injectAll } from '../injector/inject.js';
+import { isDefined } from '../utils/type-guards.js';
+import { LogLevel } from './level.js';
+import { DEFAULT_LOG_LEVEL } from './tokens.js';
+import { LogTransport } from './transport.js';
+let LogManager = class LogManager {
+    #transports = injectAll(LogTransport);
+    #moduleLevelRules = new Map();
+    #moduleLevelCache = new Map();
+    #defaultLevel = inject(DEFAULT_LOG_LEVEL, undefined, { optional: true }) ?? LogLevel.Trace;
+    log(payload) {
+        for (const transport of this.#transports) {
+            if (payload.level <= transport.level) {
+                transport.log(payload);
+            }
+        }
+    }
+    setDefaultLevel(level) {
+        this.#defaultLevel = level;
+        this.#moduleLevelCache.clear();
+    }
+    /**
+     * Sets the log level for a specific module.
+     * @param module The module (e.g., 'Api.Users' or ['Api', 'Users'])
+     * @param level The log level to set
+     */
+    setModuleLevel(module, level) {
+        const moduleString = Array.isArray(module) ? module.join('.') : module;
+        if (this.#moduleLevelRules.get(moduleString) === level) {
+            return;
+        }
+        this.#moduleLevelRules.set(moduleString, level);
+        this.#moduleLevelCache.clear();
+    }
+    /**
+     * Gets the effective log level for a given module path.
+     * It finds the most specific rule matching the module path.
+     * @param modulePath Array of module names, e.g., ['Api', 'Users']
+     * @returns The effective log level
+     */
+    getModuleLevel(modulePath) {
+        if (!isDefined(modulePath) || (modulePath.length == 0)) {
+            return this.#defaultLevel;
+        }
+        const path = Array.isArray(modulePath) ? modulePath.join('.') : modulePath;
+        const cachedLevel = this.#moduleLevelCache.get(path);
+        if (isDefined(cachedLevel)) {
+            return cachedLevel;
+        }
+        let currentPath = path;
+        while (currentPath.length > 0) {
+            const level = this.#moduleLevelRules.get(currentPath);
+            if (isDefined(level)) {
+                this.#moduleLevelCache.set(path, level); // Cache the result for the original full path
+                return level;
+            }
+            const lastDotIndex = currentPath.lastIndexOf('.');
+            if (lastDotIndex === -1) {
+                break;
+            }
+            currentPath = currentPath.substring(0, lastDotIndex);
+        }
+        this.#moduleLevelCache.set(path, this.#defaultLevel);
+        return this.#defaultLevel;
+    }
+};
+LogManager = __decorate([
+    Singleton()
+], LogManager);
+export { LogManager };

package/logger/tokens.d.ts

@@ -1,2 +1,2 @@
 import type { LogLevel } from './level.js';
-export declare const LOG_LEVEL: import("../injector/token.js").InjectionToken<LogLevel, never>;
+export declare const DEFAULT_LOG_LEVEL: import("../injector/token.js").InjectionToken<LogLevel, never>;

package/logger/tokens.js

@@ -1,2 +1,2 @@
 import { injectionToken } from '../injector/token.js';
-export const LOG_LEVEL = injectionToken('log level');
+export const DEFAULT_LOG_LEVEL = injectionToken('default log level');

package/logger/transport.d.ts

@@ -0,0 +1,14 @@
+import type { ProvidersItem } from '../injector/injector.js';
+import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
+import type { Provider } from '../injector/provider.js';
+import type { LogPayload } from './formatter.js';
+import { LogLevel } from './level.js';
+export declare class LogTransportOptions {
+    level?: LogLevel;
+}
+export declare abstract class LogTransport implements Resolvable<LogTransportOptions> {
+    readonly level: LogLevel;
+    readonly [resolveArgumentType]: LogTransportOptions;
+    abstract log(payload: LogPayload): void;
+}
+export declare function provideLogTransport<T extends LogTransport>(provider: Provider<T>): ProvidersItem;

package/logger/transport.js

@@ -0,0 +1,16 @@
+import { inject, injectArgument } from '../injector/inject.js';
+import { LogLevel } from './level.js';
+import { DEFAULT_LOG_LEVEL } from './tokens.js';
+export class LogTransportOptions {
+    level;
+}
+export class LogTransport {
+    level = injectArgument(this, { optional: true })?.level ?? inject(DEFAULT_LOG_LEVEL, undefined, { optional: true }) ?? LogLevel.Trace;
+}
+export function provideLogTransport(provider) {
+    return {
+        ...provider,
+        provide: LogTransport,
+        multi: true,
+    };
+}

package/logger/transports/console.d.ts

@@ -0,0 +1,14 @@
+import { type InjectionToken, type Resolvable, type resolveArgumentType } from '../../injector/index.js';
+import type { ProvidersItem } from '../../injector/injector.js';
+import type { LogFormatter, LogPayload } from '../formatter.js';
+import { LogLevel } from '../level.js';
+import { LogTransport, LogTransportOptions } from '../transport.js';
+export declare class ConsoleLogTransportOptions extends LogTransportOptions {
+    formatter: InjectionToken<LogFormatter>;
+}
+export declare class ConsoleLogTransport extends LogTransport implements Resolvable<ConsoleLogTransportOptions> {
+    #private;
+    readonly [resolveArgumentType]: ConsoleLogTransportOptions;
+    log(payload: LogPayload): void;
+}
+export declare function provideConsoleLogTransport(formatter: InjectionToken<LogFormatter>, level?: LogLevel): ProvidersItem;

package/logger/transports/console.js

@@ -0,0 +1,36 @@
+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;
+};
+import { Singleton } from '../../injector/decorators.js';
+import { inject, injectArgument } from '../../injector/index.js';
+import { LogLevel } from '../level.js';
+import { LogTransport, LogTransportOptions, provideLogTransport } from '../transport.js';
+export class ConsoleLogTransportOptions extends LogTransportOptions {
+    formatter;
+}
+const consoleLevelFuncMap = {
+    [LogLevel.Error]: 'error',
+    [LogLevel.Warn]: 'warn',
+    [LogLevel.Info]: 'info',
+    [LogLevel.Verbose]: 'info',
+    [LogLevel.Debug]: 'debug',
+    [LogLevel.Trace]: 'debug',
+};
+let ConsoleLogTransport = class ConsoleLogTransport extends LogTransport {
+    #formatter = inject(injectArgument(this).formatter);
+    log(payload) {
+        const message = this.#formatter.format(payload);
+        const consoleFunc = consoleLevelFuncMap[payload.level];
+        console[consoleFunc](message);
+    }
+};
+ConsoleLogTransport = __decorate([
+    Singleton()
+], ConsoleLogTransport);
+export { ConsoleLogTransport };
+export function provideConsoleLogTransport(formatter, level) {
+    return provideLogTransport({ useToken: ConsoleLogTransport, defaultArgument: { formatter, level } });
+}

package/logger/transports/index.d.ts

@@ -0,0 +1 @@
+export * from './console.js';

package/logger/transports/index.js

@@ -0,0 +1 @@
+export * from './console.js';

package/mail/clients/nodemailer.mail-client.d.ts

@@ -1,4 +1,3 @@
-import type { Disposable } from '../../disposable/disposable.js';
 import { MailClient, MailClientConfig } from '../mail.client.js';
 import type { MailData, MailSendResult } from '../models/index.js';
 export declare class NodemailerMailClient extends MailClient implements Disposable {

package/mail/clients/nodemailer.mail-client.js

@@ -32,13 +32,13 @@ let NodemailerMailClient = class NodemailerMailClient extends MailClient {
             subject: data.subject,
             text: data.content.text,
             html: data.content.html,
-            headers: data.headers
+            headers: data.headers,
         });
         return {
             messageId: result.messageId,
             accepted: result.accepted,
             rejected: result.rejected,
-            pending: result.pending
+            pending: result.pending,
         };
     }
     getTransport(config) {
@@ -62,11 +62,13 @@ function convertConfig(config) {
         host: config.host,
         port: config.port,
         secure: config.secure ?? (config.port == 465),
-        auth: isUndefined(config.auth) ? undefined : {
-            type: 'login',
-            user: config.auth.user,
-            pass: config.auth.password
-        }
+        auth: isUndefined(config.auth)
+            ? undefined
+            : {
+                type: 'login',
+                user: config.auth.user,
+                pass: config.auth.password,
+            },
     };
 }
 /**

package/message-bus/local/local-message-bus.js

@@ -36,8 +36,8 @@ LocalMessageBus = __decorate([
             useFactory: (argument, context) => {
                 const channel = assertStringPass(argument, 'LocalMessageBus resolve argument must be a string (channel)');
                 return context.resolve(LocalMessageBusProvider).get(channel);
-            }
-        }
+            },
+        },
     }),
     __metadata("design:paramtypes", [Subject, Logger])
 ], LocalMessageBus);

package/message-bus/message-bus-base.d.ts

@@ -1,7 +1,6 @@
 import type { Observable } from 'rxjs';
-import type { Logger } from '../logger/index.js';
 import { CancellationToken } from '../cancellation/token.js';
-import { disposeAsync } from '../disposable/disposable.js';
+import type { Logger } from '../logger/index.js';
 import { MessageBus } from './message-bus.js';
 export declare abstract class MessageBusBase<T> extends MessageBus<T> {
     private readonly logger;
@@ -16,7 +15,7 @@ export declare abstract class MessageBusBase<T> extends MessageBus<T> {
     constructor(logger: Logger);
     publishAndForget(message: T): void;
     publish(message: T): Promise<void>;
-    [disposeAsync](): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
     /**
      * publish messages to other instances
      * @param message message to send to other instances

package/message-bus/message-bus-base.js

@@ -1,7 +1,6 @@
 import { defer, merge, share, Subject, takeUntil } from 'rxjs';
-import { tryIgnoreLogAsync } from '../utils/try-ignore.js';
 import { CancellationToken } from '../cancellation/token.js';
-import { disposeAsync } from '../disposable/disposable.js';
+import { tryIgnoreLogAsync } from '../utils/try-ignore.js';
 import { MessageBus } from './message-bus.js';
 export class MessageBusBase extends MessageBus {
     logger;
@@ -18,21 +17,21 @@ export class MessageBusBase extends MessageBus {
         this.allMessages$ = merge(this.messages$, this.publishSubject);
     }
     publishAndForget(message) {
-        void tryIgnoreLogAsync(this.logger, async () => this.publish(message));
+        void tryIgnoreLogAsync(this.logger, async () => await this.publish(message));
     }
     async publish(message) {
         if (this.disposeToken.isSet) {
             throw new Error('message-bus is disposed');
         }
         this.publishSubject.next(message);
-        return this._publish(message);
+        await this._publish(message);
     }
-    async [disposeAsync]() {
+    async [Symbol.asyncDispose]() {
         if (this.disposeToken.isSet) {
             throw new Error('message-bus is disposed');
         }
         this.disposeToken.set();
         this.publishSubject.complete();
-        return this._dispose();
+        await this._dispose();
     }
 }

package/message-bus/message-bus.d.ts

@@ -1,6 +1,5 @@
 import type { Observable } from 'rxjs';
 import { type Resolvable, resolveArgumentType } from '../injector/interfaces.js';
-import { type AsyncDisposable, disposeAsync } from '../disposable/disposable.js';
 export type MessageBusArgument = string;
 export declare abstract class MessageBus<T> implements AsyncDisposable, Resolvable<MessageBusArgument> {
     readonly [resolveArgumentType]: string;
@@ -11,5 +10,5 @@ export declare abstract class MessageBus<T> implements AsyncDisposable, Resolvab
     dispose(): Promise<void>;
     abstract publish(message: T): Promise<void>;
     abstract publishAndForget(message: T): void;
-    abstract [disposeAsync](): Promise<void>;
+    abstract [Symbol.asyncDispose](): Promise<void>;
 }

package/message-bus/message-bus.js

@@ -1,7 +1,6 @@
 import { resolveArgumentType } from '../injector/interfaces.js';
-import { disposeAsync } from '../disposable/disposable.js';
 export class MessageBus {
     async dispose() {
-        await this[disposeAsync]();
+        await this[Symbol.asyncDispose]();
     }
 }

package/module/index.d.ts

@@ -3,7 +3,5 @@
  *
  * @module Module
  */
-export * from './module-base.js';
-export * from './module-metric-reporter.js';
 export * from './module.js';
 export * from './modules/index.js';

package/module/index.js

@@ -3,7 +3,5 @@
  *
  * @module Module
  */
-export * from './module-base.js';
-export * from './module-metric-reporter.js';
 export * from './module.js';
 export * from './modules/index.js';

package/module/module.d.ts

@@ -1,23 +1,22 @@
-import type { StringMap } from '../types/index.js';
-export declare enum ModuleMetricType {
-    Counter = 0,
-    Gauge = 1
-}
-export type ModuleMetric = {
-    type: ModuleMetricType;
-    labels?: string[];
-    getValue(): number;
+import type { CancellationSignal } from '../cancellation/index.js';
+import { CancellationToken } from '../cancellation/index.js';
+import { type EnumType } from '../enumeration/enumeration.js';
+export declare const ModuleState: {
+    readonly Running: 0;
+    readonly Stopping: 1;
+    readonly Stopped: 2;
+    readonly Erroneous: 3;
 };
-export declare enum ModuleState {
-    Running = 0,
-    Stopping = 1,
-    Stopped = 2,
-    Erroneous = 3
-}
-export interface Module {
+export type ModuleState = EnumType<typeof ModuleState>;
+export declare abstract class Module {
+    private runPromise;
+    private _state;
+    protected readonly cancellationToken: CancellationToken;
     readonly name: string;
-    readonly state: ModuleState;
-    readonly metrics: StringMap<ModuleMetric>;
+    get state(): ModuleState;
+    private get stateString();
+    constructor(name: string);
     run(): Promise<void>;
     stop(): Promise<void>;
+    protected abstract _run(cancellationSignal: CancellationSignal): Promise<void>;
 }

package/module/module.js

@@ -1,12 +1,47 @@
-export var ModuleMetricType;
-(function (ModuleMetricType) {
-    ModuleMetricType[ModuleMetricType["Counter"] = 0] = "Counter";
-    ModuleMetricType[ModuleMetricType["Gauge"] = 1] = "Gauge";
-})(ModuleMetricType || (ModuleMetricType = {}));
-export var ModuleState;
-(function (ModuleState) {
-    ModuleState[ModuleState["Running"] = 0] = "Running";
-    ModuleState[ModuleState["Stopping"] = 1] = "Stopping";
-    ModuleState[ModuleState["Stopped"] = 2] = "Stopped";
-    ModuleState[ModuleState["Erroneous"] = 3] = "Erroneous";
-})(ModuleState || (ModuleState = {}));
+import { CancellationToken } from '../cancellation/index.js';
+import { defineEnum } from '../enumeration/enumeration.js';
+import { enumValueName } from '../utils/enum.js';
+export const ModuleState = defineEnum('ModuleState', {
+    Running: 0,
+    Stopping: 1,
+    Stopped: 2,
+    Erroneous: 3,
+});
+export class Module {
+    runPromise;
+    _state;
+    cancellationToken;
+    name;
+    get state() {
+        return this._state;
+    }
+    get stateString() {
+        return enumValueName(ModuleState, this.state).toLowerCase();
+    }
+    constructor(name) {
+        this.name = name;
+        this.runPromise = Promise.resolve();
+        this._state = ModuleState.Stopped;
+        this.cancellationToken = new CancellationToken();
+    }
+    async run() {
+        if (this._state != ModuleState.Stopped) {
+            throw new Error(`cannot start module, it is ${this.stateString}`);
+        }
+        this.cancellationToken.unset();
+        try {
+            this._state = ModuleState.Running;
+            this.runPromise = this._run(this.cancellationToken);
+            await this.runPromise;
+            this._state = ModuleState.Stopped;
+        }
+        catch (error) {
+            this._state = ModuleState.Erroneous;
+            throw error;
+        }
+    }
+    async stop() {
+        this.cancellationToken.set();
+        await this.runPromise.catch(() => { });
+    }
+}

package/module/modules/function.module.d.ts

@@ -1,10 +1,10 @@
 import type { CancellationSignal } from '../../cancellation/index.js';
-import { ModuleBase } from '../module-base.js';
-import type { Module } from '../module.js';
+import type { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
+import { Module } from '../module.js';
 export type FunctionModuleFunction = (cancellationToken: CancellationSignal) => void | Promise<void>;
-export declare class FunctionModule extends ModuleBase implements Module {
-    private readonly fn;
-    readonly metrics: {};
-    constructor(fn: FunctionModuleFunction, name?: string);
+export declare class FunctionModule extends Module implements Resolvable<FunctionModuleFunction> {
+    #private;
+    readonly [resolveArgumentType]: FunctionModuleFunction;
+    constructor();
     protected _run(cancellationSignal: CancellationSignal): Promise<void>;
 }

package/module/modules/function.module.js

@@ -1,12 +1,28 @@
-import { ModuleBase } from '../module-base.js';
-export class FunctionModule extends ModuleBase {
-    fn;
-    metrics = {};
-    constructor(fn, name = fn.name) {
-        super(name);
-        this.fn = fn;
+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 { Singleton } from '../../injector/decorators.js';
+import { injectArgument } from '../../injector/inject.js';
+import { Module } from '../module.js';
+let FunctionModule = class FunctionModule extends Module {
+    #fn;
+    constructor() {
+        const fn = injectArgument(null);
+        super(fn.name);
+        this.#fn = fn;
     }
     async _run(cancellationSignal) {
-        await this.fn(cancellationSignal);
+        await this.#fn(cancellationSignal);
     }
-}
+};
+FunctionModule = __decorate([
+    Singleton(),
+    __metadata("design:paramtypes", [])
+], FunctionModule);
+export { FunctionModule };

package/module/modules/web-server.module.d.ts

@@ -1,24 +1,16 @@
 import type { CancellationSignal } from '../../cancellation/index.js';
 import type { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
-import { ModuleBase } from '../module-base.js';
-import type { Module } from '../module.js';
-import { ModuleMetricType } from '../module.js';
+import { Module } from '../module.js';
 export type WebServerModuleConfiguration = {
     port: number;
 };
 export declare const webServerModuleConfiguration: WebServerModuleConfiguration;
-export declare class WebServerModule extends ModuleBase implements Module, Resolvable<WebServerModuleConfiguration> {
+export declare class WebServerModule extends Module implements Resolvable<WebServerModuleConfiguration> {
     private readonly config;
     private readonly httpServer;
     private readonly apiGateway;
     private readonly apiControllers;
     private initialized;
-    readonly metrics: {
-        connectedSockets: {
-            type: ModuleMetricType;
-            getValue: () => number;
-        };
-    };
     readonly [resolveArgumentType]: WebServerModuleConfiguration;
     constructor();
     initialize(): void;

package/module/modules/web-server.module.js

@@ -8,27 +8,19 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { API_CONTROLLERS, ApiGateway, getApiControllerDefinition } from '../../api/server/index.js';
-import { disposeAsync } from '../../disposable/disposable.js';
 import { HttpServer } from '../../http/server/http-server.js';
 import { Singleton } from '../../injector/decorators.js';
 import { inject, injectArgument } from '../../injector/inject.js';
-import { ModuleBase } from '../module-base.js';
-import { ModuleMetricType } from '../module.js';
+import { Module } from '../module.js';
 export const webServerModuleConfiguration = {
     port: 8000,
 };
-let WebServerModule = class WebServerModule extends ModuleBase {
+let WebServerModule = class WebServerModule extends Module {
     config = injectArgument(this);
     httpServer = inject(HttpServer);
     apiGateway = inject(ApiGateway);
     apiControllers = inject(API_CONTROLLERS);
     initialized = false;
-    metrics = {
-        connectedSockets: {
-            type: ModuleMetricType.Gauge,
-            getValue: () => this.httpServer.connectedSocketsCount,
-        },
-    };
     constructor() {
         super('WebServer');
     }
@@ -45,7 +37,7 @@ let WebServerModule = class WebServerModule extends ModuleBase {
         this.initialize();
         await this.httpServer.listen(this.config.port);
         const closePromise = cancellationSignal.$set.then(async () => {
-            await this.httpServer[disposeAsync]();
+            await this.httpServer[Symbol.asyncDispose]();
         });
         for await (const context of this.httpServer) {
             void this.apiGateway.handleHttpServerRequestContext(context);

package/openid-connect/index.d.ts

@@ -4,9 +4,7 @@
  * @module OpenID Connect
  */
 export * from './cached-oidc-configuration.service.js';
-export * from './mongo-oidc-state.repository.js';
 export * from './oidc-configuration.service.js';
 export * from './oidc-state.model.js';
-export * from './oidc-state.repository.js';
 export * from './oidc.service-model.js';
 export * from './oidc.service.js';

package/openid-connect/index.js

@@ -7,10 +7,8 @@ import { Injector } from '../injector/injector.js';
 import { CachedOidcConfigurationService } from './cached-oidc-configuration.service.js';
 import { OidcConfigurationService } from './oidc-configuration.service.js';
 export * from './cached-oidc-configuration.service.js';
-export * from './mongo-oidc-state.repository.js';
 export * from './oidc-configuration.service.js';
 export * from './oidc-state.model.js';
-export * from './oidc-state.repository.js';
 export * from './oidc.service-model.js';
 export * from './oidc.service.js';
 Injector.registerSingleton(OidcConfigurationService, { useToken: CachedOidcConfigurationService });

package/openid-connect/oidc-state.model.d.ts

@@ -1,11 +1,10 @@
-import type { Entity, NewEntity } from '../database/index.js';
-export type OidcState<Data = any> = Entity & {
+import { EntityWithoutMetadata, Json } from '../orm/index.js';
+export declare class OidcState<Data> extends EntityWithoutMetadata {
     value: string;
     codeVerifier: string;
     endpoint: string;
     clientId: string;
     clientSecret: string;
     expiration: number;
-    data: Data;
-};
-export type NewOidcState<Data = any> = NewEntity<OidcState<Data>>;
+    data: Json<Data>;
+}