zibri 2.2.0 → 2.2.1

package/src/utilities/fs.utilities.ts

@@ -0,0 +1,297 @@
+import { createReadStream, createWriteStream, Dirent, ReadStream, Stats, WriteStream } from 'node:fs';
+import { access, writeFile, mkdir, readFile, readdir, rm, rename, stat } from 'node:fs/promises';
+import path from 'node:path';
+
+import { glob } from 'glob';
+
+/**
+ * The type for a file path.
+ */
+export type Path = string & {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    __brand: 'Path'
+};
+
+/**
+ * Definition for a line in a file.
+ * Contains its index, as well as its content.
+ */
+export type FileLine = {
+    /**
+     * The index of the line inside the file lines.
+     */
+    index: number,
+    /**
+     * The content of the line.
+     */
+    content: string
+};
+
+/**
+ * Encapsulates functionality of the fs package.
+ */
+export abstract class FsUtilities {
+    /**
+     * The file system separator.
+     */
+    static readonly separator: '\\' | '/' = path.sep;
+
+    /**
+     * Creates a new read stream on the file at the given path.
+     * @param path - The path to read from.
+     * @param options - Additional streaming options.
+     * @returns The newly created read stream.
+     */
+    static createReadStream(path: Path, options?: Exclude<Parameters<typeof createReadStream>[1], BufferEncoding>): ReadStream {
+        return createReadStream(path, { encoding: 'utf8', ...options });
+    }
+
+    /**
+     * Creates a new write stream on the file at the given path.
+     * @param path - The path to write to.
+     * @param options - Additional streaming options.
+     * @returns The newly created write stream.
+     */
+    static createWriteStream(path: Path, options?: Exclude<Parameters<typeof createWriteStream>[1], BufferEncoding>): WriteStream {
+        return createWriteStream(path, { encoding: 'utf8', ...options });
+    }
+
+    /**
+     * Return the extension of the path, from the last '.' to end of string in the last portion of the path. If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string.
+     * @param p - The path to evaluate.
+     * @returns The file extension.
+     */
+    static extensionName(p: Path): string {
+        return path.extname(p);
+    }
+
+    /**
+     * Return the last portion of a path. Similar to the Unix basename command. Often used to extract the file name from a fully qualified path.
+     * @param p - The path to evaluate.
+     * @returns The last portion of the given path.
+     */
+    static baseName(p: Path): string {
+        return path.basename(p);
+    }
+
+    /**
+     * Return the directory name of a path. Similar to the Unix dirname command.
+     * @param p - The path to evaluate.
+     * @returns The name of the directory as a string.
+     */
+    static dirName(p: Path): string {
+        return path.dirname(p);
+    }
+
+    /**
+     * Solve the relative path from {from} to {to} based on the current working directory.
+     * At times we have two absolute paths, and we need to derive the relative path from one to the other.
+     * This is actually the reverse transform of path.resolve.
+     * @param from - Where the relative path should start.
+     * @param to - Where the relative path should end/point to.
+     * @returns The fully resolved relative path.
+     */
+    static relative(from: Path, to: Path): Path {
+        return path.relative(from, to) as Path;
+    }
+
+    /**
+     * The right-most parameter is considered {to}. Other parameters are considered an array of {from}.
+     * Starting from leftmost {from} parameter, resolves {to} to an absolute path.
+     * If {to} isn't already absolute, {from} arguments are prepended in right to left order, until an absolute path is found.
+     * If after using all {from} paths still no absolute path is found, the current working directory is used as well.
+     * The resulting path is normalized, and trailing slashes are removed unless the path gets resolved to the root directory.
+     * @param paths - The paths that should be resolved.
+     * @returns The resolved path.
+     */
+    static resolve(...paths: string[]): Path {
+        return path.resolve(...paths) as Path;
+    }
+
+    /**
+     * Perform an asynchronous glob search for the pattern(s) specified.
+     * @param pattern - The pattern to search for.
+     * @returns The matching paths.
+     */
+    static async glob(pattern: string | string[]): Promise<Path[]> {
+        return await glob(pattern) as Path[];
+    }
+
+    /**
+     * Gets a path from the provided segments.
+     * @param paths - The segments to get the path from.
+     * @returns The cleaned up path.
+     * @throws When the path could not be built from the provided segments.
+     */
+    static getPath(...paths: string[]): Path {
+        try {
+            const basePath: string = path.join(...paths);
+            if (path.isAbsolute(basePath)) {
+                return basePath as Path;
+            }
+            return path.join('', basePath) as Path;
+        }
+        catch (error) {
+            throw new Error(`Error trying to get the path ${paths.join()}`, { cause: error });
+        }
+    }
+
+    /**
+     * Gives information about the file or directory at the provided path.
+     * @param path - The path to get info on.
+     * @returns Information like file size etc.
+     */
+    static async stat(path: Path): Promise<Stats> {
+        return await stat(path);
+    }
+
+    /**
+     * Checks if a file at the given path exists.
+     * @param path - The path to check.
+     * @returns True when a file could be accessed and false otherwise.
+     */
+    static async exists(path: Path): Promise<boolean> {
+        try {
+            await access(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+
+    /**
+     * Renames "from" to "to".
+     * @param from - The old path.
+     * @param to - The new path.
+     */
+    static async rename(from: string, to: string): Promise<void> {
+        await rename(from, to);
+    }
+
+    /**
+     * Creates a file at the given path.
+     * @param p - The path of the new file to create.
+     * @param data - The data to write into the file. Can be a raw data string or an array of lines, which are joined by \n.
+     * @param recursive - Whether or not to recursively create the file.
+     */
+    static async createFile(p: Path, data: string | string[], recursive: boolean = true): Promise<void> {
+        if (await this.exists(p)) {
+            throw new Error(`File at ${p} already exists. Did you mean to call "updateFile"?`);
+        }
+        data = this.normalizeData(data);
+        const parentDir: Path = path.dirname(p) as Path;
+        if (recursive && !await this.exists(parentDir)) {
+            await this.mkdir(parentDir, true);
+        }
+        await writeFile(p, data);
+    }
+
+    private static normalizeData(data: string | string[]): string {
+        if (Array.isArray(data)) {
+            data = data.join('\n');
+        }
+        return data;
+    }
+
+    /**
+     * Updates the file at the given path with the given data.
+     * Can either replace, prepend or append.
+     * @param path - The path of the new file to create.
+     * @param data - The data to write into the file. Can be a raw data string or an array of lines, which are joined by \n.
+     * @param action - Whether the data should replace the current content or be pre-/appended.
+     */
+    static async updateFile(
+        path: Path,
+        data: string | string[],
+        action: 'replace' | 'prepend' | 'append'
+    ): Promise<void> {
+        if (!await this.exists(path)) {
+            throw new Error(`File at ${path} does not exist. Did you mean to call "createFile"?`);
+        }
+
+        data = this.normalizeData(data);
+        switch (action) {
+            case 'replace': {
+                await writeFile(path, data);
+                break;
+            }
+            case 'append': {
+                let currentContent: string[] = await this.readFileLines(path);
+                currentContent = currentContent[0].length ? [...currentContent, data] : [data];
+                await writeFile(path, this.normalizeData(currentContent));
+                break;
+            }
+            case 'prepend': {
+                let currentContent: string[] = await this.readFileLines(path);
+                currentContent = currentContent[0].length ? [data, ...currentContent] : [data];
+                await writeFile(path, this.normalizeData(currentContent));
+                break;
+            }
+        }
+    }
+
+    /**
+     * Either creates or overrides the file at the given path with the given data.
+     * @param path - The path of the file to create/override.
+     * @param data - The data to write into the file. Can be a raw data string or an array of lines, which are joined by \n.
+     */
+    static async upsertFile(path: Path, data: string | string[]): Promise<void> {
+        if (!await this.exists(path)) {
+            await this.createFile(path, data);
+            return;
+        }
+
+        await this.updateFile(path, data, 'replace');
+    }
+
+    /**
+     * Reads the file content at the given path.
+     * Expects utf-8.
+     * @param path - The path of the file to read.
+     * @returns The content as a single string.
+     */
+    static async readFile(path: Path): Promise<string> {
+        return readFile(path, { encoding: 'utf8' });
+    }
+
+    /**
+     * Same as readFile, but returns the content as an array of lines instead.
+     * @param path - The path of the file to read the lines from.
+     * @returns The content as an array of line strings.
+     */
+    static async readFileLines(path: Path): Promise<string[]> {
+        const content: string = await this.readFile(path);
+        return content.split('\n');
+    }
+
+    /**
+     * Removes either a file or directory.
+     * @param path - The path to remove.
+     * @param recursive - Whether or not subdirectories should be deleted as well. Defaults to true.
+     */
+    static async rm(path: Path, recursive: boolean = true): Promise<void> {
+        if (!await this.exists(path)) {
+            return;
+        }
+        await rm(path, { recursive, force: true });
+    }
+
+    /**
+     * Creates a directory at the given path.
+     * @param path - The path of the directory to create.
+     * @param recursive - Whether or not missing directories in the path should be created as well. Defaults to true.
+     */
+    static async mkdir(path: Path, recursive: boolean = true): Promise<void> {
+        await mkdir(path, { recursive });
+    }
+
+    /**
+     * Gets the root level subdirectories and files of the directory at the provided path.
+     * @param path - The path of the directory to get the contents of.
+     * @returns An array of the directory contents.
+     */
+    static async readdir(path: Path): Promise<Dirent[]> {
+        return readdir(path, { withFileTypes: true });
+    }
+}

package/src/utilities/is-version.function.ts

@@ -1,5 +1,5 @@
-import { Version } from '../types';
 import { isNumeric } from './is-numeric.function';
+import { Version } from '../types/version.type';
 
 // eslint-disable-next-line jsdoc/require-returns
 /**

package/src/utilities/mask.utilities.ts

@@ -0,0 +1,17 @@
+/**
+ * Utilities for masking sensitive information like eg. Banking data.
+ */
+export abstract class MaskUtilities {
+    /**
+     * Masks the given input string.
+     * @param input - The sensitive info that should be masked.
+     * @returns The first and last two characters of the given string, with any chars in between being replaced with *.
+     */
+    static mask(input: string): string {
+        if (input.length <= 3) {
+            return input;
+        }
+        const starsCount: number = input.length - 3;
+        return input[0] + '*'.repeat(starsCount) + input.slice(-2);
+    }
+}

package/src/utilities/metadata.utilities.ts

@@ -1,15 +1,27 @@
 /* eslint-disable jsdoc/require-jsdoc */
-import { ReflectUtilities } from './reflect.utilities';
-import { DiToken } from '../di';
-import { Route, ControllerRouteConfiguration, PathParamMetadata, BodyMetadata, QueryParamMetadata, HeaderParamMetadata } from '../routing';
 import { MetadataInjectionKeys } from './metadata-injection-keys.enum';
-import { BelongsToMetadata, CurrentUserMetadata, HasRoleMetadata, IsLoggedInMetadata, IsNotLoggedInMetadata, Require2faMetadata, SkipAuthMetadata, SkipBelongsToMetadata, SkipHasRoleMetadata, SkipIsLoggedInMetadata, SkipIsNotLoggedInMetadata, SkipRequire2faMetadata } from '../auth';
-import { BackupResourceInterface, BackupResourceMetadata } from '../backup';
-import { EntityMetadata, PropertyMetadata } from '../entity';
+import { ReflectUtilities } from './reflect.utilities';
+import { CurrentUserMetadata } from '../auth/decorators/current-user.decorator';
+import { BelongsToMetadata, SkipBelongsToMetadata } from '../auth/models/belongs-to-metadata.model';
+import { HasRoleMetadata, SkipHasRoleMetadata } from '../auth/models/has-role-metadata.model';
+import { IsLoggedInMetadata, SkipIsLoggedInMetadata } from '../auth/models/is-logged-in-metadata.model';
+import { IsNotLoggedInMetadata, SkipIsNotLoggedInMetadata } from '../auth/models/is-not-logged-in-metadata.model';
+import { Require2faMetadata, SkipRequire2faMetadata } from '../auth/models/require-2fa-metadata.model';
+import { SkipAuthMetadata } from '../auth/models/skip-auth-metadata.model';
+import { BackupResourceInterface } from '../backup/backup-resource.interface';
+import { BackupResourceMetadata } from '../backup/decorators/backup-resource-metadata.model';
+import { DiToken } from '../di/models/di-token.model';
 import { BaseEntity } from '../entity/base-entity.model';
-import { OpenApiResponse } from '../open-api';
-import { Newable } from '../types';
-import { CurrentWebsocketConnectionMetadata, WebsocketControllerData, WebsocketControllerRouteConfiguration } from '../websocket';
+import { EntityMetadata } from '../entity/decorators/entity.decorator';
+import { PropertyMetadata } from '../entity/decorators/property.decorator';
+import { OpenApiResponse } from '../open-api/open-api.model';
+import { ControllerRouteConfiguration, Route } from '../routing/controller-route-configuration.model';
+import { BodyMetadata } from '../routing/decorators/body.decorator';
+import { PathParamMetadata, QueryParamMetadata, HeaderParamMetadata } from '../routing/decorators/param.decorator';
+import { Newable } from '../types/newable.type';
+import { CurrentWebsocketConnectionMetadata } from '../websocket/decorators/current-websocket-connection.decorator';
+import { WebsocketControllerData } from '../websocket/decorators/websocket-controller.decorator';
+import { WebsocketControllerRouteConfiguration } from '../websocket/models/websocket-controller-route-configuration.model';
 
 const modelPropertiesStore: WeakMap<Function, Record<string, PropertyMetadata>> = new WeakMap();
 

package/src/utilities/validate-entities-registered.function.ts

@@ -1,9 +1,9 @@
-import { DataSourceInterface } from '../data-source';
-import { inject } from '../di';
+import { DataSourceInterface } from '../data-source/data-sources/data-source.interface';
+import { inject } from '../di/inject.function';
 import type { BaseEntity } from '../entity/base-entity.model';
-import { MissingEntitiesError } from '../error-handling';
-import { GlobalRegistry } from '../global';
-import type { Newable } from '../types';
+import { MissingEntitiesError } from '../error-handling/errors/missing-entities.error';
+import { GlobalRegistry } from '../global/global-registry';
+import { Newable } from '../types/newable.type';
 
 /**
  * Validates that the given entities are registered in a data source somewhere.

package/src/validation/functions/validate-boolean.function.ts

@@ -1,5 +1,7 @@
-import { BooleanPropertyMetadata, PropertyMetadata } from '../../entity';
-import { QueryParamMetadata, HeaderParamMetadata, PathParamMetadata, BooleanParamMetadata } from '../../routing';
+import { PropertyMetadata } from '../../entity/decorators/property.decorator';
+import { BooleanPropertyMetadata } from '../../entity/models/boolean-property-metadata.model';
+import { QueryParamMetadata, HeaderParamMetadata, PathParamMetadata } from '../../routing/decorators/param.decorator';
+import { BooleanParamMetadata } from '../../routing/models/boolean-param-metadata.model';
 import { IsRequiredValidationProblem, TypeMismatchValidationProblem, ValidationProblem } from '../validation-problem.model';
 
 /**

package/src/validation/functions/validate-date.function.ts

@@ -1,7 +1,10 @@
-import { inject, ZIBRI_DI_TOKENS } from '../../di';
-import { DatePropertyMetadata, PropertyMetadata } from '../../entity';
-import { FormatDateFn } from '../../localization';
-import { QueryParamMetadata, HeaderParamMetadata, PathParamMetadata, DateParamMetadata } from '../../routing';
+import { ZIBRI_DI_TOKENS } from '../../di/default/zibri-di-tokens.default';
+import { inject } from '../../di/inject.function';
+import { PropertyMetadata } from '../../entity/decorators/property.decorator';
+import { DatePropertyMetadata } from '../../entity/models/date-property-metadata.model';
+import { FormatDateFn } from '../../localization/formatting/format-date-fn.model';
+import { QueryParamMetadata, HeaderParamMetadata, PathParamMetadata } from '../../routing/decorators/param.decorator';
+import { DateParamMetadata } from '../../routing/models/date-param-metadata.model';
 import { IsRequiredValidationProblem, TypeMismatchValidationProblem, ValidationProblem } from '../validation-problem.model';
 
 /**

package/src/validation/functions/validate-file.function.ts

@@ -1,8 +1,8 @@
-import { PropertyMetadata } from '../../entity';
+import { PropertyMetadata } from '../../entity/decorators/property.decorator';
 import { fileSizeToBytes } from '../../entity/models/file-property-metadata.model';
-import { MimeType } from '../../http';
-import { File } from '../../parsing';
-import { BigNumberUtilities } from '../../utilities';
+import { MimeType } from '../../http/mime-type.enum';
+import { File } from '../../parsing/form-data/file.model';
+import { BigNumberUtilities } from '../../utilities/big-number.utilities';
 import { MaxFileSizeValidationProblem, IsRequiredValidationProblem, TypeMismatchValidationProblem, ValidationProblem, MimeTypeMismatchValidationProblem } from '../validation-problem.model';
 
 /**

package/src/validation/functions/validate-number.function.ts

@@ -1,6 +1,8 @@
-import { NumberPropertyMetadata, PropertyMetadata } from '../../entity';
-import { QueryParamMetadata, HeaderParamMetadata, PathParamMetadata, NumberParamMetadata } from '../../routing';
-import { ObjectUtilities } from '../../utilities';
+import { PropertyMetadata } from '../../entity/decorators/property.decorator';
+import { NumberPropertyMetadata } from '../../entity/models/number-property-metadata.model';
+import { QueryParamMetadata, HeaderParamMetadata, PathParamMetadata } from '../../routing/decorators/param.decorator';
+import { NumberParamMetadata } from '../../routing/models/number-param-metadata.model';
+import { ObjectUtilities } from '../../utilities/object.utilities';
 import { IsRequiredValidationProblem, TypeMismatchValidationProblem, ValidationProblem } from '../validation-problem.model';
 
 /**

package/src/validation/functions/validate-string.function.ts

@@ -1,7 +1,8 @@
-
-import { PropertyMetadata, StringFormat, StringPropertyMetadata } from '../../entity';
-import { HeaderParamMetadata, PathParamMetadata, QueryParamMetadata, StringParamMetadata } from '../../routing';
-import { ObjectUtilities } from '../../utilities';
+import { PropertyMetadata } from '../../entity/decorators/property.decorator';
+import { StringPropertyMetadata, StringFormat } from '../../entity/models/string-property-metadata.model';
+import { QueryParamMetadata, HeaderParamMetadata, PathParamMetadata } from '../../routing/decorators/param.decorator';
+import { StringParamMetadata } from '../../routing/models/string-param-metadata.model';
+import { ObjectUtilities } from '../../utilities/object.utilities';
 import { IsRequiredValidationProblem, TypeMismatchValidationProblem, ValidationProblem } from '../validation-problem.model';
 
 const UUID_REGEX: RegExp = /^[\dA-Fa-f]{8}-[\dA-Fa-f]{4}-[1-5][\dA-Fa-f]{3}-[89ABab][\dA-Fa-f]{3}-[\dA-Fa-f]{12}$/;

package/src/validation/validation-problem.model.ts

@@ -1,7 +1,12 @@
-import { ManyToManyPropertyMetadata, ManyToOnePropertyMetadata, OneToManyPropertyMetadata, OneToOnePropertyMetadata, Relation, RelationMetadata } from '../entity';
 import { BaseEntity } from '../entity/base-entity.model';
+import { RelationMetadata } from '../entity/decorators/property.decorator';
 import { FileSize } from '../entity/models/file-property-metadata.model';
-import { MimeType } from '../http';
+import { ManyToManyPropertyMetadata } from '../entity/models/many-to-many-property-metadata.model';
+import { ManyToOnePropertyMetadata } from '../entity/models/many-to-one-property-metadata.model';
+import { OneToManyPropertyMetadata } from '../entity/models/one-to-many-property-metadata.model';
+import { OneToOnePropertyMetadata } from '../entity/models/one-to-one-property-metadata.model';
+import { Relation } from '../entity/models/relation.enum';
+import { MimeType } from '../http/mime-type.enum';
 
 /**
  * A validation problem, consisting of the key where the problem is located and a description of the problem.

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

@@ -1,4 +1,5 @@
-import { BodyMetadata, HeaderParamMetadata, PathParamMetadata, QueryParamMetadata } from '../routing';
+import { BodyMetadata } from '../routing/decorators/body.decorator';
+import { HeaderParamMetadata, PathParamMetadata, QueryParamMetadata } from '../routing/decorators/param.decorator';
 
 /**
  * Interface for a validation service.

package/src/validation/validation.service.ts

@@ -1,16 +1,24 @@
-
-import { Property, PropertyMetadata, RelationMetadata } from '../entity';
-import { BaseEntity } from '../entity/base-entity.model';
-import { ValidationError } from '../error-handling';
-import { MimeType } from '../http';
-import { FormData } from '../parsing';
-import { BodyMetadata, HeaderParamMetadata, PathParamMetadata, QueryParamMetadata } from '../routing';
-import { ExcludeStrict, Newable, OmitStrict } from '../types';
-import { MetadataUtilities, ObjectUtilities } from '../utilities';
-import { WebsocketRequest } from '../websocket';
-import { validateBoolean, validateDate, validateFile, validateNumber, validateString } from './functions';
 import { IsRequiredValidationProblem, RelationsNotAllowedValidationProblem, TypeMismatchValidationProblem, ValidationProblem } from './validation-problem.model';
 import { ValidationServiceInterface } from './validation-service.interface';
+import { BaseEntity } from '../entity/base-entity.model';
+import { validateBoolean } from './functions/validate-boolean.function';
+import { validateDate } from './functions/validate-date.function';
+import { validateFile } from './functions/validate-file.function';
+import { validateNumber } from './functions/validate-number.function';
+import { validateString } from './functions/validate-string.function';
+import { PropertyMetadata, Property, RelationMetadata } from '../entity/decorators/property.decorator';
+import { ValidationError } from '../error-handling/errors/validation.error';
+import { MimeType } from '../http/mime-type.enum';
+import { FormData } from '../parsing/form-data/form-data.model';
+import { BodyMetadata } from '../routing/decorators/body.decorator';
+import { PathParamMetadata, QueryParamMetadata, HeaderParamMetadata } from '../routing/decorators/param.decorator';
+import { ExcludeStrict } from '../types/exclude-strict.type';
+import { Newable } from '../types/newable.type';
+import { OmitStrict } from '../types/omit-strict.type';
+import { type Path } from '../utilities/fs.utilities';
+import { MetadataUtilities } from '../utilities/metadata.utilities';
+import { ObjectUtilities } from '../utilities/object.utilities';
+import { WebsocketRequest } from '../websocket/models/websocket-request.model';
 
 /**
  * Function for validating a path parameter.
@@ -140,7 +148,7 @@ export class ValidationService implements ValidationServiceInterface {
             value!: typeof meta.modelClass;
             // eslint-disable-next-line jsdoc/require-jsdoc
             @Property.string({ description: 'the path to the temporary folder where uploaded files are cached' })
-            tempFolder!: string;
+            tempFolder!: Path;
         }
 
         const cls: Newable<unknown> = meta.type === MimeType.FORM_DATA ? Temp : meta.modelClass;

package/src/websocket/decorators/current-websocket-connection.decorator.ts

@@ -1,4 +1,4 @@
-import { MetadataUtilities } from '../../utilities';
+import { MetadataUtilities } from '../../utilities/metadata.utilities';
 
 /**
  * Metadata of the \@CurrentWebsocketConnection decorator.
@@ -10,7 +10,6 @@ export type CurrentWebsocketConnectionMetadata = {
     index: number
 };
 
-// eslint-disable-next-line jsdoc/require-returns
 /**
  * Marks the parameter to be injected as the currently connected websocket.
  */

package/src/websocket/decorators/websocket-body.decorator.ts

@@ -1,8 +1,9 @@
 import { FileSize } from '../../entity/models/file-property-metadata.model';
-import { MimeType } from '../../http';
-import { JsonBodyMetadata, resolveMaxBodySize } from '../../routing';
-import { Newable, OmitStrict } from '../../types';
-import { MetadataUtilities } from '../../utilities';
+import { MimeType } from '../../http/mime-type.enum';
+import { JsonBodyMetadata, resolveMaxBodySize } from '../../routing/decorators/body.decorator';
+import { Newable } from '../../types/newable.type';
+import { OmitStrict } from '../../types/omit-strict.type';
+import { MetadataUtilities } from '../../utilities/metadata.utilities';
 
 /**
  * Metadata Input for websocket request bodies.
@@ -16,7 +17,6 @@ export type WebsocketBodyMetadataInput = Partial<OmitStrict<JsonBodyMetadata, 'm
     baseMaxSize?: FileSize
 };
 
-// eslint-disable-next-line jsdoc/require-returns
 /**
  * Defines a websocket request body property with the given data.
  * @param modelClass - The model class that defines the websocket request body properties structure.

package/src/websocket/decorators/websocket-controller.decorator.ts

@@ -1,13 +1,12 @@
-import { GlobalRegistry } from '../../global';
-import { Newable } from '../../types';
-import { MetadataUtilities } from '../../utilities';
+import { GlobalRegistry } from '../../global/global-registry';
+import { Newable } from '../../types/newable.type';
+import { MetadataUtilities } from '../../utilities/metadata.utilities';
 
 /**
  * Data of a websocket controller.
  */
 export type WebsocketControllerData = {};
 
-// eslint-disable-next-line jsdoc/require-returns
 /**
  * Marks a websocket controller class to be registered.
  */

package/src/websocket/decorators/websocket-route.decorator.ts

@@ -1,7 +1,6 @@
-import { MetadataUtilities } from '../../utilities';
-import { WebsocketControllerRouteConfiguration } from '../models';
+import { MetadataUtilities } from '../../utilities/metadata.utilities';
+import { WebsocketControllerRouteConfiguration } from '../models/websocket-controller-route-configuration.model';
 
-// eslint-disable-next-line jsdoc/require-returns
 /**
  * Defines a route to receive websocket messages.
  * @param event - The event to listen on.

package/src/websocket/models/websocket-channel.model.ts

@@ -1,5 +1,6 @@
-import { Entity, Property } from '../../entity';
 import { BaseEntity } from '../../entity/base-entity.model';
+import { Entity } from '../../entity/decorators/entity.decorator';
+import { Property } from '../../entity/decorators/property.decorator';
 
 /**
  * A websocket channel.

package/src/websocket/models/websocket-message.model.ts

@@ -1,10 +1,13 @@
 import { type LooseWebsocketEvent } from './websocket-event.enum';
-import { Repository } from '../../data-source';
-import { inject, repositoryTokenFor } from '../../di';
-import { Entity, OmitClass, Property } from '../../entity';
+import { Repository } from '../../data-source/repository';
+import { repositoryTokenFor } from '../../di/decorators/inject-repository.decorator';
+import { inject } from '../../di/inject.function';
 import { BaseEntity } from '../../entity/base-entity.model';
-import { HttpError } from '../../error-handling';
-import { HttpStatus } from '../../http';
+import { Entity } from '../../entity/decorators/entity.decorator';
+import { Property } from '../../entity/decorators/property.decorator';
+import { OmitClass } from '../../entity/omit-class.model';
+import { HttpError } from '../../error-handling/errors/http.error';
+import { HttpStatus } from '../../http/http-status.enum';
 
 /**
  * The type of a websocket message recipient.

package/src/websocket/models/websocket-options.model.ts

@@ -1,4 +1,4 @@
-import { BaseUser } from '../../auth';
+import { BaseUser } from '../../auth/models/base-user.model';
 
 /**
  * Options regarding websockets.

package/src/websocket/models/websocket-request.model.ts

@@ -1,6 +1,7 @@
-import { BaseWebsocketConnection } from './connection';
-import { Property } from '../../entity';
-import { HttpRequest, KnownHeader } from '../../http';
+import { BaseWebsocketConnection } from './connection/base-websocket-connection.model';
+import { Property } from '../../entity/decorators/property.decorator';
+import { HttpRequest } from '../../http/http-request.model';
+import { KnownHeader } from '../../http/known-header.enum';
 
 // eslint-disable-next-line jsdoc/require-jsdoc
 class QueryObject implements Record<string, string | undefined> {

package/src/websocket/services/websocket-service.interface.ts

@@ -1,6 +1,11 @@
 import { ZibriApplication } from '../../application';
-import { Newable, OmitStrict } from '../../types';
-import { LooseWebsocketEvent, BaseWebsocketConnection, WebsocketResponseHandler, CreateWebsocketMessageData, WebsocketRequestWithConnection } from '../models';
+import { Newable } from '../../types/newable.type';
+import { OmitStrict } from '../../types/omit-strict.type';
+import { BaseWebsocketConnection } from '../models/connection/base-websocket-connection.model';
+import { LooseWebsocketEvent } from '../models/websocket-event.enum';
+import { CreateWebsocketMessageData } from '../models/websocket-message.model';
+import { WebsocketRequestWithConnection } from '../models/websocket-request.model';
+import { WebsocketResponseHandler } from '../models/websocket-response.model';
 
 /**
  * The message data for sending a websocket success message.