zibri 2.3.0 → 2.4.1

package/src/validation/validation.service.ts

@@ -7,7 +7,10 @@ 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 { Relation } from '../entity/models/relation.enum';
 import { ValidationError } from '../error-handling/errors/validation.error';
 import { MimeType } from '../http/mime-type.enum';
 import { FormData } from '../parsing/form-data/form-data.model';
@@ -29,7 +32,7 @@ type PathParamValidationFunction = (
     meta: PathParamMetadata,
     parentKey: string | undefined,
     entity: unknown | undefined
-) => ValidationProblem[];
+) => ValidationProblem[] | Promise<ValidationProblem[]>;
 
 /**
  * Function for validating a query parameter.
@@ -39,7 +42,7 @@ type QueryParamValidationFunction = (
     meta: QueryParamMetadata,
     parentKey: string | undefined,
     entity: unknown | undefined
-) => ValidationProblem[];
+) => ValidationProblem[] | Promise<ValidationProblem[]>;
 
 /**
  * Function for validating a header parameter.
@@ -49,7 +52,7 @@ type HeaderParamValidationFunction = (
     meta: HeaderParamMetadata,
     parentKey: string | undefined,
     entity: unknown | undefined
-) => ValidationProblem[];
+) => ValidationProblem[] | Promise<ValidationProblem[]>;
 
 /**
  * Function for validating a single property.
@@ -60,7 +63,7 @@ type PropertyValidationFunction = (
     metadata: PropertyMetadata,
     parentKey: string | undefined,
     entity: unknown | undefined
-) => ValidationProblem[];
+) => ValidationProblem[] | Promise<ValidationProblem[]>;
 
 /**
  * The default validation service implementation of Zibri.
@@ -106,43 +109,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
@@ -154,98 +165,71 @@ export class ValidationService implements ValidationServiceInterface {
         }
 
         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 (
-            metadata.type === 'many-to-one'
-            || metadata.type === 'one-to-many'
-            || metadata.type === 'one-to-one'
-            || metadata.type === 'many-to-many'
+            metadata.type === Relation.MANY_TO_ONE
+            || metadata.type === Relation.ONE_TO_MANY
+            || metadata.type === Relation.HAS_ONE
+            || metadata.type === Relation.BELONGS_TO_ONE
+            || metadata.type === Relation.MANY_TO_MANY
         ) {
             return [new RelationsNotAllowedValidationProblem(fullKey, metadata, key)];
         }
@@ -254,23 +238,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)];
         }
@@ -282,27 +268,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)];
         }
@@ -326,15 +320,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/models/websocket-message.model.ts

@@ -21,7 +21,7 @@ export enum WebsocketRecipientType {
 /**
  * Definition of a message sent via websocket connection.
  */
