zibri 2.2.1 → 2.3.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

@@ -14,7 +14,6 @@ import { BackupService } from '../../backup/backup.service';
 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 { HttpClient } from '../../http-client/http-client';
 import { LocalizeOptionsInput } from '../../localization/models/localize-options.model';
@@ -70,19 +69,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() },
+    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 },
+    JWT_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: {

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

@@ -1,12 +1,12 @@
 import { AssetServiceInterface } from '../../assets/asset-service.interface';
 import { TwoFactorServiceInterface } from '../../auth/2fa/two-factor-service.interface';
 import { AuthServiceInterface } from '../../auth/auth-service.interface';
+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 { 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';
@@ -24,7 +24,7 @@ import { MultithreadingServiceInterface } from '../../multithreading/services/mu
 import { OpenApiServiceInterface } from '../../open-api/open-api-service.interface';
 import { ParserInterface } from '../../parsing/parser.interface';
 import { RouterInterface } from '../../routing/router.interface';
-import { Path } from '../../utilities/fs.utilities';
+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';
@@ -64,12 +64,11 @@ export const ZIBRI_DI_TOKENS = {
     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'
-    ),
+    // eslint-disable-next-line typescript/no-explicit-any
+    JWT_PASSWORD_RESET_EMAIL_TEMPLATE: ziToken<PasswordResetEmailTemplate<any, any> | undefined>('zi.jwt_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,8 +76,7 @@ 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'),
+    CURRENT_REQUEST: ziToken<HttpRequest | undefined>('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

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);
         }
@@ -78,6 +112,11 @@ export class DiContainer {
         resolvingStack.pop();
 
         this.instances.set(provider.token, instance);
+
+        if (provider.useClass) {
+            this.instances.set(provider.useClass as unknown as DiToken<unknown>, instance);
+        }
+
         return instance;
     }
 

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,7 @@ type ClassDiProvider<T> = BaseDiProvider<T> & {
     /**
      * A class to register for the token.
      */
-    useClass: Newable<NoInfer<T>>,
+    useClass: Newable<T>,
     // eslint-disable-next-line jsdoc/require-jsdoc
     useFactory?: never,
     // eslint-disable-next-line jsdoc/require-jsdoc
@@ -50,7 +50,7 @@ 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,
     // eslint-disable-next-line jsdoc/require-jsdoc
     useClass?: never,
     // eslint-disable-next-line jsdoc/require-jsdoc
@@ -62,7 +62,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,14 +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 {
+    onAppInit(app: ZibriApplication): void {
         app.options.cronJobs.push(SendQueuedEmailsCronJob);
     }
 
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    onAppShutdown(): void {
+        this.transporter.close();
+    }
+
     // eslint-disable-next-line jsdoc/require-jsdoc
     async queue(data: QueueEmailData): Promise<void> {
         await this.emailRepository.create({

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,13 +1,11 @@
-import { EmailServiceInterface } from './email-service.interface';
+import { type EmailServiceInterface } from './email-service.interface';
 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 = {
@@ -16,12 +14,18 @@ export class SendQueuedEmailsCronJob extends CronJob {
         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();
         }
     }
 }

package/src/entity/decorators/entity.decorator.ts

@@ -11,17 +11,23 @@ export type EntityMetadata = {
     /**
      * The name of the table in the db.
      */
-    tableName: string
+    tableName: string,
+    /**
+     * Whether or not this entity is allowed to exist without belonging to a data source.
+     */
+    allowOrphan: boolean
 };
 
 /**
  * Marks an entity.
- * @param tableName - The name of the table to generate for the entity.
+ * @param options - Configuration options for the entity.
  */
-export function Entity(tableName?: string): ClassDecorator {
+export function Entity(options: Partial<EntityMetadata> = {}): ClassDecorator {
+    const { tableName, allowOrphan = false } = options;
     return target => {
         const metadata: EntityMetadata = {
-            tableName: tableName ?? toSnakeCase(target.name)
+            tableName: tableName ?? toSnakeCase(target.name),
+            allowOrphan
         };
         MetadataUtilities.setEntityMetadata(target as unknown as Newable<BaseEntity>, metadata);
         GlobalRegistry.entityClasses.push(target as unknown as Newable<BaseEntity>);

package/src/entity/generation/generate-entity-files-for-provider.function.ts

@@ -4,7 +4,7 @@ import { getEntityFileName } from './get-entity-file-name.function';
 import { EntityGenerationProvider } from './providers/entity-generation-provider.interface';
 import { warn } from '../../logging/logger.helpers';
 import { OpenApiDefinition, OpenApiSchemas, OpenApiOperation, OpenApiResponseObject, OpenApiReferenceObject, OpenApiSchemaObject } from '../../open-api/open-api.model';
-import { FsUtilities, Path } from '../../utilities/fs.utilities';
+import { FsUtilities, FsPath } from '../../utilities/fs.utilities';
 import { ObjectUtilities } from '../../utilities/object.utilities';
 import { toKebabCase } from '../../utilities/to-kebab-case.function';
 import { toPascalCase } from '../../utilities/to-pascal-case.function';
@@ -16,7 +16,7 @@ export type FileToGenerate = {
     /**
      * The path where the file should be generated.
      */
-    path: Path,
+    path: FsPath,
     /**
      * The actual content of the file in lines.
      */
@@ -123,7 +123,7 @@ export async function generateEntityFilesForProvider(
             const fileName: string = getEntityFileName(provider.prefix, key);
 
             // eslint-disable-next-line sonar/no-duplicate-string
-            const filePath: Path = FsUtilities.getPath(cwd, 'src/models/generated', toKebabCase(provider.prefix), fileName);
+            const filePath: FsPath = FsUtilities.getPath(cwd, 'src/models/generated', toKebabCase(provider.prefix), fileName);
             if (await FsUtilities.exists(filePath)) {
                 processedSchemas.add(key);
                 continue;

package/src/entity/generation/generate-entity-files.function.ts

@@ -2,14 +2,14 @@ import { register } from 'ts-node';
 
 import { FileToGenerate, generateEntityFilesForProvider, GenerateEntityFilesForProviderResult } from './generate-entity-files-for-provider.function';
 import { EntityGenerationProvider } from './providers/entity-generation-provider.interface';
-import { FsUtilities, Path } from '../../utilities/fs.utilities';
+import { FsUtilities, FsPath } from '../../utilities/fs.utilities';
 
 /**
  * Resolves providers from the src/models/generated/providers.ts file and generates entities from them.
  */
 export async function generateEntityFiles(): Promise<void> {
     const cwd: string = process.cwd();
-    const providersPath: Path = await resolveProvidersPath(cwd);
+    const providersPath: FsPath = await resolveProvidersPath(cwd);
     const ext: string = FsUtilities.extensionName(providersPath).toLowerCase();
     if (ext !== '.ts') {
         return;
@@ -44,14 +44,14 @@ export async function generateEntityFiles(): Promise<void> {
 }
 
 // eslint-disable-next-line jsdoc/require-jsdoc
-async function resolveProvidersPath(cwd: string): Promise<Path> {
-    const candidates: Path[] = [
+async function resolveProvidersPath(cwd: string): Promise<FsPath> {
+    const candidates: FsPath[] = [
         FsUtilities.getPath(cwd, 'src/models/generated/providers.js'),
         FsUtilities.getPath(cwd, 'src/models/generated/providers.cjs'),
         FsUtilities.getPath(cwd, 'src/models/generated/providers.mjs'),
         FsUtilities.getPath(cwd, 'src/models/generated/providers.ts')
     ];
-    const providersPath: Path = await Promise.any(candidates.map(async p => {
+    const providersPath: FsPath = await Promise.any(candidates.map(async p => {
         if (await FsUtilities.exists(p)) {
             return p;
         }

package/src/entity/generation/providers/open-api-file.provider.ts

@@ -1,7 +1,7 @@
 import { EntityGenerationProvider } from './entity-generation-provider.interface';
 import { openApiToV3 } from './open-api-to-v3.function';
 import { OpenApiDefinition } from '../../../open-api/open-api.model';
-import { FsUtilities, Path } from '../../../utilities/fs.utilities';
+import { FsUtilities, FsPath } from '../../../utilities/fs.utilities';
 
 /**
  * An entity generation provider using a local open api file.
@@ -9,7 +9,7 @@ import { FsUtilities, Path } from '../../../utilities/fs.utilities';
 export class OpenApiFileProvider implements EntityGenerationProvider {
     constructor(
         readonly prefix: string,
-        protected readonly filePath: Path,
+        protected readonly filePath: FsPath,
         readonly generateSchemasFromPaths: boolean = false,
         readonly markAsEntities: boolean = false
     ) {}

package/src/error-handling/error-handler.ts

@@ -61,7 +61,7 @@ export const errorHandler: GlobalErrorHandler = async (error: unknown, req: Http
     }
 
     try {
-        const html: string = await PreactUtilities.render(template, { error: httpError });
+        const html: string = await PreactUtilities.renderPage(template, { error: httpError });
         res.setHeader(KnownHeader.CONTENT_TYPE, MimeType.HTML);
         res.status(httpError.status).send(html);
     }

package/src/error-handling/errors/http.error.ts

@@ -27,11 +27,7 @@ export abstract class HttpError extends Error {
     }
 }
 
-/**
- * Check whether or not the given value is a http error.
- * @param value - The value to check.
- * @returns True when value is an instance of HttpError, false otherwise.
- */
+// eslint-disable-next-line jsdoc/require-jsdoc
 export function isHttpError(value: unknown): value is HttpError {
     return value instanceof HttpError;
 }

package/src/error-handling/errors/missing-tokens.error.ts

@@ -0,0 +1,19 @@
+import { DiToken } from '../../di/models/di-token.model';
+import { InjectionToken } from '../../di/models/injection-token.model';
+
+/**
+ * An error to throw when there are tokens that are not injectable.
+ */
+export class MissingTokensError extends Error {
+    constructor(context: string, tokens: DiToken<unknown>[]) {
+        const messages: string[] = [
+            `Error initializing ${context}`,
+            'Could not inject the following tokens:'
+        ];
+        for (const token of tokens) {
+            messages.push(`  - ${token instanceof InjectionToken ? token.key : token.name}`);
+        }
+        super(messages.join('\n'));
+        this.name = 'MissingTokensError';
+    }
+}

package/src/global/after-app-init.interface.ts

@@ -0,0 +1,43 @@
+import { ZibriApplication } from '../application';
+
+// eslint-disable-next-line jsdoc/require-returns
+/**
+ * Checks if the given value implements the AfterAppInit interface.
+ * @param value - The value to check.
+ */
+export function implementsAfterAppInit(value: unknown): value is AfterAppInit {
+    if (typeof value !== 'object') {
+        return false;
+    }
+    if (value == undefined) {
+        return false;
+    }
+    if (!('afterAppInit' in value)) {
+        return false;
+    }
+
+    if (typeof value.afterAppInit !== 'function') {
+        return false;
+    }
+    return true;
+}
+
+/**
+ * Runs just after the app initializes.
+ * This is useful for things like the cron or websocket service,
+ * which creates new work that might rely on other services already being operational.
+ *
+ * In most cases you probably want to implement OnAppInit.
+ * Most relevant things like eg. The data source service are already operational there, as they implement the BeforeAppInit interface.
+ */
+export interface AfterAppInit {
+    /**
+     * Runs just after the app initializes.
+     * This is useful for things like the cron or websocket service,
+     * which creates new work that might rely on other services already being operational.
+     *
+     * In most cases you probably want to implement OnAppInit.
+     * Most relevant things like eg. The data source service are already operational there, as they implement the BeforeAppInit interface.
+     */
+    afterAppInit: (app: ZibriApplication) => void | Promise<void>
+}