@tstdl/base 0.92.155 → 0.92.156

package/ai/ai-file.service.js

@@ -164,7 +164,7 @@ let AiFileService = class AiFileService {
             contentType = blob.type;
             size = blob.size;
         }
-        this.#logger.verbose(`Uploading file "${id}" (${formatBytes(size)}) via GenAI API...`);
+        this.#logger.verbose(`Uploading file "${id}" (${formatBytes(size)})...`);
         // upload supports paths and blobs, but not streams (yet)
         const response = await this.#genAI.files.upload({ file: uploadData, config: { mimeType: contentType } });
         return {

package/api/server/gateway.d.ts

@@ -2,11 +2,9 @@ import 'urlpattern-polyfill';
 import type { HttpServerRequestContext } from '../../http/server/http-server.js';
 import { HttpServerResponse, type HttpServerRequest } from '../../http/server/index.js';
 import { resolveArgumentType, type Resolvable } from '../../injector/index.js';
-import { Logger } from '../../logger/index.js';
 import type { Type } from '../../types/index.js';
 import { type AsyncMiddleware, type AsyncMiddlewareNext } from '../../utils/middleware.js';
 import { type ApiController, type ApiDefinition, type ApiEndpointDefinition, type ApiEndpointMethod, type ApiEndpointServerImplementation } from '../types.js';
-import { ApiRequestTokenProvider } from './api-request-token.provider.js';
 import type { CorsMiddlewareOptions } from './middlewares/cors.middleware.js';
 export type ApiGatewayMiddlewareContext = {
     readonly api: ApiItem;
@@ -62,7 +60,7 @@ export declare class ApiGateway implements Resolvable<ApiGatewayOptions> {
     private readonly options;
     private composedMiddleware;
     readonly [resolveArgumentType]: ApiGatewayOptions;
-    constructor(requestTokenProvider: ApiRequestTokenProvider, logger: Logger, options?: ApiGatewayOptions);
+    constructor();
     addMiddleware(middleware: ApiGatewayMiddleware): void;
     supressErrors(...errorTypes: Type<Error>[]): void;
     registerApi<T extends ApiDefinition>(definition: ApiDefinition, implementation: ApiController<T>): void;

package/api/server/gateway.js

@@ -7,18 +7,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 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); }
-};
+var ApiGateway_1;
 import 'urlpattern-polyfill';
 import { BadRequestError } from '../../errors/bad-request.error.js';
 import { NotFoundError } from '../../errors/not-found.error.js';
 import { NotImplementedError } from '../../errors/not-implemented.error.js';
 import { HttpServerResponse } from '../../http/server/index.js';
-import { InjectArg, ResolveArg, Singleton, resolveArgumentType } from '../../injector/index.js';
+import { Singleton, inject, injectArgument, resolveArgumentType } from '../../injector/index.js';
 import { Logger } from '../../logger/index.js';
 import { Schema } from '../../schema/index.js';
 import { DataStreamSource } from '../../sse/data-stream-source.js';
+import { DataStream } from '../../sse/data-stream.js';
 import { ServerSentEventsSource } from '../../sse/server-sent-events-source.js';
 import { toArray } from '../../utils/array/array.js';
 import { composeAsyncMiddleware } from '../../utils/middleware.js';
@@ -51,25 +50,22 @@ export class ApiGatewayOptions {
      */
     defaultMaxBytes;
 }
