zibri 2.3.0 → 2.4.0

package/src/multithreading/services/multithreading.service.test.ts

@@ -3,46 +3,14 @@ import { performance } from 'perf_hooks';
 
 import { afterAll, beforeAll, describe, expect, it } from '@jest/globals';
 
+import { MultithreadingServiceInterface } from './multithreading-service.interface';
 import { MultithreadingService } from './multithreading.service';
-import { AssetService } from '../../assets/asset.service';
-import { Repository } from '../../data-source/repository';
-import { repositoryTokenFor } from '../../di/decorators/inject-repository.decorator';
-import { register } from '../../di/register.function';
-import { LogLevel } from '../../logging/log-level.enum';
-import { Logger } from '../../logging/logger';
-import { LoggerInterface } from '../../logging/logger.interface';
-import { LoggerTransport } from '../../logging/transport/logger-transport.model';
-import { OmitStrict } from '../../types/omit-strict.type';
-import { FsUtilities } from '../../utilities/fs.utilities';
+import { defaultTestServerProviders } from '../../__testing__/test-server/providers';
+import { StartedTestServer, startTestServer } from '../../__testing__/test-server/start-test-server.function';
+import { ZIBRI_DI_TOKENS } from '../../di/default/zibri-di-tokens.default';
+import { inject } from '../../di/inject.function';
+import { defineProvider } from '../../di/models/di-provider.model';
 import { Ms } from '../../utilities/ms';
-import { UUIDUtilities } from '../../utilities/uuid.utilities';
-import { BaseThreadJobWorkerData } from '../models/base-thread-job-worker-data.model';
-import { MultithreadingOptions } from '../models/multithreading-options.model';
-import { ThreadJobEntity } from '../models/thread-job-entity.model';
-
-// minimal in-memory repository used by the service in tests
-class InMemoryThreadJobRepository {
-    private readonly store: Map<string, ThreadJobEntity<BaseThreadJobWorkerData, unknown>> = new Map<string, ThreadJobEntity<BaseThreadJobWorkerData, unknown>>();
-    create(data: OmitStrict<ThreadJobEntity<BaseThreadJobWorkerData, unknown>, 'id'>): ThreadJobEntity<BaseThreadJobWorkerData, unknown> {
-        const id: string = UUIDUtilities.generate();
-        const entity: ThreadJobEntity<BaseThreadJobWorkerData, unknown> = { ...data, id };
-        this.store.set(id, entity);
-        return entity;
-    }
-    updateById(id: string, data: Partial<ThreadJobEntity<BaseThreadJobWorkerData, unknown>>): ThreadJobEntity<BaseThreadJobWorkerData, unknown> {
-        const found: ThreadJobEntity<BaseThreadJobWorkerData, unknown> = this.findById(id);
-        const updated: ThreadJobEntity<BaseThreadJobWorkerData, unknown> = { ...found, ...data };
-        this.store.set(id, updated);
-        return updated;
-    }
-    findById(id: string): ThreadJobEntity<BaseThreadJobWorkerData, unknown> {
-        const found: ThreadJobEntity<BaseThreadJobWorkerData, unknown> | undefined = this.store.get(id);
-        if (!found) {
-            throw new Error('Not found');
-        }
-        return found;
-    }
-}
 
 const allThreads: number = os.availableParallelism();
 const reserveThreadsMain: number = 1;
@@ -52,27 +20,6 @@ const availableThreads: number = allThreads - reserveThreadsLibUv - reserveThrea
 const maxThreads: number = Math.max(2, availableThreads - 1);
 const maxPriorityThreads: number = availableThreads <= 1 ? 0 : 1;
 
