zibri 2.2.1 → 2.4.0

package/src/di/decorators/injectable.decorator.ts

@@ -1,21 +1,44 @@
 import { GlobalRegistry } from '../../global/global-registry';
 import { Newable } from '../../types/newable.type';
 import { MetadataUtilities } from '../../utilities/metadata.utilities';
+import { DiProvider } from '../models/di-provider.model';
 import { DiToken } from '../models/di-token.model';
 
+/**
+ * Options for the \@injectable decorator.
+ */
+export type InjectableOptions<T> = {
+    /**
+     * An optional token where the marked class should be registered under instead of the class.
+     */
+    token?: DiToken<T>,
+    /**
+     * When the injectable should be registered. Defaults to 'immediately'.
+     */
+    register?: 'immediately' | 'onUse'
+};
+
 /**
  * Marks a class to be injectable.
- * @param token - An optional token where the marked class should be registered under instead of the class.
+ * @param options - Options for the injectable.
  */
-export function Injectable<T>(token?: DiToken<T>): ClassDecorator {
+export function Injectable<T>(options: InjectableOptions<T> = {}): ClassDecorator {
+    const { register = 'immediately', token } = options;
+
     return target => {
         MetadataUtilities.setDiToken(target, token);
         // eslint-disable-next-line unicorn/error-message
         const stack: string = new Error().stack ?? '';
         MetadataUtilities.setFilePath(target, stack);
-        GlobalRegistry.injectables.push({
+
+        const provider: DiProvider<T> = {
             token: (token ?? target) as DiToken<T>,
-            useClass: target as unknown as Newable<unknown>
-        });
+            useClass: target as unknown as Newable<T>
+        };
+        if (register === 'immediately') {
+            GlobalRegistry.injectables.push(provider);
+            return;
+        }
+        GlobalRegistry.lazyInjectables.push(provider);
     };
 }

package/src/di/default/zibri-di-providers.default.ts

@@ -9,13 +9,22 @@ import { ZIBRI_DI_TOKENS } from './zibri-di-tokens.default';
 import { AssetService } from '../../assets/asset.service';
 import { TwoFactorService } from '../../auth/2fa/two-factor.service';
 import { AuthService } from '../../auth/auth.service';
+import { EncryptionService } from '../../auth/encryption/encryption.service';
+import { AesGcmEncryptionStrategy } from '../../auth/encryption/strategies/aes-gcm.encryption-strategy';
+import { HashService } from '../../auth/hash/hash.service';
+import { BcryptHashStrategy } from '../../auth/hash/strategies/bcrypt.hash-strategy';
 import { UserService } from '../../auth/user/user.service';
 import { BackupService } from '../../backup/backup.service';
+import { CacheService } from '../../caching/cache.service';
+import { AlsUtilities } from '../../context/als.utilities';
+import { HttpRequestContext } from '../../context/request/http-request.context';
+import { ZIBRI_REQUEST_CONTEXT_TOKENS } from '../../context/request/request-context-token.model';
+import { WebsocketRequestContext } from '../../context/request/websocket-request.context';
 import { CronService } from '../../cron/cron.service';
 import { DataSourceService } from '../../data-source/data-source.service';
 import { EmailService } from '../../email/email.service';
-import { MailingListService } from '../../email/mailing-list/mailing-list.service';
 import { errorHandler } from '../../error-handling/error-handler';
+import { EventService } from '../../event/event.service';
 import { HttpClient } from '../../http-client/http-client';
 import { LocalizeOptionsInput } from '../../localization/models/localize-options.model';
 import { LogLevel } from '../../logging/log-level.enum';
@@ -24,8 +33,8 @@ import { LoggerTransport } from '../../logging/transport/logger-transport.model'
 import { PrometheusMetricsService } from '../../metrics/metrics.service';
 import { MultithreadingService } from '../../multithreading/services/multithreading.service';
 import { OpenApiService } from '../../open-api/open-api.service';
+import { CspSource } from '../../parsing/html/csp-options.model';
 import { Parser } from '../../parsing/parser';
-import { getCurrentRequest } from '../../routing/request.context';
 import { Router } from '../../routing/router';
 import { FsUtilities } from '../../utilities/fs.utilities';
 import { Ms } from '../../utilities/ms';
@@ -70,19 +79,18 @@ export const ZIBRI_DI_PROVIDERS: DiTokenProviderRecord<typeof ZIBRI_DI_TOKENS> =
     PARSER: { useClass: Parser },
     VALIDATION_SERVICE: { useClass: ValidationService },
     DATA_SOURCE_SERVICE: { useClass: DataSourceService },
-    AUTH_SERVICE: { useFactory: () => new AuthService() },
-    TWO_FACTOR_SERVICE: { useFactory: () => new TwoFactorService() },
-    OTP_HEADER: { useFactory: () => 'X-Authorization-OTP' },
+    AUTH_SERVICE: { useClass: AuthService },
+    TWO_FACTOR_SERVICE: { useClass: TwoFactorService },
+    OTP_HEADER: { useFactory: () => 'x-authorization-otp' },
     OTP_LENGTH: { useFactory: () => 6 },
-    USER_SERVICE: { useFactory: () => new UserService() },
+    USER_SERVICE: { useClass: UserService },
     JWT_ACCESS_TOKEN_SECRET: { useFactory: () => undefined },
     JWT_REFRESH_TOKEN_SECRET: { useFactory: () => undefined },
+    PASSWORD_RESET_EMAIL_TEMPLATE: { useFactory: () => undefined },
     JWT_ACCESS_TOKEN_EXPIRES_IN_MS: { useFactory: () => Ms.HOUR },
     JWT_REFRESH_TOKEN_EXPIRES_IN_MS: { useFactory: () => 100 * Ms.DAY },
     CRON_SERVICE: { useClass: CronService },
     EMAIL_SERVICE: { useClass: EmailService },
-    MAILING_LIST_SERVICE: { useClass: MailingListService },
-    MAILING_LIST_SUBSCRIPTION_CONFIRMATION_TOKEN_EXPIRES_IN_MS: { useFactory: () => Ms.DAY },
     FILE_UPLOAD_TEMP_FOLDER: { useFactory: () => FsUtilities.getPath(__dirname, 'temp') },
     LOCALIZE_OPTIONS_INPUT: { useFactory: () => ({}) },
     LOCALIZE_OPTIONS: {
@@ -99,9 +107,8 @@ export const ZIBRI_DI_PROVIDERS: DiTokenProviderRecord<typeof ZIBRI_DI_TOKENS> =
     FORMAT_PRICE: { useFactory: () => formatPrice },
     FORMAT_PERCENT: { useFactory: () => formatPercent },
     EMAIL_CONFIG: { useFactory: () => undefined },
-    JWT_PASSWORD_RESET_TOKEN_EXPIRES_IN_MS: { useFactory: () => 300000 },
-    JWT_CONFIRM_PASSWORD_RESET_URL: { useFactory: () => undefined },
-    CURRENT_REQUEST: { useFactory: () => getCurrentRequest() },
+    PASSWORD_RESET_TOKEN_EXPIRES_IN_MS: { useFactory: () => 300000 },
+    CONFIRM_PASSWORD_RESET_URL: { useFactory: () => undefined },
     MULTITHREADING_OPTIONS: {
         useFactory: () => ({
             maxThreads,
@@ -113,5 +120,65 @@ export const ZIBRI_DI_PROVIDERS: DiTokenProviderRecord<typeof ZIBRI_DI_TOKENS> =
     MULTITHREADING_SERVICE: { useClass: MultithreadingService },
     WEBSOCKET_SERVICE: { useClass: WebsocketService },
     WEBSOCKET_OPTIONS: { useFactory: () => ({ timeoutInMs: Ms.SECOND * 5, isAllowedToConnect: () => true }) },
-    HTTP_CLIENT: { useClass: HttpClient }
+    HTTP_CLIENT: { useClass: HttpClient },
+    EVENT_SERVICE: { useClass: EventService },
+    CORRELATION_ID_HEADER: { useValue: 'x-correlation-id' },
+    CSRF_TOKEN_HEADER: { useValue: 'x-csrf-token' },
+    COOKIE_AUTH_SESSION_OPTIONS: {
+        useValue: {
+            name: 'sessionId',
+            sameSite: 'lax',
+            path: '/'
+        }
+    },
+    COOKIE_AUTH_REFRESH_SESSION_OPTIONS: {
+        useValue: {
+            name: 'refreshSessionId',
+            sameSite: 'lax',
+            path: '/'
+        }
+    },
+    COOKIE_SIGN_SECRET: { useValue: undefined },
+    COOKIE_AUTH_SESSION_EXPIRES_IN_MS: { useValue: Ms.DAY },
+    COOKIE_AUTH_REFRESH_SESSION_EXPIRES_IN_MS: { useValue: Ms.DAY * 100 },
+    HASH_SERVICE: { useClass: HashService },
+    HASH_STRATEGIES: { useValue: [BcryptHashStrategy] },
+    ENCRYPTION_SERVICE: { useClass: EncryptionService },
+    ENCRYPTION_STRATEGIES: { useValue: [AesGcmEncryptionStrategy] },
+    ENCRYPTION_MASTER_OPTIONS: { useValue: undefined },
+    CACHE_SERVICE: { useClass: CacheService },
+    // dynamic
+    CURRENT_REQUEST_CONTEXT: {
+        useFactory: () => AlsUtilities.getCurrentRequestContext(),
+        cache: false
+    },
+    DEFAULT_CSP_OPTIONS: {
+        useFactory: () => {
+            const context: HttpRequestContext | WebsocketRequestContext | undefined = inject(ZIBRI_DI_TOKENS.CURRENT_REQUEST_CONTEXT);
+            const nonce: string | undefined = context?.get(ZIBRI_REQUEST_CONTEXT_TOKENS.NONCE);
+            const nonceSrc: CspSource | undefined = nonce ? `'nonce-${nonce}'` : undefined;
+            return {
+                baseUri: ['\'self\''],
+                connectSrc: [],
+                defaultSrc: ['\'self\''],
+                fontSrc: [],
+                formAction: ['\'self\''],
+                frameAncestors: ['\'self\''],
+                imgSrc: [],
+                mediaSrc: [],
+                objectSrc: ['\'none\''],
+                scriptSrc: [
+                    '\'self\'',
+                    ...nonceSrc ? [nonceSrc] : []
+                ],
+                scriptSrcAttr: ['\'none\''],
+                styleSrc: []
+            };
+        },
+        cache: false
+    },
+    CURRENT_CACHE_CONTEXT: {
+        useFactory: () => AlsUtilities.getCurrentCacheContext(),
+        cache: false
+    }
 };

package/src/di/default/zibri-di-tokens.default.ts

@@ -1,20 +1,30 @@
 import { AssetServiceInterface } from '../../assets/asset-service.interface';
 import { TwoFactorServiceInterface } from '../../auth/2fa/two-factor-service.interface';
 import { AuthServiceInterface } from '../../auth/auth-service.interface';
+import { EncryptionMasterOptions } from '../../auth/encryption/encryption-master-options.model';
+import { EncryptionServiceInterface } from '../../auth/encryption/encryption-service.interface';
+import { EncryptionStrategyInterface } from '../../auth/encryption/strategies/encryption-strategy.interface';
+import { HashServiceInterface } from '../../auth/hash/hash-service.interface';
+import { HashStrategyInterface } from '../../auth/hash/strategies/hash-strategy.interface';
+import { CookieAuthSessionOptionsInput } from '../../auth/strategies/cookie/cookie-auth.auth-strategy';
+import { PasswordResetEmailTemplate } from '../../auth/strategies/jwt/jwt-auth.controller';
 import { UserServiceInterface } from '../../auth/user/user-service.interface';
 import { BackupServiceInterface } from '../../backup/backup-service.interface';
+import { CacheServiceInterface } from '../../caching/cache-service.interface';
+import { HttpRequestContext } from '../../context/request/http-request.context';
+import { WebsocketRequestContext } from '../../context/request/websocket-request.context';
 import { CronServiceInterface } from '../../cron/cron-service.interface';
 import { DataSourceServiceInterface } from '../../data-source/data-source-service.interface';
 import { EmailServiceInterface } from '../../email/email-service.interface';
-import { MailingListServiceInterface } from '../../email/mailing-list/mailing-list-service.interface';
 import { EmailConfigInput } from '../../email/models/email-config.model';
 import { GlobalErrorHandler, ErrorPageTemplate } from '../../error-handling/error-handler.model';
-import { HttpRequest } from '../../http/http-request.model';
+import { EventServiceInterface } from '../../event/event-service.interface';
 import { HttpClientInterface } from '../../http-client/http-client.interface';
 import { FormatDateFn } from '../../localization/formatting/format-date-fn.model';
 import { FormatPercentFn } from '../../localization/formatting/format-percent-fn.model';
 import { FormatPriceFn } from '../../localization/formatting/format-price-fn.model';
 import { LocalizeOptionsInput, LocalizeOptions } from '../../localization/models/localize-options.model';
+import { LogCacheContext } from '../../logging/log-context.model';
 import { LogLevel } from '../../logging/log-level.enum';
 import { LoggerInterface } from '../../logging/logger.interface';
 import { LoggerTransport, BaseLoggerTransportConfig } from '../../logging/transport/logger-transport.model';
@@ -22,9 +32,11 @@ import { MetricsServiceInterface } from '../../metrics/metrics-service.interface
 import { MultithreadingOptions } from '../../multithreading/models/multithreading-options.model';
 import { MultithreadingServiceInterface } from '../../multithreading/services/multithreading-service.interface';
 import { OpenApiServiceInterface } from '../../open-api/open-api-service.interface';
+import { CspOptions } from '../../parsing/html/csp-options.model';
 import { ParserInterface } from '../../parsing/parser.interface';
 import { RouterInterface } from '../../routing/router.interface';
-import { Path } from '../../utilities/fs.utilities';
+import { Newable } from '../../types/newable.type';
+import { FsPath } from '../../utilities/fs.utilities';
 import { ValidationServiceInterface } from '../../validation/validation-service.interface';
 import { WebsocketOptions } from '../../websocket/models/websocket-options.model';
 import { WebsocketServiceInterface } from '../../websocket/services/websocket-service.interface';
@@ -41,6 +53,7 @@ function ziToken<T = never>(k: `zi.${string}`): InjectionToken<T> {
  */
 // eslint-disable-next-line typescript/typedef
 export const ZIBRI_DI_TOKENS = {
+    // static/singleton tokens
     ROUTER: ziToken<RouterInterface>('zi.router'),
     LOGGER: ziToken<LoggerInterface>('zi.logger'),
     LOGGER_TRANSPORTS: ziToken<LoggerTransport<BaseLoggerTransportConfig>[]>('zi.logger_transports'),
@@ -62,14 +75,17 @@ export const ZIBRI_DI_TOKENS = {
     JWT_ACCESS_TOKEN_EXPIRES_IN_MS: ziToken<number>('zi.jwt_access_token_expires_in_ms'),
     JWT_REFRESH_TOKEN_SECRET: ziToken<string | undefined>('zi.jwt_refresh_token_secret'),
     JWT_REFRESH_TOKEN_EXPIRES_IN_MS: ziToken<number>('zi.jwt_refresh_token_expires_in_ms'),
-    JWT_PASSWORD_RESET_TOKEN_EXPIRES_IN_MS: ziToken<number>('zi.jwt_password_reset_token_expires_in_ms'),
-    JWT_CONFIRM_PASSWORD_RESET_URL: ziToken<string | undefined>('zi.jwt_confirm_password_reset_url'),
-    MAILING_LIST_SUBSCRIPTION_CONFIRMATION_TOKEN_EXPIRES_IN_MS: ziToken<number>(
-        'zi.mailing_list_subscription_confirmation_token_expires_in_ms'
-    ),
+    COOKIE_AUTH_SESSION_OPTIONS: ziToken<CookieAuthSessionOptionsInput>('zi.cookie_auth_session_options'),
+    COOKIE_AUTH_REFRESH_SESSION_OPTIONS: ziToken<CookieAuthSessionOptionsInput>('zi.cookie_auth_refresh_session_options'),
+    COOKIE_AUTH_SESSION_EXPIRES_IN_MS: ziToken<number>('zi.cookie_auth_session_expires_in_ms'),
+    COOKIE_AUTH_REFRESH_SESSION_EXPIRES_IN_MS: ziToken<number>('zi.cookie_auth_refresh_session_expires_in_ms'),
+    PASSWORD_RESET_TOKEN_EXPIRES_IN_MS: ziToken<number>('zi.password_reset_token_expires_in_ms'),
+    CONFIRM_PASSWORD_RESET_URL: ziToken<string | undefined>('zi.confirm_password_reset_url'),
+    // eslint-disable-next-line typescript/no-explicit-any
+    PASSWORD_RESET_EMAIL_TEMPLATE: ziToken<PasswordResetEmailTemplate<any, any> | undefined>('zi.password_reset_email_template'),
     USER_SERVICE: ziToken<UserServiceInterface>('zi.user_service'),
     CRON_SERVICE: ziToken<CronServiceInterface>('zi.cron_service'),
-    FILE_UPLOAD_TEMP_FOLDER: ziToken<Path>('zi.file_upload_temp_folder'),
+    FILE_UPLOAD_TEMP_FOLDER: ziToken<FsPath>('zi.file_upload_temp_folder'),
     LOCALIZE_OPTIONS_INPUT: ziToken<LocalizeOptionsInput>('zi.localize_options_input'),
     LOCALIZE_OPTIONS: ziToken<LocalizeOptions>('zi.localize_options'),
     FORMAT_DATE: ziToken<FormatDateFn>('zi.format_date'),
@@ -77,12 +93,30 @@ export const ZIBRI_DI_TOKENS = {
     FORMAT_PERCENT: ziToken<FormatPercentFn>('zi.format_percent'),
     EMAIL_SERVICE: ziToken<EmailServiceInterface>('zi.email_service'),
     EMAIL_CONFIG: ziToken<EmailConfigInput | undefined>('zi.email_config'),
-    MAILING_LIST_SERVICE: ziToken<MailingListServiceInterface | undefined>('zi.mailing_list_service'),
-    CURRENT_REQUEST: ziToken<HttpRequest>('zi.current_request'),
     MULTITHREADING_SERVICE: ziToken<MultithreadingServiceInterface>('zi.multithreading_service'),
     MULTITHREADING_OPTIONS: ziToken<MultithreadingOptions>('zi.multithreading_options'),
     // eslint-disable-next-line typescript/no-explicit-any
     WEBSOCKET_SERVICE: ziToken<WebsocketServiceInterface<any>>('zi.websocket_service'),
     WEBSOCKET_OPTIONS: ziToken<WebsocketOptions>('zi.websocket_options'),
-    HTTP_CLIENT: ziToken<HttpClientInterface>('zi.http_client')
+    HTTP_CLIENT: ziToken<HttpClientInterface>('zi.http_client'),
+    EVENT_SERVICE: ziToken<EventServiceInterface<Record<string, unknown>>>('zi.event_service'),
+    CORRELATION_ID_HEADER: ziToken<string>('zi.correlation_id_header'),
+    CSRF_TOKEN_HEADER: ziToken<string>('zi.csrf_token_header'),
+    COOKIE_SIGN_SECRET: ziToken<string | undefined>('zi.cookie_sign_secret'),
+    HASH_SERVICE: ziToken<HashServiceInterface>('zi.hash_service'),
+    HASH_STRATEGIES: ziToken<Newable<HashStrategyInterface<Record<string, unknown>>>[]>('zi.hash_strategies'),
+    ENCRYPTION_SERVICE: ziToken<EncryptionServiceInterface>('zi.encryption_service'),
+    ENCRYPTION_STRATEGIES: ziToken<
+        // eslint-disable-next-line typescript/no-explicit-any
+        Newable<EncryptionStrategyInterface<any, any, any>>[]
+    >('zi.encryption_strategies'),
+    // eslint-disable-next-line typescript/no-explicit-any
+    ENCRYPTION_MASTER_OPTIONS: ziToken<EncryptionMasterOptions<any, any, any> | undefined>(
+        'zi.encryption_master_options'
+    ),
+    CACHE_SERVICE: ziToken<CacheServiceInterface>('zi.cache_service'),
+    // dynamic/context based tokens
+    CURRENT_REQUEST_CONTEXT: ziToken<HttpRequestContext | WebsocketRequestContext | undefined>('zi.current_request_context'),
+    DEFAULT_CSP_OPTIONS: ziToken<CspOptions>('zi.default_csp_options'),
+    CURRENT_CACHE_CONTEXT: ziToken<LogCacheContext[] | undefined>('zi.current_cache_context')
 } as const satisfies TokenRecord;

package/src/di/di-container.ts

@@ -26,6 +26,25 @@ export class DiContainer {
         }
     }
 
+    /**
+     * Gets all registered tokens of the DI Container.
+     * @returns The tokens as an array.
+     */
+    getAllRegisteredTokens(): DiToken<unknown>[] {
+        const seen: Set<unknown> = new Set<unknown>();
+        const unique: DiToken<unknown>[] = [];
+
+        for (const [token, provider] of this.providers) {
+            const identity: unknown = provider.useClass ?? provider.useFactory ?? provider.useValue ?? token;
+            if (!seen.has(identity)) {
+                seen.add(identity);
+                unique.push(token);
+            }
+        }
+
+        return unique;
+    }
+
     /**
      * Gets the DI Container instance.
      * @returns The instance.
@@ -47,7 +66,7 @@ export class DiContainer {
     /**
      * Removes the provided token from the dependency injection system.
      * @param token - The token to unregister.
-     * @throws When the app is initialized or running.
+     * @throws When the app is initialized or started.
      */
     unregister<T>(token: DiToken<T>): void {
         this.providers.delete(token);
@@ -65,11 +84,26 @@ export class DiContainer {
             return this.instances.get(token) as T;
         }
 
-        const provider: DiProvider<T> | undefined = this.providers.get(token) as DiProvider<T> | undefined;
+        let provider: DiProvider<T> | undefined = this.providers.get(token) as DiProvider<T> | undefined;
+        if (!provider) {
+            const lazy: DiProvider<unknown> | undefined = GlobalRegistry.lazyInjectables.find(p => p.token === token);
+            if (lazy) {
+                this.register(lazy); // promote into providers so future lookups are O(1)
+                provider = lazy as DiProvider<T>;
+            }
+        }
+
         if (!provider) {
             throw new NoProviderError(token, resolvingStack);
         }
 
+        // If useClass, check if we already have an instance of that class cached under the class itself
+        if (provider.useClass && this.instances.has(provider.useClass as unknown as DiToken<unknown>)) {
+            const existing: T = this.instances.get(provider.useClass as unknown as DiToken<unknown>) as T;
+            this.instances.set(token, existing); // cache under this token too for next time
+            return existing;
+        }
+
         if (provider.useClass || provider.useFactory) {
             resolvingStack.push(provider.useClass ?? provider.useFactory);
         }
@@ -77,14 +111,24 @@ export class DiContainer {
         const instance: T = this.createInstanceFromProvider(provider, resolvingStack);
         resolvingStack.pop();
 
-        this.instances.set(provider.token, instance);
+        if (provider.useValue != undefined || ((provider.useFactory || provider.useClass) && provider.cache !== false)) {
+            this.instances.set(provider.token, instance);
+        }
+
+        if (provider.useClass) {
+            this.instances.set(provider.useClass as unknown as DiToken<unknown>, instance);
+        }
+
         return instance;
     }
 
     private createInstanceFromProvider<T>(provider: DiProvider<T>, resolvingStack: Function[]): T {
+        if ('useValue' in provider) {
+            return provider.useValue as T;
+        }
+
         const provide: Newable<T> | ((...deps: unknown[]) => T) | T | undefined = provider.useClass
-            ?? provider.useFactory
-            ?? provider.useValue;
+            ?? provider.useFactory;
 
         if (provide == undefined) {
             throw new Error(`Provider for ${provider.token.toString()} is invalid`);
@@ -114,12 +158,9 @@ export class DiContainer {
         if (provider.useClass) {
             return new provider.useClass(...deps);
         }
-        if (provider.useFactory) {
+        if (provider.useFactory != undefined) {
             return provider.useFactory(...deps);
         }
-        if ('useValue' in provider) {
-            return provider.useValue;
-        }
 
         throw new Error(`Provider for ${(provider as DiProvider<T>).token.toString()} is invalid`);
     }

package/src/di/errors/no-provider.error.ts

@@ -19,8 +19,10 @@ function getNoProviderMessage(token: DiToken<unknown>, resolvingStack: Function[
             return `No provider for token "${token.key}". Did you forget to decorate it with @Inject()?`;
         }
         const currentClass: Function = resolvingStack[resolvingStack.length - 1];
-        const paramTypes: unknown[] = MetadataUtilities.getParamTypes(currentClass);
-        const index: number = paramTypes.findIndex(param => param === token);
+        const injectTokens: Record<number, DiToken<unknown>> = MetadataUtilities.getInjectParamTokens(currentClass);
+        const index: number = Number(
+            Object.entries(injectTokens).find(([, t]) => t === token)?.[0] ?? -1
+        );
         return `No provider for the token at index ${index} of class "${currentClass.name}". Did you forget to decorate it with @Inject()?`;
     }
     return `No provider for class "${token.name}". Did you forget to decorate it with @Injectable()?`;

package/src/di/get-all-registered-tokens.function.ts

@@ -0,0 +1,10 @@
+import { DiContainer } from './di-container';
+import { DiToken } from './models/di-token.model';
+
+/**
+ * Gets all registered DI tokens.
+ * @returns The tokens as an array.
+ */
+export function getAllRegisteredTokens(): DiToken<unknown>[] {
+    return DiContainer.getInstance().getAllRegisteredTokens();
+}

package/src/di/models/di-provider.model.ts

@@ -38,7 +38,13 @@ type ClassDiProvider<T> = BaseDiProvider<T> & {
     /**
      * A class to register for the token.
      */
-    useClass: Newable<NoInfer<T>>,
+    useClass: Newable<T>,
+    /**
+     * Whether or not the newly created class instance should be cached or recreated on every injection.
+     *
+     * Defaults to true.
+     */
+    cache?: boolean,
     // eslint-disable-next-line jsdoc/require-jsdoc
     useFactory?: never,
     // eslint-disable-next-line jsdoc/require-jsdoc
@@ -50,7 +56,13 @@ type FactoryDiProvider<T> = BaseDiProvider<T> & {
     /**
      * A factory function that resolves the value to register for the token.
      */
-    useFactory: (...deps: unknown[]) => NoInfer<T>,
+    useFactory: (...deps: unknown[]) => T,
+    /**
+     * Whether or not the result of the function should be cached or recomputed on every injection.
+     *
+     * Defaults to true.
+     */
+    cache?: boolean,
     // eslint-disable-next-line jsdoc/require-jsdoc
     useClass?: never,
     // eslint-disable-next-line jsdoc/require-jsdoc
@@ -62,7 +74,7 @@ type ValueDiProvider<T> = BaseDiProvider<T> & {
     /**
      * A value to register for the token.
      */
-    useValue: NoInfer<T>,
+    useValue: T,
     // eslint-disable-next-line jsdoc/require-jsdoc
     useFactory?: never,
     // eslint-disable-next-line jsdoc/require-jsdoc

package/src/di/register.function.ts

@@ -5,10 +5,10 @@ import { DiProvider } from './models/di-provider.model';
 /**
  * Registers a new DI provider.
  * @param provider - The provider to register.
- * @throws When the app is initialized or running.
+ * @throws When the app is initialized or started.
  */
 export function register<T>(provider: DiProvider<T>): void {
-    if (GlobalRegistry.isAppInitialized() || GlobalRegistry.isAppRunning()) {
+    if (GlobalRegistry.isAppInitialized() || GlobalRegistry.isAppStarted()) {
         throw new Error('You can only register providers before the app has been initialized');
     }
     const di: DiContainer = DiContainer.getInstance();

package/src/di/unregister.function.ts

@@ -5,10 +5,10 @@ import { DiToken } from './models/di-token.model';
 /**
  * Removes the provided token from the dependency injection system.
  * @param token - The token to unregister.
- * @throws When the app is initialized or running.
+ * @throws When the app is initialized or started.
  */
 export function unregister<T>(token: DiToken<T>): void {
-    if (GlobalRegistry.isAppInitialized() || GlobalRegistry.isAppRunning()) {
+    if (GlobalRegistry.isAppInitialized() || GlobalRegistry.isAppStarted()) {
         throw new Error('You can only unregister providers before the app has been initialized');
     }
     const di: DiContainer = DiContainer.getInstance();

package/src/email/email-service.interface.ts

@@ -1,14 +1,9 @@
-import { ZibriApplication } from '../application';
 import { QueueEmailData } from './models/create-email-data.model';
 
 /**
  * Interface for a email service.
  */
 export interface EmailServiceInterface {
-    /**
-     * Attaches the service to the Zibri application.
-     */
-    attachTo: (app: ZibriApplication) => void,
     /**
      * Queues a new email.
      */

package/src/email/email.service.ts

@@ -7,29 +7,30 @@ import { CreateEmailData, QueueEmailData } from './models/create-email-data.mode
 import { SendQueuedEmailsCronJob } from './send-queued-emails.cron-job';
 import { Repository } from '../data-source/repository';
 import { Email } from './models/email.model';
-import { repositoryTokenFor } from '../di/decorators/inject-repository.decorator';
+import { InjectRepository } from '../di/decorators/inject-repository.decorator';
+import { Inject } from '../di/decorators/inject.decorator';
+import { Injectable } from '../di/decorators/injectable.decorator';
 import { ZIBRI_DI_TOKENS } from '../di/default/zibri-di-tokens.default';
 import { inject } from '../di/inject.function';
-import { LoggerInterface } from '../logging/logger.interface';
+import { type LoggerInterface } from '../logging/logger.interface';
 import { RateLimiter } from '../rate-limiting/rate-limiter';
 import { FsUtilities } from '../utilities/fs.utilities';
 import { EmailAttachment } from './models/email-attachment.model';
 import { EmailConfig, EmailConfigInput } from './models/email-config.model';
 import { EmailPriority } from './models/email-priority.enum';
 import { EmailStatus } from './models/email-status.enum';
+import { OnAppInit } from '../global/on-app-init.interface';
+import { OnAppShutdown } from '../global/on-app-shutdown.interface';
 
 /**
  * Default email service implementation of Zibri.
  */
-export class EmailService implements EmailServiceInterface {
+@Injectable({ register: 'onUse' })
+export class EmailService implements EmailServiceInterface, OnAppInit, OnAppShutdown {
     /**
      * The internal nodemailer transporter.
      */
     protected readonly transporter: Transporter<SMTPTransport.SentMessageInfo, SMTPTransport.Options>;
-    /**
-     * The repository that handles storing and receiving emails from the db.
-     */
-    protected readonly emailRepository: Repository<Email, CreateEmailData>;
     /**
      * The email configuration.
      */
@@ -38,13 +39,13 @@ export class EmailService implements EmailServiceInterface {
      * A rate limiter to prevent overloading the email provider.
      */
     protected readonly rateLimiter: RateLimiter;
-    /**
-     * A logger.
-     */
-    protected readonly logger: LoggerInterface;
 
-    constructor() {
-        this.emailRepository = inject(repositoryTokenFor(Email));
+    constructor(
+        @Inject(ZIBRI_DI_TOKENS.LOGGER)
+        private readonly logger: LoggerInterface,
+        @InjectRepository(Email)
+        private readonly emailRepository: Repository<Email, CreateEmailData>
+    ) {
         const config: EmailConfigInput | undefined = inject(ZIBRI_DI_TOKENS.EMAIL_CONFIG);
         if (!config) {
             throw new Error('no email config was provided for the token "ZIBRI_DI_TOKENS.MAIL_CONFIG"');
@@ -55,12 +56,18 @@ export class EmailService implements EmailServiceInterface {
         };
         this.rateLimiter = RateLimiter.perHour(this.config.maxEmailsPerHour);
         this.transporter = createTransport({ ...this.config, secure: config?.port === 465 });
-        this.logger = inject(ZIBRI_DI_TOKENS.LOGGER);
     }
 
     // eslint-disable-next-line jsdoc/require-jsdoc
-    attachTo(app: ZibriApplication): void {
-        app.options.cronJobs.push(SendQueuedEmailsCronJob);
+    onAppInit(app: ZibriApplication): void {
+        if (!app.options.cronJobs.includes(SendQueuedEmailsCronJob)) {
+            app.options.cronJobs.push(SendQueuedEmailsCronJob);
+        }
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    onAppShutdown(): void {
+        this.transporter.close();
     }
 
     // eslint-disable-next-line jsdoc/require-jsdoc

package/src/email/models/email-attachment.model.ts

@@ -1,5 +1,5 @@
 import { Property } from '../../entity/decorators/property.decorator';
-import { type Path } from '../../utilities/fs.utilities';
+import { type FsPath } from '../../utilities/fs.utilities';
 
 /**
  * An email attachment, consisting of filename and path.
@@ -15,5 +15,5 @@ export class EmailAttachment {
      * The path of the attachment.
      */
     @Property.string()
-    path!: Path;
+    path!: FsPath;
 }

package/src/email/send-queued-emails.cron-job.ts

@@ -1,27 +1,32 @@
-import { EmailServiceInterface } from './email-service.interface';
+import { type EmailServiceInterface } from './email-service.interface';
+import { CronExpression } from '../cron/cron-expression.utilities';
 import { CronJob, InitialCronConfig } from '../cron/cron-job.model';
-import { Injectable } from '../di/decorators/injectable.decorator';
+import { Inject } from '../di/decorators/inject.decorator';
 import { ZIBRI_DI_TOKENS } from '../di/default/zibri-di-tokens.default';
-import { inject } from '../di/inject.function';
 
 /**
  * Cron Job for sending out queued emails.
  */
-@Injectable()
 export class SendQueuedEmailsCronJob extends CronJob {
     // eslint-disable-next-line jsdoc/require-jsdoc
     initialConfig: InitialCronConfig = {
         name: 'send queued emails',
-        cron: '*/5 * * * * *',
+        cron: CronExpression.every(5, 'seconds').build(),
         runOnInit: false
     };
 
+    constructor(
+        @Inject(ZIBRI_DI_TOKENS.EMAIL_SERVICE)
+        private readonly emailService: EmailServiceInterface
+    ) {
+        super();
+    }
+
     // eslint-disable-next-line jsdoc/require-jsdoc
     async onTick(): Promise<void> {
-        const emailService: EmailServiceInterface = inject(ZIBRI_DI_TOKENS.EMAIL_SERVICE);
         let goOn: boolean = true;
         while (goOn) {
-            goOn = await emailService.sendQueuedEmails();
+            goOn = await this.emailService.sendQueuedEmails();
         }
     }
 }