zibri 2.2.0 → 2.2.1

package/src/handlebars/generate-handlebar-type-files.function.ts

@@ -1,13 +1,9 @@
-import { readFile, writeFile, stat } from 'fs/promises';
-import { dirname, basename, join } from 'path';
-
-import { sync as globSync } from 'glob';
-import { parse } from 'handlebars';
-
-import { ObjectUtilities, pathExists } from '../utilities';
 import { AstProgram } from './ast.model';
+import { HandlebarUtilities } from './handlebar.utilities';
 import { resolveAllArrayKeys } from './resolve-all-array-keys.function';
 import { resolveTree } from './resolve-tree.function';
+import { FsUtilities, Path } from '../utilities/fs.utilities';
+import { ObjectUtilities } from '../utilities/object.utilities';
 
 // eslint-disable-next-line jsdoc/require-jsdoc
 export type PathTree = {
@@ -18,7 +14,7 @@ export type PathTree = {
  * Generate type files for handlebar files (.hbs), so that they expose a correctly typed "renderTemplate" function.
  */
 export async function generateHandlebarTypeFiles(): Promise<void> {
-    const templateFiles: string[] = globSync('src/templates/**/*.hbs');
+    const templateFiles: Path[] = await FsUtilities.glob('src/templates/**/*.hbs');
 
     for (const file of templateFiles) {
         if (await canBeSkipped(file)) {
@@ -26,8 +22,8 @@ export async function generateHandlebarTypeFiles(): Promise<void> {
         }
 
         try {
-            const src: string = await readFile(file, 'utf8');
-            const ast: AstProgram = parse(src, { srcName: file }) as AstProgram;
+            const src: string = await FsUtilities.readFile(file);
+            const ast: AstProgram = HandlebarUtilities.parse(src, { srcName: file });
             await generateHandlebarType(ast, file);
         }
         catch (error) {
@@ -38,7 +34,7 @@ export async function generateHandlebarTypeFiles(): Promise<void> {
 }
 
 // eslint-disable-next-line jsdoc/require-jsdoc
-export async function generateHandlebarType(ast: AstProgram, file: string): Promise<string[]> {
+export async function generateHandlebarType(ast: AstProgram, file: Path): Promise<string[]> {
     const arrayKeys: string[] = [...new Set(resolveAllArrayKeys(ast, undefined))];
     const tree: PathTree = resolveTree(ast, arrayKeys);
     const arrayKeysWithoutThis: string[] = arrayKeys.map(k => k.replaceAll('this.', ''));
@@ -46,14 +42,21 @@ export async function generateHandlebarType(ast: AstProgram, file: string): Prom
 }
 
 // eslint-disable-next-line jsdoc/require-jsdoc
-async function generateTypeFile(tree: PathTree, arrayKeys: string[], file: string): Promise<string[]> {
+async function generateTypeFile(tree: PathTree, arrayKeys: string[], file: Path): Promise<string[]> {
+    const typeLines: string[] = generateInterfaceLines(tree, arrayKeys);
+    const type: string[] = typeLines.length
+        ? [
+            'type Context = {',
+            ...typeLines,
+            '};'
+        ]
+        : ['type Context = Record<string, never>;'];
+
     const content: string = [
         '// auto-generated — do not edit',
-        `import raw from './${basename(file)}';`,
+        `import raw from './${FsUtilities.baseName(file)}';`,
         '',
-        'interface Context {',
-        ...generateInterfaceLines(tree, arrayKeys),
-        '}',
+        ...type,
         '',
         'const renderTemplate: (ctx: Context) => string = raw;',
         'export default renderTemplate;'
@@ -61,8 +64,8 @@ async function generateTypeFile(tree: PathTree, arrayKeys: string[], file: strin
         .join('\n')
         .replace('mailingListData:', 'mailingListData?:');
 
-    const outFile: string = join(dirname(file), `${basename(file)}.ts`);
-    await writeFile(outFile, content, 'utf8');
+    const outFile: Path = FsUtilities.getPath(FsUtilities.dirName(file), `${FsUtilities.baseName(file)}.ts`);
+    await FsUtilities.upsertFile(outFile, content);
 
     return content.split('\n');
 }
@@ -102,13 +105,13 @@ function generateInterfaceLines(
 }
 
 // eslint-disable-next-line jsdoc/require-jsdoc
-async function canBeSkipped(hbsFile: string): Promise<boolean> {
-    const tsFile: string = `${hbsFile}.ts`;
+async function canBeSkipped(hbsFile: Path): Promise<boolean> {
+    const tsFile: Path = FsUtilities.getPath(`${hbsFile}.ts`);
 
-    if (!await pathExists(tsFile)) {
+    if (!await FsUtilities.exists(tsFile)) {
         return false;
     }
 
-    const [hbsStats, tsStats] = await Promise.all([stat(hbsFile), stat(tsFile)]);
+    const [hbsStats, tsStats] = await Promise.all([FsUtilities.stat(hbsFile), FsUtilities.stat(tsFile)]);
     return tsStats.mtimeMs >= hbsStats.mtimeMs;
 }

package/src/handlebars/handlebar.utilities.ts

@@ -1,6 +1,11 @@
-import handlebars from 'handlebars';
+import handlebars, { ParseOptions } from 'handlebars';
 
-import { TreeNode } from '../assets';
+import { AstProgram } from './ast.model';
+import { ZIBRI_DI_TOKENS } from '../di/default/zibri-di-tokens.default';
+import { inject } from '../di/inject.function';
+import { FsUtilities, Path } from '../utilities/fs.utilities';
+import { MaskUtilities } from '../utilities/mask.utilities';
+import { toCamelCase } from '../utilities/to-camel-case.function';
 
 /**
  * Utilities for handling handlebar templates.
@@ -12,9 +17,13 @@ export abstract class HandlebarUtilities {
      * Initializes the handlebar utilities.
      * @param H - The external handlebar object. Is needed so helpers can be registered both inside and outside of Zibri.
      */
-    static init(H: typeof Handlebars): void {
+    static async init(H: typeof Handlebars): Promise<void> {
         this.H = H;
         this.registerHelper('json', (context) => JSON.stringify(context));
+        this.registerHelper('concat', (...args: unknown[]) => {
+            args.pop();
+            return args.join('');
+        });
         // eslint-disable-next-line typescript/no-unsafe-return
         this.registerHelper('??', (a, b) => a ?? b);
         this.registerHelper('and',
@@ -32,44 +41,76 @@ export abstract class HandlebarUtilities {
             if (typeof value !== 'string') {
                 return '';
             }
-            return new handlebars.SafeString(mask(value));
+            return new handlebars.SafeString(MaskUtilities.mask(value));
         });
-        this.registerHelper(
-            'renderTree',
-            function(
-                this: handlebars.HelperOptions, // ← explicitly type `this`
-                nodes: TreeNode[]
-            ): handlebars.SafeString {
-                let out: string = '';
-                for (const node of nodes) {
-                    if (node.type === 'directory') {
-                        out += `<details><summary>${handlebars.escapeExpression(node.name)
-                        }</summary>`;
-                        // 2) Call the helper recursively using `apply` so `this` stays typed
-                        out += (handlebars.helpers.renderTree as Function).apply(this, [node.children]);
-                        out += '</details>';
-                    }
-                    else {
-                        out += `<a class="file-link" href="${handlebars.escapeExpression(node.route)
-                        }">${handlebars.escapeExpression(node.name)}</a>`;
-                    }
-                }
-                return new handlebars.SafeString(out);
-            }
-        );
+
+        const componentsDir: string = inject(ZIBRI_DI_TOKENS.ASSET_SERVICE).componentTemplatePath;
+        const files: Path[] = await FsUtilities.glob(FsUtilities.getPath(componentsDir, '*.hbs'));
+        for (const file of files) {
+            const src: string = await FsUtilities.readFile(file);
+            const base: string = FsUtilities.baseName(file).split('.hbs')[0];
+            const partialName: string = toCamelCase(base);
+            this.registerPartial(partialName, src);
+        }
+    }
+
+    /**
+     * Compiles the given handlebars string.
+     * @param input - The handlebars template in form of a string.
+     * @param options - Additional options for compilation.
+     * @returns The compiled template function.
+     */
+    static render<T>(input: string, options?: CompileOptions): HandlebarsTemplateDelegate<T> {
+        if (typeof this.H.compile !== 'function') {
+            return handlebars.compile(input, options);
+        }
+        return this.H.compile(input, options);
+    }
+
+    /**
+     * Parses the given handlebars string into an AST.
+     * @param input - The handlebars template in form of a string.
+     * @param options - Additional options for parsing the template.
+     * @returns The abstract syntax tree of the template.
+     */
+    static parse(input: string, options?: ParseOptions): AstProgram {
+        return handlebars.parse(input, options) as AstProgram;
     }
 
     private static registerHelper(name: string, fn: Handlebars.HelperDelegate): void {
         handlebars.registerHelper(name, fn);
         this.H.registerHelper(name, fn);
     }
-}
 
-// eslint-disable-next-line jsdoc/require-jsdoc
-function mask(input: string): string {
-    if (input.length <= 3) {
-        return input;
+    private static registerPartial(name: string, template: string): void {
+        let compiledFn: HandlebarsTemplateDelegate;
+
+        // 1) If injected instance has a compiler, prefer it (keeps compile + runtime identical)
+        if (typeof this.H.compile === 'function') {
+            compiledFn = this.H.compile(template);
+        }
+        else {
+            // 2) Injected runtime is probably runtime-only. Create a template function that runtime understands:
+            //    a) precompile with local full compiler -> returns a JS string for the templateSpec
+            //    b) evaluate that spec to an object and call this.H.template(spec) to get a function
+            if (typeof this.H.template !== 'function') {
+                // Unexpected: fallback to local compile (best-effort)
+                compiledFn = handlebars.compile(template);
+            }
+            else {
+                // Precompile to a template spec text
+                const specSource: TemplateSpecification = handlebars.precompile(template);
+                // specSource is JS source that evaluates to the templateSpec object.
+                // Convert it into an object by evaluating it in a safe local function scope.
+                // This uses `new Function` which is the same approach Handlebars' CLI/runtime uses.
+                // eslint-disable-next-line typescript/no-unsafe-assignment, typescript/no-implied-eval, typescript/no-unsafe-call, typescript/no-base-to-string
+                const specObj: TemplateSpecification = new Function(`return (${specSource})`)();
+                // Now produce a runtime function using the injected runtime
+                compiledFn = this.H.template(specObj);
+            }
+        }
+
+        handlebars.registerPartial(name, compiledFn);
+        this.H.registerPartial(name, compiledFn);
     }
-    const starsCount: number = input.length - 3;
-    return input[0] + '*'.repeat(starsCount) + input.slice(-2);
 }

package/src/handlebars/render-template.function.ts

@@ -1,13 +1,12 @@
-import { readFile } from 'fs/promises';
-import path from 'path';
-
-import { compile } from 'handlebars';
-
-import { AssetServiceInterface } from '../assets';
-import { inject, ZIBRI_DI_TOKENS } from '../di';
-import { MailingList, MailingListSubscriber } from '../email';
-import { GlobalRegistry } from '../global';
-import { OmitStrict } from '../types';
+import { HandlebarUtilities } from './handlebar.utilities';
+import { AssetServiceInterface } from '../assets/asset-service.interface';
+import { ZIBRI_DI_TOKENS } from '../di/default/zibri-di-tokens.default';
+import { inject } from '../di/inject.function';
+import { MailingListSubscriber } from '../email/mailing-list/models/mailing-list-subscriber.model';
+import { MailingList } from '../email/mailing-list/models/mailing-list.model';
+import { GlobalRegistry } from '../global/global-registry';
+import { OmitStrict } from '../types/omit-strict.type';
+import { FsUtilities, Path } from '../utilities/fs.utilities';
 
 // eslint-disable-next-line jsdoc/require-jsdoc
 export type BaseEmailTemplateData = {
@@ -85,34 +84,21 @@ export type BasePageTemplateDataInput = {
 export async function renderEmailTemplate<T extends BaseEmailTemplateDataInput>(templateName: `${string}.hbs`, data: T): Promise<string> {
     (data.base as BasePageTemplateData['base']).baseUrl = GlobalRegistry.getAppData('baseUrl') ?? '';
     const assetService: AssetServiceInterface = inject(ZIBRI_DI_TOKENS.ASSET_SERVICE);
-    const content: string = await renderTemplate(path.join(assetService.emailTemplatePath, templateName) as `${string}.hbs`, data);
+    const content: string = await renderTemplate(FsUtilities.getPath(assetService.emailTemplatePath, templateName) as `${Path}.hbs`, data);
     return await renderTemplate(
-        path.join(assetService.emailTemplatePath, 'base-email.hbs') as `${string}.hbs`,
+        FsUtilities.getPath(assetService.emailTemplatePath, 'base-email.hbs') as `${Path}.hbs`,
         { content, base: data.base }
     );
 }
 
-/**
- * Renders the page template with the given name.
- * @param templateName - The name of the template.
- * @param data - The data to fill into the template.
- * @returns The rendered html.
- */
-export async function renderPageTemplate<T extends BasePageTemplateDataInput>(templateName: `${string}.hbs`, data: T): Promise<string> {
-    (data.base as BasePageTemplateData['base']).baseUrl = GlobalRegistry.getAppData('baseUrl') ?? '';
-    const assetService: AssetServiceInterface = inject(ZIBRI_DI_TOKENS.ASSET_SERVICE);
-    const content: string = await renderTemplate(path.join(assetService.pageTemplatePath, templateName) as `${string}.hbs`, data);
-    return await renderTemplate(path.join(assetService.pageTemplatePath, 'base-page.hbs') as `${string}.hbs`, { content, base: data.base });
-}
-
 /**
  * Renders the template at the given path with the given data.
  * @param path - The path of the handlebars template file.
  * @param data - The data to fill into the template.
  * @returns The rendered html string.
  */
-export async function renderTemplate<T extends Record<string, unknown>>(path: `${string}.hbs`, data: T): Promise<string> {
-    const source: string = await readFile(path, { encoding: 'utf8' });
+export async function renderTemplate<T extends Record<string, unknown>>(path: `${Path}.hbs`, data: T): Promise<string> {
+    const source: string = await FsUtilities.readFile(path as Path);
     return renderTemplateString(source, data);
 }
 
@@ -126,7 +112,7 @@ export function renderTemplateString<T extends Record<string, unknown>>(
     templateString: string,
     data: T
 ): string {
-    const template: HandlebarsTemplateDelegate = compile(templateString);
+    const template: HandlebarsTemplateDelegate<T> = HandlebarUtilities.render(templateString);
     const html: string = template(data);
     return html;
 }

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

@@ -1,4 +1,4 @@
-import { AstBlockStatement, AstExpression, AstProgram } from './ast.model';
+import { AstBlockStatement, AstExpression, AstProgram, AstStatement } from './ast.model';
 import { resolveKeyForPathExpression } from './resolve-key-for-path-expression.function';
 
 // eslint-disable-next-line jsdoc/require-jsdoc
@@ -10,6 +10,13 @@ export function resolveAllArrayKeys(ast: AstProgram, parentKey: string | undefin
                 res.push(...resolveArrayKeysForBlockStatement(element, parentKey));
                 break;
             }
+            case 'PartialBlockStatement': {
+                // nested program, but do NOT mark params as arrays
+                if (element.program) {
+                    res.push(...resolveAllArrayKeys(element.program, parentKey));
+                }
+                break;
+            }
             case 'PartialStatement':
             case 'CommentStatement':
             case 'MustacheStatement':
@@ -17,9 +24,8 @@ export function resolveAllArrayKeys(ast: AstProgram, parentKey: string | undefin
                 // reached leaf
                 break;
             }
-            case 'PartialBlockStatement':
             default: {
-                throw new Error(`Unknown AST Element ${element.type}`);
+                throw new Error(`Unknown AST Element ${(element as AstStatement).type}`);
             }
         }
     }

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

@@ -14,7 +14,7 @@ export function resolveKeysForPartialStatement(
     }
 
     // 2) named params (hash)
-    for (const pair of stmt.hash.pairs) {
+    for (const pair of stmt.hash?.pairs ?? []) {
         res.push(...resolveKeysForExpression(pair.value, parentKey));
     }
 
@@ -40,7 +40,7 @@ export function resolveKeysForExpression(
             for (const p of param.params.slice(1)) {
                 out.push(...resolveKeysForExpression(p, parentKey));
             }
-            for (const pair of param.hash.pairs) {
+            for (const pair of param.hash?.pairs ?? []) {
                 out.push(...resolveKeysForExpression(pair.value, parentKey));
             }
             return out;

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.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

@@ -2,15 +2,18 @@ import axios, { AxiosInstance, AxiosResponse, RawAxiosRequestConfig, ResponseTyp
 
 import { HttpClientResponse, HttpClientResponseForBodyType } from './http-client-response.model';
 import { HttpClientHeaderValue, HttpClientInterface, HttpOptionsInput } from './http-client.interface';
-import { Inject, ZIBRI_DI_TOKENS } from '../di';
+import { Inject } from '../di/decorators/inject.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> = {