zibri 2.2.0 → 2.3.0

package/src/assets/asset.service.ts

@@ -1,20 +1,20 @@
-import { Dirent } from 'fs';
-import { readdir } from 'fs/promises';
-import path from 'path';
+import { Dirent } from 'node:fs';
 
 import express from 'express';
 
 import { AssetServiceInterface } from './asset-service.interface';
 import { ZibriApplication } from '../application';
-import { Inject, ZIBRI_DI_TOKENS } from '../di';
-import { GlobalRegistry } from '../global';
-import { renderPageTemplate } from '../handlebars';
-import { HttpMethod } from '../http';
-import type { LoggerInterface } from '../logging';
+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 { OnAppInit } from '../global/on-app-init.interface';
+import { HttpMethod } from '../http/http-method.enum';
+import { type LoggerInterface } from '../logging/logger.interface';
 import { FileResponse } from '../parsing/form-data/file-response.model';
-import { HtmlResponse } from '../parsing/html/html-response.model';
-import { Route } from '../routing';
-import { ObjectUtilities } from '../utilities';
+import { Route } from '../routing/controller-route-configuration.model';
+import { FsUtilities, FsPath } from '../utilities/fs.utilities';
+import { ObjectUtilities } from '../utilities/object.utilities';
 
 // eslint-disable-next-line jsdoc/require-jsdoc
 type FileNode = { type: 'file', name: string, route: string };
@@ -34,15 +34,14 @@ type WalkedPath = { relPath: string, isFile: boolean };
 /**
  * Default asset service implementation of Zibri.
  */
