zibri 2.3.0 → 2.4.0

package/src/handlebars/resolve-all-array-keys.function.ts

@@ -1,5 +1,6 @@
 import { AstBlockStatement, AstExpression, AstProgram, AstStatement } from './ast.model';
 import { resolveKeyForPathExpression } from './resolve-key-for-path-expression.function';
+import { JsonUtilities } from '../utilities/json.utilities';
 
 // eslint-disable-next-line jsdoc/require-jsdoc
 export function resolveAllArrayKeys(ast: AstProgram, parentKey: string | undefined): string[] {
@@ -61,7 +62,7 @@ function resolveArrayKeysForBlockStatement(element: AstBlockStatement, parentKey
 // eslint-disable-next-line jsdoc/require-jsdoc
 function getArrayKeyFromArrayParams(params: AstExpression[], parentKey: string | undefined): string {
     if (params.length !== 1) {
-        throw new Error(`Got more than 1 param ${JSON.stringify(params)}`);
+        throw new Error(`Got more than 1 param ${JsonUtilities.stringify(params)}`);
     }
 
     switch (params[0].type) {

package/src/handlebars/resolve-keys-for-block-statement.function.ts

@@ -1,6 +1,7 @@
 import { AstBlockStatement, AstExpression } from './ast.model';
 import { resolveKeyForPathExpression } from './resolve-key-for-path-expression.function';
 import { resolveAllKeys } from './resolve-tree.function';
+import { JsonUtilities } from '../utilities/json.utilities';
 
 // eslint-disable-next-line jsdoc/require-jsdoc
 export function resolveKeysForBlockStatement(element: AstBlockStatement, parentKey: string | undefined): string[] {
@@ -28,8 +29,8 @@ export function resolveKeysForBlockStatement(element: AstBlockStatement, parentK
         case 'with':
         case 'log': {
             throw new Error(`Not implemented yet "${element.path.original}"`);
-            res.push(...resolveAllKeys(element.program, parentKey));
-            break;
+            // res.push(...resolveAllKeys(element.program, parentKey));
+            // break;
         }
         default: {
             throw new Error(`Unknown AST path.original "${element.path.original}"`);
@@ -41,7 +42,7 @@ export function resolveKeysForBlockStatement(element: AstBlockStatement, parentK
 // eslint-disable-next-line jsdoc/require-jsdoc
 function getKeyFromArrayParams(params: AstExpression[], parentKey: string | undefined): string {
     if (params.length !== 1) {
-        throw new Error(`Got more than 1 param ${JSON.stringify(params)}`);
+        throw new Error(`Got more than 1 param ${JsonUtilities.stringify(params)}`);
     }
 
     switch (params[0].type) {
@@ -70,7 +71,7 @@ function getKeyFromArrayParams(params: AstExpression[], parentKey: string | unde
 // eslint-disable-next-line jsdoc/require-jsdoc
 function getKeyFromIfParams(params: AstExpression[], parentKey: string | undefined): string {
     if (params.length !== 1) {
-        throw new Error(`Got more than 1 param ${JSON.stringify(params)}`);
+        throw new Error(`Got more than 1 param ${JsonUtilities.stringify(params)}`);
     }
 
     switch (params[0].type) {

package/src/http/cookie-options.model.ts

@@ -0,0 +1,11 @@
+import { CookieOptions as ExpressCookieOptions } from 'express';
+
+/**
+ * Options for a cookie.
+ */
+export type CookieOptions = ExpressCookieOptions & {
+    /**
+     * The name of the cookie.
+     */
+    name: string
+};

package/src/http/http-request.model.ts

@@ -1,5 +1,6 @@
 import { Request } from 'express';
 
+import { HttpMethod } from './http-method.enum';
 import { KnownHeader } from './known-header.enum';
 import { OmitStrict } from '../types/omit-strict.type';
 
@@ -12,7 +13,7 @@ export type HttpRequest<
     QueryParamsObject extends Record<string, unknown> = Record<string, string | undefined>,
     HeaderParamsObject extends Record<string, unknown> = Partial<Record<KnownHeader, string | undefined>>
 // eslint-disable-next-line typescript/no-explicit-any
-> = OmitStrict<Request<Record<string, string>, any, T>, 'query' | 'headers' | 'params'> & {
+> = OmitStrict<Request<Record<string, string>, any, T>, 'query' | 'headers' | 'params' | 'method'> & {
     /**
      * The path parameters of the request, as an object.
      */
@@ -24,7 +25,11 @@ export type HttpRequest<
     /**
      * The header parameters of the request, as an object.
      */
-    headers: HeaderParamsObject
+    headers: HeaderParamsObject,
+    /**
+     * The http method of the request.
+     */
+    method: HttpMethod
 };
 
 /**

package/src/http/known-header.enum.ts

@@ -4,31 +4,35 @@ import { ObjectUtilities } from '../utilities/object.utilities';
  * Known http headers.
  */
 export enum KnownHeader {
-    ACCEPT = 'Accept',
-    ACCEPT_ENCODING = 'Accept-Encoding',
-    AUTHORIZATION = 'Authorization',
-    CACHE_CONTROL = 'Cache-Control',
-    CONTENT_LENGTH = 'Content-Length',
-    CONTENT_TYPE = 'Content-Type',
-    CONTENT_DISPOSITION = 'Content-Disposition',
-    COOKIE = 'Cookie',
-    HOST = 'Host',
-    ORIGIN = 'Origin',
-    REFERER = 'Referer',
-    USER_AGENT = 'User-Agent',
-    X_REQUESTED_WITH = 'X-Requested-With',
-    X_FORWARDED_FOR = 'X-Forwarded-For',
-    X_FORWARDED_HOST = 'X-Forwarded-Host',
-    X_FORWARDED_PROTO = 'X-Forwarded-Proto',
-    X_REAL_IP = 'X-Real-IP',
-    X_CORRELATION_ID = 'X-Correlation-ID',
-    IF_NONE_MATCH = 'If-None-Match',
-    IIF_MODIFIED_SINCE = 'If-Modified-Since',
-    CONNECTION = 'Connection',
-    DNT = 'DNT',
-    SEC_FETCH_MODE = 'Sec-Fetch-Mode',
-    SEC_FETCH_SITE = 'Sec-Fetch-Site',
-    TE = 'TE'
+    ACCEPT = 'accept',
+    ACCEPT_ENCODING = 'accept-encoding',
+    AUTHORIZATION = 'authorization',
+    CACHE_CONTROL = 'cache-control',
+    CONTENT_LENGTH = 'content-length',
+    CONTENT_TYPE = 'content-type',
+    CONTENT_DISPOSITION = 'content-disposition',
+    CONTENT_SECURITY_POLICY = 'content-security-policy',
+    COOKIE = 'cookie',
+    HOST = 'host',
+    STRICT_TRANSPORT_SECURITY = 'strict-transport-security',
+    ORIGIN = 'origin',
+    REFERER = 'referer',
+    REFERRER_POLICY = 'referrer-policy',
+    USER_AGENT = 'user-agent',
+    X_FRAME_OPTIONS = 'x-frame-options',
+    X_CONTENT_TYPE_OPTIONS = 'x-content-type-options',
+    X_REQUESTED_WITH = 'x-requested-with',
+    X_FORWARDED_FOR = 'x-forwarded-for',
+    X_FORWARDED_HOST = 'x-forwarded-host',
+    X_FORWARDED_PROTO = 'x-forwarded-proto',
+    X_REAL_IP = 'x-real-ip',
+    IF_NONE_MATCH = 'if-none-match',
+    IIF_MODIFIED_SINCE = 'if-modified-since',
+    CONNECTION = 'connection',
+    DNT = 'dnt',
+    SEC_FETCH_MODE = 'sec-fetch-mode',
+    SEC_FETCH_SITE = 'sec-fetch-site',
+    TE = 'te'
 }
 
 /**
@@ -37,5 +41,5 @@ export enum KnownHeader {
  * @returns True when the KnownHeader enum values include the given value, false otherwise.
  */
 export function isKnownHeader(value: string): value is KnownHeader {
-    return ObjectUtilities.values(KnownHeader).includes(value as KnownHeader);
+    return ObjectUtilities.values(KnownHeader).includes(value.toLowerCase() as KnownHeader);
 }

package/src/http/mime-type.enum.ts

@@ -4,29 +4,68 @@ import { ExcludeStrict } from '../types/exclude-strict.type';
  * All known mime types.
  */
 export enum MimeType {
+    // Application
     JSON = 'application/json',
     XML = 'application/xml',
-    HTML = 'text/html',
     FORM_DATA = 'multipart/form-data',
     FORM_URL_ENCODED = 'application/x-www-form-urlencoded',
     OCTET_STREAM = 'application/octet-stream',
+    PDF = 'application/pdf',
+    ZIP = 'application/zip',
+    GZIP = 'application/gzip',
+    TAR = 'application/x-tar',
+    WASM = 'application/wasm',
+    JSON_LD = 'application/ld+json',
+    // eslint-disable-next-line cspell/spellchecker
+    NDJSON = 'application/x-ndjson',
+    XLSX = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    DOCX = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    // eslint-disable-next-line cspell/spellchecker
+    PPTX = 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    // Text
+    HTML = 'text/html',
+    CSS = 'text/css',
+    CSV = 'text/csv',
+    TXT = 'text/plain',
+    JAVASCRIPT = 'text/javascript',
+    YAML = 'text/yaml',
+    EVENT_STREAM = 'text/event-stream',
+    // Image
     PNG = 'image/png',
     JPEG = 'image/jpeg',
-    ZIP = 'application/zip',
+    GIF = 'image/gif',
+    WEBP = 'image/webp',
     SVG = 'image/svg+xml',
-    CSS = 'text/css',
+    ICO = 'image/x-icon',
+    BMP = 'image/bmp',
+    TIFF = 'image/tiff',
+    AVIF = 'image/avif',
+    // Audio
+    MP3 = 'audio/mpeg',
+    WAV = 'audio/wav',
+    OGG_AUDIO = 'audio/ogg',
+    WEBM_AUDIO = 'audio/webm',
+    // Video
+    MP4 = 'video/mp4',
+    WEBM_VIDEO = 'video/webm',
+    OGG_VIDEO = 'video/ogg',
+    // Font
     TTF = 'font/ttf',
-    PDF = 'application/pdf',
-    CSV = 'text/csv',
-    XLSX = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-    DOCX = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-    TXT = 'text/plain'
+    OTF = 'font/otf',
+    WOFF = 'font/woff',
+    WOFF2 = 'font/woff2'
 }
 
 /**
  * File mime types.
  */
-export type FileMimeType = ExcludeStrict<MimeType, MimeType.OCTET_STREAM | MimeType.FORM_DATA | MimeType.FORM_URL_ENCODED>;
+export type FileMimeType = ExcludeStrict<
+    MimeType,
+    MimeType.OCTET_STREAM
+    | MimeType.FORM_DATA
+    | MimeType.FORM_URL_ENCODED
+    | MimeType.EVENT_STREAM
+>;
 
 /**
  * File mime types with the possibility to provide custom mime types.

package/src/http/mime-type.helpers.ts

@@ -4,42 +4,113 @@ import { ObjectUtilities } from '../utilities/object.utilities';
 /**
  * All possible file extensions.
  */
-export type FileExtension = typeof mimeTypeToExtension[FileMimeType] | '.jpg';
+export type FileExtension = NonNullable<(typeof mimeTypeToExtensions)[keyof typeof mimeTypeToExtensions]>[number];
 
 // eslint-disable-next-line typescript/typedef
-const mimeTypeToExtension = {
-    [MimeType.JSON]: '.json',
-    [MimeType.HTML]: '.html',
-    [MimeType.PNG]: '.png',
-    [MimeType.JPEG]: '.jpeg',
-    [MimeType.ZIP]: '.zip',
-    [MimeType.SVG]: '.svg',
-    [MimeType.CSS]: '.css',
-    [MimeType.TTF]: '.ttf',
-    [MimeType.PDF]: '.pdf',
-    [MimeType.CSV]: '.csv',
-    [MimeType.XLSX]: '.xlsx',
-    [MimeType.DOCX]: '.docx',
-    [MimeType.TXT]: '.txt',
-    [MimeType.XML]: '.xml'
-} satisfies Record<FileMimeType, Lowercase<`.${string}`> | undefined>;
+const mimeTypeToExtensions = {
+    [MimeType.JSON]: ['.json'],
+    [MimeType.HTML]: ['.html', '.htm'],
+    [MimeType.PNG]: ['.png'],
+    // eslint-disable-next-line cspell/spellchecker
+    [MimeType.JPEG]: ['.jpeg', '.jpg', '.jpe', '.jfif'],
+    [MimeType.ZIP]: ['.zip'],
+    // eslint-disable-next-line cspell/spellchecker
+    [MimeType.SVG]: ['.svg', '.svgz'],
+    [MimeType.CSS]: ['.css'],
+    [MimeType.TTF]: ['.ttf'],
+    [MimeType.PDF]: ['.pdf'],
+    [MimeType.CSV]: ['.csv'],
+    [MimeType.XLSX]: ['.xlsx'],
+    [MimeType.DOCX]: ['.docx'],
+    [MimeType.TXT]: ['.txt'],
+    [MimeType.XML]: ['.xml'],
+    [MimeType.GZIP]: ['.gz', '.gzip'],
+    [MimeType.TAR]: ['.tar'],
+    [MimeType.WASM]: ['.wasm'],
+    // eslint-disable-next-line cspell/spellchecker
+    [MimeType.JSON_LD]: ['.jsonld', '.json-ld'],
+    // eslint-disable-next-line cspell/spellchecker
+    [MimeType.NDJSON]: ['.ndjson', '.jsonl'],
+    [MimeType.PPTX]: ['.pptx'],
+    [MimeType.JAVASCRIPT]: ['.js', '.cjs', '.mjs'],
+    [MimeType.YAML]: ['.yaml', '.yml'],
+    [MimeType.GIF]: ['.gif'],
+    [MimeType.WEBP]: ['.webp'],
+    [MimeType.ICO]: ['.ico', '.cur'],
+    [MimeType.BMP]: ['.bmp', '.dib'],
+    [MimeType.TIFF]: ['.tif', '.tiff'],
+    [MimeType.AVIF]: ['.avif'],
+    [MimeType.MP3]: ['.mp3'],
+    [MimeType.WAV]: ['.wav'],
+    [MimeType.OGG_AUDIO]: ['.ogg', '.oga'],
+    [MimeType.WEBM_AUDIO]: ['.weba'],
+    [MimeType.MP4]: ['.mp4', '.m4v'],
+    [MimeType.WEBM_VIDEO]: ['.webm'],
+    [MimeType.OGG_VIDEO]: ['.ogv'],
+    [MimeType.OTF]: ['.otf'],
+    [MimeType.WOFF]: ['.woff'],
+    [MimeType.WOFF2]: ['.woff2']
+} satisfies Record<FileMimeType, readonly Lowercase<`.${string}`>[] | undefined>;
 
 const extensionToMimeType: Record<FileExtension, MimeType | undefined> = {
-    '.css': MimeType.CSS,
+    '.json': MimeType.JSON,
+    '.html': MimeType.HTML,
+    '.htm': MimeType.HTML,
     '.png': MimeType.PNG,
-    '.jpg': MimeType.JPEG,
     '.jpeg': MimeType.JPEG,
-    '.svg': MimeType.SVG,
+    '.jpg': MimeType.JPEG,
+    '.jpe': MimeType.JPEG,
+    // eslint-disable-next-line cspell/spellchecker
+    '.jfif': MimeType.JPEG,
     '.zip': MimeType.ZIP,
+    '.svg': MimeType.SVG,
+    // eslint-disable-next-line cspell/spellchecker
+    '.svgz': MimeType.SVG,
+    '.css': MimeType.CSS,
     '.ttf': MimeType.TTF,
     '.pdf': MimeType.PDF,
     '.csv': MimeType.CSV,
     '.xlsx': MimeType.XLSX,
-    '.json': MimeType.JSON,
     '.docx': MimeType.DOCX,
     '.txt': MimeType.TXT,
-    '.html': MimeType.HTML,
-    '.xml': MimeType.XML
+    '.xml': MimeType.XML,
+    '.gz': MimeType.GZIP,
+    '.gzip': MimeType.GZIP,
+    '.tar': MimeType.TAR,
+    '.wasm': MimeType.WASM,
+    // eslint-disable-next-line cspell/spellchecker
+    '.jsonld': MimeType.JSON_LD,
+    '.json-ld': MimeType.JSON_LD,
+    // eslint-disable-next-line cspell/spellchecker
+    '.ndjson': MimeType.NDJSON,
+    '.jsonl': MimeType.NDJSON,
+    '.pptx': MimeType.PPTX,
+    '.js': MimeType.JAVASCRIPT,
+    '.cjs': MimeType.JAVASCRIPT,
+    '.mjs': MimeType.JAVASCRIPT,
+    '.yaml': MimeType.YAML,
+    '.yml': MimeType.YAML,
+    '.gif': MimeType.GIF,
+    '.webp': MimeType.WEBP,
+    '.ico': MimeType.ICO,
+    '.cur': MimeType.ICO,
+    '.bmp': MimeType.BMP,
+    '.dib': MimeType.BMP,
+    '.tif': MimeType.TIFF,
+    '.tiff': MimeType.TIFF,
+    '.avif': MimeType.AVIF,
+    '.mp3': MimeType.MP3,
+    '.wav': MimeType.WAV,
+    '.ogg': MimeType.OGG_AUDIO,
+    '.oga': MimeType.OGG_AUDIO,
+    '.weba': MimeType.WEBM_AUDIO,
+    '.mp4': MimeType.MP4,
+    '.m4v': MimeType.MP4,
+    '.webm': MimeType.WEBM_VIDEO,
+    '.ogv': MimeType.OGG_VIDEO,
+    '.otf': MimeType.OTF,
+    '.woff': MimeType.WOFF,
+    '.woff2': MimeType.WOFF2
 } as const;
 
 /**
@@ -60,7 +131,7 @@ export function resolveMimeType(path: string): MimeType {
  * @returns The resolved file extension or undefined if it could not be resolved.
  */
 export function resolveFileExtension(type: LooseFileMimeType): FileExtension | undefined {
-    const extension: FileExtension | undefined = mimeTypeToExtension[type as FileMimeType];
+    const extension: FileExtension | undefined = mimeTypeToExtensions[type as FileMimeType]?.at(0);
     return extension;
 }
 

package/src/http-client/http-client.interface.ts

@@ -37,9 +37,10 @@ type HttpOptions<
      */
     timeoutMs: number,
     /**
-     * The amount of times that the request should be retried before finally failing.
+     * The amount of times that the request should be attempted before finally failing.
+     * Defaults to 1.
      */
-    retries: number,
+    attempts: number,
     /**
      * Definition on how the response body should look like. Can either be a class that defines the structure of the body or a full body metadata definition.
      *

package/src/http-client/http-client.test.ts

@@ -16,6 +16,7 @@ import { FormDataBodyParser } from '../parsing/form-data/form-data.body-parser';
 import { FormData } from '../parsing/form-data/form-data.model';
 import { JsonBodyParser } from '../parsing/json/json.body-parser';
 import { Parser } from '../parsing/parser';
+import { JsonUtilities } from '../utilities/json.utilities';
 
 class Item {
     @Property.string()
@@ -49,15 +50,15 @@ describe('post', () => {
         });
         app.post('/form-data/valid', (_req, res) => {
             const form: NodeFormData = new NodeFormData();
-            form.append('file', JSON.stringify({ hello: 'world' }), {
+            form.append('file', JsonUtilities.stringify({ hello: 'world' }), {
                 filename: 'payload.json',
                 contentType: MimeType.JSON
             });
-            form.append('files', JSON.stringify({ hello: 'world2' }), {
+            form.append('files', JsonUtilities.stringify({ hello: 'world2' }), {
                 filename: 'files.json',
                 contentType: MimeType.JSON
             });
-            form.append('files', JSON.stringify({ hello: 'world3' }), {
+            form.append('files', JsonUtilities.stringify({ hello: 'world3' }), {
                 filename: 'files.json',
                 contentType: MimeType.JSON
             });
@@ -67,7 +68,7 @@ describe('post', () => {
         });
         app.post('/form-data/invalid', (_req, res) => {
             const form: NodeFormData = new NodeFormData();
-            form.append('file', JSON.stringify({ hello: 'world' }), {
+            form.append('file', JsonUtilities.stringify({ hello: 'world' }), {
                 filename: 'payload.json',
                 contentType: MimeType.JSON
             });

package/src/http-client/http-client.ts

@@ -12,11 +12,12 @@ import { KnownHeader } from '../http/known-header.enum';
 import { MimeType } from '../http/mime-type.enum';
 import { type ParserInterface } from '../parsing/parser.interface';
 import { BodyMetadata, resolveMaxBodySize } from '../routing/decorators/body.decorator';
-import { HeaderParamMetadataInput, HeaderParamMetadata } from '../routing/decorators/param.decorator';
+import { HeaderParamMetadata, HeaderParamMetadataInput } from '../routing/decorators/param.decorator';
 import { createHeaderParamMetadata } from '../routing/param-metdata.helpers';
 import { HeaderMetaObjectToParamsObject, HeaderMetaInputObjectToMetaObject } from '../routing/route-configuration.model';
 import { Newable } from '../types/newable.type';
 import { Ms } from '../utilities/ms';
+import { ObjectUtilities } from '../utilities/object.utilities';
 import { type ValidationServiceInterface } from '../validation/validation-service.interface';
 
 const responseTypeForMimeType: Record<BodyMetadata['type'], ResponseType> = {
@@ -201,7 +202,7 @@ export class HttpClient implements HttpClientInterface {
         let axiosResponse: AxiosResponse<unknown> | undefined = undefined;
         let error: unknown = undefined;
 
-        for (let i: number = 0; i < (options?.retries ?? 1); i++) {
+        for (let i: number = 0; i < (options?.attempts ?? 1); i++) {
             if (axiosResponse != undefined) {
                 continue;
             }
@@ -234,8 +235,8 @@ export class HttpClient implements HttpClientInterface {
                     }
                 }
             }
-            catch (error_) {
-                error = error_;
+            catch (_error) {
+                error = _error;
             }
         }
 
@@ -308,31 +309,34 @@ export class HttpClient implements HttpClientInterface {
         }
 
         try {
-            this.validationService.validateBody(responseBody, metadata);
+            await this.validationService.validateBody(responseBody, metadata);
         }
         catch (error) {
             throw new Error('Could not validate response body', { cause: error });
         }
 
-        for (const key in options.responseHeaders) {
-            const headerMetadata: HeaderParamMetadata = createHeaderParamMetadata(key, options.responseHeaders[key]);
-            try {
-                (res.headers[key] as unknown) = this.parser.parseHeaderParam(
-                    res as unknown as HttpClientResponse,
-                    headerMetadata
-                );
-            }
-            catch (error) {
-                throw new Error(`Could not parse response header "${headerMetadata.name}"`, { cause: error });
-            }
+        await Promise.all(
+            ObjectUtilities.keys(options.responseHeaders ?? {}).map(async (key) => {
+                // eslint-disable-next-line typescript/no-non-null-assertion
+                const headerMetadata: HeaderParamMetadata = createHeaderParamMetadata(key, options.responseHeaders![key]);
+                try {
+                    (res.headers[key] as unknown) = this.parser.parseHeaderParam(
+                        res as unknown as HttpClientResponse,
+                        headerMetadata
+                    );
+                }
+                catch (error) {
+                    throw new Error(`Could not parse response header "${headerMetadata.name}"`, { cause: error });
+                }
 
-            try {
-                this.validationService.validateHeaderParam(res.headers[key], headerMetadata);
-            }
-            catch (error) {
-                throw new Error(`Could not validate response header "${headerMetadata.name}"`, { cause: error });
-            }
-        }
+                try {
+                    await this.validationService.validateHeaderParam(res.headers[key], headerMetadata);
+                }
+                catch (error) {
+                    throw new Error(`Could not validate response header "${headerMetadata.name}"`, { cause: error });
+                }
+            })
+        );
 
         return { ...res, body: responseBody };
     }