-const options: MultithreadingOptions = {
-    maxThreads: maxThreads,
-    maxPriorityThreads: maxPriorityThreads,
-    defaultTimeoutMs: Ms.HOUR,
-    defaultTimeoutPriorityMs: Ms.MINUTE * 5
-};
-
-const repo: Repository<ThreadJobEntity<BaseThreadJobWorkerData, unknown>> = new InMemoryThreadJobRepository() as unknown as Repository<ThreadJobEntity<BaseThreadJobWorkerData, unknown>>;
-const logger: LoggerInterface = new Logger(
-    [LoggerTransport.console(LogLevel.INFO)],
-    {
-        [LogLevel.INFO]: 1,
-        [LogLevel.DEBUG]: 1,
-        [LogLevel.WARN]: 1,
-        [LogLevel.ERROR]: 1,
-        [LogLevel.CRITICAL]: 1
-    }
-);
-const assetService: AssetService = new AssetService(logger);
-(assetService.assetsPath as unknown as string) = FsUtilities.getPath(__dirname, '../../../sandbox/assets');
-
 function fib(n: number): number {
     if (n < 2) {
         return n;
@@ -86,7 +33,8 @@ const warmStart: number = performance.now();
 fib(n);
 const tSingle: number = performance.now() - warmStart;
 
-let multithreadingService: MultithreadingService;
+let multithreadingService: MultithreadingServiceInterface;
+let server: StartedTestServer;
 
 describe('MultithreadingService - performance vs main event loop', () => {
     beforeAll(async () => {
@@ -95,15 +43,31 @@ describe('MultithreadingService - performance vs main event loop', () => {
         }
         // eslint-disable-next-line no-console
         console.debug('allThreads', allThreads);
-        register({ token: repositoryTokenFor(ThreadJobEntity), useFactory: () => repo });
-        multithreadingService = new MultithreadingService(options, assetService, logger);
-        await multithreadingService.onAppInit();
+        server = await startTestServer({
+            providers: [
+                ...defaultTestServerProviders,
+                defineProvider({
+                    token: ZIBRI_DI_TOKENS.MULTITHREADING_OPTIONS,
+                    useValue: {
+                        maxThreads: maxThreads,
+                        maxPriorityThreads: maxPriorityThreads,
+                        defaultTimeoutMs: Ms.HOUR,
+                        defaultTimeoutPriorityMs: Ms.MINUTE * 5
+                    }
+                }),
+                defineProvider({
+                    token: ZIBRI_DI_TOKENS.MULTITHREADING_SERVICE,
+                    useClass: MultithreadingService
+                })
+            ]
+        });
+        multithreadingService = inject(ZIBRI_DI_TOKENS.MULTITHREADING_SERVICE);
     }, 30000);
     afterAll(async () => {
         if (allThreads <= 2) {
             return;
         }
-        await multithreadingService.onAppShutdown();
+        await server.shutdown();
     });
 
     it('runs CPU heavy tasks significantly faster via worker threads', async () => {
@@ -113,14 +77,14 @@ describe('MultithreadingService - performance vs main event loop', () => {
         // measure sequential main-thread execution
         const startMain: number = performance.now();
         const mainResults: number[] = [];
-        for (let i: number = 0; i < options.maxThreads; i++) {
+        for (let i: number = 0; i < maxThreads; i++) {
             mainResults.push(fib(n));
         }
         const mainMs: number = performance.now() - startMain;
 
         // measure worker-thread execution (parallel)
         const startWorkers: number = performance.now();
-        const workerPromises: Promise<number>[] = Array.from({ length: options.maxThreads }, () => multithreadingService.run(fib, n));
+        const workerPromises: Promise<number>[] = Array.from({ length: maxThreads }, async () => await multithreadingService.run(fib, n));
         const workerResults: number[] = await Promise.all(workerPromises);
         const workersMs: number = performance.now() - startWorkers;
 
@@ -128,13 +92,13 @@ describe('MultithreadingService - performance vs main event loop', () => {
         expect(workerResults).toEqual(mainResults);
 
         // assert worker run is significantly faster than main-thread sequential run
-        const thresholdFactor: number = computeAdaptiveThresholdFactor(options.maxThreads, options.maxThreads);
+        const thresholdFactor: number = computeAdaptiveThresholdFactor(maxThreads, maxThreads);
         // eslint-disable-next-line no-console
         console.debug('threshold factor:', thresholdFactor, 'multithreading should be below:', mainMs * thresholdFactor);
         // eslint-disable-next-line no-console
         console.debug(`main: ${Math.round(mainMs)} ms, workers: ${Math.round(workersMs)} ms`);
         expect(workersMs).toBeLessThan(mainMs * thresholdFactor);
-    }, (options.maxThreads * tSingle) * 2);
+    }, (maxThreads * tSingle) * 2);
 });
 
 export function computeAdaptiveThresholdFactor(

package/src/multithreading/services/multithreading.service.ts

@@ -17,6 +17,7 @@ import { OnAppShutdown } from '../../global/on-app-shutdown.interface';
 import { type LoggerInterface } from '../../logging/logger.interface';
 import { OmitStrict } from '../../types/omit-strict.type';
 import { FsUtilities, FsPath } from '../../utilities/fs.utilities';
+import { JsonUtilities } from '../../utilities/json.utilities';
 import { UUIDUtilities } from '../../utilities/uuid.utilities';
 import { BaseFunctionThreadJobWorkerData, BaseThreadJobWorkerData } from '../models/base-thread-job-worker-data.model';
 import { type MultithreadingOptions } from '../models/multithreading-options.model';
@@ -88,7 +89,7 @@ export class MultithreadingService implements MultithreadingServiceInterface, On
 
         worker.on('message', m => void this.handleWorkerMessage(m, threadJobWorker.threadId));
         worker.on('exit', code => void this.handleWorkerExit(code, threadJobWorker.threadId));
-        worker.on('error', error => void this.handleWorkerError(error, threadJobWorker.threadId));
+        worker.on('error', (error: Error) => void this.handleWorkerError(error, threadJobWorker.threadId));
 
         this.idleWorkers.push(threadJobWorker);
     }
@@ -321,7 +322,7 @@ export class MultithreadingService implements MultithreadingServiceInterface, On
     }
 
     private async handleWorkerMessage<MessageType>(message: MessageType, threadId: number): Promise<void> {
-        await this.logger.debug(`got message from worker:\n${JSON.stringify(message, undefined, 2)}`);
+        await this.logger.debug(`got message from worker:\n${JsonUtilities.stringify(message, undefined, 2)}`);
 
         const job: ThreadJob<BaseThreadJobWorkerData, unknown> | undefined = this.getJobByThreadId(threadId);
         if (!job) {

package/src/open-api/open-api.service.ts

@@ -37,6 +37,7 @@ import { RouteHandler } from '../routing/route-configuration.model';
 import { type RouterInterface } from '../routing/router.interface';
 import { Newable } from '../types/newable.type';
 import { FsUtilities, FsPath } from '../utilities/fs.utilities';
+import { JsonUtilities } from '../utilities/json.utilities';
 import { MetadataUtilities } from '../utilities/metadata.utilities';
 import { ObjectUtilities } from '../utilities/object.utilities';
 
@@ -140,7 +141,7 @@ export class OpenApiService implements OpenApiServiceInterface, OnAppInit {
                 res.type('.js').send([
                     'window.onload = function() {',
                     '    SwaggerUIBundle({',
-                    `        spec: ${JSON.stringify(definition)},`,
+                    `        spec: ${JsonUtilities.stringify(definition)},`,
                     '        dom_id: \'#swagger-ui\',',
                     '        presets: [',
                     '            SwaggerUIBundle.presets.apis,',
@@ -448,7 +449,7 @@ export class OpenApiService implements OpenApiServiceInterface, OnAppInit {
                     return undefined;
                 }
                 const propMeta: Record<string, PropertyMetadata> = MetadataUtilities.getModelProperties(response.cls);
-                const schema: OpenApiSchemaObject = this.buildOpenApiSchemaForProperties(propMeta, response.cls);
+                const schema: OpenApiSchemaObject = this.buildOpenApiSchemaForProperties(propMeta, response.cls, 'response');
 
                 if (response.isArray === true) {
                     return { [MimeType.JSON]: { schema: { type: 'array', items: schema } } };
@@ -490,7 +491,7 @@ export class OpenApiService implements OpenApiServiceInterface, OnAppInit {
                         continue;
                     }
                     const propMeta: Record<string, PropertyMetadata> = MetadataUtilities.getModelProperties(response.cls);
-                    const schema: OpenApiSchemaObject = this.buildOpenApiSchemaForProperties(propMeta, response.cls);
+                    const schema: OpenApiSchemaObject = this.buildOpenApiSchemaForProperties(propMeta, response.cls, 'response');
                     if (response.isArray === true) {
                         schemas.push({ type: 'array', items: schema });
                         continue;
@@ -543,7 +544,7 @@ export class OpenApiService implements OpenApiServiceInterface, OnAppInit {
             return undefined;
         }
         const propMeta: Record<string, PropertyMetadata> = MetadataUtilities.getModelProperties(metadata.modelClass);
-        const schema: OpenApiSchemaObject = this.buildOpenApiSchemaForProperties(propMeta, metadata.modelClass);
+        const schema: OpenApiSchemaObject = this.buildOpenApiSchemaForProperties(propMeta, metadata.modelClass, 'request');
         return {
             required: typeof metadata.required === 'boolean' ? metadata.required : undefined,
             description: metadata.description,
@@ -552,17 +553,23 @@ export class OpenApiService implements OpenApiServiceInterface, OnAppInit {
     }
 
     // eslint-disable-next-line sonar/cognitive-complexity
-    private buildOpenApiSchemaForProperties(propMeta: Record<string, PropertyMetadata>, entity: Newable<unknown>): OpenApiSchemaObject {
+    private buildOpenApiSchemaForProperties(
+        propMeta: Record<string, PropertyMetadata>,
+        entity: Newable<unknown>,
+        context: 'request' | 'response'
+    ): OpenApiSchemaObject {
         const properties: Record<string, OpenApiSchemaObject> = {};
         const required: string[] = [];
 
         for (const [key, meta] of ObjectUtilities.entries(propMeta)) {
+            if (meta.exclude === true && context === 'response') {
+                continue;
+            }
             // mark required
-            if ((
-                typeof meta.required === 'boolean'
-                    ? meta.required
-                    : false)
+            if (
+                (typeof meta.required === 'boolean' ? meta.required : false)
                 && (!('default' in meta) || meta.default == undefined)
+                && (meta.exclude === false || context === 'response')
             ) {
                 required.push(key);
             }
@@ -605,14 +612,20 @@ export class OpenApiService implements OpenApiServiceInterface, OnAppInit {
                 }
                 case 'object': {
                     const objectPropMeta: Record<string, PropertyMetadata> = MetadataUtilities.getModelProperties(meta.cls());
-                    properties[key] = { ...this.buildOpenApiSchemaForProperties(objectPropMeta, entity), description: meta.description };
+                    properties[key] = {
+                        ...this.buildOpenApiSchemaForProperties(objectPropMeta, entity, context),
+                        description: meta.description
+                    };
                     continue;
                 }
                 case Relation.ONE_TO_ONE:
                 case Relation.MANY_TO_ONE: {
                     const targetClass: Newable<BaseEntity> = this.getTargetClassForRelation(meta, entity);
                     const objectPropMeta: Record<string, PropertyMetadata> = MetadataUtilities.getModelProperties(targetClass);
-                    properties[key] = { ...this.buildOpenApiSchemaForProperties(objectPropMeta, entity), description: meta.description };
+                    properties[key] = {
+                        ...this.buildOpenApiSchemaForProperties(objectPropMeta, entity, context),
+                        description: meta.description
+                    };
                     continue;
                 }
                 case Relation.MANY_TO_MANY:
@@ -627,10 +640,12 @@ export class OpenApiService implements OpenApiServiceInterface, OnAppInit {
                                 required: true,
                                 description: undefined,
                                 excludeFromChangeSets: false,
+                                exclude: false,
                                 allowAdditionalProperties: false
                             }
                         },
-                        entity
+                        entity,
+                        context
                     );
                     properties[key] = {
                         type: 'array',
@@ -643,7 +658,7 @@ export class OpenApiService implements OpenApiServiceInterface, OnAppInit {
                     if (meta.items.type === 'object') {
                         entity = meta.items.cls();
                     }
-                    const items: OpenApiSchemaObject = this.buildOpenApiSchemaForProperties({ items: meta.items }, entity);
+                    const items: OpenApiSchemaObject = this.buildOpenApiSchemaForProperties({ items: meta.items }, entity, context);
                     properties[key] = {
                         type: 'array',
                         description: meta.description,
@@ -756,7 +771,7 @@ export class OpenApiService implements OpenApiServiceInterface, OnAppInit {
                 const propMeta: Record<string, PropertyMetadata> = MetadataUtilities.getModelProperties(meta.cls());
                 return {
                     description: meta.description,
-                    ...this.buildOpenApiSchemaForProperties(propMeta, meta.cls())
+                    ...this.buildOpenApiSchemaForProperties(propMeta, meta.cls(), 'request')
                 };
             }
             case 'array': {

package/src/parsing/form-data/file-response.model.ts

@@ -2,11 +2,13 @@ import { Readable } from 'stream';
 
 import { ZIBRI_DI_TOKENS } from '../../di/default/zibri-di-tokens.default';
 import { inject } from '../../di/inject.function';
-import { LooseFileMimeType } from '../../http/mime-type.enum';
+import { LooseFileMimeType, MimeType } from '../../http/mime-type.enum';
 import { resolveMimeType } from '../../http/mime-type.helpers';
 import { LoggerInterface } from '../../logging/logger.interface';
+import { DeepPartial } from '../../types/deep-partial.type';
 import { OmitStrict } from '../../types/omit-strict.type';
 import { FsUtilities, FsPath } from '../../utilities/fs.utilities';
+import { buildCspOptions, CspOptions } from '../html/csp-options.model';
 
 /**
  * Data shared by all FileResponses.
@@ -20,7 +22,12 @@ type BaseFileResponseData = {
      * The size of the file to send in bytes.
      * Used to set the Content-Length header.
      */
-    size?: number
+    size?: number,
+    /**
+     * The configuration for CSP headers.
+     * Can either be false to not set any, true to set the default CSP headers or a custom configuration.
+     */
+    csp?: boolean | DeepPartial<CspOptions>
 };
 
 /**
@@ -61,7 +68,8 @@ export class FileResponse {
         readonly data: Readable | string,
         readonly filename: string,
         readonly mimeType: LooseFileMimeType,
-        readonly size: number | undefined
+        readonly size: number | undefined,
+        readonly csp: boolean | CspOptions
     ) {}
 
     /**
@@ -84,8 +92,9 @@ export class FileResponse {
         }
 
         const size: number = options?.size ?? (await FsUtilities.stat(fullPath)).size;
+        const csp: boolean | CspOptions = buildCspOptions(options?.csp, this.getDefaultCsp(mimeType));
 
-        return new this(fullPath, fileName, mimeType, size);
+        return new this(fullPath, fileName, mimeType, size, csp);
     }
 
     /**
@@ -95,6 +104,14 @@ export class FileResponse {
      */
     static fromStream(input: StreamFileResponseData): FileResponse {
         const mimeType: string = input.mimeType ?? resolveMimeType(input.filename);
-        return new this(input.stream, input.filename, mimeType, input.size);
+        const csp: boolean | CspOptions = buildCspOptions(input?.csp, this.getDefaultCsp(mimeType));
+        return new this(input.stream, input.filename, mimeType, input.size, csp);
+    }
+
+    private static getDefaultCsp(mimeType: string): boolean | CspOptions {
+        if (mimeType === MimeType.SVG) {
+            return inject(ZIBRI_DI_TOKENS.DEFAULT_CSP_OPTIONS);
+        }
+        return false;
     }
 }

package/src/parsing/form-data/form-data-body-parser-cleanup.cron-job.ts

@@ -1,6 +1,7 @@
 import { Dirent } from 'node:fs';
 
 import { CLEANUP_AT_FILE_NAME } from './form-data.model';
+import { CronExpression } from '../../cron/cron-expression.utilities';
 import { CronJob, InitialCronConfig } from '../../cron/cron-job.model';
 import { Inject } from '../../di/decorators/inject.decorator';
 import { ZIBRI_DI_TOKENS } from '../../di/default/zibri-di-tokens.default';
@@ -13,7 +14,7 @@ export class FormDataBodyParserCleanupCronJob extends CronJob {
     // eslint-disable-next-line jsdoc/require-jsdoc
     initialConfig: InitialCronConfig = {
         name: 'FormDataBodyParser Cleanup',
-        cron: '0 0 * * *',
+        cron: CronExpression.daily().build(),
         runOnInit: false
     };
 

package/src/parsing/form-data/form-data.body-parser.ts

@@ -21,9 +21,9 @@ import { ContentTooLargeError } from '../../error-handling/errors/content-too-la
 import { KnownHeader } from '../../http/known-header.enum';
 import { FileExtension, resolveFileExtension } from '../../http/mime-type.helpers';
 import { HttpClientResponse } from '../../http-client/http-client-response.model';
-import { BigNumberUtilities } from '../../utilities/big-number.utilities';
 import { FsUtilities, FsPath } from '../../utilities/fs.utilities';
 import { MetadataUtilities } from '../../utilities/metadata.utilities';
+import { BigNumber, NumberUtilities } from '../../utilities/number.utilities';
 import { UUIDUtilities } from '../../utilities/uuid.utilities';
 import { BodyParser } from '../decorators/body-parser.decorator';
 import { parseArray } from '../functions/parse-array.function';
@@ -51,7 +51,9 @@ export class FormDataBodyParser implements BodyParserInterface, OnAppInit {
 
     // eslint-disable-next-line jsdoc/require-jsdoc
     onAppInit(app: ZibriApplication): void {
-        app.options.cronJobs.push(FormDataBodyParserCleanupCronJob);
+        if (!app.options.cronJobs.includes(FormDataBodyParserCleanupCronJob)) {
+            app.options.cronJobs.push(FormDataBodyParserCleanupCronJob);
+        }
     }
 
     // eslint-disable-next-line jsdoc/require-jsdoc
@@ -84,8 +86,8 @@ export class FormDataBodyParser implements BodyParserInterface, OnAppInit {
         if (metadata.type !== MimeType.FORM_DATA) {
             throw new Error(`${metadata.type} is not supported`);
         }
-        const contentLength: string | undefined = headers[KnownHeader.CONTENT_LENGTH] ?? headers[KnownHeader.CONTENT_LENGTH];
-        if (contentLength && BigNumberUtilities.new(Number(contentLength)).isGreaterThan(metadata.maxSize)) {
+        const contentLength: string | undefined = headers[KnownHeader.CONTENT_LENGTH];
+        if (contentLength && NumberUtilities.new(Number(contentLength)).isGreaterThan(metadata.maxSize)) {
             throw new ContentTooLargeError();
         }
 
@@ -133,10 +135,10 @@ export class FormDataBodyParser implements BodyParserInterface, OnAppInit {
 
     private requestToDataObject<T extends object>(request: ParsedForm, metadata: BodyMetadata): T {
         const multiPartMap: Map<keyof T, FormDataValue> = new Map();
+        const properties: Record<string, PropertyMetadata> = MetadataUtilities.getModelProperties(metadata.modelClass);
         this.addStringValuesToMap(request, multiPartMap);
-        this.addFilesToMap<T>(request, multiPartMap, metadata);
+        this.addFilesToMap<T>(request, multiPartMap, properties);
 
-        const properties: Record<string, PropertyMetadata> = MetadataUtilities.getModelProperties(metadata.modelClass);
         const res: Partial<Record<keyof T, unknown>> = {};
         for (const [key, value] of multiPartMap) {
             if (typeof value !== 'string') {
@@ -187,11 +189,10 @@ export class FormDataBodyParser implements BodyParserInterface, OnAppInit {
     private addFilesToMap<T extends object>(
         request: ParsedForm,
         values: Map<keyof T, FormDataValue>,
-        metadata: BodyMetadata
+        properties: Record<string, PropertyMetadata>
     ): void {
         for (const key in request.filesMap) {
-            const formDataProperties: Record<string, PropertyMetadata> = MetadataUtilities.getModelProperties(metadata.modelClass);
-            const property: PropertyMetadata = formDataProperties[key];
+            const property: PropertyMetadata = properties[key];
             this.addFileArrayToMap(request.filesMap[key], values, property);
         }
     }
@@ -258,7 +259,7 @@ export class FormDataBodyParser implements BodyParserInterface, OnAppInit {
             const filesMap: Record<string, File[]> = {};
             const filePromises: Promise<void>[] = [];
 
-            let received: BigNumber = BigNumberUtilities.new(0);
+            let received: BigNumber = NumberUtilities.new(0);
             let aborted: boolean = false;
 
             bb.on('field', (name: string, val: string) => {
@@ -267,7 +268,7 @@ export class FormDataBodyParser implements BodyParserInterface, OnAppInit {
                 }
 
                 const bytes: number = Buffer.byteLength(val, 'utf8');
-                received = BigNumberUtilities.add(received, bytes);
+                received = NumberUtilities.add(received, bytes);
                 if (received.isGreaterThan(metadata.maxSize)) {
                     aborted = true;
                     // stop parsing and abort
@@ -303,7 +304,7 @@ export class FormDataBodyParser implements BodyParserInterface, OnAppInit {
                         return;
                     }
 
-                    received = BigNumberUtilities.add(received, chunk.length);
+                    received = NumberUtilities.add(received, chunk.length);
                     if (received.isGreaterThan(metadata.maxSize)) {
                         aborted = true;
                         writeStream.destroy();

package/src/parsing/functions/parse-array.function.ts

@@ -5,6 +5,7 @@ import { parseObject } from './parse-object.function';
 import { parseString } from './parse-string.function';
 import { ArrayPropertyItemMetadata } from '../../entity/models/array-property-metadata.model';
 import { ArrayParamItemMetadata } from '../../routing/models/array-param-metadata.model';
+import { JsonUtilities } from '../../utilities/json.utilities';
 
 // eslint-disable-next-line jsdoc/require-jsdoc
 export function parseArray(
@@ -18,7 +19,7 @@ export function parseArray(
     let simpleParsedValue: unknown = rawValue;
     try {
         if (typeof rawValue === 'string') {
-            simpleParsedValue = JSON.parse(rawValue);
+            simpleParsedValue = JsonUtilities.parse(rawValue);
         }
     }
     catch {

package/src/parsing/functions/parse-number.function.ts

@@ -1,9 +1,32 @@
 import { isNumeric } from '../../utilities/is-numeric.function';
 
+/**
+ * Regex that matches integers.
+ */
+export const INTEGER_REGEX: RegExp = /^-?(0|[1-9]\d*)$/;
+
 // eslint-disable-next-line jsdoc/require-jsdoc
 export function parseNumber(rawValue: unknown): unknown {
     if (!isNumeric(rawValue)) {
         return rawValue;
     }
+
+    if (typeof rawValue !== 'string') {
+        return rawValue;
+    }
+
+    if (!INTEGER_REGEX.test(rawValue)) {
+        const asNumber: number = Number(rawValue);
+        return Number.isFinite(asNumber) ? asNumber : rawValue;
+    }
+
+    const asBigInt: bigint = BigInt(rawValue);
+    if (
+        asBigInt > BigInt(Number.MAX_SAFE_INTEGER)
+        || asBigInt < BigInt(Number.MIN_SAFE_INTEGER)
+    ) {
+        return asBigInt;
+    }
+
     return Number(rawValue);
 }

package/src/parsing/functions/parse-object.function.ts

@@ -6,6 +6,7 @@ import { parseString } from './parse-string.function';
 import { PropertyMetadata } from '../../entity/decorators/property.decorator';
 import { Relation } from '../../entity/models/relation.enum';
 import { Newable } from '../../types/newable.type';
+import { JsonUtilities } from '../../utilities/json.utilities';
 import { MetadataUtilities } from '../../utilities/metadata.utilities';
 import { ObjectUtilities } from '../../utilities/object.utilities';
 
@@ -21,7 +22,7 @@ export function parseObject(
     let simpleParsedValue: unknown = rawValue;
     try {
         if (typeof rawValue === 'string') {
-            simpleParsedValue = JSON.parse(rawValue);
+            simpleParsedValue = JsonUtilities.parse(rawValue);
         }
     }
     catch {

package/src/parsing/functions/parse-object.test.ts

@@ -3,6 +3,7 @@ import { describe, expect, it } from '@jest/globals';
 
 import { parseObject } from './parse-object.function';
 import { Property } from '../../entity/decorators/property.decorator';
+import { JsonUtilities } from '../../utilities/json.utilities';
 
 class Dummy {}
 
@@ -13,7 +14,7 @@ class Dummy2 {
 
 describe('parseObject', () => {
     it('parses date correctly', () => {
-        const parsedObject: { testDate: Date } = parseObject(JSON.stringify({ testDate: new Date() }), Dummy2) as { testDate: Date };
+        const parsedObject: { testDate: Date } = parseObject(JsonUtilities.stringify({ testDate: new Date() }), Dummy2) as { testDate: Date };
         expect(parsedObject.testDate).toBeInstanceOf(Date);
     });