-let ApiGateway = class ApiGateway {
-    requestTokenProvider;
-    logger;
+let ApiGateway = ApiGateway_1 = class ApiGateway {
+    requestTokenProvider = inject(ApiRequestTokenProvider);
+    logger = inject(Logger, ApiGateway_1.name);
     prefix;
     apis;
     middlewares;
     supressedErrors;
     catchErrorMiddleware;
-    options;
+    options = injectArgument(this, { optional: true }) ?? {};
     composedMiddleware;
-    constructor(requestTokenProvider, logger, options = {}) {
-        this.requestTokenProvider = requestTokenProvider;
-        this.logger = logger;
-        this.options = options;
-        this.prefix = isNull(options.prefix) ? null : (options.prefix ?? 'api');
+    constructor() {
+        this.prefix = isNull(this.options.prefix) ? null : (this.options.prefix ?? 'api');
         this.apis = new Map();
-        this.middlewares = options.middlewares ?? [];
-        this.supressedErrors = new Set(options.supressedErrors);
-        this.catchErrorMiddleware = getCatchErrorMiddleware(this.supressedErrors, logger);
+        this.middlewares = this.options.middlewares ?? [];
+        this.supressedErrors = new Set(this.options.supressedErrors);
+        this.catchErrorMiddleware = getCatchErrorMiddleware(this.supressedErrors, this.logger);
         this.updateMiddleware();
     }
     addMiddleware(middleware) {
@@ -193,20 +189,18 @@ let ApiGateway = class ApiGateway {
                 : isBlob(result) ? { stream: result.stream() }
                     : isReadableStream(result) ? { stream: result }
                         : (result instanceof ServerSentEventsSource) ? { events: result }
-                            : (result instanceof DataStreamSource) ? { events: result.eventSource }
+                            : (context.endpoint.definition.result == DataStream) ? { events: DataStreamSource.fromIterable(result).eventSource }
                                 : (context.endpoint.definition.result == String) ? { text: result }
                                     : { json: result };
         }
         await next();
     }
 };
-ApiGateway = __decorate([
+ApiGateway = ApiGateway_1 = __decorate([
     Singleton({
         defaultArgumentProvider: (context) => context.resolve(API_MODULE_OPTIONS).gatewayOptions,
     }),
-    __param(1, ResolveArg('ApiGateway')),
-    __param(2, InjectArg()),
-    __metadata("design:paramtypes", [ApiRequestTokenProvider, Logger, ApiGatewayOptions])
+    __metadata("design:paramtypes", [])
 ], ApiGateway);
 export { ApiGateway };
 async function getBody(request, options, schema) {

package/authentication/authentication.api.d.ts

@@ -23,7 +23,7 @@ export type AuthenticationApiDefinition<AdditionalTokenPayload extends Record =
 export declare const authenticationApiDefinition: {
     resource: string;
     endpoints: {
-        getToken: {
+        login: {
             resource: string;
             method: "POST";
             parameters: ObjectSchema<{
@@ -83,6 +83,17 @@ export declare const authenticationApiDefinition: {
                 [dontWaitForValidToken]: boolean;
             };
         };
+        changeSecret: {
+            resource: string;
+            method: "POST";
+            parameters: ObjectSchema<{
+                readonly subject: string;
+                readonly currentSecret: string;
+                readonly newSecret: string;
+            }>;
+            result: import("../schema/index.js").LiteralSchema<"ok">;
+            credentials: true;
+        };
         initSecretReset: {
             resource: string;
             method: "POST";
@@ -131,7 +142,7 @@ export declare const authenticationApiDefinition: {
 export declare function getAuthenticationApiDefinition<AdditionalTokenPayload extends Record, AuthenticationData, AdditionalInitSecretResetData, AdditionalEndpoints extends ApiEndpointsDefinition>(additionalTokenPayloadSchema: ObjectSchemaOrType<AdditionalTokenPayload>, authenticationDataSchema: SchemaTestable<AuthenticationData>, initSecretResetDataSchema: SchemaTestable<AdditionalInitSecretResetData>, resource?: string, additionalEndpoints?: AdditionalEndpoints): {
     resource: string;
     endpoints: {
-        getToken: {
+        login: {
             resource: string;
             method: "POST";
             parameters: ObjectSchema<{
@@ -191,6 +202,17 @@ export declare function getAuthenticationApiDefinition<AdditionalTokenPayload ex
                 [dontWaitForValidToken]: boolean;
             };
         };
+        changeSecret: {
+            resource: string;
+            method: "POST";
+            parameters: ObjectSchema<{
+                readonly subject: string;
+                readonly currentSecret: string;
+                readonly newSecret: string;
+            }>;
+            result: import("../schema/index.js").LiteralSchema<"ok">;
+            credentials: true;
+        };
         initSecretReset: {
             resource: string;
             method: "POST";
@@ -234,7 +256,7 @@ export declare function getAuthenticationApiDefinition<AdditionalTokenPayload ex
  * @template AdditionalInitSecretResetData Type of additional secret reset data
  */
 export declare function getAuthenticationApiEndpointsDefinition<AdditionalTokenPayload extends Record, AuthenticationData, AdditionalInitSecretResetData>(additionalTokenPayloadSchema: ObjectSchemaOrType<AdditionalTokenPayload>, authenticationDataSchema: SchemaTestable<AuthenticationData>, additionalInitSecretResetDataSchema: SchemaTestable<AdditionalInitSecretResetData>): {
-    getToken: {
+    login: {
         resource: string;
         method: "POST";
         parameters: ObjectSchema<{
@@ -294,6 +316,17 @@ export declare function getAuthenticationApiEndpointsDefinition<AdditionalTokenP
             [dontWaitForValidToken]: boolean;
         };
     };
+    changeSecret: {
+        resource: string;
+        method: "POST";
+        parameters: ObjectSchema<{
+            readonly subject: string;
+            readonly currentSecret: string;
+            readonly newSecret: string;
+        }>;
+        result: import("../schema/index.js").LiteralSchema<"ok">;
+        credentials: true;
+    };
     initSecretReset: {
         resource: string;
         method: "POST";

package/authentication/authentication.api.js

@@ -44,7 +44,7 @@ export function getAuthenticationApiDefinition(additionalTokenPayloadSchema, aut
 export function getAuthenticationApiEndpointsDefinition(additionalTokenPayloadSchema, authenticationDataSchema, additionalInitSecretResetDataSchema) {
     const tokenResultSchema = assign(TokenPayloadBase, additionalTokenPayloadSchema);
     return {
-        getToken: {
+        login: {
             resource: 'token',
             method: 'POST',
             parameters: explicitObject({
@@ -104,6 +104,17 @@ export function getAuthenticationApiEndpointsDefinition(additionalTokenPayloadSc
                 [dontWaitForValidToken]: true,
             },
         },
+        changeSecret: {
+            resource: 'secret/change',
+            method: 'POST',
+            parameters: explicitObject({
+                subject: string(),
+                currentSecret: string(),
+                newSecret: string(),
+            }),
+            result: literal('ok'),
+            credentials: true,
+        },
         initSecretReset: {
             resource: 'secret/init-reset',
             method: 'POST',

package/authentication/client/authentication.service.js

@@ -195,7 +195,7 @@ let AuthenticationClientService = class AuthenticationClientService {
         if (isDefined(data)) {
             this.setAdditionalData(data);
         }
-        const token = await this.client.getToken({ subject, secret, data: this.authenticationData });
+        const token = await this.client.login({ subject, secret, data: this.authenticationData });
         this.setNewToken(token);
     }
     /**

package/authentication/server/authentication.api-controller.d.ts

@@ -19,9 +19,8 @@ export declare class AuthenticationApiController<AdditionalTokenPayload extends
      * Get a token for a subject and secret.
      * @param parameters The parameters for the request.
      * @returns The token result.
-     * @throws {InvalidCredentialsError} If the credentials are invalid.
      */
-    getToken({ parameters }: ApiRequestContext<AuthenticationApiDefinition<AdditionalTokenPayload, AuthenticationData, AdditionalInitSecretResetData>, 'getToken'>): Promise<ApiServerResult<AuthenticationApiDefinition<AdditionalTokenPayload, AuthenticationData, AdditionalInitSecretResetData>, 'getToken'>>;
+    login({ parameters }: ApiRequestContext<AuthenticationApiDefinition<AdditionalTokenPayload, AuthenticationData, AdditionalInitSecretResetData>, 'login'>): Promise<ApiServerResult<AuthenticationApiDefinition<AdditionalTokenPayload, AuthenticationData, AdditionalInitSecretResetData>, 'login'>>;
     /**
      * Refresh a token.
      * @param request The request context.
@@ -49,6 +48,7 @@ export declare class AuthenticationApiController<AdditionalTokenPayload extends
      * @returns 'ok' if the session was ended.
      */
     endSession({ request }: ApiRequestContext<AuthenticationApiDefinition<AdditionalTokenPayload, AuthenticationData, AdditionalInitSecretResetData>, 'endSession'>): Promise<ApiServerResult<AuthenticationApiDefinition<AdditionalTokenPayload, AuthenticationData, AdditionalInitSecretResetData>, 'endSession'>>;
+    changeSecret({ parameters }: ApiRequestContext<AuthenticationApiDefinition<AdditionalTokenPayload, AuthenticationData, AdditionalInitSecretResetData>, 'changeSecret'>): Promise<ApiServerResult<AuthenticationApiDefinition<AdditionalTokenPayload, AuthenticationData, AdditionalInitSecretResetData>, 'changeSecret'>>;
     /**
      * Initialize a secret reset.
      * @param parameters The parameters for the request.

package/authentication/server/authentication.api-controller.js

@@ -8,7 +8,6 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { apiController } from '../../api/server/index.js';
-import { InvalidCredentialsError } from '../../errors/invalid-credentials.error.js';
 import { HttpServerResponse } from '../../http/server/index.js';
 import { currentTimestamp } from '../../utils/date-time.js';
 import { assertDefinedPass, isDefined } from '../../utils/type-guards.js';
@@ -33,14 +32,9 @@ let AuthenticationApiController = class AuthenticationApiController {
      * Get a token for a subject and secret.
      * @param parameters The parameters for the request.
      * @returns The token result.
-     * @throws {InvalidCredentialsError} If the credentials are invalid.
      */
-    async getToken({ parameters }) {
-        const authenticationResult = await this.authenticationService.authenticate(parameters.subject, parameters.secret);
-        if (!authenticationResult.success) {
-            throw new InvalidCredentialsError();
-        }
-        const result = await this.authenticationService.getToken(authenticationResult.subject, parameters.data);
+    async login({ parameters }) {
+        const result = await this.authenticationService.login(parameters.subject, parameters.secret, parameters.data);
         return this.getTokenResponse(result);
     }
     /**
@@ -112,6 +106,10 @@ let AuthenticationApiController = class AuthenticationApiController {
             },
         });
     }
+    async changeSecret({ parameters }) {
+        await this.authenticationService.changeSecret(parameters.subject, parameters.currentSecret, parameters.newSecret);
+        return 'ok';
+    }
     /**
      * Initialize a secret reset.
      * @param parameters The parameters for the request.

package/authentication/server/authentication.service.d.ts

@@ -130,6 +130,20 @@ type CreateRefreshTokenResult = {
  */
 export declare class AuthenticationService<AdditionalTokenPayload extends Record = Record<never>, AuthenticationData = void, AdditionalInitSecretResetData = void> implements AfterResolve {
     #private;
+    readonly hooks: {
+        beforeLogin: import("../../utils/async-hook/async-hook.js").AsyncHook<{
+            subject: string;
+        }, never, unknown>;
+        afterLogin: import("../../utils/async-hook/async-hook.js").AsyncHook<{
+            subject: string;
+        }, never, unknown>;
+        beforeChangeSecret: import("../../utils/async-hook/async-hook.js").AsyncHook<{
+            subject: string;
+        }, never, unknown>;
+        afterChangeSecret: import("../../utils/async-hook/async-hook.js").AsyncHook<{
+            subject: string;
+        }, never, unknown>;
+    };
     private readonly tokenVersion;
     private readonly tokenTimeToLive;
     private readonly refreshTokenTimeToLive;
@@ -148,7 +162,7 @@ export declare class AuthenticationService<AdditionalTokenPayload extends Record
     initialize(): Promise<void>;
     /**
      * Sets the credentials for a subject.
-     * This method should not be exposed to the public API without a secret reset token check.
+     * This method should not be exposed to the public API without an authenticated current password or secret reset token check.
      * @param subject The subject to set the credentials for.
      * @param secret The secret to set.
      * @param options Options for setting the credentials.
@@ -171,6 +185,14 @@ export declare class AuthenticationService<AdditionalTokenPayload extends Record
     getToken(subject: string, authenticationData: AuthenticationData, { impersonator }?: {
         impersonator?: string;
     }): Promise<TokenResult<AdditionalTokenPayload>>;
+    /**
+     * Logs in a subject.
+     * @param subject The subject to log in.
+     * @param secret The secret to log in with.
+     * @param data Additional authentication data.
+     * @returns Token
+     */
+    login(subject: string, secret: string, data: AuthenticationData): Promise<TokenResult<AdditionalTokenPayload>>;
     /**
      * Ends a session.
      * @param sessionId The id of the session to end.
@@ -205,12 +227,19 @@ export declare class AuthenticationService<AdditionalTokenPayload extends Record
      */
     unimpersonate(impersonatorRefreshToken: string, authenticationData: AuthenticationData): Promise<TokenResult<AdditionalTokenPayload>>;
     /**
-     * Initializes a secret reset.
+     * Initializes a secret reset. This usually involves sending an email for verification.
      * @param subject The subject to reset the secret for.
      * @param data Additional data for the secret reset.
      * @throws {NotImplementedError} If no ancillary service is registered.
      */
     initSecretReset(subject: string, data: AdditionalInitSecretResetData): Promise<void>;
+    /**
+     * Changes a subject's secret.
+     * @param subject The subject to change the secret for.
+     * @param currentSecret The current secret.
+     * @param newSecret The new secret.
+     */
+    changeSecret(subject: string, currentSecret: string, newSecret: string): Promise<void>;
     /**
      * Resets a secret.
      * @param tokenString The secret reset token.

package/authentication/server/authentication.service.js

@@ -5,6 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { ForbiddenError } from '../../errors/forbidden.error.js';
+import { InvalidCredentialsError } from '../../errors/index.js';
 import { InvalidTokenError } from '../../errors/invalid-token.error.js';
 import { NotFoundError } from '../../errors/not-found.error.js';
 import { NotImplementedError } from '../../errors/not-implemented.error.js';
@@ -14,6 +15,7 @@ import { Logger } from '../../logger/logger.js';
 import { DatabaseConfig } from '../../orm/server/index.js';
 import { EntityRepositoryConfig, injectRepository } from '../../orm/server/repository.js';
 import { Alphabet } from '../../utils/alphabet.js';
+import { asyncHook } from '../../utils/async-hook/async-hook.js';
 import { decodeBase64, encodeBase64 } from '../../utils/base64.js';
 import { deriveBytesMultiple, importPbkdf2Key } from '../../utils/cryptography.js';
 import { currentTimestamp, timestampToTimestampSeconds } from '../../utils/date-time.js';
@@ -84,6 +86,12 @@ let AuthenticationService = class AuthenticationService {
     #keyValueStore = inject((KeyValueStore), 'authentication');
     #options = inject(AuthenticationServiceOptions);
     #logger = inject(Logger, 'authentication');
+    hooks = {
+        beforeLogin: asyncHook(),
+        afterLogin: asyncHook(),
+        beforeChangeSecret: asyncHook(),
+        afterChangeSecret: asyncHook(),
+    };
     tokenVersion = this.#options.version ?? 1;
     tokenTimeToLive = this.#options.tokenTimeToLive ?? (5 * millisecondsPerMinute);
     refreshTokenTimeToLive = this.#options.refreshTokenTimeToLive ?? (5 * millisecondsPerDay);
@@ -113,7 +121,7 @@ let AuthenticationService = class AuthenticationService {
     }
     /**
      * Sets the credentials for a subject.
-     * This method should not be exposed to the public API without a secret reset token check.
+     * This method should not be exposed to the public API without an authenticated current password or secret reset token check.
      * @param subject The subject to set the credentials for.
      * @param secret The secret to set.
      * @param options Options for setting the credentials.
@@ -190,6 +198,23 @@ let AuthenticationService = class AuthenticationService {
             return { token, jsonToken, refreshToken: refreshToken.token };
         });
     }
+    /**
+     * Logs in a subject.
+     * @param subject The subject to log in.
+     * @param secret The secret to log in with.
+     * @param data Additional authentication data.
+     * @returns Token
+     */
+    async login(subject, secret, data) {
+        const authenticationResult = await this.authenticate(subject, secret);
+        if (!authenticationResult.success) {
+            throw new InvalidCredentialsError();
+        }
+        await this.hooks.afterLogin.trigger({ subject: authenticationResult.subject });
+        const token = await this.getToken(authenticationResult.subject, data);
+        await this.hooks.afterLogin.trigger({ subject: authenticationResult.subject });
+        return token;
+    }
     /**
      * Ends a session.
      * @param sessionId The id of the session to end.
@@ -264,14 +289,14 @@ let AuthenticationService = class AuthenticationService {
         return await this.refresh(impersonatorRefreshToken, authenticationData, { omitImpersonator: true });
     }
     /**
-     * Initializes a secret reset.
+     * Initializes a secret reset. This usually involves sending an email for verification.
      * @param subject The subject to reset the secret for.
      * @param data Additional data for the secret reset.
      * @throws {NotImplementedError} If no ancillary service is registered.
      */
     async initSecretReset(subject, data) {
         if (isUndefined(this.#authenticationAncillaryService)) {
-            throw new NotImplementedError();
+            throw new NotImplementedError('No ancillary service registered.');
         }
         const actualSubject = await this.tryResolveSubject(subject);
         if (isUndefined(actualSubject)) {
@@ -291,6 +316,21 @@ let AuthenticationService = class AuthenticationService {
         };
         await this.#authenticationAncillaryService.handleInitSecretReset(initSecretResetData);
     }
+    /**
+     * Changes a subject's secret.
+     * @param subject The subject to change the secret for.
+     * @param currentSecret The current secret.
+     * @param newSecret The new secret.
+     */
+    async changeSecret(subject, currentSecret, newSecret) {
+        const authenticationResult = await this.authenticate(subject, currentSecret);
+        if (!authenticationResult.success) {
+            throw new ForbiddenError('Invalid credentials.');
+        }
+        await this.hooks.beforeChangeSecret.trigger({ subject });
+        await this.setCredentials(subject, newSecret);
+        await this.hooks.afterChangeSecret.trigger({ subject });
+    }
     /**
      * Resets a secret.
      * @param tokenString The secret reset token.

package/browser/browser.service.d.ts

@@ -26,7 +26,6 @@ export declare class BrowserService implements AsyncDisposable, Resolvable<Brows
     private readonly persistentBrowserContexts;
     readonly options: BrowserServiceOptions | undefined;
     readonly [resolveArgumentType]: BrowserServiceArgument;
-    constructor(options?: BrowserServiceOptions);
     [disposeAsync](): Promise<void>;
     /**
      * @deprecated internal use only

package/browser/browser.service.js

@@ -4,14 +4,9 @@ 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 { disposeAsync } from '../disposable/disposable.js';
-import { InjectArg, Singleton } from '../injector/decorators.js';
+import { Singleton } from '../injector/decorators.js';
+import { injectArgument } from '../injector/inject.js';
 import { filterUndefinedFromRecord } from '../utils/object/object.js';
 import { isDefined } from '../utils/type-guards.js';
 import { BrowserContextController } from './browser-context-controller.js';
@@ -22,16 +17,11 @@ export class BrowserServiceOptions {
     defaultNewBrowserOptions;
 }
 let BrowserService = class BrowserService {
-    browsers;
-    persistentBrowserContexts;
-    options;
-    constructor(options) {
-        this.options = options;
-        this.browsers = new Set();
-        this.persistentBrowserContexts = new Set();
-    }
+    browsers = new Set();
+    persistentBrowserContexts = new Set();
+    options = injectArgument(this, { optional: true });
     async [disposeAsync]() {
-        return this.dispose();
+        await this.dispose();
     }
     /**
      * @deprecated internal use only
@@ -89,8 +79,6 @@ let BrowserService = class BrowserService {
     }
 };
 BrowserService = __decorate([
-    Singleton(),
-    __param(0, InjectArg()),
-    __metadata("design:paramtypes", [BrowserServiceOptions])
+    Singleton()
 ], BrowserService);
 export { BrowserService };

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

@@ -79,9 +79,9 @@ import { DocumentFileService } from './document-file.service.js';
 import { DocumentPropertyService } from './document-property.service.js';
 import { DocumentTagService } from './document-tag.service.js';
 import { DocumentManagementSingleton } from './singleton.js';
-const CLASSIFY_MODEL = 'gemini-2.5-flash-lite-preview-06-17';
+const CLASSIFY_MODEL = 'gemini-2.5-flash-lite';
 const EXTRACT_MODEL = 'gemini-2.5-flash';
-const ASSIGN_MODEL = 'gemini-2.5-flash-lite-preview-06-17';
+const ASSIGN_MODEL = 'gemini-2.5-flash-lite';
 let DocumentManagementAiService = DocumentManagementAiService_1 = class DocumentManagementAiService {
     #documentCollectionService = inject(DocumentCollectionService);
     #documentTagService = inject(DocumentTagService);

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

@@ -4,7 +4,7 @@ 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;
 };
-import { and, isNotNull as drizzleIsNotNull, isNull as drizzleIsNull, eq, inArray, or } from 'drizzle-orm';
+import { and, isNotNull as drizzleIsNotNull, isNull as drizzleIsNull, eq, inArray, or, sql } from 'drizzle-orm';
 import { BadRequestError } from '../../../errors/bad-request.error.js';
 import { NotFoundError } from '../../../errors/not-found.error.js';
 import { inject } from '../../../injector/index.js';
@@ -39,7 +39,7 @@ let DocumentPropertyService = class DocumentPropertyService extends Transactiona
         propertyTenantId: autoAlias(documentProperty.tenantId),
         label: documentProperty.label,
         dataType: documentProperty.dataType,
-        value: coalesce(toJsonb(documentPropertyValue.text), toJsonb(documentPropertyValue.integer), toJsonb(documentPropertyValue.decimal), toJsonb(documentPropertyValue.boolean), toJsonb(documentPropertyValue.date)).as('value'),
+        value: coalesce(toJsonb(documentPropertyValue.text), toJsonb(documentPropertyValue.integer), toJsonb(documentPropertyValue.decimal), toJsonb(documentPropertyValue.boolean), toJsonb(sql `${documentPropertyValue.date} - '1970-01-01'`)).as('value'),
     })
         .from(document)
         .innerJoin(documentType, and(eq(documentType.id, document.typeId), or(drizzleIsNull(documentType.tenantId), eq(documentType.tenantId, document.tenantId))))
@@ -117,7 +117,7 @@ let DocumentPropertyService = class DocumentPropertyService extends Transactiona
             });
             const deletePropertyIds = propertyValues.filter((value) => isNull(value.value)).map(({ propertyId }) => propertyId);
             await this.#documentPropertyValueRepository.withTransaction(tx).hardDeleteManyByQuery({ tenantId: document.tenantId, documentId: document.id, propertyId: { $in: deletePropertyIds } });
-            await this.#documentPropertyValueRepository.withTransaction(tx).upsertMany(['documentId', 'propertyId'], upserts);
+            await this.#documentPropertyValueRepository.withTransaction(tx).upsertMany(['tenantId', 'documentId', 'propertyId'], upserts);
             this.#observationService.documentChange(document.id, tx);
         });
     }

package/document-management/server/validators/ai-validation-executor.js

@@ -21,7 +21,7 @@ let AiValidationExecutor = class AiValidationExecutor extends DocumentValidation
     async execute(context) {
         const validationPrompt = await this.getPrompt(context);
         const model = match(this.difficulty)
-            .with('easy', () => 'gemini-2.5-flash-lite-preview-06-17')
+            .with('easy', () => 'gemini-2.5-flash-lite')
             .with('medium-low', () => 'gemini-2.5-flash')
             .with('medium-high', () => 'gemini-2.5-flash')
             .with('hard', () => 'gemini-2.5-pro')

package/document-management/service-models/enriched/enriched-document.view.d.ts

@@ -3,6 +3,7 @@ import type { TypedOmit } from '../../../types/index.js';
 import type { DocumentApproval, DocumentTag, DocumentValidationExecution, DocumentWorkflow } from '../../models/index.js';
 import type { DocumentPropertyValueView, DocumentView } from '../document-management.view-model.js';
 import { EnrichedDocumentAssignment } from './enriched-document-assignment.view.js';
+import type { EnrichedDocumentCategory } from './enriched-document-category.view.js';
 import type { EnrichedDocumentManagementData } from './enriched-document-management-data.view.js';
 import type { EnrichedDocumentType } from './enriched-document-type.view.js';
 export declare class EnrichedDocument implements TypedOmit<DocumentView, 'typeId' | 'assignment' | 'tagIds' | 'createUserId'> {
@@ -23,6 +24,7 @@ export declare class EnrichedDocument implements TypedOmit<DocumentView, 'typeId
     readonly workflows: DocumentWorkflow[];
     readonly validations: DocumentValidationExecution[];
     readonly metadata: EntityMetadata;
+    get category(): EnrichedDocumentCategory | null;
     get type(): EnrichedDocumentType | null;
     get assignments(): EnrichedDocumentAssignment;
     get tags(): DocumentTag[];

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

@@ -29,6 +29,9 @@ export class EnrichedDocument {
     workflows;
     validations;
     metadata;
+    get category() {
+        return this.type?.category ?? null;
+    }
     get type() {
         if (isNull(this.#documentView.typeId)) {
             return null;
@@ -74,6 +77,11 @@ export class EnrichedDocument {
         this.metadata = document.metadata;
     }
 }
+__decorate([
+    Memoize(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EnrichedDocument.prototype, "category", null);
 __decorate([
     Memoize(),
     __metadata("design:type", Object),

package/message-bus/broadcast-channel/broadcast-channel-message-bus-provider.d.ts

@@ -1,8 +1,6 @@
-import { Logger } from '../../logger/index.js';
 import type { MessageBusProvider } from '../message-bus-provider.js';
 import type { MessageBus } from '../message-bus.js';
 export declare class BroadcastChannelMessageBusProvider implements MessageBusProvider {
     private readonly logger;
-    constructor(logger: Logger);
     get<T>(channel: string): MessageBus<T>;
 }

package/message-bus/broadcast-channel/broadcast-channel-message-bus-provider.js

@@ -4,27 +4,17 @@ 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 { Injectable, ResolveArg } from '../../injector/index.js';
+var BroadcastChannelMessageBusProvider_1;
+import { inject, Injectable } from '../../injector/index.js';
 import { Logger } from '../../logger/index.js';
 import { BroadcastChannelMessageBus } from './broadcast-channel-message-bus.js';
-let BroadcastChannelMessageBusProvider = class BroadcastChannelMessageBusProvider {
-    logger;
-    constructor(logger) {
-        this.logger = logger;
-    }
+let BroadcastChannelMessageBusProvider = BroadcastChannelMessageBusProvider_1 = class BroadcastChannelMessageBusProvider {
+    logger = inject(Logger, BroadcastChannelMessageBusProvider_1.name);
     get(channel) {
         return new BroadcastChannelMessageBus(() => new BroadcastChannel(channel), this.logger);
     }
 };
-BroadcastChannelMessageBusProvider = __decorate([
-    Injectable(),
-    __param(0, ResolveArg('BroadcastChannelMessageBusProvider')),
-    __metadata("design:paramtypes", [Logger])
+BroadcastChannelMessageBusProvider = BroadcastChannelMessageBusProvider_1 = __decorate([
+    Injectable()
 ], BroadcastChannelMessageBusProvider);
 export { BroadcastChannelMessageBusProvider };

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

@@ -1,9 +1,7 @@
-import { Logger } from '../../logger/index.js';
 import { MessageBusProvider } from '../message-bus-provider.js';
 import { LocalMessageBus } from './local-message-bus.js';
 export declare class LocalMessageBusProvider extends MessageBusProvider {
     private readonly logger;
     private readonly channelSubjectsMap;
-    constructor(logger: Logger);
     get<T>(channel: string): LocalMessageBus<T>;
 }

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

@@ -4,28 +4,18 @@ 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); }
-};
+var LocalMessageBusProvider_1;
 import { Subject } from 'rxjs';
 import { WeakRefMap } from '../../data-structures/weak-ref-map.js';
-import { ResolveArg, Singleton } from '../../injector/index.js';
+import { inject, Singleton } from '../../injector/index.js';
 import { Logger } from '../../logger/index.js';
 import { FactoryMap } from '../../utils/factory-map.js';
 import { isUndefined } from '../../utils/type-guards.js';
 import { MessageBusProvider } from '../message-bus-provider.js';
 import { LocalMessageBus } from './local-message-bus.js';
-let LocalMessageBusProvider = class LocalMessageBusProvider extends MessageBusProvider {
-    logger;
-    channelSubjectsMap;
-    constructor(logger) {
-        super();
-        this.logger = logger;
-        this.channelSubjectsMap = new FactoryMap(() => new Subject(), WeakRefMap.supported ? new WeakRefMap() : undefined);
-    }
+let LocalMessageBusProvider = LocalMessageBusProvider_1 = class LocalMessageBusProvider extends MessageBusProvider {
+    logger = inject(Logger, LocalMessageBusProvider_1.name);
+    channelSubjectsMap = new FactoryMap(() => new Subject(), WeakRefMap.supported ? new WeakRefMap() : undefined);
     get(channel) {
         const subject = this.channelSubjectsMap.get(channel);
         if (isUndefined(subject)) {
@@ -35,9 +25,7 @@ let LocalMessageBusProvider = class LocalMessageBusProvider extends MessageBusPr
         return new LocalMessageBus(subject, this.logger);
     }
 };
-LocalMessageBusProvider = __decorate([
-    Singleton(),
-    __param(0, ResolveArg('LocalMessageBus')),
-    __metadata("design:paramtypes", [Logger])
+LocalMessageBusProvider = LocalMessageBusProvider_1 = __decorate([
+    Singleton()
 ], LocalMessageBusProvider);
 export { LocalMessageBusProvider };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.155",
+  "version": "0.92.156",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -148,8 +148,8 @@
   },
   "peerDependencies": {
     "@elastic/elasticsearch": "^9.1",
-    "@google-cloud/storage": "^7.16",
-    "@google/genai": "^1.14",
+    "@google-cloud/storage": "^7.17",
+    "@google/genai": "^1.15",
     "@tstdl/angular": "^0.92",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",
@@ -196,7 +196,7 @@
     "typedoc-plugin-markdown": "4.8",
     "typedoc-plugin-missing-exports": "4.1",
     "typescript": "5.8",
-    "typescript-eslint": "8.39"
+    "typescript-eslint": "8.40"
   },
   "overrides": {
     "drizzle-kit": {

package/queue/mongo/mongo-job.repository.js

@@ -20,7 +20,7 @@ const indexes = [
     { key: { queue: 1, priority: 1, enqueueTimestamp: 1, lastDequeueTimestamp: 1, tries: 1 } },
     { key: { queue: 1, tag: 1 } },
     { key: { queue: 1, batch: 1 } },
-    { key: { queue: 1, tries: 1 } }
+    { key: { queue: 1, tries: 1 } },
 ];
 let MongoJobRepository = class MongoJobRepository extends MongoEntityRepository {
     constructor(collection, logger) {
@@ -31,7 +31,7 @@ let MongoJobRepository = class MongoJobRepository extends MongoEntityRepository
         const updateQuery = (uniqueTagStrategy == UniqueTagStrategy.KeepOld)
             ? { $setOnInsert: { _id: getNewId(), ...rest } }
             : { $set: rest, $setOnInsert: { _id: getNewId() } };
-        return this.baseRepository.loadByFilterAndUpdate({ queue, tag }, updateQuery, { upsert: true, returnDocument: 'after' });
+        return await this.baseRepository.loadByFilterAndUpdate({ queue, tag }, updateQuery, { upsert: true, returnDocument: 'after' });
     }
     async bulkInsertWithUniqueTagStrategy(newJobs, uniqueTagStrategy) {
         const bulk = this.baseRepository.bulk();

package/queue/mongo/queue.provider.d.ts

@@ -1,17 +1,13 @@
 import type { CollectionArgument, MongoRepositoryConfig } from '../../database/mongo/index.js';
-import { resolveArgumentType, type Resolvable } from '../../injector/interfaces.js';
-import { LockProvider } from '../../lock/index.js';
-import { MessageBusProvider } from '../../message-bus/index.js';
+import { resolveArgumentType, type Resolvable } from '../../injector/index.js';
 import { QueueProvider, type QueueConfig } from '../../queue/index.js';
 import type { MongoJob } from './job.js';
-import { MongoJobRepository } from './mongo-job.repository.js';
 import { MongoQueue } from './queue.js';
 export declare class MongoQueueProvider extends QueueProvider implements Resolvable<CollectionArgument<MongoJob>> {
     private readonly repository;
     private readonly lockProvider;
     private readonly messageBusProvider;
     readonly [resolveArgumentType]: CollectionArgument<MongoJob>;
-    constructor(repository: MongoJobRepository<any>, lockProvider: LockProvider, messageBusProvider: MessageBusProvider);
     get<T>(name: string, config?: QueueConfig): MongoQueue<T>;
 }
 /**

package/queue/mongo/queue.provider.js

@@ -4,15 +4,7 @@ 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 { ForwardArg, ResolveArg, Singleton } from '../../injector/decorators.js';
-import { Injector } from '../../injector/injector.js';
-import { resolveArgumentType } from '../../injector/interfaces.js';
+import { inject, injectArgument, Injector, resolveArgumentType, Singleton } from '../../injector/index.js';
 import { LockProvider } from '../../lock/index.js';
 import { MessageBusProvider } from '../../message-bus/index.js';
 import { Queue, QueueProvider } from '../../queue/index.js';
@@ -20,25 +12,16 @@ import { MongoJobRepository } from './mongo-job.repository.js';
 import { MongoQueue } from './queue.js';
 let defaultJobRepositoryConfig;
 let MongoQueueProvider = class MongoQueueProvider extends QueueProvider {
-    repository;
-    lockProvider;
-    messageBusProvider;
-    constructor(repository, lockProvider, messageBusProvider) {
-        super();
-        this.repository = repository;
-        this.lockProvider = lockProvider;
-        this.messageBusProvider = messageBusProvider;
-    }
+    repository = inject((MongoJobRepository), injectArgument(this));
+    lockProvider = inject(LockProvider, 'queue:');
+    messageBusProvider = inject(MessageBusProvider);
     get(name, config) {
         const lock = this.lockProvider.get(name);
         return new MongoQueue(this.repository, lock, this.messageBusProvider, name, config);
     }
 };
 MongoQueueProvider = __decorate([
-    Singleton({ defaultArgumentProvider: () => defaultJobRepositoryConfig }),
-    __param(0, ForwardArg()),
-    __param(1, ResolveArg('queue:')),
-    __metadata("design:paramtypes", [MongoJobRepository, LockProvider, MessageBusProvider])
+    Singleton({ defaultArgumentProvider: () => defaultJobRepositoryConfig })
 ], MongoQueueProvider);
 export { MongoQueueProvider };
 /**

package/templates/module.js

@@ -9,7 +9,7 @@ import { TEMPLATE_RENDERERS, TEMPLATE_RESOLVERS } from './tokens.js';
 export const templateModuleConfig = {
     templateProvider: undefined,
     templateResolvers: [StringTemplateResolver],
-    templateRenderers: [StringTemplateRenderer]
+    templateRenderers: [StringTemplateRenderer],
 };
 Injector.registerSingleton(TEMPLATE_RESOLVERS, { useToken: TemplateResolver, resolveAll: true });
 Injector.registerSingleton(TEMPLATE_RENDERERS, { useToken: TemplateRenderer, resolveAll: true });

package/templates/template-renderer.provider.d.ts

@@ -1,7 +1,6 @@
 import type { TemplateRenderer } from './template.renderer.js';
 export declare class TemplateRendererProvider {
     private readonly renderers;
-    constructor(renderers?: TemplateRenderer[]);
     register(renderer: TemplateRenderer): void;
     has(type: string): boolean;
     get(type: string): TemplateRenderer;

package/templates/template-renderer.provider.js

@@ -4,19 +4,10 @@ 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 { Inject, Optional, Singleton } from '../injector/decorators.js';
+import { inject, Singleton } from '../injector/index.js';
 import { TEMPLATE_RENDERERS } from './tokens.js';
 let TemplateRendererProvider = class TemplateRendererProvider {
-    renderers;
-    constructor(renderers = []) {
-        this.renderers = new Set(renderers);
-    }
+    renderers = new Set(inject(TEMPLATE_RENDERERS, undefined, { optional: true }) ?? []);
     register(renderer) {
         this.renderers.add(renderer);
     }
@@ -38,9 +29,6 @@ let TemplateRendererProvider = class TemplateRendererProvider {
     }
 };
 TemplateRendererProvider = __decorate([
-    Singleton(),
-    __param(0, Inject(TEMPLATE_RENDERERS)),
-    __param(0, Optional()),
-    __metadata("design:paramtypes", [Array])
+    Singleton()
 ], TemplateRendererProvider);
 export { TemplateRendererProvider };

package/templates/template-resolver.provider.d.ts

@@ -1,7 +1,6 @@
 import type { TemplateResolver } from './template.resolver.js';
 export declare class TemplateResolverProvider {
     private readonly resolvers;
-    constructor(resolvers?: TemplateResolver[]);
     register(renderer: TemplateResolver): void;
     has(type: string): boolean;
     get(type: string): TemplateResolver;

package/templates/template-resolver.provider.js

@@ -4,19 +4,10 @@ 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 { Inject, Optional, Singleton } from '../injector/decorators.js';
+import { inject, Singleton } from '../injector/index.js';
 import { TEMPLATE_RESOLVERS } from './tokens.js';
 let TemplateResolverProvider = class TemplateResolverProvider {
-    resolvers;
-    constructor(resolvers = []) {
-        this.resolvers = new Set(resolvers);
-    }
+    resolvers = new Set(inject(TEMPLATE_RESOLVERS, undefined, { optional: true }) ?? []);
     register(renderer) {
         this.resolvers.add(renderer);
     }
@@ -38,9 +29,6 @@ let TemplateResolverProvider = class TemplateResolverProvider {
     }
 };
 TemplateResolverProvider = __decorate([
-    Singleton(),
-    __param(0, Inject(TEMPLATE_RESOLVERS)),
-    __param(0, Optional()),
-    __metadata("design:paramtypes", [Array])
+    Singleton()
 ], TemplateResolverProvider);
 export { TemplateResolverProvider };

package/templates/template.service.d.ts

@@ -1,8 +1,5 @@
 import type { Record } from '../types/index.js';
-import { TemplateRendererProvider } from './template-renderer.provider.js';
-import { TemplateResolverProvider } from './template-resolver.provider.js';
 import type { Template, TemplateContext } from './template.model.js';
-import { TemplateProvider } from './template.provider.js';
 export type TemplateServiceRenderResult<T extends Template = Template> = {
     name: string;
     fields: Record<keyof T['fields'], string>;
@@ -12,7 +9,6 @@ export declare class TemplateService {
     private readonly templateProvider;
     private readonly templateRendererProvider;
     private readonly templateResolverProvider;
-    constructor(templateProvider: TemplateProvider | undefined, templateRendererProvider: TemplateRendererProvider, templateResolverProvider: TemplateResolverProvider);
     get<T extends Template = Template>(key: string): Promise<T>;
     render<T extends Template = Template>(keyOrTemplate: string | T, templateContext?: TemplateContext<T>): Promise<TemplateServiceRenderResult<T>>;
 }

package/templates/template.service.js

@@ -4,13 +4,8 @@ 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 { Inject, Optional, Singleton } from '../injector/decorators.js';
+import { Singleton } from '../injector/decorators.js';
+import { inject } from '../injector/inject.js';
 import { objectEntries } from '../utils/object/object.js';
 import { _throw } from '../utils/throw.js';
 import { isString } from '../utils/type-guards.js';
@@ -18,14 +13,9 @@ import { TemplateRendererProvider } from './template-renderer.provider.js';
 import { TemplateResolverProvider } from './template-resolver.provider.js';
 import { TemplateProvider } from './template.provider.js';
 let TemplateService = class TemplateService {
-    templateProvider;
-    templateRendererProvider;
-    templateResolverProvider;
-    constructor(templateProvider, templateRendererProvider, templateResolverProvider) {
-        this.templateProvider = templateProvider ?? { get: () => _throw(new Error('No template provider provided. Cannot render template-keys.')) };
-        this.templateRendererProvider = templateRendererProvider;
-        this.templateResolverProvider = templateResolverProvider;
-    }
+    templateProvider = inject(TemplateProvider, undefined, { optional: true }) ?? { get: () => _throw(new Error('No template provider provided. Cannot render template-keys.')) };
+    templateRendererProvider = inject(TemplateRendererProvider);
+    templateResolverProvider = inject(TemplateResolverProvider);
     async get(key) {
         const template = await this.templateProvider.get(key);
         return template;
@@ -48,10 +38,6 @@ let TemplateService = class TemplateService {
     }
 };
 TemplateService = __decorate([
-    Singleton(),
-    __param(0, Inject(TemplateProvider)),
-    __param(0, Optional()),
-    __metadata("design:paramtypes", [Object, TemplateRendererProvider,
-        TemplateResolverProvider])
+    Singleton()
 ], TemplateService);
 export { TemplateService };

package/text/localization.service.d.ts

@@ -1,5 +1,4 @@
 import type { Observable } from 'rxjs';
-import { Logger } from '../logger/index.js';
 import type { Signal } from '../signals/api.js';
 import type { Enumeration, EnumerationValue, Record } from '../types/index.js';
 import type { PropertyName } from '../utils/object/property-name.js';
@@ -69,7 +68,6 @@ export declare class LocalizationService {
     readonly availableLanguages: Signal<Language[]>;
     readonly activeLanguage$: Observable<Language | null>;
     readonly availableLanguages$: Observable<Language[]>;
-    constructor(logger: Logger);
     registerLocalization(...localizations: Localization[]): void;
     hasLanguage(languageCode: string): boolean;
     getLanguage(languageCode: string): Language;

package/text/localization.service.js

@@ -4,14 +4,10 @@ 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); }
-};
+var _a;
+var LocalizationService_1;
 import { DetailsError } from '../errors/details.error.js';
-import { ResolveArg, Singleton } from '../injector/decorators.js';
+import { inject, Singleton } from '../injector/index.js';
 import { Logger } from '../logger/index.js';
 import { computed, signal, toObservable } from '../signals/api.js';
 import { enumEntries, enumValueName } from '../utils/enum.js';
@@ -48,8 +44,8 @@ export function getLocalizationKeys(_localization) {
 export const autoEnumerationLocalization = memoize(_autoEnumerationLocalization);
 const parametersPattern = /(?:\{\{\s*(?<parameter>\w+)\s*\}\})/ug;
 const warnedMissingKeys = new Set();
-let LocalizationService = class LocalizationService {
-    #logger;
+let LocalizationService = LocalizationService_1 = class LocalizationService {
+    #logger = inject(Logger, LocalizationService_1.name);
     #localizations = new Map();
     #activeLanguage = signal(null);
     #availableLanguages = signal([]);
@@ -64,9 +60,6 @@ let LocalizationService = class LocalizationService {
     availableLanguages = this.#availableLanguages.asReadonly();
     activeLanguage$ = toObservable(this.activeLanguage);
     availableLanguages$ = toObservable(this.availableLanguages);
-    constructor(logger) {
-        this.#logger = logger;
-    }
     registerLocalization(...localizations) {
         for (const localization of localizations) {
             const mappedLocalization = buildMappedLocalization(localization);
@@ -180,10 +173,8 @@ let LocalizationService = class LocalizationService {
         return result;
     }
 };
-LocalizationService = __decorate([
-    Singleton(),
-    __param(0, ResolveArg('LocalizationService')),
-    __metadata("design:paramtypes", [Logger])
+LocalizationService = LocalizationService_1 = __decorate([
+    Singleton()
 ], LocalizationService);
 export { LocalizationService };
 export function enumerationLocalization(enumeration, nameOrLocalization, localizationOrNothing) {