zibri 2.2.0 → 2.3.0

package/src/data-source/repository.test.ts

@@ -1,15 +1,17 @@
 import { beforeAll, afterAll, describe, it, expect } from '@jest/globals';
 import { PostgreSqlContainer, StartedPostgreSqlContainer } from '@testcontainers/postgresql';
 
-import { DataSource } from './decorators';
-import { inject } from '../di';
-import { PostgresDataSource, PostgresOptions } from './data-sources';
-import { MigrationEntity } from './migration';
-import { POSTGRES_TEST_IMAGE } from '../__testing__';
-import { BaseEntity } from '../entity/base-entity.model';
-import { Newable, OmitStrict } from '../types';
+import { POSTGRES_TEST_IMAGE } from '../__testing__/constants';
+import { PostgresDataSource, PostgresOptions } from './data-sources/postgres-data-source.model';
+import { DataSource } from './decorators/data-source.decorator';
+import { MigrationEntity } from './migration/migration-entity.model';
 import { Repository } from './repository';
-import { Entity, Property } from '../entity';
+import { inject } from '../di/inject.function';
+import { BaseEntity } from '../entity/base-entity.model';
+import { Entity } from '../entity/decorators/entity.decorator';
+import { Property } from '../entity/decorators/property.decorator';
+import { Newable } from '../types/newable.type';
+import { OmitStrict } from '../types/omit-strict.type';
 
 @Entity()
 class VisitStats extends BaseEntity {

package/src/data-source/repository.ts

@@ -1,17 +1,29 @@
 import { Repository as TORepository, FindOptionsWhere, EntityManager, QueryFailedError as TOQueryFailedError } from 'typeorm';
 
-import { inject, ZIBRI_DI_TOKENS } from '../di';
-import { NotFoundError } from '../error-handling';
-import { LoggerInterface } from '../logging';
-import { DeepPartial, Newable } from '../types';
-import { Transaction } from './transaction';
-import { ArrayPropertyMetadata, PropertyMetadata, Relation } from '../entity';
-import { CreateAllOptions, CreateOptions, DeleteAllOptions, DeleteByIdOptions, FindAllOptions, FindAllPaginatedOptions, FindByIdOptions, FindOneOptions, UpdateAllOptions, UpdateByIdOptions, Where } from './models';
+import { QueryFailedError } from './query-failed.error';
 import { BaseEntity } from '../entity/base-entity.model';
-import { PaginationResult } from '../open-api';
-import { MetadataUtilities } from '../utilities';
+import { Transaction } from './transaction/transaction.model';
+import { PropertyMetadata } from '../entity/decorators/property.decorator';
+import { ArrayPropertyMetadata } from '../entity/models/array-property-metadata.model';
+import { Relation } from '../entity/models/relation.enum';
+import { LoggerInterface } from '../logging/logger.interface';
+import { PaginationResult } from '../open-api/pagination-result.model';
+import { DeepPartial } from '../types/deep-partial.type';
+import { Newable } from '../types/newable.type';
+import { MetadataUtilities } from '../utilities/metadata.utilities';
 import { whereFilterToFindOptionsWhere } from './models/where/where-filter-to-find-options-where.function';
-import { QueryFailedError } from './query-failed.error';
+import { NotFoundError } from '../error-handling/errors/not-found.error';
+import { CreateAllOptions } from './models/options/create-all-options.model';
+import { CreateOptions } from './models/options/create-options.model';
+import { DeleteAllOptions } from './models/options/delete-all-options.model';
+import { DeleteByIdOptions } from './models/options/delete-by-id-options.model';
+import { FindAllOptions } from './models/options/find-all-options.model';
+import { FindAllPaginatedOptions } from './models/options/find-all-paginated-options.model';
+import { FindByIdOptions } from './models/options/find-by-id-options.model';
+import { FindOneOptions } from './models/options/find-one-options.model';
+import { UpdateAllOptions } from './models/options/update-all-options.model';
+import { UpdateByIdOptions } from './models/options/update-by-id-options.model';
+import { Where } from './models/where/where-filter.model';
 
 /**
  * A repository that handles data source related things for its entity.
@@ -21,12 +33,13 @@ export class Repository<
     CreateData extends DeepPartial<T> = DeepPartial<T>,
     UpdateData extends DeepPartial<T> = DeepPartial<T>
 > {
-    // eslint-disable-next-line jsdoc/require-jsdoc
-    protected readonly logger: LoggerInterface;
     private readonly typeOrmRepository: TORepository<T>;
 
-    constructor(protected readonly entityClass: Newable<T>, repo: TORepository<T> | Repository<T>) {
-        this.logger = inject(ZIBRI_DI_TOKENS.LOGGER);
+    constructor(
+        protected readonly entityClass: Newable<T>,
+        repo: TORepository<T> | Repository<T>,
+        protected readonly logger: LoggerInterface
+    ) {
         this.typeOrmRepository = repo instanceof Repository ? repo.typeOrmRepository : repo;
     }
 
@@ -71,7 +84,6 @@ export class Repository<
                     }
                     case Relation.MANY_TO_MANY:
                     case Relation.ONE_TO_MANY: {
-                        // TODO
                         await this.setDefaultValuesForArray(data[key as keyof Data] as unknown[], {
                             ...property,
                             type: 'array',

package/src/data-source/transaction/transaction.test.ts

@@ -1,16 +1,16 @@
 import { afterAll, beforeAll, describe, expect, it } from '@jest/globals';
-import { PostgreSqlContainer } from '@testcontainers/postgresql';
-import { StartedTestContainer } from 'testcontainers';
 
-import { POSTGRES_TEST_IMAGE } from '../../__testing__';
-import { Entity, Property } from '../../entity';
-import { BaseEntity } from '../../entity/base-entity.model';
-import { Newable } from '../../types';
-import { PostgresDataSource, PostgresOptions } from '../data-sources';
-import { DataSource } from '../decorators';
+import { createTestDataSource, defaultTestServerEntities } from '../../__testing__/test-server/create-test-data-source.function';
+import { StartedTestServer, startTestServer } from '../../__testing__/test-server/start-test-server.function';
+import { repositoryTokenFor } from '../../di/decorators/inject-repository.decorator';
+import { inject } from '../../di/inject.function';
 import { Repository } from '../repository';
 import { Transaction } from './transaction.model';
-import { MigrationEntity } from '../migration';
+import { Entity } from '../../entity/decorators/entity.decorator';
+import { Property } from '../../entity/decorators/property.decorator';
+import { Newable } from '../../types/newable.type';
+import { DataSourceInterface } from '../data-sources/data-source.interface';
+import { PostgresDataSource } from '../data-sources/postgres-data-source.model';
 
 @Entity()
 class Item {
@@ -21,36 +21,16 @@ class Item {
     value!: string;
 }
 
-@DataSource()
-class DbDataSource extends PostgresDataSource {
-    options: PostgresOptions = {
-        host: 'localhost',
-        username: 'postgres',
-        password: 'password',
-        database: 'db',
-        synchronize: true
-    };
-    entities: Newable<BaseEntity>[] = [MigrationEntity, Item];
-}
-
-let container: StartedTestContainer;
-let dataSource: DbDataSource;
+let server: StartedTestServer;
+let dataSource: DataSourceInterface;
 let repo: Repository<Item>;
 
 describe('transaction', () => {
     beforeAll(async () => {
-        container = await new PostgreSqlContainer(POSTGRES_TEST_IMAGE)
-            .withDatabase('db')
-            .withUsername('postgres')
-            .withPassword('password')
-            .start();
-        dataSource = new DbDataSource();
-        dataSource.options = {
-            ...dataSource.options,
-            port: container.getMappedPort(5432)
-        };
-        await dataSource.init();
-        repo = dataSource.getRepository(Item);
+        const dataSourceClass: Newable<PostgresDataSource> = createTestDataSource({ entities: [...defaultTestServerEntities, Item] });
+        server = await startTestServer({ dataSources: [dataSourceClass] });
+        dataSource = inject(dataSourceClass);
+        repo = inject(repositoryTokenFor(Item));
     }, 15000);
 
     it('should see changes inside transaction, but not outside until committed', async () => {
@@ -70,6 +50,6 @@ describe('transaction', () => {
     });
 
     afterAll(async () => {
-        await container?.stop();
+        await server.shutdown();
     });
 });

package/src/di/decorators/inject-repository.decorator.ts

@@ -1,8 +1,9 @@
-import { Repository } from '../../data-source';
+import { Repository } from '../../data-source/repository';
 import { BaseEntity } from '../../entity/base-entity.model';
-import { Newable } from '../../types';
-import { MetadataUtilities } from '../../utilities';
-import { DiToken, InjectionToken } from '../models';
+import { Newable } from '../../types/newable.type';
+import { MetadataUtilities } from '../../utilities/metadata.utilities';
+import { DiToken } from '../models/di-token.model';
+import { InjectionToken } from '../models/injection-token.model';
 
 const allRepositoryTokens: Record<string, DiToken<Repository<BaseEntity>>> = {};
 
@@ -17,7 +18,6 @@ export function repositoryTokenFor<T extends Newable<BaseEntity>>(entity: T): Di
     return allRepositoryTokens[key] as DiToken<Repository<InstanceType<T>>>;
 }
 
-// eslint-disable-next-line jsdoc/require-returns
 /**
  * Marks the parameter to be injected as a Repository of the provided class.
  * @param entityClass - The class of which the Repository should be injected.

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

@@ -1,7 +1,7 @@
-import { MetadataUtilities } from '../../utilities';
-import { DiToken } from '../models';
 
-// eslint-disable-next-line jsdoc/require-returns
+import { MetadataUtilities } from '../../utilities/metadata.utilities';
+import { DiToken } from '../models/di-token.model';
+
 /**
  * Marks the parameter to be injected.
  * @param token - The token that should be used to inject the parameter.

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

@@ -1,22 +1,44 @@
-import { GlobalRegistry } from '../../global';
-import { Newable } from '../../types';
-import { MetadataUtilities } from '../../utilities';
-import { DiToken } from '../models';
+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'
+};
 
-// eslint-disable-next-line jsdoc/require-returns
 /**
  * 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

@@ -1,31 +1,36 @@
 /* eslint-disable jsdoc/require-jsdoc */
 import os from 'node:os';
-import path from 'node:path';
 
-import { ZIBRI_DI_TOKENS } from './zibri-di-tokens.default';
-import { AssetService } from '../../assets';
-import { AuthService, UserService, TwoFactorService } from '../../auth';
-import { BackupService } from '../../backup';
-import { CronService } from '../../cron';
-import { DataSourceService } from '../../data-source';
-import { EmailService, MailingListService } from '../../email';
-import { errorHandler } from '../../error-handling';
-import { HttpClient } from '../../http-client';
-import { LocalizeOptionsInput } from '../../localization';
 import { formatDate } from '../../localization/formatting/format-date.function';
 import { formatPercent } from '../../localization/formatting/format-percent.function';
 import { formatPrice } from '../../localization/formatting/format-price.function';
-import { Logger, LoggerTransport, LogLevel } from '../../logging';
-import { PrometheusMetricsService } from '../../metrics';
-import { MultithreadingService } from '../../multithreading';
-import { OpenApiService } from '../../open-api';
-import { Parser } from '../../parsing';
-import { getCurrentRequest, Router } from '../../routing';
-import { Ms } from '../../utilities';
-import { ValidationService } from '../../validation';
-import { WebsocketService } from '../../websocket';
 import { inject } from '../inject.function';
-import { DiTokenProviderRecord } from '../models';
+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 { UserService } from '../../auth/user/user.service';
+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 { errorHandler } from '../../error-handling/error-handler';
+import { HttpClient } from '../../http-client/http-client';
+import { LocalizeOptionsInput } from '../../localization/models/localize-options.model';
+import { LogLevel } from '../../logging/log-level.enum';
+import { Logger } from '../../logging/logger';
+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 { 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';
+import { ValidationService } from '../../validation/validation.service';
+import { WebsocketService } from '../../websocket/services/websocket.service';
+import { DiTokenProviderRecord } from '../models/di-token.model';
 
 const allThreads: number = os.availableParallelism();
 
@@ -59,24 +64,24 @@ export const ZIBRI_DI_PROVIDERS: DiTokenProviderRecord<typeof ZIBRI_DI_TOKENS> =
     ASSET_SERVICE: { useClass: AssetService },
     BACKUP_SERVICE: { useClass: BackupService },
     GLOBAL_ERROR_HANDLER: { useFactory: () => errorHandler },
+    ERROR_PAGE_TEMPLATE: { useFactory: () => undefined },
     OPEN_API_SERVICE: { useClass: OpenApiService },
     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: () => path.join(__dirname, 'temp') },
+    FILE_UPLOAD_TEMP_FOLDER: { useFactory: () => FsUtilities.getPath(__dirname, 'temp') },
     LOCALIZE_OPTIONS_INPUT: { useFactory: () => ({}) },
     LOCALIZE_OPTIONS: {
         useFactory: () => {

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

@@ -1,22 +1,35 @@
-import { AssetServiceInterface } from '../../assets';
-import { AuthServiceInterface, TwoFactorServiceInterface, UserServiceInterface } from '../../auth';
-import { BackupServiceInterface } from '../../backup';
-import { CronServiceInterface } from '../../cron';
-import { DataSourceServiceInterface } from '../../data-source';
-import { EmailConfigInput, EmailServiceInterface, MailingListServiceInterface } from '../../email';
-import { GlobalErrorHandler } from '../../error-handling';
-import { HttpRequest } from '../../http';
-import { HttpClientInterface } from '../../http-client';
-import { FormatDateFn, FormatPercentFn, FormatPriceFn, LocalizeOptions, LocalizeOptionsInput } from '../../localization';
-import { BaseLoggerTransportConfig, LoggerInterface, LoggerTransport, LogLevel } from '../../logging';
-import { MetricsServiceInterface } from '../../metrics';
-import { MultithreadingOptions, MultithreadingServiceInterface } from '../../multithreading';
-import { OpenApiServiceInterface } from '../../open-api';
-import { ParserInterface } from '../../parsing';
-import { RouterInterface } from '../../routing';
-import { ValidationServiceInterface } from '../../validation';
-import { WebsocketOptions, WebsocketServiceInterface } from '../../websocket';
-import { InjectionToken, TokenRecord } from '../models';
+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 { EmailConfigInput } from '../../email/models/email-config.model';
+import { GlobalErrorHandler, ErrorPageTemplate } from '../../error-handling/error-handler.model';
+import { HttpRequest } from '../../http/http-request.model';
+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 { LogLevel } from '../../logging/log-level.enum';
+import { LoggerInterface } from '../../logging/logger.interface';
+import { LoggerTransport, BaseLoggerTransportConfig } from '../../logging/transport/logger-transport.model';
+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 { ParserInterface } from '../../parsing/parser.interface';
+import { RouterInterface } from '../../routing/router.interface';
+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';
+import { TokenRecord } from '../models/di-token.model';
+import { InjectionToken } from '../models/injection-token.model';
 
 // eslint-disable-next-line jsdoc/require-jsdoc
 function ziToken<T = never>(k: `zi.${string}`): InjectionToken<T> {
@@ -36,6 +49,7 @@ export const ZIBRI_DI_TOKENS = {
     ASSET_SERVICE: ziToken<AssetServiceInterface>('zi.asset_service'),
     BACKUP_SERVICE: ziToken<BackupServiceInterface>('zi.backup_service'),
     GLOBAL_ERROR_HANDLER: ziToken<GlobalErrorHandler>('zi.global_error_handler'),
+    ERROR_PAGE_TEMPLATE: ziToken<ErrorPageTemplate | undefined>('zi.error_page_template'),
     OPEN_API_SERVICE: ziToken<OpenApiServiceInterface>('zi.open_api_service'),
     AUTH_SERVICE: ziToken<AuthServiceInterface>('zi.auth_service'),
     TWO_FACTOR_SERVICE: ziToken<TwoFactorServiceInterface>('zi.two_factor_service'),
@@ -50,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<string>('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'),
@@ -63,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

@@ -1,10 +1,12 @@
-import { GlobalRegistry } from '../global';
-import { Newable } from '../types';
-import { MetadataUtilities, ObjectUtilities } from '../utilities';
-import { ZIBRI_DI_TOKENS } from './default';
+import { GlobalRegistry } from '../global/global-registry';
+import { Newable } from '../types/newable.type';
+import { MetadataUtilities } from '../utilities/metadata.utilities';
+import { ObjectUtilities } from '../utilities/object.utilities';
 import { ZIBRI_DI_PROVIDERS } from './default/zibri-di-providers.default';
+import { ZIBRI_DI_TOKENS } from './default/zibri-di-tokens.default';
 import { NoProviderError } from './errors/no-provider.error';
-import { DiToken, DiProvider, providersFromTokenRecord } from './models';
+import { DiProvider } from './models/di-provider.model';
+import { DiToken, providersFromTokenRecord } from './models/di-token.model';
 
 /**
  * The dependency injection container.
@@ -24,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.
@@ -45,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);
@@ -63,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);
         }
@@ -76,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/get-dependency-stack-trace.function.ts

@@ -1,4 +1,4 @@
-import { MetadataUtilities } from '../../utilities';
+import { MetadataUtilities } from '../../utilities/metadata.utilities';
 
 /**
  * Gets the stack trace for dependency resolution.

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

@@ -1,6 +1,7 @@
 import { getDependencyStackTrace } from './get-dependency-stack-trace.function';
-import { MetadataUtilities } from '../../utilities';
-import { DiToken, InjectionToken } from '../models';
+import { MetadataUtilities } from '../../utilities/metadata.utilities';
+import { DiToken } from '../models/di-token.model';
+import { InjectionToken } from '../models/injection-token.model';
 
 /**
  * Get the no providers error message from the provided token and stack.
@@ -18,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/inject.function.ts

@@ -1,5 +1,5 @@
 import { DiContainer } from './di-container';
-import { DiToken } from './models';
+import { DiToken } from './models/di-token.model';
 
 /**
  * Injects the registered value for the provided token.

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

@@ -1,5 +1,17 @@
 import { DiToken } from './di-token.model';
-import { Newable, OmitStrict } from '../../types';
+import { Newable } from '../../types/newable.type';
+import { OmitStrict } from '../../types/omit-strict.type';
+
+/**
+ * A type safe way to define providers when eg. Inside arrays.
+ *
+ * Does not do anything else.
+ * @param provider - The provider.
+ * @returns Just the given provider, without doing anything at all.
+ */
+export function defineProvider<T>(provider: DiProvider<T>): DiProvider<T> {
+    return provider;
+}
 
 /**
  * A DI provider.

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

@@ -1,7 +1,7 @@
 import { DiProvider, DiProviderWithoutToken } from './di-provider.model';
 import { InjectionToken } from './injection-token.model';
-import { Newable } from '../../types';
-import { ObjectUtilities } from '../../utilities';
+import { Newable } from '../../types/newable.type';
+import { ObjectUtilities } from '../../utilities/object.utilities';
 
 /**
  * A token where DI values can be registered under.

package/src/di/models/injection-token.model.ts

@@ -1,4 +1,3 @@
-
 const allInjectionTokenKeys: string[] = [];
 
 /**