@tstdl/base 0.92.167 → 0.93.0

package/application/application.d.ts

@@ -1,30 +1,24 @@
-import type { CancellationSignal } from '../cancellation/token.js';
+import { CancellationSignal } from '../cancellation/token.js';
+import { type ProvidersItem } from '../injector/injector.js';
 import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
 import type { LoggerArgument } from '../logger/index.js';
-import type { Module } from '../module/module.js';
-import type { FunctionModuleFunction } from '../module/modules/function.module.js';
+import { Module } from '../module/index.js';
 import type { OneOrMany, Type } from '../types/index.js';
-export type BootstrapFn = () => void | Promise<void>;
-export type RunOptions = {
-    bootstrap?: OneOrMany<BootstrapFn>;
-};
+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_INITIALIZER: import("../injector/token.js").InjectionToken<InitializerFn, never>;
+export declare const APPLICATION_DESTRUCTOR: import("../injector/token.js").InjectionToken<DestructorFn, never>;
 export type ApplicationArgument = LoggerArgument;
 export declare class Application implements Resolvable<ApplicationArgument> {
     #private;
-    static _instance: Application | undefined;
-    private static get instance();
     readonly [resolveArgumentType]: string;
+    static create(name: string, providers?: OneOrMany<ProvidersItem>[]): Application;
+    static run(name: string, providers?: OneOrMany<ProvidersItem>[]): Application;
     get shutdownSignal(): CancellationSignal;
-    static get shutdownSignal(): CancellationSignal;
-    static registerModule(moduleType: Type<Module>): void;
-    static registerModuleFunction(fn: FunctionModuleFunction): void;
-    static run(...functionsAndModules: [RunOptions | OneOrMany<FunctionModuleFunction | Type<Module>>, ...OneOrMany<FunctionModuleFunction | Type<Module>>[]]): void;
-    static waitForShutdown(): Promise<void>;
-    static shutdown(): Promise<void>;
-    static requestShutdown(): void;
     registerModule(moduleType: Module | Type<Module>): void;
-    registerModuleFunction(fn: FunctionModuleFunction): void;
-    run(...optionsFunctionsAndModules: [RunOptions | OneOrMany<FunctionModuleFunction | Type<Module>>, ...OneOrMany<FunctionModuleFunction | Type<Module>>[]]): void;
+    run(): void;
+    runAndWait(): Promise<void>;
     shutdown(): Promise<void>;
     requestShutdown(): void;
     waitForShutdown(): Promise<void>;

package/application/application.js

@@ -5,75 +5,54 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 var Application_1;
-import { getGlobalInjector } from '../core.js';
+import { CancellationSignal, CancellationToken } from '../cancellation/token.js';
 import { Singleton } from '../injector/decorators.js';
-import { inject, injectArgument, runInInjectionContext } from '../injector/inject.js';
+import { inject, injectAll, injectArgument, runInInjectionContext } from '../injector/inject.js';
 import { Injector } from '../injector/injector.js';
+import { injectionToken } from '../injector/token.js';
 import { Logger } from '../logger/index.js';
-import { ModuleBase } from '../module/module-base.js';
-import { ModuleState } from '../module/module.js';
-import { FunctionModule } from '../module/modules/function.module.js';
-import { getShutdownSignal, getShutdownToken } from '../process-shutdown.js';
+import { Module, ModuleState } from '../module/index.js';
 import { DeferredPromise } from '../promise/deferred-promise.js';
-import { toArray } from '../utils/array/array.js';
 import { mapAsync } from '../utils/async-iterable-helpers/map.js';
 import { toArrayAsync } from '../utils/async-iterable-helpers/to-array.js';
-import { isDefined, isFunction, isObject, isUndefined } from '../utils/type-guards.js';
-let Application = class Application {
-    static { Application_1 = this; }
-    static _instance;
-    static get instance() {
-        if (isUndefined(this._instance)) {
-            this._instance = getGlobalInjector().resolve(Application_1, 'App');
-            // @ts-expect-error readonly
-            this._instance.#shutdownToken = getShutdownToken();
-        }
-        return this._instance;
-    }
+import { isDefined, isFunction } from '../utils/type-guards.js';
+export const APPLICATION_MODULE = injectionToken('ApplicationModule');
+export const APPLICATION_INITIALIZER = injectionToken('ApplicationInitializer');
+export const APPLICATION_DESTRUCTOR = injectionToken('ApplicationDestructor');
+let Application = Application_1 = class Application {
     #name = injectArgument(this);
-    #injector = inject(Injector).fork(`${this.#name}Injector`);
-    #logger = this.#injector.resolve(Logger, this.#name);
-    #moduleTypesAndInstances = new Set();
+    #injector = inject(Injector);
+    #logger = inject(Logger, this.#name);
+    #moduleTypesAndInstances = new Set(injectAll(APPLICATION_MODULE, undefined, { optional: true }));
     #shutdownPromise = new DeferredPromise();
-    #shutdownToken = getShutdownSignal().createChild();
-    get shutdownSignal() {
-        return this.#shutdownToken.signal;
-    }
-    static get shutdownSignal() {
-        return Application_1.instance.shutdownSignal;
-    }
-    static registerModule(moduleType) {
-        Application_1.instance.registerModule(moduleType);
-    }
-    static registerModuleFunction(fn) {
-        Application_1.instance.registerModuleFunction(fn);
-    }
-    static run(...functionsAndModules) {
-        Application_1.instance.run(...functionsAndModules);
-    }
-    static async waitForShutdown() {
-        return Application_1.instance.waitForShutdown();
+    #shutdownToken = inject(CancellationSignal, undefined, { optional: true })?.createChild() ?? new CancellationToken();
+    static create(name, providers = []) {
+        const injector = new Injector(`${name}Injector`);
+        for (const providersItem of providers.flat()) {
+            injector.register(providersItem.provide, providersItem, { multi: providersItem.multi });
+        }
+        return injector.resolve(Application_1, name);
     }
-    static async shutdown() {
-        await Application_1.instance.shutdown();
+    static run(name, providers = []) {
+        const app = Application_1.create(name, providers);
+        app.run();
+        return app;
     }
-    static requestShutdown() {
-        Application_1.instance.requestShutdown();
+    get shutdownSignal() {
+        return this.#shutdownToken.signal;
     }
     registerModule(moduleType) {
         this.#moduleTypesAndInstances.add(moduleType);
     }
-    registerModuleFunction(fn) {
-        const module = new FunctionModule(fn);
-        this.registerModule(module);
-    }
-    run(...optionsFunctionsAndModules) {
+    run() {
         if (this.#shutdownToken.isSet) {
             throw new Error('Application was shut down.');
         }
-        const options = ((optionsFunctionsAndModules.length > 0) && isObject(optionsFunctionsAndModules[0])) ? optionsFunctionsAndModules[0] : undefined;
-        const functionsAndModules = (isUndefined(options) ? optionsFunctionsAndModules : optionsFunctionsAndModules.slice(1));
-        void this._run(functionsAndModules, options);
+        void this._run();
+    }
+    async runAndWait() {
+        this.run();
+        await this.waitForShutdown();
     }
     async shutdown() {
         this.requestShutdown();
@@ -86,28 +65,19 @@ let Application = class Application {
         this.#shutdownToken.set();
     }
     async waitForShutdown() {
-        return this.#shutdownPromise;
+        await this.#shutdownPromise;
     }
-    async _run(functionsAndModules, options = {}) {
+    async _run() {
         let modules;
         try {
-            for (const fnOrModule of functionsAndModules.flatMap((fns) => fns)) {
-                if (fnOrModule.prototype instanceof ModuleBase) {
-                    this.registerModule(fnOrModule);
-                }
-                else {
-                    this.registerModuleFunction(fnOrModule);
-                }
+            const initializers = await this.#injector.resolveAllAsync(APPLICATION_INITIALIZER, undefined, { optional: true });
+            for (const initializer of initializers) {
+                await runInInjectionContext(this.#injector, initializer);
             }
-            if (isDefined(options.bootstrap)) {
-                for (const fn of toArray(options.bootstrap)) {
-                    await runInInjectionContext(this.#injector, fn);
-                }
-            }
-            modules = await toArrayAsync(mapAsync(this.#moduleTypesAndInstances, async (instanceOrType) => (isFunction(instanceOrType) ? this.#injector.resolveAsync(instanceOrType) : instanceOrType)));
+            modules = await toArrayAsync(mapAsync(this.#moduleTypesAndInstances, async (instanceOrType) => (isFunction(instanceOrType) ? await this.#injector.resolveAsync(instanceOrType) : instanceOrType)));
             await Promise.race([
                 this.runModules(modules),
-                this.shutdownSignal
+                this.shutdownSignal,
             ]);
         }
         catch (error) {
@@ -119,6 +89,15 @@ let Application = class Application {
             if (isDefined(modules)) {
                 await this.stopModules(modules);
             }
+            const destructors = await this.#injector.resolveAllAsync(APPLICATION_DESTRUCTOR, undefined, { optional: true });
+            for (const destructor of destructors) {
+                try {
+                    await runInInjectionContext(this.#injector, destructor);
+                }
+                catch (error) {
+                    this.#logger.error(error, { message: 'An error occurred during application destruction.' });
+                }
+            }
             await this.#injector.dispose();
             this.#logger.info('Bye');
         }
@@ -128,7 +107,7 @@ let Application = class Application {
         const promises = modules.map(async (module) => {
             try {
                 this.#logger.info(`Starting module ${module.name}`);
-                await runInInjectionContext(this.#injector, async () => module.run());
+                await runInInjectionContext(this.#injector, async () => await module.run());
                 this.#logger.info(`Module ${module.name} stopped.`);
             }
             catch (error) {

package/application/index.d.ts

@@ -1,6 +1,2 @@
-/**
- * Start application modules and shutting down the app
- *
- * @module Application
- */
 export * from './application.js';
+export * from './providers.js';

package/application/index.js

@@ -1,6 +1,2 @@
-/**
- * Start application modules and shutting down the app
- *
- * @module Application
- */
 export * from './application.js';
+export * from './providers.js';

package/application/providers.d.ts

@@ -0,0 +1,10 @@
+import { CancellationSignal } from '../cancellation/index.js';
+import { 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 provideModules(...functionsAndModules: OneOrMany<FunctionModuleFunction | Type<Module>>[]): ProvidersItem[];
+export declare function provideInitializer(fn: InitializerFn): ProvidersItem;
+export declare function provideDestructor(fn: DestructorFn): ProvidersItem;
+export declare function provideShutdownSignal(signal: CancellationSignal): ProvidersItem;
+export declare function provideSignalHandler(): ProvidersItem;

package/application/providers.js

@@ -0,0 +1,54 @@
+import { CancellationSignal } from '../cancellation/index.js';
+import { inject } from '../injector/index.js';
+import { Logger } from '../logger/index.js';
+import { FunctionModule, Module } from '../module/index.js';
+import { isFunction } from '../utils/type-guards.js';
+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'];
+export function provideModules(...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 };
+        }
+        else {
+            throw new TypeError('Invalid module or function provided to provideModules');
+        }
+    });
+}
+export function provideInitializer(fn) {
+    return { provide: APPLICATION_INITIALIZER, useValue: fn, multi: true };
+}
+export function provideDestructor(fn) {
+    return { provide: APPLICATION_DESTRUCTOR, useValue: fn, multi: true };
+}
+export function provideShutdownSignal(signal) {
+    return { provide: CancellationSignal, useValue: signal };
+}
+export function provideSignalHandler() {
+    let signalCounter = 0;
+    return provideInitializer(() => {
+        const application = inject(Application);
+        const logger = inject(Logger);
+        for (const event of quitEvents) {
+            process.on(event, (...args) => {
+                logger.error(`QuitEvent occurred: ${event}`, { details: args });
+                application.requestShutdown();
+            });
+        }
+        for (const quitSignal of quitSignals) {
+            process.on(quitSignal, (signal) => {
+                logger.info(`${signal} received, quitting.`);
+                application.requestShutdown();
+                if (++signalCounter > 1) {
+                    logger.warn('Forcefully quitting due to multiple signals...');
+                    setTimeout(() => process.exit(1), 1);
+                }
+            });
+        }
+    });
+}

package/audit/audit.model.d.ts

@@ -0,0 +1,15 @@
+import { EntityWithoutMetadata, Json, Timestamp, Uuid } from '../orm/index.js';
+import { ActorType, AuditOutcome, AuditSeverity } from './types.js';
+export declare class AuditEvent extends EntityWithoutMetadata {
+    timestamp: Timestamp;
+    correlationId?: Uuid;
+    module: string;
+    action: string;
+    outcome: AuditOutcome;
+    severity: AuditSeverity;
+    actorId: string;
+    actorType: ActorType;
+    targetId: string;
+    targetType: string;
+    details?: Json<unknown>;
+}

package/audit/audit.model.js

@@ -0,0 +1,73 @@
+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 { EntityWithoutMetadata, Json, Table, Timestamp, Uuid } from '../orm/index.js';
+import { Enumeration, StringProperty } from '../schema/index.js';
+import { ActorType, AuditOutcome, AuditSeverity } from './types.js';
+let AuditEvent = class AuditEvent extends EntityWithoutMetadata {
+    timestamp;
+    correlationId;
+    module;
+    action;
+    outcome;
+    severity;
+    actorId;
+    actorType;
+    targetId;
+    targetType;
+    details;
+};
+__decorate([
+    Timestamp(),
+    __metadata("design:type", Number)
+], AuditEvent.prototype, "timestamp", void 0);
+__decorate([
+    Uuid({ nullable: true }),
+    __metadata("design:type", String)
+], AuditEvent.prototype, "correlationId", void 0);
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], AuditEvent.prototype, "module", void 0);
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], AuditEvent.prototype, "action", void 0);
+__decorate([
+    Enumeration(AuditOutcome),
+    __metadata("design:type", String)
+], AuditEvent.prototype, "outcome", void 0);
+__decorate([
+    Enumeration(AuditSeverity),
+    __metadata("design:type", String)
+], AuditEvent.prototype, "severity", void 0);
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], AuditEvent.prototype, "actorId", void 0);
+__decorate([
+    Enumeration(ActorType),
+    __metadata("design:type", String)
+], AuditEvent.prototype, "actorType", void 0);
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], AuditEvent.prototype, "targetId", void 0);
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], AuditEvent.prototype, "targetType", void 0);
+__decorate([
+    Json({ nullable: true }),
+    __metadata("design:type", Object)
+], AuditEvent.prototype, "details", void 0);
+AuditEvent = __decorate([
+    Table({ name: 'event' })
+], AuditEvent);
+export { AuditEvent };

package/audit/auditor.d.ts

@@ -0,0 +1,42 @@
+import { type Resolvable, type resolveArgumentType } from '../injector/index.js';
+import type { UndefinableJsonObject } from '../types/index.js';
+import type { ActorType } from './types.js';
+import { AuditOutcome, AuditSeverity } from './types.js';
+export type AuditPayload = Partial<{
+    correlationId?: string;
+    outcome?: AuditOutcome;
+    severity?: AuditSeverity;
+    actorId?: string;
+    actorType?: ActorType;
+    targetId?: string;
+    targetType?: string;
+    details?: UndefinableJsonObject;
+}>;
+export type AuditorArgument = string | string[] | {
+    module?: string | string[];
+    context?: Partial<AuditPayload>;
+};
+export declare class Auditor implements Resolvable<AuditorArgument> {
+    #private;
+    readonly module: string[];
+    readonly context: Partial<Partial<{
+        correlationId?: string;
+        outcome?: AuditOutcome;
+        severity?: AuditSeverity;
+        actorId?: string;
+        actorType?: ActorType;
+        targetId?: string;
+        targetType?: string;
+        details?: UndefinableJsonObject;
+    }>>;
+    get moduleString(): string;
+    readonly [resolveArgumentType]: AuditorArgument;
+    fork(subModule: string | string[]): Auditor;
+    with(context: Partial<AuditPayload>): Auditor;
+    withCorrelation(): Auditor;
+    log(action: string, data?: AuditPayload): Promise<void>;
+    info(action: string, data: AuditPayload): Promise<void>;
+    warn(action: string, data: AuditPayload): Promise<void>;
+    error(action: string, data: AuditPayload): Promise<void>;
+    critical(action: string, data: AuditPayload): Promise<void>;
+}

package/audit/auditor.js

@@ -0,0 +1,111 @@
+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);
+};
+var Auditor_1;
+import { createContextProvider } from '../context/index.js';
+import { Injectable, injectArgument } from '../injector/index.js';
+import { injectRepository } from '../orm/server/index.js';
+import { TRANSACTION_TIMESTAMP } from '../orm/sqls.js';
+import { toArray } from '../utils/array/index.js';
+import { Memoize } from '../utils/function/memoize.js';
+import { filterUndefinedFromRecord, objectKeys } from '../utils/object/object.js';
+import { assertDefinedPass, isArray, isNotArray, isObject, isString } from '../utils/type-guards.js';
+import { AuditEvent } from './audit.model.js';
+import { AuditOutcome, AuditSeverity } from './types.js';
+const { runInAuditorCreationContext, getCurrentAuditorCreationContext, isInAuditorCreationContext } = createContextProvider('AuditorCreation');
+let Auditor = Auditor_1 = class Auditor {
+    #repository = injectRepository(AuditEvent);
+    #argument = isInAuditorCreationContext() ? injectArgument(this, { optional: true }) : undefined;
+    #creationContext = getCurrentAuditorCreationContext();
+    module = this.#creationContext?.module ?? moduleFromArgument(this.#argument);
+    context = this.#creationContext?.context ?? ((isObject(this.#argument) && isNotArray(this.#argument)) ? (this.#argument.context ?? {}) : {});
+    get moduleString() {
+        return this.module.join('.');
+    }
+    fork(subModule) {
+        return runInAuditorCreationContext({
+            module: [...this.module, ...toArray(subModule)],
+            context: this.context,
+        }, () => new Auditor_1());
+    }
+    with(context) {
+        return runInAuditorCreationContext({
+            module: this.module,
+            context: { ...this.context, ...context, details: { ...this.context.details, ...context.details } },
+        }, () => new Auditor_1());
+    }
+    withCorrelation() {
+        return this.with({ correlationId: this.context.correlationId ?? crypto.randomUUID() });
+    }
+    async log(action, data) {
+        const mergedData = { ...this.context, ...data, details: filterUndefinedFromRecord({ ...this.context.details, ...data?.details }) };
+        await this.#repository.insert({
+            timestamp: TRANSACTION_TIMESTAMP,
+            correlationId: mergedData.correlationId,
+            module: this.moduleString,
+            action: action,
+            outcome: assertDefinedPass(mergedData.outcome, 'Audit outcome is required'),
+            severity: assertDefinedPass(mergedData.severity, 'Audit severity is required'),
+            actorId: assertDefinedPass(mergedData.actorId, 'Audit actorId is required'),
+            actorType: assertDefinedPass(mergedData.actorType, 'Audit actorType is required'),
+            targetId: assertDefinedPass(mergedData.targetId, 'Audit targetId is required'),
+            targetType: assertDefinedPass(mergedData.targetType, 'Audit targetType is required'),
+            details: (objectKeys(mergedData.details).length > 0) ? mergedData.details : undefined,
+        });
+    }
+    async info(action, data) {
+        await this.log(action, {
+            ...data,
+            severity: AuditSeverity.Info,
+            outcome: data.outcome ?? AuditOutcome.Success,
+        });
+    }
+    async warn(action, data) {
+        await this.log(action, {
+            ...data,
+            severity: AuditSeverity.Warn,
+            outcome: data.outcome ?? AuditOutcome.Failure,
+        });
+    }
+    async error(action, data) {
+        await this.log(action, {
+            ...data,
+            severity: AuditSeverity.Error,
+            outcome: data.outcome ?? AuditOutcome.Failure,
+        });
+    }
+    async critical(action, data) {
+        await this.log(action, {
+            ...data,
+            severity: AuditSeverity.Critical,
+            outcome: data.outcome ?? AuditOutcome.Failure,
+        });
+    }
+};
+__decorate([
+    Memoize(),
+    __metadata("design:type", String),
+    __metadata("design:paramtypes", [])
+], Auditor.prototype, "moduleString", null);
+Auditor = Auditor_1 = __decorate([
+    Injectable()
+], Auditor);
+export { Auditor };
+function moduleFromArgument(argument) {
+    if (isString(argument)) {
+        return [argument];
+    }
+    if (isArray(argument)) {
+        return argument;
+    }
+    if (isObject(argument)) {
+        return moduleFromArgument(argument.module);
+    }
+    return [];
+}

package/audit/index.d.ts

@@ -0,0 +1,3 @@
+export * from './auditor.js';
+export * from './audit.model.js';
+export * from './types.js';

package/audit/index.js

@@ -0,0 +1,3 @@
+export * from './auditor.js';
+export * from './audit.model.js';
+export * from './types.js';

package/audit/types.d.ts

@@ -0,0 +1,22 @@
+import { type EnumType } from '../enumeration/index.js';
+export declare const AuditSeverity: {
+    readonly Info: "info";
+    readonly Warn: "warn";
+    readonly Error: "error";
+    readonly Critical: "critical";
+};
+export type AuditSeverity = EnumType<typeof AuditSeverity>;
+export declare const AuditOutcome: {
+    readonly Pending: "pending";
+    readonly Success: "success";
+    readonly Cancelled: "cancelled";
+    readonly Failure: "failure";
+    readonly Denied: "denied";
+};
+export type AuditOutcome = EnumType<typeof AuditOutcome>;
+export declare const ActorType: {
+    readonly User: "user";
+    readonly System: "system";
+    readonly ApiKey: "api-key";
+};
+export type ActorType = EnumType<typeof ActorType>;

package/audit/types.js

@@ -0,0 +1,19 @@
+import { defineEnum } from '../enumeration/index.js';
+export const AuditSeverity = defineEnum('AuditSeverity', {
+    Info: 'info',
+    Warn: 'warn',
+    Error: 'error',
+    Critical: 'critical',
+});
+export const AuditOutcome = defineEnum('AuditOutcome', {
+    Pending: 'pending',
+    Success: 'success',
+    Cancelled: 'cancelled',
+    Failure: 'failure',
+    Denied: 'denied',
+});
+export const ActorType = defineEnum('ActorType', {
+    User: 'user',
+    System: 'system',
+    ApiKey: 'api-key',
+});

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

@@ -1,5 +1,3 @@
-import type { AsyncDisposable } from '../../disposable/index.js';
-import { disposeAsync } from '../../disposable/index.js';
 import type { AfterResolve } from '../../injector/index.js';
 import { afterResolve } from '../../injector/index.js';
 import type { Record } from '../../types/index.js';
@@ -95,7 +93,7 @@ export declare class AuthenticationClientService<AdditionalTokenPayload extends
      */
     initialize(): void;
     /** @internal */
-    [disposeAsync](): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
     /**
      * Disposes the service.
      * Stops refresh loop and completes subjects.

package/authentication/client/authentication.service.js

@@ -9,7 +9,6 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { Subject, filter, firstValueFrom, race, timer } from 'rxjs';
 import { CancellationToken } from '../../cancellation/token.js';
-import { disposeAsync } from '../../disposable/index.js';
 import { BadRequestError } from '../../errors/bad-request.error.js';
 import { ForbiddenError } from '../../errors/forbidden.error.js';
 import { InvalidTokenError } from '../../errors/invalid-token.error.js';
@@ -162,7 +161,7 @@ let AuthenticationClientService = class AuthenticationClientService {
         void this.refreshLoop();
     }
     /** @internal */
-    async [disposeAsync]() {
+    async [Symbol.asyncDispose]() {
         await this.dispose();
     }
     /**
@@ -254,7 +253,7 @@ let AuthenticationClientService = class AuthenticationClientService {
         if (this.impersonated()) {
             throw new Error('Already impersonating. Please unimpersonate first.');
         }
-        await this.lock.use(lockTimeout, true, async () => {
+        await this.lock.use(lockTimeout, async () => {
             this.impersonatorAuthenticationData = this.authenticationData;
             this.authenticationData = data;
             try {
@@ -275,7 +274,7 @@ let AuthenticationClientService = class AuthenticationClientService {
      * @param data Additional authentication data. If not provided, the data from before impersonation is used.
      */
     async unimpersonate(data) {
-        await this.lock.use(lockTimeout, true, async () => {
+        await this.lock.use(lockTimeout, async () => {
             const newData = data ?? this.impersonatorAuthenticationData;
             try {
                 const token = await this.client.unimpersonate({ data: newData });
@@ -334,7 +333,7 @@ let AuthenticationClientService = class AuthenticationClientService {
         while (this.disposeToken.isUnset) {
             try {
                 // Use a non-blocking lock to ensure only one tab/instance runs the refresh logic at a time.
-                await this.lock.use(0, false, async () => await this.refreshLoopIteration());
+                await this.lock.tryUse(undefined, async () => await this.refreshLoopIteration());
                 // Calculate delay until the next refresh check.
                 // The buffer ensures we refresh *before* the token actually expires.
                 const delay = ((this.token()?.exp ?? 0) - this.estimatedServerTimestampSeconds() - refreshBufferSeconds) * millisecondsPerSecond;