zibri 2.3.0 → 2.4.0

package/src/validation/validation.service.ts

@@ -7,6 +7,8 @@ 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';
@@ -29,7 +31,7 @@ type PathParamValidationFunction = (
     meta: PathParamMetadata,
     parentKey: string | undefined,
     entity: unknown | undefined
-) => ValidationProblem[];
+) => ValidationProblem[] | Promise<ValidationProblem[]>;
 
 /**
  * Function for validating a query parameter.
@@ -39,7 +41,7 @@ type QueryParamValidationFunction = (
     meta: QueryParamMetadata,
     parentKey: string | undefined,
     entity: unknown | undefined
-) => ValidationProblem[];
+) => ValidationProblem[] | Promise<ValidationProblem[]>;
 
 /**
  * Function for validating a header parameter.
@@ -49,7 +51,7 @@ type HeaderParamValidationFunction = (
     meta: HeaderParamMetadata,
     parentKey: string | undefined,
     entity: unknown | undefined
-) => ValidationProblem[];
+) => ValidationProblem[] | Promise<ValidationProblem[]>;
 
 /**
  * Function for validating a single property.
@@ -60,7 +62,7 @@ type PropertyValidationFunction = (
     metadata: PropertyMetadata,
     parentKey: string | undefined,
     entity: unknown | undefined
-) => ValidationProblem[];
+) => ValidationProblem[] | Promise<ValidationProblem[]>;
 
 /**
  * The default validation service implementation of Zibri.
@@ -106,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
@@ -154,91 +164,63 @@ 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 (
@@ -254,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)];
         }
@@ -282,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)];
         }
@@ -326,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/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,
@@ -337,13 +341,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 +388,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 +452,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 +572,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 +649,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
         );
     }
 }

package/dist/cjs/auth/hash.utilities.d.ts

@@ -1,19 +0,0 @@
-/**
- * Provides utilities around hashing and comparing hashes.
- */
-export declare abstract class HashUtilities {
-    /**
-     * Hashes the given value.
-     * @param value - The value to hash.
-     * @returns A bcrypt hash.
-     */
-    static hash(value: string): Promise<string>;
-    /**
-     * Checks if the hash of the given value equals the hash.
-     * @param value - The value to compare.
-     * @param hash - The hash to compare against.
-     * @returns True when they are equal, false otherwise.
-     */
-    static equal(value: string, hash: string): Promise<boolean>;
-}
-//# sourceMappingURL=hash.utilities.d.ts.map

package/dist/cjs/auth/hash.utilities.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hash.utilities.d.ts","sourceRoot":"","sources":["../../../src/auth/hash.utilities.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,8BAAsB,aAAa;IAC/B;;;;OAIG;WACU,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAGjD;;;;;OAKG;WACU,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAGpE"}

package/dist/cjs/auth/hash.utilities.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HashUtilities = void 0;
-const bcryptjs_1 = require("bcryptjs");
-/**
- * Provides utilities around hashing and comparing hashes.
- */
-class HashUtilities {
-    /**
-     * Hashes the given value.
-     * @param value - The value to hash.
-     * @returns A bcrypt hash.
-     */
-    static async hash(value) {
-        return await (0, bcryptjs_1.hash)(value, await (0, bcryptjs_1.genSalt)());
-    }
-    /**
-     * Checks if the hash of the given value equals the hash.
-     * @param value - The value to compare.
-     * @param hash - The hash to compare against.
-     * @returns True when they are equal, false otherwise.
-     */
-    static async equal(value, hash) {
-        return await (0, bcryptjs_1.compare)(value, hash);
-    }
-}
-exports.HashUtilities = HashUtilities;
-//# sourceMappingURL=hash.utilities.js.map

package/dist/cjs/auth/hash.utilities.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hash.utilities.js","sourceRoot":"","sources":["../../../src/auth/hash.utilities.ts"],"names":[],"mappings":";;;AAAA,uCAAkD;AAElD;;GAEG;AACH,MAAsB,aAAa;IAC/B;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAa;QAC3B,OAAO,MAAM,IAAA,eAAI,EAAC,KAAK,EAAE,MAAM,IAAA,kBAAO,GAAE,CAAC,CAAC;IAC9C,CAAC;IACD;;;;;OAKG;IACH,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,KAAa,EAAE,IAAY;QAC1C,OAAO,MAAM,IAAA,kBAAO,EAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACtC,CAAC;CACJ;AAlBD,sCAkBC"}

package/dist/cjs/metrics/scrape-metrics.cron-job.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scrape-metrics.cron-job.d.ts","sourceRoot":"","sources":["../../../src/metrics/scrape-metrics.cron-job.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAC3E,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAIpE;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,OAAO;IAUzC,OAAO,CAAC,QAAQ,CAAC,cAAc;IARnC,aAAa,EAAE,iBAAiB,CAI9B;gBAImB,cAAc,EAAE,uBAAuB;IAMtD,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAIhC"}

package/dist/cjs/metrics/scrape-metrics.cron-job.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"scrape-metrics.cron-job.js","sourceRoot":"","sources":["../../../src/metrics/scrape-metrics.cron-job.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AACA,2DAAoE;AACpE,wEAA2D;AAC3D,mFAAwE;AAExE;;GAEG;AACH,IAAa,oBAAoB,GAAjC,MAAa,oBAAqB,SAAQ,wBAAO;IAUxB;IATrB,+CAA+C;IAC/C,aAAa,GAAsB;QAC/B,IAAI,EAAE,gBAAgB;QACtB,IAAI,EAAE,eAAe;QACrB,SAAS,EAAE,KAAK;KACnB,CAAC;IAEF,YAEqB,cAAuC;QAExD,KAAK,EAAE,CAAC;QAFS,mBAAc,GAAd,cAAc,CAAyB;IAG5D,CAAC;IAED,+CAA+C;IAC/C,KAAK,CAAC,MAAM;QACR,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;QAC3C,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;IACxC,CAAC;CACJ,CAAA;AApBY,oDAAoB;+BAApB,oBAAoB;IASxB,WAAA,IAAA,yBAAM,EAAC,yCAAe,CAAC,eAAe,CAAC,CAAA;;GATnC,oBAAoB,CAoBhC"}

package/dist/cjs/routing/request.context.d.ts

@@ -1,15 +0,0 @@
-import { HttpRequest } from '../http/http-request.model';
-/**
- * Runs the given function with the request saved in async local storage.
- * @param req - The request.
- * @param fn - The function to run.
- * @returns The result of the function.
- */
-export declare function runWithRequest<T>(req: HttpRequest, fn: () => T): T;
-/**
- * Resolves the currently active request from the async local storage.
- * @returns The currently active http request.
- * @throws When the async local storage store has not been initialized yet.
- */
-export declare function getCurrentRequest(): HttpRequest | undefined;
-//# sourceMappingURL=request.context.d.ts.map

package/dist/cjs/routing/request.context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"request.context.d.ts","sourceRoot":"","sources":["../../../src/routing/request.context.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAczD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAElE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,WAAW,GAAG,SAAS,CAG3D"}