@tstdl/base 0.92.167 → 0.93.0

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>;
+}

package/openid-connect/oidc-state.model.js

@@ -1 +1,51 @@
-export {};
+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 { ExpiresAt as Expires } from '../orm/decorators.js';
+import { EntityWithoutMetadata, Json, Unique } from '../orm/index.js';
+import { any, NumberProperty, StringProperty } from '../schema/index.js';
+export class OidcState extends EntityWithoutMetadata {
+    value;
+    codeVerifier;
+    endpoint;
+    clientId;
+    clientSecret;
+    expiration;
+    data;
+}
+__decorate([
+    Unique(),
+    StringProperty(),
+    __metadata("design:type", String)
+], OidcState.prototype, "value", void 0);
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], OidcState.prototype, "codeVerifier", void 0);
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], OidcState.prototype, "endpoint", void 0);
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], OidcState.prototype, "clientId", void 0);
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], OidcState.prototype, "clientSecret", void 0);
+__decorate([
+    Expires(),
+    NumberProperty(),
+    __metadata("design:type", Number)
+], OidcState.prototype, "expiration", void 0);
+__decorate([
+    Json({ schema: any() }),
+    __metadata("design:type", Object)
+], OidcState.prototype, "data", void 0);

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

@@ -1,4 +1,4 @@
-export type OidcInitParameters<Data = void> = {
+export type OidcInitParameters<Data> = {
     endpoint: string;
     clientId: string;
     clientSecret: string;

package/openid-connect/oidc.service.d.ts

@@ -1,15 +1,11 @@
-import { HttpClient } from '../http/client/index.js';
 import type { Record } from '../types/index.js';
-import { OidcConfigurationService } from './oidc-configuration.service.js';
-import type { OidcState } from './oidc-state.model.js';
-import { OidcStateRepository } from './oidc-state.repository.js';
+import { OidcState } from './oidc-state.model.js';
 import type { OidcGetTokenParameters, OidcInitParameters, OidcInitResult, OidcRefreshTokenParameters, OidcToken } from './oidc.service-model.js';
-export declare class OidcService<Data = any> {
+export declare class OidcService<Data> {
     private readonly oidcConfigurationService;
     private readonly maybeOidcStateRepository;
     private readonly httpClient;
     private get oidcStateRepository();
-    constructor(oidcConfigurationService: OidcConfigurationService, oidcStateRepository: OidcStateRepository | undefined, httpClient: HttpClient);
     initAuthorization({ endpoint, clientId, clientSecret, scope, expiration, data }: OidcInitParameters<Data>): Promise<OidcInitResult>;
     getState(state: string): Promise<OidcState<Data>>;
     deleteState(state: string): Promise<void>;

package/openid-connect/oidc.service.js

@@ -4,57 +4,46 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
 import { ForbiddenError } from '../errors/forbidden.error.js';
 import { NotImplementedError } from '../errors/not-implemented.error.js';
 import { HttpClient } from '../http/client/index.js';
 import { HttpHeaders } from '../http/http-headers.js';
-import { Inject, Optional, Singleton } from '../injector/index.js';
-import { Schema, object, optional, string } from '../schema/index.js';
+import { inject, Singleton } from '../injector/index.js';
+import { injectRepository } from '../orm/server/repository.js';
+import { object, optional, Schema, string } from '../schema/index.js';
 import { Alphabet } from '../utils/alphabet.js';
 import { digest } from '../utils/cryptography.js';
 import { currentTimestamp } from '../utils/date-time.js';
 import { getRandomString } from '../utils/random.js';
 import { assertDefinedPass, isUndefined } from '../utils/type-guards.js';
 import { OidcConfigurationService } from './oidc-configuration.service.js';
-import { OidcStateRepository } from './oidc-state.repository.js';
+import { OidcState } from './oidc-state.model.js';
 const tokenResponseSchema = object({
     /* eslint-disable @typescript-eslint/naming-convention */
     access_token: string(),
     id_token: optional(string()),
     token_type: string(),
-    refresh_token: optional(string())
+    refresh_token: optional(string()),
     /* eslint-enable @typescript-eslint/naming-convention */
 });
 let OidcService = class OidcService {
-    oidcConfigurationService;
-    maybeOidcStateRepository;
-    httpClient;
+    oidcConfigurationService = inject(OidcConfigurationService);
+    maybeOidcStateRepository = injectRepository(OidcState);
+    httpClient = inject(HttpClient);
     get oidcStateRepository() {
         return assertDefinedPass(this.maybeOidcStateRepository, 'OidcStateRepository is not provided but required.');
     }
-    constructor(oidcConfigurationService, oidcStateRepository, httpClient) {
-        this.oidcConfigurationService = oidcConfigurationService;
-        this.maybeOidcStateRepository = oidcStateRepository;
-        this.httpClient = httpClient;
-    }
     async initAuthorization({ endpoint, clientId, clientSecret, scope, expiration, data }) {
         const oidcConfiguration = await this.oidcConfigurationService.getConfiguration(endpoint);
-        const state = {
+        const state = await this.oidcStateRepository.insert({
             value: getRandomString(64, Alphabet.LowerUpperCaseNumbers),
             codeVerifier: getRandomString(64, Alphabet.LowerUpperCaseNumbers),
             endpoint,
             clientId,
             clientSecret,
             expiration: currentTimestamp() + expiration,
-            data
-        };
-        await this.oidcStateRepository.insert(state);
+            data,
+        });
         const codeChallenge = await digest('SHA-256', state.codeVerifier).toBase64Url();
         const result = {
             authorizationEndpoint: oidcConfiguration.authorizationEndpoint,
@@ -62,21 +51,22 @@ let OidcService = class OidcService {
             clientId,
             scope,
             codeChallenge,
-            codeChallengeMethod: 'S256'
+            codeChallengeMethod: 'S256',
         };
         return result;
     }
     async getState(state) {
-        return this.oidcStateRepository.loadByFilter({ value: state });
+        return await this.oidcStateRepository.loadByQuery({ value: state });
     }
     async deleteState(state) {
-        await this.oidcStateRepository.deleteByFilter({ value: state });
+        await this.oidcStateRepository.deleteByQuery({ value: state });
     }
     async validateState(state) {
-        const oidcState = await this.oidcStateRepository.tryLoadByFilterAndDelete({ value: state });
+        const oidcState = await this.oidcStateRepository.tryLoadByQuery({ value: state });
         if (isUndefined(oidcState)) {
-            throw new ForbiddenError('invalid state code');
+            throw new ForbiddenError('Invalid state code.');
         }
+        await this.oidcStateRepository.deleteByQuery({ value: state });
         return oidcState;
     }
     async getToken(parameters, additionalData) {
@@ -96,7 +86,7 @@ let OidcService = class OidcService {
                     code: parameters.code,
                     code_verifier: parameters.codeVerifier,
                     redirect_uri: parameters.redirectUri,
-                    ...additionalData
+                    ...additionalData,
                     /* eslint-enable @typescript-eslint/naming-convention */
                 };
                 break;
@@ -105,7 +95,7 @@ let OidcService = class OidcService {
                     /* eslint-disable @typescript-eslint/naming-convention */
                     grant_type: 'client_credentials',
                     scope: parameters.scope,
-                    ...additionalData
+                    ...additionalData,
                     /* eslint-enable @typescript-eslint/naming-convention */
                 };
                 break;
@@ -122,8 +112,8 @@ let OidcService = class OidcService {
                 authorization = {
                     basic: {
                         username: parameters.clientId,
-                        password: parameters.clientSecret
-                    }
+                        password: parameters.clientSecret,
+                    },
                 };
                 break;
             default:
@@ -139,7 +129,7 @@ let OidcService = class OidcService {
             client_id: clientId,
             client_secret: clientSecret,
             grant_type: 'refresh_token',
-            refresh_token: refreshToken
+            refresh_token: refreshToken,
             /* eslint-enable @typescript-eslint/naming-convention */
         };
         const tokenResponse = await this.httpClient.postJson(oidcConfiguration.tokenEndpoint, { headers: { authorization: `Bearer ${refreshToken}` }, body: { form: formData } });
@@ -155,10 +145,7 @@ let OidcService = class OidcService {
     }
 };
 OidcService = __decorate([
-    Singleton(),
-    __param(1, Inject(OidcStateRepository)),
-    __param(1, Optional()),
-    __metadata("design:paramtypes", [OidcConfigurationService, Object, HttpClient])
+    Singleton()
 ], OidcService);
 export { OidcService };
 function parseTokenResponse(response) {
@@ -168,7 +155,7 @@ function parseTokenResponse(response) {
         accessToken: access_token,
         idToken: id_token,
         refreshToken: refresh_token,
-        raw: response
+        raw: response,
     };
     return token;
 }

package/orm/decorators.d.ts

@@ -57,6 +57,9 @@ export type OrmColumnReflectionData = {
         targetColumn?: TargetColumnPaths<any>;
     }[];
     encrypted?: boolean;
+    expirationField?: {
+        mode: 'soft' | 'hard';
+    };
 };
 /**
  * Reflection data for unique constraints.
@@ -121,7 +124,7 @@ export declare function createColumnDecorator(data?: OrmColumnReflectionData): P
  * @param data - The ORM reflection data to add.
  * @returns A class or property decorator.
  */
-export declare function createTableAndColumnDecorator(data?: OrmColumnReflectionData): ClassDecorator & PropertyDecorator;
+export declare function createTableAndColumnDecorator(data?: OrmColumnReflectionData): PropertyDecorator & ClassDecorator;
 /**
  * Decorator to specify ORM column options.
  * @param options - Column configuration options.
@@ -217,4 +220,10 @@ export declare function Index<T extends Entity | EntityWithoutMetadata = any>(op
  * @returns A class decorator.
  */
 export declare function Index<T extends Entity | EntityWithoutMetadata = any>(columns: Columns<T>, options?: IndexReflectionData<T>['options']): ClassDecorator;
+/**
+ * Decorator to mark a column as an expiration field. This will be used to automatically delete records when expired.
+ * @param mode - Whether to delete soft or hard.
+ * @returns A property decorator.
+ */
+export declare function ExpiresAt(mode?: 'soft' | 'hard'): PropertyDecorator;
 export {};