-export class AssetService implements AssetServiceInterface {
+@Injectable({ register: 'onUse' })
+export class AssetService implements AssetServiceInterface, OnAppInit {
     // eslint-disable-next-line jsdoc/require-jsdoc
-    readonly assetsPath: string = path.join(__dirname, 'assets');
+    readonly assetsPath: FsPath = FsUtilities.getPath(__dirname, 'assets');
     // eslint-disable-next-line jsdoc/require-jsdoc
-    readonly publicAssetsPath: string = path.join(this.assetsPath, 'public');
+    readonly publicAssetsPath: FsPath = FsUtilities.getPath(this.assetsPath, 'public');
     // eslint-disable-next-line jsdoc/require-jsdoc
-    readonly pageTemplatePath: string = path.join(this.assetsPath, 'templates', 'pages');
-    // eslint-disable-next-line jsdoc/require-jsdoc
-    readonly emailTemplatePath: string = path.join(this.assetsPath, 'templates', 'emails');
+    readonly componentTemplatePath: FsPath = FsUtilities.getPath(this.assetsPath, 'templates', 'components');
     // eslint-disable-next-line jsdoc/require-jsdoc
     readonly assetsRoute: Route = '/assets';
 
@@ -52,52 +51,26 @@ export class AssetService implements AssetServiceInterface {
     ) {}
 
     // eslint-disable-next-line jsdoc/require-jsdoc
-    async attachTo(app: ZibriApplication): Promise<void> {
+    async onAppInit(app: ZibriApplication): Promise<void> {
         await this.logger.info(`registers public static assets from folder "${this.publicAssetsPath}" at ${this.assetsRoute}`);
         app.use(this.assetsRoute, express.static(this.publicAssetsPath));
-        await app.router.register({
-            httpMethod: HttpMethod.GET,
-            route: '/',
-            handler: async () => {
-                const html: string = await renderPageTemplate(
-                    'index.hbs',
-                    {
-                        name: GlobalRegistry.getAppData('name'),
-                        base: {
-                            title: GlobalRegistry.getAppData('name') ?? ''
-                        }
-                    }
-                );
-                return HtmlResponse.fromString(html);
-            }
-        });
-        await app.router.register({
-            httpMethod: HttpMethod.GET,
-            route: this.assetsRoute,
-            handler: async () => {
-                const tree: TreeNode[] = await this.buildFileTree();
-                const html: string = await renderPageTemplate(
-                    'assets.hbs',
-                    {
-                        name: GlobalRegistry.getAppData('name'),
-                        base: {
-                            title: GlobalRegistry.getAppData('name') ?? ''
-                        },
-                        tree
-                    }
-                );
-                return HtmlResponse.fromString(html);
-            }
-        });
-        await app.router.register({
+
+        await inject(ZIBRI_DI_TOKENS.ROUTER).registerRoute({
             httpMethod: HttpMethod.GET,
             route: '/favicon.ico',
-            handler: () => FileResponse.fromPath(path.join(this.publicAssetsPath, 'favicon.png'))
+            handler: () => FileResponse.fromPath(FsUtilities.getPath(this.publicAssetsPath, 'favicon.png'))
         });
 
+        // await app.router.registerRoute({
+        //     httpMethod: HttpMethod.GET,
+        //     route: '/favicon.ico',
+        //     handler: () => FileResponse.fromPath(FsUtilities.getPath(this.publicAssetsPath, 'favicon.png'))
+        // });
+
     }
 
-    private async buildFileTree(): Promise<TreeNode[]> {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    async buildFileTree(): Promise<TreeNode[]> {
         // 1) Gather every path relative to assetsPath
         const items: WalkedPath[] = await this.walk(this.publicAssetsPath);
 
@@ -105,7 +78,7 @@ export class AssetService implements AssetServiceInterface {
         const root: NodeMap = {};
 
         for (const item of items) {
-            const segments: string[] = item.relPath.split(path.sep);
+            const segments: string[] = item.relPath.split(FsUtilities.separator);
             let current: NodeMap = root;
 
             for (let i: number = 0; i < segments.length; i++) {
@@ -151,14 +124,14 @@ export class AssetService implements AssetServiceInterface {
     }
 
     private async walk(
-        dir: string,
-        base: string = dir
+        dir: FsPath,
+        base: FsPath = dir
     ): Promise<WalkedPath[]> {
-        const entries: Dirent[] = await readdir(dir, { withFileTypes: true });
+        const entries: Dirent[] = await FsUtilities.readdir(dir);
         const results: WalkedPath[] = [];
         for (const entry of entries) {
-            const abs: string = path.join(dir, entry.name);
-            const rel: string = path.relative(base, abs);
+            const abs: FsPath = FsUtilities.getPath(dir, entry.name);
+            const rel: FsPath = FsUtilities.relative(base, abs);
             if (entry.isDirectory()) {
                 results.push({ relPath: rel, isFile: false });
                 results.push(...await this.walk(abs, base));

package/src/auth/2fa/methods/otp/otp-credentials.model.ts

@@ -1,10 +1,12 @@
-import { Entity, OmitClass, Property } from '../../../../entity';
 import { BaseEntity } from '../../../../entity/base-entity.model';
+import { Entity } from '../../../../entity/decorators/entity.decorator';
+import { Property } from '../../../../entity/decorators/property.decorator';
+import { OmitClass } from '../../../../entity/omit-class.model';
 
 /**
  * Credentials for a one time password.
  */
-@Entity()
+@Entity({ allowOrphan: true })
 export class OtpCredentials extends BaseEntity {
     /**
      * The user id that these credentials belong to.

package/src/auth/2fa/methods/otp/otp.two-factor-method.ts

@@ -1,16 +1,18 @@
 import { randomBytes } from 'node:crypto';
 
 import { HiBase32Utilities } from './hi-base32.utilities';
-import { Repository } from '../../../../data-source';
-import { inject, Inject, repositoryTokenFor, ZIBRI_DI_TOKENS } from '../../../../di';
-import { UnauthorizedError } from '../../../../error-handling';
-import { HttpRequest, KnownHeader } from '../../../../http';
-import { validateEntitiesRegistered } from '../../../../utilities';
-import { WebsocketRequest } from '../../../../websocket';
-import { BaseUser } from '../../../models';
 import { TwoFactorMethod } from '../two-factor-method.interface';
 import { OtpCredentials, OtpCredentialsCreateData } from './otp-credentials.model';
 import { OtpUtilities } from './otp.utilities';
+import { Repository } from '../../../../data-source/repository';
+import { InjectRepository } from '../../../../di/decorators/inject-repository.decorator';
+import { Inject } from '../../../../di/decorators/inject.decorator';
+import { ZIBRI_DI_TOKENS } from '../../../../di/default/zibri-di-tokens.default';
+import { UnauthorizedError } from '../../../../error-handling/errors/unauthorized.error';
+import { HttpRequest } from '../../../../http/http-request.model';
+import { KnownHeader } from '../../../../http/known-header.enum';
+import { WebsocketRequest } from '../../../../websocket/models/websocket-request.model';
+import { BaseUser } from '../../../models/base-user.model';
 
 /**
  * The data for confirming the registration of the otp two factor method.
@@ -27,29 +29,15 @@ export type OtpConfirmRegisterData = {
  */
 export class OtpTwoFactorMethod implements TwoFactorMethod<never, OtpConfirmRegisterData> {
 
-    private get otpCredentialsRepository(): Repository<OtpCredentials, OtpCredentialsCreateData> {
-        return inject(repositoryTokenFor(OtpCredentials));
-    }
-
     constructor(
         @Inject(ZIBRI_DI_TOKENS.OTP_HEADER)
         private readonly otpHeader: KnownHeader,
         @Inject(ZIBRI_DI_TOKENS.OTP_LENGTH)
-        private readonly otpLength: number
+        private readonly otpLength: number,
+        @InjectRepository(OtpCredentials)
+        private readonly otpCredentialsRepository: Repository<OtpCredentials, OtpCredentialsCreateData>
     ) {}
 
-    // eslint-disable-next-line jsdoc/require-jsdoc
-    init(): void {
-        if (this.otpHeader == undefined) {
-            throw new Error('No value provided for ZIBRI_DI_TOKENS.OTP_HEADER');
-        }
-        if (this.otpLength == undefined) {
-            throw new Error('No value provided for ZIBRI_DI_TOKENS.OTP_LENGTH');
-        }
-
-        validateEntitiesRegistered(this.constructor.name, OtpCredentials);
-    }
-
     // eslint-disable-next-line jsdoc/require-jsdoc
     async requestRegisterForUser<Role extends string, UserType extends BaseUser<Role>>(
         user: UserType

package/src/auth/2fa/methods/two-factor-method.interface.ts

@@ -1,15 +1,11 @@
-import { HttpRequest } from '../../../http';
-import { WebsocketRequest } from '../../../websocket';
-import { BaseUser } from '../../models';
+import { HttpRequest } from '../../../http/http-request.model';
+import { WebsocketRequest } from '../../../websocket/models/websocket-request.model';
+import { BaseUser } from '../../models/base-user.model';
 
 /**
  * Interface for a two factor method.
  */
 export interface TwoFactorMethod<TwoFactorRequestRegisterData, TwoFactorConfirmRegisterData> {
-    /**
-     * Initializes the two factor method.
-     */
-    init: () => void,
     /**
      * Requests to register the two factor method for the given user.
      */
@@ -35,4 +31,27 @@ export interface TwoFactorMethod<TwoFactorRequestRegisterData, TwoFactorConfirmR
         user: UserType,
         request: HttpRequest | WebsocketRequest
     ) => void | Promise<void>
+}
+
+/**
+ * Checks whether or not the given value is a two factor method.
+ * @param value - The value to check.
+ * @returns True if all keys of the TwoFactorMethod interface are present, false otherwise.
+ */
+export function isTwoFactorMethod(value: unknown): value is TwoFactorMethod<unknown, unknown> {
+    if (value == undefined) {
+        return false;
+    }
+    if (typeof value !== 'object') {
+        return false;
+    }
+
+    const keys: (keyof TwoFactorMethod<unknown, unknown>)[] = [
+        'requestRegisterForUser',
+        'confirmRegisterForUser',
+        'unregisterForUser',
+        'validate'
+    ];
+
+    return !keys.find(key => !(key in value));
 }

package/src/auth/2fa/two-factor-methods.model.ts

@@ -1,5 +1,5 @@
-import { TwoFactorMethod } from './methods';
-import { Newable } from '../../types';
+import { TwoFactorMethod } from './methods/two-factor-method.interface';
+import { Newable } from '../../types/newable.type';
 
 /**
  * A generic two factor method array.

package/src/auth/2fa/two-factor-service.interface.ts

@@ -1,8 +1,8 @@
-import { HttpRequest } from '../../http';
-import { WebsocketRequest } from '../../websocket';
-import { BaseUser } from '../models';
-import { TwoFactorMethod } from './methods';
+import { TwoFactorMethod } from './methods/two-factor-method.interface';
 import { TwoFactorMethods } from './two-factor-methods.model';
+import { HttpRequest } from '../../http/http-request.model';
+import { WebsocketRequest } from '../../websocket/models/websocket-request.model';
+import { BaseUser } from '../models/base-user.model';
 
 /**
  * Interface for a two factor service.
@@ -12,10 +12,6 @@ export interface TwoFactorServiceInterface {
      * The different two factor methods provided.
      */
     readonly twoFactorMethods: TwoFactorMethods,
-    /**
-     * Initializes the service.
-     */
-    init: (twoFactorMethods: TwoFactorMethods) => Promise<void>,
     /**
      * Requests the registration of the given two factor method for the given user.
      */

package/src/auth/2fa/two-factor.service.ts

@@ -1,31 +1,34 @@
-import { inject, ZIBRI_DI_TOKENS } from '../../di';
+import { ZibriApplication } from '../../application';
+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 { register } from '../../di/register.function';
-import { HttpRequest } from '../../http';
-import { LoggerInterface } from '../../logging';
-import { WebsocketRequest } from '../../websocket';
-import { BaseUser } from '../models';
-import { TwoFactorMethod } from './methods';
+import { OnAppInit } from '../../global/on-app-init.interface';
+import { HttpRequest } from '../../http/http-request.model';
+import { type LoggerInterface } from '../../logging/logger.interface';
+import { WebsocketRequest } from '../../websocket/models/websocket-request.model';
+import { BaseUser } from '../models/base-user.model';
+import { TwoFactorMethod } from './methods/two-factor-method.interface';
 import { TwoFactorMethods } from './two-factor-methods.model';
 import { TwoFactorServiceInterface } from './two-factor-service.interface';
 
 /**
  * Default implementation of the two factor service.
  */
-export class TwoFactorService implements TwoFactorServiceInterface {
+@Injectable({ register: 'onUse' })
+export class TwoFactorService implements TwoFactorServiceInterface, OnAppInit {
     // eslint-disable-next-line jsdoc/require-jsdoc
     readonly twoFactorMethods: TwoFactorMethods = [];
 
-    /**
-     * A logger.
-     */
-    protected readonly logger: LoggerInterface;
-
-    constructor() {
-        this.logger = inject(ZIBRI_DI_TOKENS.LOGGER);
-    }
+    constructor(
+        @Inject(ZIBRI_DI_TOKENS.LOGGER)
+        private readonly logger: LoggerInterface
+    ) { }
 
     // eslint-disable-next-line jsdoc/require-jsdoc
-    async init(twoFactorMethods: TwoFactorMethods): Promise<void> {
+    async onAppInit({ options }: ZibriApplication): Promise<void> {
+        const { twoFactorMethods } = options;
         for (const method of twoFactorMethods) {
             register({ token: method, useClass: method });
             this.twoFactorMethods.push(method);
@@ -36,7 +39,6 @@ export class TwoFactorService implements TwoFactorServiceInterface {
             );
             for (const method of twoFactorMethods) {
                 await this.logger.info(`  - ${method.name}`);
-                inject(method).init();
             }
         }
     }

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

@@ -1,9 +1,15 @@
 import { BaseEntity } from '../entity/base-entity.model';
-import { HttpRequest } from '../http';
-import { Newable } from '../types';
-import { WebsocketRequest } from '../websocket';
-import { BaseUser, BelongsToMetadata, HasRoleMetadata, IsLoggedInMetadata, IsNotLoggedInMetadata, Require2faMetadata } from './models';
-import { AuthStrategies, AuthStrategyInterface } from './strategies';
+import { HttpRequest } from '../http/http-request.model';
+import { Newable } from '../types/newable.type';
+import { BaseUser } from './models/base-user.model';
+import { BelongsToMetadata } from './models/belongs-to-metadata.model';
+import { HasRoleMetadata } from './models/has-role-metadata.model';
+import { IsLoggedInMetadata } from './models/is-logged-in-metadata.model';
+import { IsNotLoggedInMetadata } from './models/is-not-logged-in-metadata.model';
+import { Require2faMetadata } from './models/require-2fa-metadata.model';
+import { AuthStrategies } from './strategies/auth-strategies.model';
+import { AuthStrategyInterface } from './strategies/auth-strategy.interface';
+import { WebsocketRequest } from '../websocket/models/websocket-request.model';
 
 /**
  * Interface for an auth service.
@@ -13,10 +19,6 @@ export interface AuthServiceInterface {
      * The different auth strategies provided.
      */
     readonly strategies: AuthStrategies,
-    /**
-     * Initializes the service.
-     */
-    init: (strategies: AuthStrategies) => void | Promise<void>,
     /**
      * Checks if the provided method on the provided controller can be accessed by the current user.
      */

package/src/auth/auth.service.ts

@@ -1,40 +1,48 @@
-import { inject, ZIBRI_DI_TOKENS } from '../di';
+import { AuthServiceInterface } from './auth-service.interface';
+import { ZibriApplication } from '../application';
 import { register } from '../di/register.function';
 import { BaseEntity } from '../entity/base-entity.model';
-import { UnauthorizedError } from '../error-handling';
-import { HttpRequest } from '../http';
-import { LoggerInterface } from '../logging';
-import { Newable } from '../types';
-import { MetadataUtilities, PromiseUtilities } from '../utilities';
-import { WebsocketRequest } from '../websocket';
-import { TwoFactorServiceInterface } from './2fa';
-import { AuthServiceInterface } from './auth-service.interface';
-import { BaseUser, BelongsToMetadata, HasRoleMetadata, IsLoggedInMetadata, IsNotLoggedInMetadata, Require2faMetadata, SkipAuthMetadata, SkipBelongsToMetadata, SkipHasRoleMetadata, SkipIsLoggedInMetadata, SkipIsNotLoggedInMetadata, SkipRequire2faMetadata } from './models';
-import { AuthStrategies, AuthStrategyInterface } from './strategies';
+import { type TwoFactorServiceInterface } from './2fa/two-factor-service.interface';
+import { BaseUser } from './models/base-user.model';
+import { BelongsToMetadata, SkipBelongsToMetadata } from './models/belongs-to-metadata.model';
+import { HasRoleMetadata, SkipHasRoleMetadata } from './models/has-role-metadata.model';
+import { IsLoggedInMetadata, SkipIsLoggedInMetadata } from './models/is-logged-in-metadata.model';
+import { IsNotLoggedInMetadata, SkipIsNotLoggedInMetadata } from './models/is-not-logged-in-metadata.model';
+import { Require2faMetadata, SkipRequire2faMetadata } from './models/require-2fa-metadata.model';
+import { SkipAuthMetadata } from './models/skip-auth-metadata.model';
+import { AuthStrategies } from './strategies/auth-strategies.model';
+import { AuthStrategyInterface } from './strategies/auth-strategy.interface';
+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 { UnauthorizedError } from '../error-handling/errors/unauthorized.error';
+import { OnAppInit } from '../global/on-app-init.interface';
+import { HttpRequest } from '../http/http-request.model';
+import { type LoggerInterface } from '../logging/logger.interface';
+import { Newable } from '../types/newable.type';
+import { MetadataUtilities } from '../utilities/metadata.utilities';
+import { PromiseUtilities } from '../utilities/promise.utilities';
+import { WebsocketRequest } from '../websocket/models/websocket-request.model';
 
 /**
  * Default auth service implementation of Zibri.
  */
-export class AuthService implements AuthServiceInterface {
-    /**
-     * A logger.
-     */
-    protected readonly logger: LoggerInterface;
-
+@Injectable({ register: 'onUse' })
+export class AuthService implements AuthServiceInterface, OnAppInit {
     // eslint-disable-next-line jsdoc/require-jsdoc
     readonly strategies: AuthStrategies = [];
 
-    // eslint-disable-next-line jsdoc/require-jsdoc
-    get twoFactorService(): TwoFactorServiceInterface {
-        return inject(ZIBRI_DI_TOKENS.TWO_FACTOR_SERVICE);
-    }
-
-    constructor() {
-        this.logger = inject(ZIBRI_DI_TOKENS.LOGGER);
-    }
+    constructor(
+        @Inject(ZIBRI_DI_TOKENS.LOGGER)
+        private readonly logger: LoggerInterface,
+        @Inject(ZIBRI_DI_TOKENS.TWO_FACTOR_SERVICE)
+        private readonly twoFactorService: TwoFactorServiceInterface
+    ) {}
 
     // eslint-disable-next-line jsdoc/require-jsdoc
-    async init(authStrategies: AuthStrategies): Promise<void> {
+    async onAppInit({ options }: ZibriApplication): Promise<void> {
+        const { authStrategies } = options;
         for (const strategy of authStrategies) {
             register({ token: strategy, useClass: strategy });
             this.strategies.push(strategy);
@@ -45,7 +53,6 @@ export class AuthService implements AuthServiceInterface {
             );
             for (const strategy of authStrategies) {
                 await this.logger.info(`  - ${strategy.name}`);
-                inject(strategy).init();
             }
         }
     }

package/src/auth/decorators/auth.decorator.ts

@@ -3,7 +3,7 @@ import { hasRoleDecorator, HasRoleFn } from './has-role.decorator';
 import { isLoggedInDecorator, IsLoggedInFn } from './is-logged-in.decorator';
 import { isNotLoggedInDecorator, IsNotLoggedInFn } from './is-not-logged-in.decorator';
 import { require2faDecorator, Require2faFn } from './require-2fa.decorator';
-import { MetadataUtilities } from '../../utilities';
+import { MetadataUtilities } from '../../utilities/metadata.utilities';
 
 /**
  * Bundles decorators for marking controller endpoints for authentication and authorization.
@@ -40,7 +40,6 @@ export namespace Auth {
      */
     export const require2fa: Require2faFn = require2faDecorator;
 
-    // eslint-disable-next-line jsdoc/require-returns
     /**
      * Skips all auth related validation.
      */

package/src/auth/decorators/belongs-to.decorator.ts

@@ -1,8 +1,8 @@
 import { BaseEntity } from '../../entity/base-entity.model';
-import { Newable } from '../../types';
-import { MetadataUtilities } from '../../utilities';
-import { BelongsToMetadata } from '../models';
-import { AuthStrategies } from '../strategies';
+import { Newable } from '../../types/newable.type';
+import { MetadataUtilities } from '../../utilities/metadata.utilities';
+import { BelongsToMetadata } from '../models/belongs-to-metadata.model';
+import { AuthStrategies } from '../strategies/auth-strategies.model';
 
 /**
  * The type of the belongs to decorator.

package/src/auth/decorators/current-user.decorator.ts

@@ -1,5 +1,5 @@
-import { MetadataUtilities } from '../../utilities';
-import { AuthStrategies } from '../strategies';
+import { MetadataUtilities } from '../../utilities/metadata.utilities';
+import { AuthStrategies } from '../strategies/auth-strategies.model';
 
 /**
  * Metadata of the \@CurrentUser decorator.
@@ -20,7 +20,6 @@ export type CurrentUserMetadata = {
     allowedStrategies?: AuthStrategies
 };
 
-// eslint-disable-next-line jsdoc/require-returns
 /**
  * Marks the parameter to be injected as the currently logged in user.
  * @param required - If set to false, the injected user is allowed to be undefined.

package/src/auth/decorators/has-role.decorator.ts

@@ -1,6 +1,6 @@
-import { MetadataUtilities } from '../../utilities';
-import { HasRoleMetadata } from '../models';
-import { AuthStrategies } from '../strategies';
+import { MetadataUtilities } from '../../utilities/metadata.utilities';
+import { HasRoleMetadata } from '../models/has-role-metadata.model';
+import { AuthStrategies } from '../strategies/auth-strategies.model';
 
 /**
  * The type of the has role decorator.

package/src/auth/decorators/is-logged-in.decorator.ts

@@ -1,6 +1,6 @@
-import { MetadataUtilities } from '../../utilities';
-import { IsLoggedInMetadata } from '../models';
-import { AuthStrategies } from '../strategies';
+import { MetadataUtilities } from '../../utilities/metadata.utilities';
+import { IsLoggedInMetadata } from '../models/is-logged-in-metadata.model';
+import { AuthStrategies } from '../strategies/auth-strategies.model';
 
 /**
  * The type of the is logged in decorator.

package/src/auth/decorators/is-not-logged-in.decorator.ts

@@ -1,6 +1,6 @@
-import { MetadataUtilities } from '../../utilities';
-import { IsNotLoggedInMetadata } from '../models';
-import { AuthStrategies } from '../strategies';
+import { MetadataUtilities } from '../../utilities/metadata.utilities';
+import { IsNotLoggedInMetadata } from '../models/is-not-logged-in-metadata.model';
+import { AuthStrategies } from '../strategies/auth-strategies.model';
 
 /**
  * The type of the is not logged in decorator.

package/src/auth/decorators/require-2fa.decorator.ts

@@ -1,6 +1,6 @@
-import { MetadataUtilities } from '../../utilities';
-import { TwoFactorMethods } from '../2fa';
-import { Require2faMetadata } from '../models';
+import { MetadataUtilities } from '../../utilities/metadata.utilities';
+import { TwoFactorMethods } from '../2fa/two-factor-methods.model';
+import { Require2faMetadata } from '../models/require-2fa-metadata.model';
 
 /**
  * The type of the require 2fa decorator.

package/src/auth/decorators/user-repo.decorator.ts

@@ -1,10 +1,11 @@
-import { DiToken } from '../../di';
-import { GlobalRegistry } from '../../global';
-import { Newable } from '../../types';
-import { MetadataUtilities } from '../../utilities';
-import { BaseUser, UserRepositories } from '../models';
 
-// eslint-disable-next-line jsdoc/require-returns
+import { DiToken } from '../../di/models/di-token.model';
+import { GlobalRegistry } from '../../global/global-registry';
+import { Newable } from '../../types/newable.type';
+import { MetadataUtilities } from '../../utilities/metadata.utilities';
+import { BaseUser } from '../models/base-user.model';
+import { UserRepositories } from '../models/user-repositories.model';
+
 /**
  * Marks the given class as a user repository.
  * This registers it to be injected directly, without using "@InjectRepository".

package/src/auth/models/base-user.model.ts

@@ -1,6 +1,7 @@
-import { Property } from '../../entity';
 import { BaseEntity } from '../../entity/base-entity.model';
-import { AnyEnum, Newable } from '../../types';
+import { Property } from '../../entity/decorators/property.decorator';
+import { AnyEnum } from '../../types/any-enum.type';
+import { Newable } from '../../types/newable.type';
 
 /**
  * Common properties shared by all users.

package/src/auth/models/belongs-to-metadata.model.ts

@@ -1,7 +1,7 @@
-import { AuthStrategies } from '../strategies';
 import { SkipAuthMetadata } from './skip-auth-metadata.model';
 import { BaseEntity } from '../../entity/base-entity.model';
-import { Newable } from '../../types';
+import { Newable } from '../../types/newable.type';
+import { AuthStrategies } from '../strategies/auth-strategies.model';
 
 /**
  * Metadata for the \@Auth.belongsTo decorator.

package/src/auth/models/has-role-metadata.model.ts

@@ -1,5 +1,5 @@
-import { AuthStrategies } from '../strategies';
 import { SkipAuthMetadata } from './skip-auth-metadata.model';
+import { AuthStrategies } from '../strategies/auth-strategies.model';
 
 /**
  * Metadata for the \@Auth.hasRole decorator.

package/src/auth/models/is-logged-in-metadata.model.ts

@@ -1,5 +1,5 @@
-import { AuthStrategies } from '../strategies';
 import { SkipAuthMetadata } from './skip-auth-metadata.model';
+import { AuthStrategies } from '../strategies/auth-strategies.model';
 
 /**
  * Metadata for the \@Auth.isLoggedIn decorator.

package/src/auth/models/is-not-logged-in-metadata.model.ts

@@ -1,5 +1,5 @@
-import { AuthStrategies } from '../strategies';
 import { SkipAuthMetadata } from './skip-auth-metadata.model';
+import { AuthStrategies } from '../strategies/auth-strategies.model';
 
 /**
  * Metadata for the \@Auth.isNotLoggedIn decorator.