zibri 2.1.7 → 2.2.1

package/src/error-handling/error-handler.ts

@@ -1,17 +1,17 @@
-import { readFile } from 'fs';
-import path from 'path';
-
 import { NextFunction } from 'express';
-import handlebars from 'handlebars';
 
-import { GlobalErrorHandler } from './error-handler.model';
-import { inject, ZIBRI_DI_TOKENS } from '../di';
-import { LoggerInterface } from '../logging';
-import { HttpError, InternalServerError, isHttpError } from './errors';
+import { ErrorPageTemplate, GlobalErrorHandler } from './error-handler.model';
 import { isError } from './is-error.function';
-import { AssetServiceInterface } from '../assets';
-import { GlobalRegistry } from '../global';
-import { HttpRequest, HttpResponse, KnownHeader, MimeType } from '../http';
+import { ZIBRI_DI_TOKENS } from '../di/default/zibri-di-tokens.default';
+import { inject } from '../di/inject.function';
+import { HttpRequest } from '../http/http-request.model';
+import { HttpResponse } from '../http/http-response.model';
+import { HttpError, isHttpError } from './errors/http.error';
+import { KnownHeader } from '../http/known-header.enum';
+import { MimeType } from '../http/mime-type.enum';
+import { LoggerInterface } from '../logging/logger.interface';
+import { PreactUtilities } from '../preact/preact.utilities';
+import { InternalServerError } from './errors/internal-server.error';
 
 /**
  * The default error handler implementation of Zibri.
@@ -43,26 +43,36 @@ export const errorHandler: GlobalErrorHandler = async (error: unknown, req: Http
         return;
     }
 
-    const assetService: AssetServiceInterface = inject(ZIBRI_DI_TOKENS.ASSET_SERVICE);
-    // eslint-disable-next-line promise/prefer-await-to-callbacks
-    readFile(path.join(assetService.pageTemplatePath, 'error.hbs'), 'utf8', (err, source) => {
-        if (err) {
-            res.status(httpError.status).json({
-                status: httpError.status,
-                name: httpError.name,
-                message: httpError.message,
-                paragraphs: httpError.paragraphs
-            });
-            return;
-        }
-
-        // compile the template
-        const template: HandlebarsTemplateDelegate = handlebars.compile(source);
-        const html: string = template({ error: httpError, name: GlobalRegistry.getAppData('name') });
+    const template: ErrorPageTemplate | undefined = inject(ZIBRI_DI_TOKENS.ERROR_PAGE_TEMPLATE);
+    if (!template) {
+        const logger: LoggerInterface = inject(ZIBRI_DI_TOKENS.LOGGER);
+        await logger.warn('Could not find a template for the error page.');
+        await logger.warn(
+            'Either provide ZIBRI_DI_TOKENS.ERROR_PAGE_TEMPLATE or your own error handler (ZIBRI_DI_TOKENS.GLOBAL_ERROR_HANDLER).'
+        );
+        await logger.warn('Falling back to returning a json response');
+        res.status(httpError.status).json({
+            status: httpError.status,
+            name: httpError.name,
+            message: httpError.message,
+            paragraphs: httpError.paragraphs
+        });
+        return;
+    }
 
+    try {
+        const html: string = await PreactUtilities.render(template, { error: httpError });
         res.setHeader(KnownHeader.CONTENT_TYPE, MimeType.HTML);
         res.status(httpError.status).send(html);
-    });
+    }
+    catch {
+        res.status(httpError.status).json({
+            status: httpError.status,
+            name: httpError.name,
+            message: httpError.message,
+            paragraphs: httpError.paragraphs
+        });
+    }
 };
 
 // eslint-disable-next-line jsdoc/require-jsdoc

package/src/error-handling/errors/bad-request.error.ts

@@ -1,5 +1,5 @@
 import { HttpError } from './http.error';
-import { HttpStatus } from '../../http';
+import { HttpStatus } from '../../http/http-status.enum';
 
 /**
  * An error to throw when the user send some invalid data to the server.

package/src/error-handling/errors/conflict.error.ts

@@ -1,5 +1,5 @@
 import { HttpError } from './http.error';
-import { HttpStatus } from '../../http';
+import { HttpStatus } from '../../http/http-status.enum';
 
 /**
  * An error to throw when the user send some invalid data to the server.

package/src/error-handling/errors/content-too-large.error.ts

@@ -1,5 +1,5 @@
 import { HttpError } from './http.error';
-import { HttpStatus } from '../../http';
+import { HttpStatus } from '../../http/http-status.enum';
 
 /**
  * An error to throw when the user send some content that is larger than allowed.

package/src/error-handling/errors/http.error.ts

@@ -1,4 +1,4 @@
-import { HttpStatus } from '../../http';
+import { HttpStatus } from '../../http/http-status.enum';
 
 /**
  * A base http error.

package/src/error-handling/errors/internal-server.error.ts

@@ -1,5 +1,5 @@
 import { HttpError } from './http.error';
-import { HttpStatus } from '../../http';
+import { HttpStatus } from '../../http/http-status.enum';
 
 /**
  * An error to throw when something unexpected happened inside the server.

package/src/error-handling/errors/missing-entities.error.ts

@@ -1,5 +1,5 @@
 import { BaseEntity } from '../../entity/base-entity.model';
-import { Newable } from '../../types';
+import { Newable } from '../../types/newable.type';
 
 /**
  * An error to throw when there are entities that are not registered in a data source.

package/src/error-handling/errors/not-found.error.ts

@@ -1,5 +1,5 @@
 import { HttpError } from './http.error';
-import { HttpStatus } from '../../http';
+import { HttpStatus } from '../../http/http-status.enum';
 
 /**
  * An error to throw when the requested resource could not be found.

package/src/error-handling/errors/too-many-requests.error.ts

@@ -1,5 +1,5 @@
 import { HttpError } from './http.error';
-import { HttpStatus } from '../../http';
+import { HttpStatus } from '../../http/http-status.enum';
 
 /**
  * An error to throw when there have been too many requests in a too short amount of time.

package/src/error-handling/errors/unauthorized.error.ts

@@ -1,5 +1,5 @@
 import { HttpError } from './http.error';
-import { HttpStatus } from '../../http';
+import { HttpStatus } from '../../http/http-status.enum';
 
 /**
  * An error to throw when a user does something that he is not allowed to.

package/src/error-handling/errors/validation.error.ts

@@ -1,5 +1,5 @@
 import { BadRequestError } from './bad-request.error';
-import { ValidationProblem } from '../../validation';
+import { ValidationProblem } from '../../validation/validation-problem.model';
 
 // eslint-disable-next-line jsdoc/require-jsdoc
 type ValidationErrorType = 'body' | 'path' | 'query' | 'header' | 'websocketRequest';

package/src/global/global-registry.ts

@@ -1,11 +1,12 @@
 import { ZibriApplicationOptions } from '../application-options.model';
-import { UserRepositories } from '../auth';
-import { BackupResourceInterface } from '../backup';
-import { DataSourceInterface } from '../data-source';
-import { DiProvider } from '../di';
+import { UserRepositories } from '../auth/models/user-repositories.model';
+import { BackupResourceInterface } from '../backup/backup-resource.interface';
+import { DataSourceInterface } from '../data-source/data-sources/data-source.interface';
+import { DiProvider } from '../di/models/di-provider.model';
 import { BaseEntity } from '../entity/base-entity.model';
-import { BodyParserInterface } from '../parsing';
-import { Newable, Version } from '../types';
+import { BodyParserInterface } from '../parsing/body-parser.interface';
+import { Newable } from '../types/newable.type';
+import { Version } from '../types/version.type';
 
 /**
  * The possible state that the app can be in.

package/src/handlebars/ast.model.ts

@@ -1,5 +1,5 @@
 /* eslint-disable jsdoc/require-jsdoc */
