zibri 2.2.0 → 2.3.0

package/src/handlebars/resolve-tree.function.ts

@@ -42,7 +42,7 @@ function isParentArray(parts: string[], arrayKeys: string[]): boolean {
     return arrayKeys.includes(parent);
 }
 
-// eslint-disable-next-line jsdoc/require-jsdoc
+// eslint-disable-next-line jsdoc/require-jsdoc, sonar/cognitive-complexity
 export function resolveAllKeys(ast: AstProgram, parentKey: string | undefined): string[] {
     const res: string[] = [];
     for (const element of ast.body) {
@@ -74,12 +74,26 @@ export function resolveAllKeys(ast: AstProgram, parentKey: string | undefined):
                 res.push(...resolveKeysForPartialStatement(element, parentKey));
                 break;
             }
+            case 'PartialBlockStatement': {
+                // 1) Positional params
+                for (const param of element.params) {
+                    res.push(...resolveKeysForExpression(param, parentKey));
+                }
+                // 2) Named params (hash)
+                for (const pair of element.hash?.pairs ?? []) {
+                    res.push(...resolveKeysForExpression(pair.value, parentKey));
+                }
+                // 3) Traverse nested block
+                if (element.program) {
+                    res.push(...resolveAllKeys(element.program, parentKey));
+                }
+                break;
+            }
             case 'CommentStatement':
             case 'ContentStatement': {
                 // reached leaf
                 break;
             }
-            case 'PartialBlockStatement':
             default: {
                 throw new Error(`Unknown AST Element ${(element as AstStatement).type}`);
             }

package/src/handlebars/test/generate-handlebar-type.test.ts

@@ -1,12 +1,11 @@
-import { readFile } from 'fs/promises';
-import * as fsPromises from 'fs/promises';
-import path from 'path';
+import * as fsPromises from 'node:fs/promises';
 
 import { describe, expect, it, jest } from '@jest/globals';
-import { parse } from 'handlebars';
 
+import { FsUtilities } from '../../utilities/fs.utilities';
 import { AstProgram } from '../ast.model';
 import { generateHandlebarType } from '../generate-handlebar-type-files.function';
+import { HandlebarUtilities } from '../handlebar.utilities';
 
 jest.mock('fs/promises', () => {
     // Pull in the real implementations…
@@ -20,15 +19,15 @@ jest.mock('fs/promises', () => {
 
 describe('generateHandlebarType', () => {
     it('example.hbs', async () => {
-        const src: string = await readFile(path.join(__dirname, 'example.hbs'), 'utf8');
-        const ast: AstProgram = parse(src, { srcName: './example.hbs' }) as AstProgram;
-        const lines: string[] = await generateHandlebarType(ast, 'example.hbs');
+        const src: string = await FsUtilities.readFile(FsUtilities.getPath(__dirname, 'example.hbs'));
+        const ast: AstProgram = HandlebarUtilities.parse(src, { srcName: './example.hbs' });
+        const lines: string[] = await generateHandlebarType(ast, FsUtilities.getPath('example.hbs'));
 
         expect(lines).toEqual([
             '// auto-generated — do not edit',
             'import raw from \'./example.hbs\';',
             '',
-            'interface Context {',
+            'type Context = {',
             '    user: {',
             '        name: string',
             '    },',
@@ -45,7 +44,7 @@ describe('generateHandlebarType', () => {
             '        }[]',
             '    }[],',
             '    categories: string[]',
-            '}',
+            '};',
             '',
             'const renderTemplate: (ctx: Context) => string = raw;',
             'export default renderTemplate;'
@@ -53,15 +52,15 @@ describe('generateHandlebarType', () => {
     });
 
     it('example-2.hbs', async () => {
-        const src: string = await readFile(path.join(__dirname, 'example-2.hbs'), 'utf8');
-        const ast: AstProgram = parse(src, { srcName: './example-2.hbs' }) as AstProgram;
-        const lines: string[] = await generateHandlebarType(ast, 'example-2.hbs');
+        const src: string = await FsUtilities.readFile(FsUtilities.getPath(__dirname, 'example-2.hbs'));
+        const ast: AstProgram = HandlebarUtilities.parse(src, { srcName: './example-2.hbs' });
+        const lines: string[] = await generateHandlebarType(ast, FsUtilities.getPath('example-2.hbs'));
 
         expect(lines).toEqual([
             '// auto-generated — do not edit',
             'import raw from \'./example-2.hbs\';',
             '',
-            'interface Context {',
+            'type Context = {',
             '    currentUser: {',
             '        name: string,',
             '        role: string,',
@@ -85,7 +84,7 @@ describe('generateHandlebarType', () => {
             '        mode: string',
             '    },',
             '    year: string',
-            '}',
+            '};',
             '',
             'const renderTemplate: (ctx: Context) => string = raw;',
             'export default renderTemplate;'

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

@@ -1,7 +1,7 @@
 import { Request } from 'express';
 
-import { OmitStrict } from '../types';
 import { KnownHeader } from './known-header.enum';
+import { OmitStrict } from '../types/omit-strict.type';
 
 /**
  * Http request. Based on Request from express.

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

@@ -1,8 +1,8 @@
 import { Response } from 'express';
 
-import { OmitStrict } from '../types';
 import { KnownHeader } from './known-header.enum';
 import { MimeType } from './mime-type.enum';
+import { OmitStrict } from '../types/omit-strict.type';
 
 // eslint-disable-next-line jsdoc/require-jsdoc
 type ValueTypeForHeader<T extends KnownHeader> = T extends KnownHeader.CONTENT_TYPE

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

@@ -1,4 +1,4 @@
-import { ObjectUtilities } from '../utilities';
+import { ObjectUtilities } from '../utilities/object.utilities';
 
 /**
  * Known http headers.

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

@@ -1,4 +1,4 @@
-import { ExcludeStrict } from '../types';
+import { ExcludeStrict } from '../types/exclude-strict.type';
 
 /**
  * All known mime types.

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

@@ -1,5 +1,5 @@
-import { ObjectUtilities } from '../utilities';
 import { FileMimeType, LooseFileMimeType, MimeType } from './mime-type.enum';
+import { ObjectUtilities } from '../utilities/object.utilities';
 
 /**
  * All possible file extensions.

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

@@ -1,6 +1,8 @@
-import { MimeType, KnownHeader, HttpStatus } from '../http';
-import { FormData } from '../parsing';
-import { BodyMetadata } from '../routing';
+import { HttpStatus } from '../http/http-status.enum';
+import { KnownHeader } from '../http/known-header.enum';
+import { MimeType } from '../http/mime-type.enum';
+import { FormData } from '../parsing/form-data/form-data.model';
+import { BodyMetadata } from '../routing/decorators/body.decorator';
 
 /**
  * Definition for a response from using the http client.

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

@@ -0,0 +1,94 @@
+import { HttpClientResponse } from './http-client-response.model';
+import { HttpMethod } from '../http/http-method.enum';
+import { OmitStrict } from '../types/omit-strict.type';
+
+/**
+ * Data of the http request that was sent.
+ */
+export type HttpClientErrorRequestData = {
+    /**
+     * The request method.
+     */
+    method: HttpMethod,
+    /**
+     * The body of the request.
+     */
+    body: unknown,
+    /**
+     * The headers of the request.
+     */
+    headers: Record<string, unknown>,
+    /**
+     * The full url of the request.
+     */
+    url: string
+};
+
+/**
+ * Data of the http response that was received.
+ */
+export type HttpClientErrorResponseData = OmitStrict<HttpClientResponse<unknown, Record<string, unknown>>, 'rawBody'>;
+
+/**
+ * Options for creating a http client error.
+ */
+export type HttpClientErrorOptions = {
+    /**
+     * The data of the response, if one could be received.
+     */
+    responseData: HttpClientErrorResponseData | undefined,
+    /**
+     * The data of the request, if one could be made.
+     */
+    requestData: HttpClientErrorRequestData | undefined
+};
+
+/**
+ * Error that is thrown when a request from the http client didn't work.
+ */
+export class HttpClientError extends Error {
+    /**
+     * The data of the response, if one could be received.
+     */
+    readonly responseData?: HttpClientErrorResponseData;
+    /**
+     * The data of the request, if one could be made.
+     */
+    readonly requestData?: HttpClientErrorRequestData;
+
+    constructor(message: string, data: HttpClientErrorOptions, options?: ErrorOptions | undefined) {
+        super(getErrorMessage(message, data), options);
+        this.name = 'HttpClientError';
+        this.responseData = data.responseData;
+        this.requestData = data.requestData;
+
+        Object.defineProperty(this, 'message', { enumerable: true });
+    }
+}
+
+/**
+ * Check whether or not the given value is a http client error.
+ * @param value - The value to check.
+ * @returns True when the values name is 'HttpClientError', false otherwise.
+ */
+export function isHttpClientError(value: unknown): value is HttpClientError {
+    return typeof value === 'object' && value != undefined && 'name' in value && value.name === 'HttpClientError';
+}
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+function getErrorMessage(message: string, data: HttpClientErrorOptions): string {
+    if (!data.responseData) {
+        if (data.requestData) {
+            return `No response received for ${data.requestData.method.toUpperCase()} ${data.requestData.url}:\n${message}`;
+        }
+        return `Could not send the request:\n${message}`;
+    }
+
+    if (!data.requestData) {
+        return `Could not send the request:\n${message}`;
+    }
+
+    const fullUrl: string = `${data.requestData.method.toUpperCase()} ${data.requestData.url}`;
+
+    return `Request ${fullUrl} failed with ${data.responseData.status} ${data.responseData.statusText}`;
+}

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

@@ -1,7 +1,12 @@
 import { HttpClientResponseForBodyType } from './http-client-response.model';
-import { HttpMethod, KnownHeader, MimeType } from '../http';
-import { BodyMetadata, BodyMetadataInput, HeaderMetaInputObjectToMetaObject, HeaderMetaObjectToParamsObject, HeaderParamMetadataInput } from '../routing';
-import { Newable, OmitStrict } from '../types';
+import { HttpMethod } from '../http/http-method.enum';
+import { KnownHeader } from '../http/known-header.enum';
+import { MimeType } from '../http/mime-type.enum';
+import { BodyMetadata, BodyMetadataInput } from '../routing/decorators/body.decorator';
+import { HeaderParamMetadataInput } from '../routing/decorators/param.decorator';
+import { HeaderMetaObjectToParamsObject, HeaderMetaInputObjectToMetaObject } from '../routing/route-configuration.model';
+import { Newable } from '../types/newable.type';
+import { OmitStrict } from '../types/omit-strict.type';
 
 /**
  * Possible values to send as headers when using the http client.

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

@@ -5,13 +5,17 @@ import { afterAll, beforeAll, describe, expect, it } from '@jest/globals';
 import express from 'express';
 import NodeFormData from 'form-data';
 
-import { Property } from '../entity';
 import { HttpClientResponse } from './http-client-response.model';
 import { HttpClientInterface } from './http-client.interface';
-import { inject, ZIBRI_DI_TOKENS } from '../di';
+import { ZIBRI_DI_TOKENS } from '../di/default/zibri-di-tokens.default';
+import { inject } from '../di/inject.function';
+import { Property } from '../entity/decorators/property.decorator';
 import { KnownHeader } from '../http/known-header.enum';
 import { MimeType } from '../http/mime-type.enum';
-import { File, FormData, FormDataBodyParser, JsonBodyParser, Parser } from '../parsing';
+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';
 
 class Item {
     @Property.string()

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

@@ -1,16 +1,22 @@
-import axios, { AxiosInstance, AxiosResponse, RawAxiosRequestConfig, ResponseType } from 'axios';
+
+import axios, { AxiosInstance, AxiosResponse, isAxiosError, RawAxiosRequestConfig, ResponseType } from 'axios';
 
 import { HttpClientResponse, HttpClientResponseForBodyType } from './http-client-response.model';
+import { HttpClientError } from './http-client.error';
 import { HttpClientHeaderValue, HttpClientInterface, HttpOptionsInput } from './http-client.interface';
-import { Inject, ZIBRI_DI_TOKENS } from '../di';
+import { Inject } from '../di/decorators/inject.decorator';
+import { Injectable } from '../di/decorators/injectable.decorator';
+import { ZIBRI_DI_TOKENS } from '../di/default/zibri-di-tokens.default';
 import { HttpMethod } from '../http/http-method.enum';
 import { KnownHeader } from '../http/known-header.enum';
 import { MimeType } from '../http/mime-type.enum';
 import { type ParserInterface } from '../parsing/parser.interface';
-import { BodyMetadata, HeaderMetaInputObjectToMetaObject, HeaderMetaObjectToParamsObject, HeaderParamMetadata, HeaderParamMetadataInput, resolveMaxBodySize } from '../routing';
+import { BodyMetadata, resolveMaxBodySize } from '../routing/decorators/body.decorator';
+import { HeaderParamMetadataInput, HeaderParamMetadata } from '../routing/decorators/param.decorator';
 import { createHeaderParamMetadata } from '../routing/param-metdata.helpers';
-import { Newable } from '../types';
-import { Ms } from '../utilities';
+import { HeaderMetaObjectToParamsObject, HeaderMetaInputObjectToMetaObject } from '../routing/route-configuration.model';
+import { Newable } from '../types/newable.type';
+import { Ms } from '../utilities/ms';
 import { type ValidationServiceInterface } from '../validation/validation-service.interface';
 
 const responseTypeForMimeType: Record<BodyMetadata['type'], ResponseType> = {
@@ -36,6 +42,7 @@ const responseTypeForMimeType: Record<BodyMetadata['type'], ResponseType> = {
 /**
  * Default http client implementation of Zibri.
  */
+@Injectable({ register: 'onUse' })
 export class HttpClient implements HttpClientInterface {
     private readonly axios: AxiosInstance;
 
@@ -233,6 +240,29 @@ export class HttpClient implements HttpClientInterface {
         }
 
         if (!axiosResponse) {
+            if (isAxiosError(error)) {
+                throw new HttpClientError(
+                    error.message,
+                    {
+                        responseData: error.response
+                            ? {
+                                body: error.response.data,
+                                headers: error.response.headers as Record<string, unknown>,
+                                status: error.response.status,
+                                statusText: error.response.statusText
+                            }
+                            : undefined,
+                        requestData: error.config
+                            ? {
+                                method,
+                                url,
+                                body: requestBody,
+                                headers: error.config.headers
+                            }
+                            : undefined
+                    }
+                );
+            }
             throw error instanceof Error ? error : new Error('Could not get a response');
         }
 
@@ -246,7 +276,7 @@ export class HttpClient implements HttpClientInterface {
             body: undefined as unknown as T,
             status: axiosResponse.status,
             statusText: axiosResponse.statusText,
-            headers: axiosResponse.headers as HeaderParamsObject
+            headers: axiosResponse.headers
         } as HttpClientResponseForBodyType<
             T,
             HeaderMetaObjectToParamsObject<HeaderMetaInputObjectToMetaObject<ResponseHeaderMetaInputObject>>,