zibri 2.2.1 → 2.4.0

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

@@ -1,8 +1,12 @@
+import { HttpRequestContext } from '../../context/request/http-request.context';
+import { WebsocketRequestContext } from '../../context/request/websocket-request.context';
+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 { fileSizeToBytes } from '../../entity/models/file-property-metadata.model';
 import { MimeType } from '../../http/mime-type.enum';
 import { File } from '../../parsing/form-data/file.model';
-import { BigNumberUtilities } from '../../utilities/big-number.utilities';
+import { NumberUtilities } from '../../utilities/number.utilities';
 import { MaxFileSizeValidationProblem, IsRequiredValidationProblem, TypeMismatchValidationProblem, ValidationProblem, MimeTypeMismatchValidationProblem } from '../validation-problem.model';
 
 /**
@@ -15,36 +19,27 @@ import { MaxFileSizeValidationProblem, IsRequiredValidationProblem, TypeMismatch
  * @returns All validation problems found.
  * @throws When the property is not a file property.
  */
-export function validateFile(
+export async function validateFile(
     key: string,
     property: unknown,
     metadata: PropertyMetadata,
     parentKey: string | undefined,
     entity: unknown | undefined
-): ValidationProblem[] {
+): Promise<ValidationProblem[]> {
     if (metadata.type !== 'file') {
         throw new Error(`Tried to validate a file but received metadata of type "${metadata.type}"`);
     }
     const fullKey: string = parentKey ? `${parentKey}.${key}` : key;
-    if (
-        property == undefined
-        && 'required' in metadata
-        && (typeof metadata.required === 'boolean' ? metadata.required : metadata.required(entity))
-    ) {
-        return [new IsRequiredValidationProblem(fullKey)];
-    }
-    if (
-        property == undefined
-        && 'required' in metadata
-        && !(typeof metadata.required === 'boolean' ? metadata.required : metadata.required(entity))
-    ) {
-        return [];
+    if (property == undefined && 'required' in metadata) {
+        const context: HttpRequestContext | WebsocketRequestContext | undefined = inject(ZIBRI_DI_TOKENS.CURRENT_REQUEST_CONTEXT);
+        const isRequired: boolean = typeof metadata.required === 'boolean' ? metadata.required : await metadata.required(entity, context);
+        return isRequired ? [new IsRequiredValidationProblem(fullKey)] : [];
     }
     if (!(property instanceof File)) {
         return [new TypeMismatchValidationProblem(fullKey, 'file')];
     }
 
-    if (BigNumberUtilities.new(property.size).isGreaterThan(fileSizeToBytes(metadata.maxSize))) {
+    if (NumberUtilities.new(property.size).isGreaterThan(fileSizeToBytes(metadata.maxSize))) {
         return [new MaxFileSizeValidationProblem(fullKey, metadata.maxSize)];
     }
     if (metadata.allowedMimeTypes !== 'all' && !metadata.allowedMimeTypes.includes(property.mimetype as MimeType)) {

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

@@ -1,5 +1,12 @@
+import assert from 'node:assert';
+
+import { HttpRequestContext } from '../../context/request/http-request.context';
+import { WebsocketRequestContext } from '../../context/request/websocket-request.context';
+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 { NumberPropertyMetadata } from '../../entity/models/number-property-metadata.model';
+import { NumberFormat, NumberPropertyMetadata } from '../../entity/models/number-property-metadata.model';
+import { INTEGER_REGEX } from '../../parsing/functions/parse-number.function';
 import { QueryParamMetadata, HeaderParamMetadata, PathParamMetadata } from '../../routing/decorators/param.decorator';
 import { NumberParamMetadata } from '../../routing/models/number-param-metadata.model';
 import { ObjectUtilities } from '../../utilities/object.utilities';
@@ -14,34 +21,38 @@ import { IsRequiredValidationProblem, TypeMismatchValidationProblem, ValidationP
  * @param entity - The entity that this value belongs to.
  * @returns All validation problems found.
  */
-export function validateNumber(
+// eslint-disable-next-line sonar/cognitive-complexity
+export async function validateNumber(
     key: string,
     property: unknown,
     metadata: PropertyMetadata | QueryParamMetadata | HeaderParamMetadata | PathParamMetadata,
     parentKey: string | undefined,
     entity: unknown | undefined
-): ValidationProblem[] {
+): Promise<ValidationProblem[]> {
     const meta: NumberPropertyMetadata | NumberParamMetadata = metadata as NumberPropertyMetadata | NumberParamMetadata;
     const fullKey: string = parentKey ? `${parentKey}.${key}` : key;
-    if (
-        property == undefined
-        && (meta as NumberPropertyMetadata).default == undefined
-        && (typeof metadata.required === 'boolean' ? metadata.required : metadata.required(entity))
-    ) {
-        return [new IsRequiredValidationProblem(fullKey)];
-    }
-    if (
-        property == undefined
-        && (
-            !(typeof metadata.required === 'boolean' ? metadata.required : metadata.required(entity))
-            || (meta as NumberPropertyMetadata).default != undefined
-        )
-    ) {
-        return [];
-    }
-    if (typeof property !== 'number') {
+    if (property == undefined) {
+        const context: HttpRequestContext | WebsocketRequestContext | undefined = inject(ZIBRI_DI_TOKENS.CURRENT_REQUEST_CONTEXT);
+        const isRequired: boolean = typeof metadata.required === 'boolean' ? metadata.required : await metadata.required(entity, context);
+        if ((meta as NumberPropertyMetadata).default == undefined && isRequired) {
+            return [new IsRequiredValidationProblem(fullKey)];
+        }
+        if (!isRequired || (meta as NumberPropertyMetadata).default != undefined) {
+            return [];
+        }
+    }
+    if (typeof property !== 'number' && meta.format !== 'bigint') {
         return [new TypeMismatchValidationProblem(fullKey, 'number')];
     }
+    if (typeof property !== 'bigint' && meta.format === 'bigint') {
+        return [new TypeMismatchValidationProblem(fullKey, 'BigIntString')];
+    }
+
+    assert(typeof property === 'bigint' || typeof property === 'number');
+
+    if (meta.format && !isFormatValid(meta.format, property)) {
+        return [{ key: fullKey, message: `needs to be in format "${meta.format}"` }];
+    }
     if (meta.enum && !ObjectUtilities.values(meta.enum).includes(property)) {
         return [{ key: fullKey, message: `needs to match one of "${ObjectUtilities.values(meta.enum)}"` }];
     }
@@ -52,4 +63,16 @@ export function validateNumber(
         return [{ key: fullKey, message: `needs to be at most ${meta.max}` }];
     }
     return [];
+}
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+function isFormatValid(format: NumberFormat, value: number | bigint): boolean {
+    switch (format) {
+        case 'bigint': {
+            return INTEGER_REGEX.test(value.toString());
+        }
+        case 'integer': {
+            return Number.isInteger(value);
+        }
+    }
 }

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

@@ -1,3 +1,7 @@
+import { HttpRequestContext } from '../../context/request/http-request.context';
+import { WebsocketRequestContext } from '../../context/request/websocket-request.context';
+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 { StringPropertyMetadata, StringFormat } from '../../entity/models/string-property-metadata.model';
 import { QueryParamMetadata, HeaderParamMetadata, PathParamMetadata } from '../../routing/decorators/param.decorator';
@@ -18,27 +22,36 @@ const EMAIL_REGEX: RegExp = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  * @returns All validation problems found.
  */
 // eslint-disable-next-line sonar/cognitive-complexity
-export function validateString(
+export async function validateString(
     key: string,
     property: unknown,
     metadata: PropertyMetadata | QueryParamMetadata | HeaderParamMetadata | PathParamMetadata,
     parentKey: string | undefined,
     entity: unknown | undefined
-): ValidationProblem[] {
-    const meta: StringPropertyMetadata | StringParamMetadata = metadata as StringPropertyMetadata | StringParamMetadata;
+): Promise<ValidationProblem[]> {
+    // eslint-disable-next-line typescript/no-explicit-any
+    const meta: StringPropertyMetadata<any, any, any, any, any> | StringParamMetadata<any, any, any, any, any>
+        // eslint-disable-next-line typescript/no-explicit-any
+        = metadata as StringPropertyMetadata<any, any, any, any, any> | StringParamMetadata<any, any, any, any, any>;
     const fullKey: string = parentKey ? `${parentKey}.${key}` : key;
+    const context: HttpRequestContext | WebsocketRequestContext | undefined = inject(ZIBRI_DI_TOKENS.CURRENT_REQUEST_CONTEXT);
+    const isRequired: boolean = typeof metadata.required === 'boolean'
+        ? metadata.required
+        : await metadata.required(entity, context);
     if (
         property == undefined
-        && (meta as StringPropertyMetadata).default == undefined
-        && (typeof metadata.required === 'boolean' ? metadata.required : metadata.required(entity))
+        // eslint-disable-next-line typescript/no-explicit-any
+        && (meta as StringPropertyMetadata<any, any, any, any, any>).default == undefined
+        && isRequired
     ) {
         return [new IsRequiredValidationProblem(fullKey)];
     }
     if (
         property == undefined
         && (
-            !(typeof metadata.required === 'boolean' ? metadata.required : metadata.required(entity))
-            || (meta as StringPropertyMetadata).default != undefined
+            !isRequired
+            // eslint-disable-next-line typescript/no-explicit-any
+            || (meta as StringPropertyMetadata<any, any, any, any, any>).default != undefined
         )
     ) {
         return [];

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

@@ -8,22 +8,22 @@ export interface ValidationServiceInterface {
     /**
      * Validate a request/response body.
      */
-    validateBody: (body: unknown, meta: BodyMetadata) => void,
+    validateBody: (body: unknown, meta: BodyMetadata) => void | Promise<void>,
     /**
      * Validate a header param.
      */
-    validateHeaderParam: (param: unknown, meta: HeaderParamMetadata) => void,
+    validateHeaderParam: (param: unknown, meta: HeaderParamMetadata) => void | Promise<void>,
     /**
      * Validate a path parameter.
      */
-    validatePathParam: (param: unknown, meta: PathParamMetadata) => void,
+    validatePathParam: (param: unknown, meta: PathParamMetadata) => void | Promise<void>,
     /**
      * Validate a query parameter.
      */
-    validateQueryParam: (param: unknown, meta: QueryParamMetadata) => void,
+    validateQueryParam: (param: unknown, meta: QueryParamMetadata) => void | Promise<void>,
     /**
      * Checks if the given value is a valid websocket request.
      * This does NOT check its content like the body or params, but only the base structure.
      */
-    validateWebsocketRequest: (req: unknown) => void
+    validateWebsocketRequest: (req: unknown) => void | Promise<void>
 }

package/src/validation/validation.service.ts

@@ -6,6 +6,9 @@ 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 { Injectable } from '../di/decorators/injectable.decorator';
+import { ZIBRI_DI_TOKENS } from '../di/default/zibri-di-tokens.default';
+import { inject } from '../di/inject.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';
@@ -15,7 +18,7 @@ import { PathParamMetadata, QueryParamMetadata, HeaderParamMetadata } from '../r
 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 { type FsPath } from '../utilities/fs.utilities';
 import { MetadataUtilities } from '../utilities/metadata.utilities';
 import { ObjectUtilities } from '../utilities/object.utilities';
 import { WebsocketRequest } from '../websocket/models/websocket-request.model';
@@ -28,7 +31,7 @@ type PathParamValidationFunction = (
     meta: PathParamMetadata,
     parentKey: string | undefined,
     entity: unknown | undefined
-) => ValidationProblem[];
+) => ValidationProblem[] | Promise<ValidationProblem[]>;
 
 /**
  * Function for validating a query parameter.
@@ -38,7 +41,7 @@ type QueryParamValidationFunction = (
     meta: QueryParamMetadata,
     parentKey: string | undefined,
     entity: unknown | undefined
-) => ValidationProblem[];
+) => ValidationProblem[] | Promise<ValidationProblem[]>;
 
 /**
  * Function for validating a header parameter.
@@ -48,7 +51,7 @@ type HeaderParamValidationFunction = (
     meta: HeaderParamMetadata,
     parentKey: string | undefined,
     entity: unknown | undefined
-) => ValidationProblem[];
+) => ValidationProblem[] | Promise<ValidationProblem[]>;
 
 /**
  * Function for validating a single property.
@@ -59,11 +62,12 @@ type PropertyValidationFunction = (
     metadata: PropertyMetadata,
     parentKey: string | undefined,
     entity: unknown | undefined
-) => ValidationProblem[];
+) => ValidationProblem[] | Promise<ValidationProblem[]>;
 
 /**
  * The default validation service implementation of Zibri.
  */
+@Injectable({ register: 'onUse' })
 export class ValidationService implements ValidationServiceInterface {
 
     private readonly pathParamValidationFunctions: Record<PathParamMetadata['type'], PathParamValidationFunction> = {
@@ -104,43 +108,51 @@ export class ValidationService implements ValidationServiceInterface {
     };
 
     // eslint-disable-next-line jsdoc/require-jsdoc
-    validateHeaderParam(param: unknown, meta: HeaderParamMetadata): void {
+    async validateHeaderParam(param: unknown, meta: HeaderParamMetadata): Promise<void> {
         const validate: HeaderParamValidationFunction | undefined = this.headerParamValidationFunctions[meta.type];
         if (validate == undefined) {
             throw new Error(`Unknown type for header parameter "${meta.name}": ${meta.type}`);
         }
-        const res: ValidationProblem[] = validate(param, meta, undefined, param);
+        const res: ValidationProblem[] = await validate(param, meta, undefined, param);
         if (res.length) {
-            throw new ValidationError('header', res);
+            throw new ValidationError('header', meta.name, res);
         }
     }
 
     // eslint-disable-next-line jsdoc/require-jsdoc
-    validatePathParam(param: unknown, meta: PathParamMetadata): void {
+    async validatePathParam(param: unknown, meta: PathParamMetadata): Promise<void> {
         const validate: PathParamValidationFunction | undefined = this.pathParamValidationFunctions[meta.type];
         if (validate == undefined) {
             throw new Error(`Unknown type for path parameter "${meta.name}": ${meta.type}`);
         }
-        const res: ValidationProblem[] = validate(param, meta, undefined, param);
+        const res: ValidationProblem[] = await validate(param, meta, undefined, param);
         if (res.length) {
-            throw new ValidationError('path', res);
+            throw new ValidationError('path', meta.name, res);
         }
     }
 
     // eslint-disable-next-line jsdoc/require-jsdoc
-    validateQueryParam(param: unknown, meta: QueryParamMetadata): void {
+    async validateQueryParam(param: unknown, meta: QueryParamMetadata): Promise<void> {
         const validate: QueryParamValidationFunction | undefined = this.queryParamValidationFunctions[meta.type];
         if (validate == undefined) {
             throw new Error(`Unknown type for query parameter "${meta.name}": ${meta.type}`);
         }
-        const res: ValidationProblem[] = validate(param, meta, undefined, param);
+        const res: ValidationProblem[] = await validate(param, meta, undefined, param);
         if (res.length) {
-            throw new ValidationError('query', res);
+            throw new ValidationError('query', meta.name, res);
         }
     }
 
     // eslint-disable-next-line jsdoc/require-jsdoc
-    validateBody(body: unknown, meta: BodyMetadata): void {
+    async validateBody(body: unknown, meta: BodyMetadata): Promise<void> {
+        const res: ValidationProblem[] = await this.getBodyValidationProblems(body, meta);
+        if (res.length) {
+            throw new ValidationError('body', undefined, res);
+        }
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    async getBodyValidationProblems(body: unknown, meta: BodyMetadata): Promise<ValidationProblem[]> {
         // eslint-disable-next-line jsdoc/require-jsdoc
         class Temp implements OmitStrict<FormData<typeof meta.modelClass>, 'cleanup'> {
             // eslint-disable-next-line jsdoc/require-jsdoc
@@ -148,95 +160,67 @@ 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!: Path;
+            tempFolder!: FsPath;
         }
 
         const cls: Newable<unknown> = meta.type === MimeType.FORM_DATA ? Temp : meta.modelClass;
-        let res: ValidationProblem[];
         if (meta.isArray) {
             if (!Array.isArray(body)) {
-                throw new ValidationError('body', [new TypeMismatchValidationProblem('body', 'array')]);
+                return [new TypeMismatchValidationProblem('body', 'array')];
             }
-            res = body.reduce<ValidationProblem[]>((prev, curr, i) => [
-                ...prev,
-                ...this.validateModel(curr, cls, `[${i}]`, meta.allowAdditionalProperties)
-            ], []);
-        }
-        else {
-            res = this.validateModel(body, cls, undefined, meta.allowAdditionalProperties);
-        }
-        if (res.length) {
-            throw new ValidationError('body', res);
+            const res: ValidationProblem[] = [];
+            await Promise.all(body.map(async (v, i) => {
+                res.push(...await this.validateModel(v, cls, `[${i}]`, meta.allowAdditionalProperties));
+            }));
+            return res;
         }
+
+        return await this.validateModel(body, cls, undefined, meta.allowAdditionalProperties);
     }
 
     // eslint-disable-next-line jsdoc/require-jsdoc
-    validateWebsocketRequest(req: unknown): void {
-        const res: ValidationProblem[] = this.validateModel(req, WebsocketRequest, undefined, false);
+    async validateWebsocketRequest(req: unknown): Promise<void> {
+        const res: ValidationProblem[] = await this.validateModel(req, WebsocketRequest, undefined, false);
         if (res.length) {
-            throw new ValidationError('websocketRequest', res);
+            throw new ValidationError('websocketRequest', undefined, res);
         }
-
-        // // validate query
-        // for (const key in req.query) {
-        //     if (typeof req.query[key] != 'string' || typeof req.query[key] != 'undefined') {
-        //         res.push({ key, message: 'needs to be a string or undefined' });
-        //     }
-        // }
-        // // validate headers
-        // for (const key in req.headers) {
-        //     if (!isKnownHeader(key)) {
-        //         res.push({ key, message: 'this key is not a known header' });
-        //     }
-        //     else if (typeof req.headers[key] != 'string' || typeof req.headers[key] != 'undefined') {
-        //         res.push({ key, message: 'needs to be a string or undefined' });
-        //     }
-        // }
-        // // validate params
-        // for (const key in req.params) {
-        //     if (typeof req.params[key] != 'string' || typeof req.params[key] != 'undefined') {
-        //         res.push({ key, message: 'needs to be a string or undefined' });
-        //     }
-        // }
-        // if (res.length) {
-        //     throw new ValidationError('websocketRequest', res);
-        // }
     }
 
-    private validateModel(
+    private async validateModel(
         body: unknown,
         cls: Newable<unknown>,
         parentKey: string | undefined,
         allowAdditionalProperties: boolean
-    ): ValidationProblem[] {
+    ): Promise<ValidationProblem[]> {
         const modelProperties: Record<string, PropertyMetadata> = MetadataUtilities.getModelProperties(cls);
 
         const keysOfBody: string[] = ObjectUtilities.keys(body as Record<string, unknown>);
         const keysOfModel: string[] = ObjectUtilities.keys(modelProperties);
         const unknownKeys: string[] = keysOfBody.filter(k => !keysOfModel.includes(k));
         const res: ValidationProblem[] = [];
-        for (const key of unknownKeys) {
-            if (allowAdditionalProperties) {
-                continue;
+        if (!allowAdditionalProperties) {
+            for (const key of unknownKeys) {
+                const fullKey: string = parentKey ? `${parentKey}.${key}` : key;
+                res.push({ key: fullKey, message: 'this key is unknown' });
             }
-            const fullKey: string = parentKey ? `${parentKey}.${key}` : key;
-            res.push({ key: fullKey, message: 'this key is unknown' });
-        }
-        for (const [propertyKey, metadata] of ObjectUtilities.entries(modelProperties)) {
-            const property: unknown = (body as Record<string, unknown>)[propertyKey];
-            const errors: ValidationProblem[] = this.validateProperty(propertyKey, property, metadata, parentKey, body);
-            res.push(...errors);
         }
+        await Promise.all(
+            keysOfModel.map(async k => {
+                const property: unknown = (body as Record<string, unknown>)[k];
+                const errors: ValidationProblem[] = await this.validateProperty(k, property, modelProperties[k], parentKey, body);
+                res.push(...errors);
+            })
+        );
         return res;
     }
 
-    private validateProperty(
+    private async validateProperty(
         key: string,
         property: unknown,
         metadata: PropertyMetadata,
         parentKey: string | undefined,
         entity: unknown | undefined
-    ): ValidationProblem[] {
+    ): Promise<ValidationProblem[]> {
         const fullKey: string = parentKey ? `${parentKey}.${key}` : key;
 
         if (
@@ -252,23 +236,25 @@ export class ValidationService implements ValidationServiceInterface {
         if (validate == undefined) {
             throw new Error(`Unknown type for property "${fullKey}": ${metadata.type}`);
         }
-        const res: ValidationProblem[] = validate(key, property, metadata, parentKey, entity);
+        const res: ValidationProblem[] = await validate(key, property, metadata, parentKey, entity);
         return res;
     }
 
-    private validateArrayProperty(
+    private async validateArrayProperty(
         key: string,
         property: unknown,
         metadata: PropertyMetadata | QueryParamMetadata | HeaderParamMetadata | PathParamMetadata,
         parentKey: string | undefined,
         entity: unknown | undefined
-    ): ValidationProblem[] {
+    ): Promise<ValidationProblem[]> {
         if (metadata.type !== 'array') {
             throw new Error('Tried to do array based validation on a non array value.');
         }
         const fullKey: string = parentKey ? `${parentKey}.${key}` : key;
 
-        const required: boolean = typeof metadata.required === 'boolean' ? metadata.required : metadata.required(entity);
+        const required: boolean = typeof metadata.required === 'boolean'
+            ? metadata.required
+            : await metadata.required(entity, inject(ZIBRI_DI_TOKENS.CURRENT_REQUEST_CONTEXT));
         if (property == undefined && required) {
             return [new IsRequiredValidationProblem(fullKey)];
         }
@@ -280,27 +266,35 @@ export class ValidationService implements ValidationServiceInterface {
         }
 
         const res: ValidationProblem[] = [];
-        for (let i: number = 0; i < property.length; i++) {
+        await Promise.all(property.map(async (v, i) => {
             const item: unknown = property[i];
-            const errors: ValidationProblem[] = this.validateProperty(String(i), item, metadata.items as PropertyMetadata, key, entity);
+            const errors: ValidationProblem[] = await this.validateProperty(
+                String(i),
+                item,
+                metadata.items as PropertyMetadata,
+                key,
+                entity
+            );
             res.push(...errors);
-        }
+        }));
         return res;
     }
 
-    private validateObjectProperty(
+    private async validateObjectProperty(
         key: string,
         property: unknown,
         metadata: PropertyMetadata | QueryParamMetadata | HeaderParamMetadata | PathParamMetadata,
         parentKey: string | undefined,
         entity: unknown | undefined
-    ): ValidationProblem[] {
+    ): Promise<ValidationProblem[]> {
         if (metadata.type !== 'object') {
             throw new Error('Tried to do object based validation on a non object value.');
         }
         const fullKey: string = parentKey ? `${parentKey}.${key}` : key;
 
-        const required: boolean = typeof metadata.required === 'boolean' ? metadata.required : metadata.required(entity);
+        const required: boolean = typeof metadata.required === 'boolean'
+            ? metadata.required
+            : await metadata.required(entity, inject(ZIBRI_DI_TOKENS.CURRENT_REQUEST_CONTEXT));
         if (property == undefined && required) {
             return [new IsRequiredValidationProblem(fullKey)];
         }
@@ -324,15 +318,17 @@ export class ValidationService implements ValidationServiceInterface {
                 res.push({ key: k, message: 'this key is unknown' });
             }
             if (res.length) {
-                throw new ValidationError('body', res);
+                throw new ValidationError('body', undefined, res);
             }
         }
 
-        for (const [propertyKey, m] of ObjectUtilities.entries(objectProperties)) {
-            const childProperty: unknown = (property as Record<string, unknown>)[propertyKey];
-            const errors: ValidationProblem[] = this.validateProperty(propertyKey, childProperty, m, key, entity);
-            res.push(...errors);
-        }
+        await Promise.all(
+            ObjectUtilities.entries(objectProperties).map(async ([propertyKey, m]) => {
+                const childProperty: unknown = (property as Record<string, unknown>)[propertyKey];
+                const errors: ValidationProblem[] = await this.validateProperty(propertyKey, childProperty, m, key, entity);
+                res.push(...errors);
+            })
+        );
         return res;
     }
 }

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

@@ -5,17 +5,24 @@ import { MetadataUtilities } from '../../utilities/metadata.utilities';
 /**
  * Data of a websocket controller.
  */
-export type WebsocketControllerData = {};
+export type WebsocketControllerData = {
+    /**
+     * Whether or not this websocket controller is allowed to exist without being registered in the application.
+     */
+    allowOrphan: boolean
+};
 
 /**
  * Marks a websocket controller class to be registered.
+ * @param options - Options for the websocket controller.
  */
-export function WebsocketController(): ClassDecorator {
+export function WebsocketController(options: Partial<WebsocketControllerData> = {}): ClassDecorator {
+    const { allowOrphan = false } = options;
     return target => {
         // eslint-disable-next-line unicorn/error-message
         const stack: string = new Error().stack ?? '';
         MetadataUtilities.setFilePath(target, stack);
-        MetadataUtilities.setWebsocketController(target, {});
+        MetadataUtilities.setWebsocketControllerData(target, { allowOrphan });
         GlobalRegistry.injectables.push({
             token: target as unknown as Newable<unknown>,
             useClass: target as unknown as Newable<unknown>

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

@@ -1,4 +1,3 @@
-import { ZibriApplication } from '../../application';
 import { Newable } from '../../types/newable.type';
 import { OmitStrict } from '../../types/omit-strict.type';
 import { BaseWebsocketConnection } from '../models/connection/base-websocket-connection.model';
@@ -109,10 +108,6 @@ export type WebsocketSendToMultipleResult<
  * A service for handling websockets.
  */
 export interface WebsocketServiceInterface<Connection extends BaseWebsocketConnection> {
-    /**
-     * Attaches the service to the application.
-     */
-    attachTo: (app: ZibriApplication) => void | Promise<void>,
     /**
      * Registers a websocket controller that listens to events.
      */