-import { OmitStrict } from '../types';
+import { OmitStrict } from '../types/omit-strict.type';
 
 export type AstProgram = OmitStrict<hbs.AST.Program, 'body'> & { body: AstStatement[] };
 
@@ -19,7 +19,7 @@ export type AstBlockPathExpression = OmitStrict<AstPathExpression, 'original'> &
 export type AstSubExpression = OmitStrict<hbs.AST.SubExpression, 'path' | 'params' | 'hash'> & {
     path: AstPathExpression,
     params: AstExpression[],
-    hash: AstHash
+    hash: AstHash | undefined
 };
 
 export type AstStringLiteral = hbs.AST.StringLiteral;
@@ -87,7 +87,7 @@ export type AstPartialBlockStatement = OmitStrict<
     name: AstPathExpression,
     params: AstExpression[],
     hash: AstHash,
-    program: AstProgram
+    program: AstProgram | undefined
 };
 
 export type AstStatement = AstBlockStatement

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 { 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');
 }
@@ -75,7 +78,7 @@ function generateInterfaceLines(
     currentPath = ''
 ): string[] {
     const lines: string[] = [];
-    const keys: string[] = Object.keys(tree);
+    const keys: string[] = ObjectUtilities.keys(tree);
 
     for (let i: number = 0; i < keys.length; i++) {
         const key: string = keys[i];
@@ -86,7 +89,7 @@ function generateInterfaceLines(
         const suffix: string = arrayKeys.includes(fullPath) ? '[]' : '';
         const comma: string = isLast ? '' : ','; // no comma for last
 
-        const childKeys: string[] = Object.keys(subtree);
+        const childKeys: string[] = ObjectUtilities.keys(subtree);
 
         if (childKeys.length === 0) {
             lines.push(`${indent}${key}: string${suffix}${comma}`);
@@ -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}`);
             }