-@Entity()
+@Entity({ defaultOrder: { seq: 'ASC' } })
 export class WebsocketMessage extends BaseEntity {
     /**
      * The date at which the message was created.

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

@@ -4,37 +4,45 @@ 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> {
-    [key: string]: string | undefined
+class QueryObject implements Record<string, unknown> {
+    [key: string]: unknown
 }
 
 // eslint-disable-next-line jsdoc/require-jsdoc
 class ParamsObject extends QueryObject {}
 
 // eslint-disable-next-line jsdoc/require-jsdoc
-class HeadersObject implements Partial<Record<KnownHeader, string | undefined>> {
-    [key: string]: string | undefined
+class HeadersObject implements Partial<Record<KnownHeader, unknown>> {
+    [key: string]: unknown
 }
 
 /**
  * A websocket request sent from a client.
  */
-export class WebsocketRequest implements Partial<Pick<HttpRequest, 'headers' | 'body' | 'query' | 'params'>> {
+export class WebsocketRequest<
+    T = unknown,
+    PathParamsObject extends Record<string, unknown> = Record<string, string | undefined>,
+    QueryParamsObject extends Record<string, unknown> = Record<string, string | undefined>,
+    HeaderParamsObject extends Record<string, unknown> = Partial<Record<KnownHeader, string | undefined>>
+> implements Partial<Pick<
+    HttpRequest<T, PathParamsObject, QueryParamsObject, HeaderParamsObject>,
+    'headers' | 'body' | 'query' | 'params'>
+> {
     // eslint-disable-next-line jsdoc/require-jsdoc
     @Property.object({ cls: () => QueryObject, required: false, allowAdditionalProperties: true })
-    query: QueryObject | undefined;
+    query: QueryParamsObject | undefined;
 
     // eslint-disable-next-line jsdoc/require-jsdoc
     @Property.object({ cls: () => HeadersObject, allowAdditionalProperties: true })
-    headers!: Partial<Record<KnownHeader, string | undefined>>;
+    headers!: HeaderParamsObject;
 
     // eslint-disable-next-line jsdoc/require-jsdoc
     @Property.object({ cls: () => ParamsObject, required: false, allowAdditionalProperties: true })
-    params: ParamsObject | undefined;
+    params: PathParamsObject | undefined;
 
     // eslint-disable-next-line jsdoc/require-jsdoc
     @Property.unknown({ required: false })
-    body: unknown | undefined;
+    body: T | undefined;
 }
 
 /**

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

@@ -4,6 +4,8 @@ import { WebsocketSendData, WebsocketSendDataMessage, WebsocketSendToAllData, We
 import { ZibriApplication } from '../../application';
 import { type AuthServiceInterface } from '../../auth/auth-service.interface';
 import { BaseUser } from '../../auth/models/base-user.model';
+import { AlsUtilities } from '../../context/als.utilities';
+import { WebsocketRequestContext } from '../../context/request/websocket-request.context';
 import { WhereFilter } from '../../data-source/models/where/where-filter.model';
 import { Repository } from '../../data-source/repository';
 import { InjectRepository } from '../../di/decorators/inject-repository.decorator';
@@ -25,11 +27,11 @@ import { type LoggerInterface } from '../../logging/logger.interface';
 import { type ParserInterface } from '../../parsing/parser.interface';
 import { resolveRouteParams } from '../../routing/resolve-route-params.function';
 import { Newable } from '../../types/newable.type';
+import { JsonUtilities } from '../../utilities/json.utilities';
 import { MetadataUtilities } from '../../utilities/metadata.utilities';
 import { UUIDUtilities } from '../../utilities/uuid.utilities';
 import { type ValidationServiceInterface } from '../../validation/validation-service.interface';
 import { WebsocketControllerData } from '../decorators/websocket-controller.decorator';
-import { BaseWebsocketConnection } from '../models/connection/base-websocket-connection.model';
 import { SocketIOWebsocketConnection } from '../models/connection/socket-io-websocket-connection.model';
 import { WebsocketChannel } from '../models/websocket-channel.model';
 import { WebsocketControllerRouteConfiguration } from '../models/websocket-controller-route-configuration.model';
@@ -99,14 +101,17 @@ export class WebsocketService implements WebsocketServiceInterface<SocketIOWebso
     }
 
     private async onConnect(socket: Socket): Promise<void> {
-        const websocketRequest: WebsocketRequest = {
+        const request: WebsocketRequest = {
             headers: socket.handshake.headers as Partial<Record<KnownHeader, string | undefined>>,
             body: undefined,
             query: socket.handshake.query as Partial<Record<string, string | undefined>>,
             params: {}
         };
+        let connection: SocketIOWebsocketConnection | undefined = this.connections.find(c => c.id === socket.id);
+
+        const context: WebsocketRequestContext = new WebsocketRequestContext(request, connection, undefined, undefined);
         const currentUser: BaseUser<string> | undefined = await this.authService.getCurrentUser(
-            websocketRequest,
+            context,
             this.authService.strategies,
             false
         );
@@ -117,7 +122,6 @@ export class WebsocketService implements WebsocketServiceInterface<SocketIOWebso
             return;
         }
 
-        let connection: SocketIOWebsocketConnection | undefined = this.connections.find(c => c.id === socket.id);
         if (connection) {
             connection.offset = socket.handshake.auth.offset as number;
             await this.recoverConnection(connection, currentUser);
@@ -181,7 +185,7 @@ export class WebsocketService implements WebsocketServiceInterface<SocketIOWebso
             }
             const req: unknown = args[0];
             try {
-                this.validationService.validateWebsocketRequest(req);
+                await this.validationService.validateWebsocketRequest(req);
                 await handler(connection, req as WebsocketRequest, responseHandler);
                 return;
             }
@@ -200,7 +204,7 @@ export class WebsocketService implements WebsocketServiceInterface<SocketIOWebso
                     persist = true;
                 }
 
-                await this.logger.debug(`got an error ${JSON.stringify(globalError)}`);
+                await this.logger.debug(`got an error ${JsonUtilities.stringify(globalError)}`);
 
                 await this.send({
                     connection,
@@ -252,8 +256,7 @@ export class WebsocketService implements WebsocketServiceInterface<SocketIOWebso
         }
 
         const messages: WebsocketMessage[] = await this.messageRepository.findAll({
-            where: whereFilters,
-            order: { seq: 'ASC' }
+            where: whereFilters
         });
 
         for (const m of messages) {
@@ -337,13 +340,17 @@ export class WebsocketService implements WebsocketServiceInterface<SocketIOWebso
 
         if (data.expectResponse) {
             const res: WebsocketRequestWithConnection<SocketIOWebsocketConnection> = {
-                request: await data.connection.emitWithAck(data.event, message, this.options.timeoutInMs),
+                request: await data.connection.emitWithAck(
+                    data.event,
+                    JsonUtilities.parse(JsonUtilities.stringify(message)),
+                    this.options.timeoutInMs
+                ),
                 connection: data.connection
             };
             return res as B extends false ? void : WebsocketRequestWithConnection<SocketIOWebsocketConnection>;
         }
 
-        data.connection.emit(data.event, message);
+        data.connection.emit(data.event, JsonUtilities.parse(JsonUtilities.stringify(message)));
         return undefined as B extends false ? void : WebsocketRequestWithConnection<SocketIOWebsocketConnection>;
     }
 
@@ -380,7 +387,7 @@ export class WebsocketService implements WebsocketServiceInterface<SocketIOWebso
         }
 
         if (!data.expectResponse) {
-            this.socketServer.to(channel.name).emit(data.event, message);
+            this.socketServer.to(channel.name).emit(data.event, JsonUtilities.parse(JsonUtilities.stringify(message)));
             return undefined as B extends false ? void : WebsocketRequestWithConnection<SocketIOWebsocketConnection>[];
         }
 
@@ -444,7 +451,7 @@ export class WebsocketService implements WebsocketServiceInterface<SocketIOWebso
         }
 
         if (!expectResponse) {
-            this.socketServer.emit(data.event, message);
+            this.socketServer.emit(data.event, JsonUtilities.parse(JsonUtilities.stringify(message)));
             return undefined as B extends false ? void : WebsocketRequestWithConnection<SocketIOWebsocketConnection>[];
         }
 
@@ -564,59 +571,61 @@ export class WebsocketService implements WebsocketServiceInterface<SocketIOWebso
             req: WebsocketRequest,
             ack: WebsocketResponseHandler | undefined
         ) => {
-            try {
-                await this.authService.checkAccess(controllerClass, route.controllerMethod, req);
-                const controller: unknown = inject(controllerClass);
-                const params: unknown[] = await this.resolveRouteParams(
-                    controllerClass,
-                    route.controllerMethod,
-                    // eslint-disable-next-line typescript/no-unsafe-member-access, typescript/no-explicit-any
-                    ((controller as any)[route.controllerMethod] as Function).length,
-                    req,
-                    connection
-                );
-
-                // eslint-disable-next-line typescript/no-unsafe-call, typescript/no-explicit-any, typescript/no-unsafe-member-access
-                const res: unknown = await ((controller as any)[route.controllerMethod] as Function)(...params) as unknown;
-                await this.send({
-                    connection,
-                    event: WebsocketEvent.RESPONSE,
-                    expectResponse: true,
-                    message: {
-                        ok: true,
-                        data: res,
-                        senderConnectionId: undefined,
-                        senderUserId: undefined
-                    },
-                    persist: false,
-                    responseHandler: ack
-                });
-            }
-            catch (error) {
-                const err: HttpError = toHttpError(error);
-                await this.send({
-                    connection,
-                    event: WebsocketEvent.RESPONSE,
-                    message: {
-                        ok: false,
-                        error: err,
-                        status: err.status,
-                        senderUserId: undefined,
-                        senderConnectionId: undefined
-                    },
-                    responseHandler: ack,
-                    expectResponse: true,
-                    persist: !isHttpError(error) || error.status >= 500
-                });
-                if (err.status === HttpStatus.UNAUTHORIZED) {
-                    this.disconnect(connection, true);
+            const context: WebsocketRequestContext = new WebsocketRequestContext(req, connection, controllerClass, route.controllerMethod);
+            await AlsUtilities.runWithWebsocketRequestContext(context, async () => {
+                try {
+                    await this.authService.checkAccess(controllerClass, route.controllerMethod, context);
+                    const controller: unknown = inject(controllerClass);
+                    const params: unknown[] = await this.resolveRouteParams(
+                        controllerClass,
+                        route.controllerMethod,
+                        // eslint-disable-next-line typescript/no-unsafe-member-access, typescript/no-explicit-any
+                        ((controller as any)[route.controllerMethod] as Function).length,
+                        context
+                    );
+
+                    // eslint-disable-next-line typescript/no-unsafe-call, typescript/no-explicit-any, typescript/no-unsafe-member-access
+                    const res: unknown = await ((controller as any)[route.controllerMethod] as Function)(...params) as unknown;
+                    await this.send({
+                        connection,
+                        event: WebsocketEvent.RESPONSE,
+                        expectResponse: true,
+                        message: {
+                            ok: true,
+                            data: res,
+                            senderConnectionId: undefined,
+                            senderUserId: undefined
+                        },
+                        persist: false,
+                        responseHandler: ack
+                    });
                 }
-                if (err.status >= 500) {
-                    const globalError: Error = new Error('Global Error', { cause: error });
-                    globalError.stack = undefined;
-                    await this.logger.error(globalError);
+                catch (error) {
+                    const err: HttpError = toHttpError(error);
+                    await this.send({
+                        connection,
+                        event: WebsocketEvent.RESPONSE,
+                        message: {
+                            ok: false,
+                            error: err,
+                            status: err.status,
+                            senderUserId: undefined,
+                            senderConnectionId: undefined
+                        },
+                        responseHandler: ack,
+                        expectResponse: true,
+                        persist: !isHttpError(error) || error.status >= 500
+                    });
+                    if (err.status === HttpStatus.UNAUTHORIZED) {
+                        this.disconnect(connection, true);
+                    }
+                    if (err.status >= 500) {
+                        const globalError: Error = new Error('Global Error', { cause: error });
+                        globalError.stack = undefined;
+                        await this.logger.error(globalError);
+                    }
                 }
-            }
+            });
         };
         return handler;
     }
@@ -639,18 +648,13 @@ export class WebsocketService implements WebsocketServiceInterface<SocketIOWebso
         controllerClass: Newable<unknown>,
         controllerMethod: string,
         totalParamCount: number,
-        req: WebsocketRequest,
-        connection: BaseWebsocketConnection
+        context: WebsocketRequestContext
     ): Promise<unknown[]> {
         return await resolveRouteParams(
             controllerClass,
             controllerMethod,
             totalParamCount,
-            req,
-            this.parser,
-            this.validationService,
-            this.authService,
-            connection
+            context
         );
     }
 }