zibri 2.3.0 → 2.4.1

package/src/global/model-registry/encryption-descriptor.ts

@@ -0,0 +1,110 @@
+import { ModelRegistry } from './model.registry';
+import { PropertyMetadata } from '../../entity/decorators/property.decorator';
+import { ArrayPropertyItemMetadata } from '../../entity/models/array-property-metadata.model';
+import { Relation } from '../../entity/models/relation.enum';
+import { EncryptionPropertyValue } from '../../entity/models/string-property-metadata.model';
+import { ExcludeStrict } from '../../types/exclude-strict.type';
+import { Newable } from '../../types/newable.type';
+import { MetadataUtilities } from '../../utilities/metadata.utilities';
+import { ObjectUtilities } from '../../utilities/object.utilities';
+
+/**
+ * A descriptor that keeps track of the encryption properties of an entity.
+ */
+export class EncryptionDescriptor<T> {
+    /**
+     * Keys that have a encryption value of true or function.
+     */
+    // eslint-disable-next-line typescript/no-explicit-any
+    readonly keys: Map<string, ExcludeStrict<EncryptionPropertyValue<any, any, any, any>, false>> = new Map();
+    /**
+     * Keys with no encrypt option but containing nested entities that might have encrypt properties.
+     */
+    readonly nestedKeys: Map<string, EncryptionDescriptor<unknown>> = new Map();
+
+    /**
+     * Updates this descriptor by the properties of the given class.
+     * @param entityClass - The class to get the encrypt properties from.
+     */
+    update(entityClass: Newable<T>): void {
+        this.keys.clear();
+        this.nestedKeys.clear();
+
+        const properties: Record<string, PropertyMetadata> = MetadataUtilities.getModelProperties(entityClass);
+
+        for (const [key, metadata] of ObjectUtilities.entries(properties)) {
+            if (('encryption' in metadata) && metadata.encryption !== undefined && metadata.encryption !== false) {
+                this.keys.set(key, metadata.encryption);
+                continue;
+            }
+
+            switch (metadata.type) {
+                case Relation.MANY_TO_ONE:
+                case Relation.HAS_ONE:
+                case Relation.BELONGS_TO_ONE:
+                case Relation.MANY_TO_MANY:
+                case Relation.ONE_TO_MANY: {
+                    const nested: EncryptionDescriptor<unknown> = ModelRegistry.get(metadata.target()).encryptionDescriptor;
+                    if (nested.hasAnything()) {
+                        this.nestedKeys.set(key, nested);
+                    }
+                    break;
+                }
+
+                case 'object': {
+                    const nested: EncryptionDescriptor<unknown> = ModelRegistry.get(metadata.cls()).encryptionDescriptor;
+                    if (nested.hasAnything()) {
+                        this.nestedKeys.set(key, nested);
+                    }
+                    break;
+                }
+
+                case 'array': {
+                    const nested: EncryptionDescriptor<unknown> | undefined = this.buildEncryptDescriptorForArrayItems(metadata.items);
+                    if (nested?.hasAnything() === true) {
+                        this.nestedKeys.set(key, nested);
+                    }
+                    break;
+                }
+
+                case 'string':
+                case 'number':
+                case 'boolean':
+                case 'date':
+                case 'file':
+                case 'unknown': {
+                    break;
+                }
+            }
+        }
+    }
+
+    // eslint-disable-next-line jsdoc/require-returns
+    /**
+     * Whether or not there are even properties somewhere that have a encrypt property.
+     */
+    hasAnything(): boolean {
+        return this.keys.size > 0 || this.nestedKeys.size > 0;
+    }
+
+    private buildEncryptDescriptorForArrayItems(
+        items: ArrayPropertyItemMetadata
+    ): EncryptionDescriptor<unknown> | undefined {
+        switch (items.type) {
+            case 'object': {
+                return ModelRegistry.get(items.cls()).encryptionDescriptor;
+            }
+            case 'array': {
+                return this.buildEncryptDescriptorForArrayItems(items.items);
+            }
+            case 'string':
+            case 'number':
+            case 'boolean':
+            case 'date':
+            case 'file':
+            case 'unknown': {
+                return undefined;
+            }
+        }
+    }
+}

package/src/global/model-registry/exclude-descriptor.ts

@@ -0,0 +1,108 @@
+import { ModelRegistry } from './model.registry';
+import { PropertyMetadata } from '../../entity/decorators/property.decorator';
+import { ArrayPropertyItemMetadata } from '../../entity/models/array-property-metadata.model';
+import { ExcludePropertyValue } from '../../entity/models/base-property-metadata.model';
+import { Relation } from '../../entity/models/relation.enum';
+import { ExcludeStrict } from '../../types/exclude-strict.type';
+import { Newable } from '../../types/newable.type';
+import { MetadataUtilities } from '../../utilities/metadata.utilities';
+
+/**
+ * A descriptor that keeps track of the exclude properties of an entity.
+ */
+export class ExcludeDescriptor<T> {
+    /**
+     * Keys that have a exclude value of true or function.
+     */
+    readonly keys: Map<string, ExcludeStrict<ExcludePropertyValue, false>> = new Map();
+    /**
+     * Keys with no exclude option but containing nested entities that might have exclude properties.
+     */
+    readonly nestedKeys: Map<string, ExcludeDescriptor<unknown>> = new Map();
+
+    /**
+     * Updates this descriptor by the properties of the given class.
+     * @param entityClass - The class to get the exclude properties from.
+     */
+    update(entityClass: Newable<T>): void {
+        this.keys.clear();
+        this.nestedKeys.clear();
+
+        const properties: Record<string, PropertyMetadata> = MetadataUtilities.getModelProperties(entityClass);
+
+        for (const [key, metadata] of Object.entries(properties)) {
+            if (metadata.exclude !== undefined && metadata.exclude !== false) {
+                this.keys.set(key, metadata.exclude);
+                continue;
+            }
+
+            switch (metadata.type) {
+                case Relation.MANY_TO_ONE:
+                case Relation.HAS_ONE:
+                case Relation.BELONGS_TO_ONE:
+                case Relation.MANY_TO_MANY:
+                case Relation.ONE_TO_MANY: {
+                    const nested: ExcludeDescriptor<unknown> = ModelRegistry.get(metadata.target()).excludeDescriptor;
+                    if (nested.hasAnything()) {
+                        this.nestedKeys.set(key, nested);
+                    }
+                    break;
+                }
+
+                case 'object': {
+                    const nested: ExcludeDescriptor<unknown> = ModelRegistry.get(metadata.cls()).excludeDescriptor;
+                    if (nested.hasAnything()) {
+                        this.nestedKeys.set(key, nested);
+                    }
+                    break;
+                }
+
+                case 'array': {
+                    const nested: ExcludeDescriptor<unknown> | undefined = this.buildExcludeDescriptorForArrayItems(metadata.items);
+                    if (nested?.hasAnything() === true) {
+                        this.nestedKeys.set(key, nested);
+                    }
+                    break;
+                }
+
+                case 'string':
+                case 'number':
+                case 'boolean':
+                case 'date':
+                case 'file':
+                case 'unknown': {
+                    break;
+                }
+            }
+        }
+    }
+
+    // eslint-disable-next-line jsdoc/require-returns
+    /**
+     * Whether or not there are even properties somewhere that have a exclude property.
+     */
+    hasAnything(): boolean {
+        return this.keys.size > 0 || this.nestedKeys.size > 0;
+    }
+
+    private buildExcludeDescriptorForArrayItems(
+        items: ArrayPropertyItemMetadata
+    ): ExcludeDescriptor<unknown> | undefined {
+        switch (items.type) {
+            case 'object': {
+                return ModelRegistry.get(items.cls()).excludeDescriptor;
+            }
+            case 'array': {
+                return this.buildExcludeDescriptorForArrayItems(items.items);
+            }
+            case 'string':
+            case 'number':
+            case 'boolean':
+            case 'date':
+            case 'file':
+            case 'unknown': {
+                return undefined;
+            }
+        }
+    }
+}

package/src/global/model-registry/hash-descriptor.ts

@@ -0,0 +1,110 @@
+import { ModelRegistry } from './model.registry';
+import { PropertyMetadata } from '../../entity/decorators/property.decorator';
+import { ArrayPropertyItemMetadata } from '../../entity/models/array-property-metadata.model';
+import { Relation } from '../../entity/models/relation.enum';
+import { HashPropertyValue } from '../../entity/models/string-property-metadata.model';
+import { ExcludeStrict } from '../../types/exclude-strict.type';
+import { Newable } from '../../types/newable.type';
+import { MetadataUtilities } from '../../utilities/metadata.utilities';
+import { ObjectUtilities } from '../../utilities/object.utilities';
+
+/**
+ * A descriptor that keeps track of the hash properties of an entity.
+ */
+export class HashDescriptor<T> {
+    /**
+     * Keys that have a hash value of true or function.
+     */
+    // eslint-disable-next-line typescript/no-explicit-any
+    readonly keys: Map<string, ExcludeStrict<HashPropertyValue<any, any>, false>> = new Map();
+    /**
+     * Keys with no hash option but containing nested entities that might have hash properties.
+     */
+    readonly nestedKeys: Map<string, HashDescriptor<unknown>> = new Map();
+
+    /**
+     * Updates this descriptor by the properties of the given class.
+     * @param entityClass - The class to get the hash properties from.
+     */
+    update(entityClass: Newable<T>): void {
+        this.keys.clear();
+        this.nestedKeys.clear();
+
+        const properties: Record<string, PropertyMetadata> = MetadataUtilities.getModelProperties(entityClass);
+
+        for (const [key, metadata] of ObjectUtilities.entries(properties)) {
+            if (('hash' in metadata) && metadata.hash !== undefined && metadata.hash !== false) {
+                this.keys.set(key, metadata.hash);
+                continue;
+            }
+
+            switch (metadata.type) {
+                case Relation.MANY_TO_ONE:
+                case Relation.HAS_ONE:
+                case Relation.BELONGS_TO_ONE:
+                case Relation.MANY_TO_MANY:
+                case Relation.ONE_TO_MANY: {
+                    const nested: HashDescriptor<unknown> = ModelRegistry.get(metadata.target()).hashDescriptor;
+                    if (nested.hasAnything()) {
+                        this.nestedKeys.set(key, nested);
+                    }
+                    break;
+                }
+
+                case 'object': {
+                    const nested: HashDescriptor<unknown> = ModelRegistry.get(metadata.cls()).hashDescriptor;
+                    if (nested.hasAnything()) {
+                        this.nestedKeys.set(key, nested);
+                    }
+                    break;
+                }
+
+                case 'array': {
+                    const nested: HashDescriptor<unknown> | undefined = this.buildHashDescriptorForArrayItems(metadata.items);
+                    if (nested?.hasAnything() === true) {
+                        this.nestedKeys.set(key, nested);
+                    }
+                    break;
+                }
+
+                case 'string':
+                case 'number':
+                case 'boolean':
+                case 'date':
+                case 'file':
+                case 'unknown': {
+                    break;
+                }
+            }
+        }
+    }
+
+    // eslint-disable-next-line jsdoc/require-returns
+    /**
+     * Whether or not there are even properties somewhere that have a hash property.
+     */
+    hasAnything(): boolean {
+        return this.keys.size > 0 || this.nestedKeys.size > 0;
+    }
+
+    private buildHashDescriptorForArrayItems(
+        items: ArrayPropertyItemMetadata
+    ): HashDescriptor<unknown> | undefined {
+        switch (items.type) {
+            case 'object': {
+                return ModelRegistry.get(items.cls()).hashDescriptor;
+            }
+            case 'array': {
+                return this.buildHashDescriptorForArrayItems(items.items);
+            }
+            case 'string':
+            case 'number':
+            case 'boolean':
+            case 'date':
+            case 'file':
+            case 'unknown': {
+                return undefined;
+            }
+        }
+    }
+}

package/src/global/model-registry/hash-hash-properties.function.ts

@@ -0,0 +1,66 @@
+import { HashDescriptor } from './hash-descriptor';
+import { ModelRegistry } from './model.registry';
+import { HashOptions, HashServiceInterface } from '../../auth/hash/hash-service.interface';
+import { AlsUtilities } from '../../context/als.utilities';
+import { HttpRequestContext } from '../../context/request/http-request.context';
+import { WebsocketRequestContext } from '../../context/request/websocket-request.context';
+import { AnyObject } from '../../entity/any-object.model';
+import { Newable } from '../../types/newable.type';
+
+/**
+ * Hashes all properties defined with the hash flag based on a pre-built HashDescriptor.
+ * @param data - The entity instance to process.
+ * @param entityClass - The entity class to get the hash properties from.
+ * @param hashService - The service responsible for hashing.
+ */
+export async function hashHashProperties<Data, EntityClass>(
+    data: Data,
+    entityClass: Newable<EntityClass>,
+    hashService: HashServiceInterface
+): Promise<void> {
+    if (data == undefined || typeof data !== 'object') {
+        return;
+    }
+
+    const context: HttpRequestContext | WebsocketRequestContext | undefined = AlsUtilities.getCurrentRequestContext();
+    const descriptor: HashDescriptor<EntityClass> = ModelRegistry.get(entityClass).hashDescriptor;
+    await hashHashPropertiesRecursive(context, data, descriptor, hashService);
+}
+
+// eslint-disable-next-line jsdoc/require-jsdoc, sonar/cognitive-complexity
+async function hashHashPropertiesRecursive<Data, EntityClass>(
+    context: HttpRequestContext | WebsocketRequestContext | undefined,
+    data: Data,
+    descriptor: HashDescriptor<EntityClass>,
+    hashService: HashServiceInterface
+): Promise<void> {
+    for (const [key, hashOptions] of descriptor.keys) {
+        if (typeof (data as AnyObject)[key] !== 'string') {
+            continue;
+        }
+        const options: true | HashOptions<AnyObject> = typeof hashOptions === 'function'
+            ? await hashOptions(data, context)
+            : hashOptions;
+
+        const hashed: string = await hashService.hash(
+            (data as AnyObject)[key] as string,
+            options === true ? undefined : options
+        );
+        (data as AnyObject)[key] = hashed;
+    }
+
+    for (const [key, nested] of descriptor.nestedKeys) {
+        const value: unknown = (data as AnyObject)[key];
+        if (value == undefined) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                await hashHashPropertiesRecursive(context, item, nested, hashService);
+            }
+        }
+        else {
+            await hashHashPropertiesRecursive(context, value, nested, hashService);
+        }
+    }
+}

package/src/global/model-registry/model.registry.ts

@@ -0,0 +1,79 @@
+import { DefaultDescriptor } from './default-descriptor';
+import { EncryptionDescriptor } from './encryption-descriptor';
+import { ExcludeDescriptor } from './exclude-descriptor';
+import { HashDescriptor } from './hash-descriptor';
+import { Newable } from '../../types/newable.type';
+
+/**
+ * Data stored per entity class in the registry.
+ */
+export type ModelRegistryData<T> = {
+    /**
+     * Pre-built exclude descriptor for this class.
+     */
+    readonly excludeDescriptor: ExcludeDescriptor<T>,
+    /**
+     * Pre-built encryption descriptor for this class.
+     */
+    readonly encryptionDescriptor: EncryptionDescriptor<T>,
+    /**
+     * Pre-built hash descriptor for this class.
+     */
+    readonly hashDescriptor: HashDescriptor<T>,
+    /**
+     * Pre-built default descriptor for this class.
+     */
+    readonly defaultDescriptor: DefaultDescriptor
+};
+
+/**
+ * Centralized registry for per-class model data.
+ * Acts as the single source of truth for model properties and derived descriptors.
+ * Keeps all data consistent when properties are updated via setModelProperties.
+ */
+export abstract class ModelRegistry {
+    /**
+     * Stores fully resolved (inheritance-merged) model data per class.
+     * Placeholder instances are mutated in place to keep cross-references valid.
+     */
+    private static readonly cache: Map<Newable<unknown>, ModelRegistryData<unknown>> = new Map();
+
+    /**
+     * Returns the cached model data for the given class, building it if necessary.
+     * @param entityClass - The entity class to get model data for.
+     * @returns The model data for the given class.
+     */
+    static get<T>(entityClass: Newable<T>): ModelRegistryData<T> {
+        return this.cache.get(entityClass) ?? this.buildInPlace(entityClass);
+    }
+
+    /**
+     * Builds or rebuilds the model data for the given class in place.
+     * Reuses the existing placeholder if present so that any nestedKey references
+     * held by other descriptors remain valid after a rebuild.
+     * @param entityClass - The class to build data for.
+     * @returns The model data for the given class.
+     */
+    private static buildInPlace<T>(entityClass: Newable<T>): ModelRegistryData<T> {
+        // Reuse existing placeholder if present — keeps external nestedKey references valid
+        let modelRegistryData: ModelRegistryData<unknown> | undefined = this.cache.get(entityClass);
+        if (!modelRegistryData) {
+            modelRegistryData = {
+                excludeDescriptor: new ExcludeDescriptor<T>(),
+                encryptionDescriptor: new EncryptionDescriptor<T>(),
+                hashDescriptor: new HashDescriptor(),
+                defaultDescriptor: new DefaultDescriptor()
+            };
+            this.cache.set(entityClass, modelRegistryData);
+        }
+
+        // Resolve inherited properties first, so descriptors see the full picture
+        // modelRegistryData.properties = ;
+        modelRegistryData.encryptionDescriptor.update(entityClass);
+        modelRegistryData.hashDescriptor.update(entityClass);
+        modelRegistryData.excludeDescriptor.update(entityClass);
+        modelRegistryData.defaultDescriptor.update(entityClass);
+
+        return modelRegistryData;
+    }
+}

package/src/global/model-registry/remove-exclude-properties.function.ts

@@ -0,0 +1,76 @@
+import { ExcludeDescriptor } from './exclude-descriptor';
+import { ModelRegistry } from './model.registry';
+import { AlsUtilities } from '../../context/als.utilities';
+import { AnyObject } from '../../entity/any-object.model';
+import { Newable } from '../../types/newable.type';
+import { MetadataInjectionKeys } from '../../utilities/metadata-injection-keys.enum';
+
+/**
+ * Replaces all properties defined with "exclude: true" (or a function returning true)
+ * with non-enumerable getters, based on a pre-built ExcludeDescriptor.
+ * @param data - The entity instance to process.
+ * @param entityClass - The entity class to get the exclude properties from.
+ */
+export async function removeExcludeProperties<Data, EntityClass>(
+    data: Data,
+    entityClass: Newable<EntityClass>
+): Promise<void> {
+    if (data == undefined || typeof data !== 'object') {
+        return;
+    }
+
+    const descriptor: ExcludeDescriptor<EntityClass> = ModelRegistry.get(entityClass).excludeDescriptor;
+    await removeExcludePropertiesRecursive(data, descriptor);
+}
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+async function removeExcludePropertiesRecursive<Data, EntityClass>(
+    data: Data,
+    descriptor: ExcludeDescriptor<EntityClass>
+): Promise<void> {
+    for (const [key, excludeValue] of descriptor.keys) {
+        const shouldExclude: boolean = typeof excludeValue === 'function'
+            ? await excludeValue(data, AlsUtilities.getCurrentRequestContext())
+            : excludeValue;
+        if (shouldExclude) {
+            hideProperty(data as AnyObject, key);
+        }
+    }
+
+    for (const [key, nested] of descriptor.nestedKeys) {
+        const value: unknown = (data as AnyObject)[key];
+        if (value == undefined) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                await removeExcludePropertiesRecursive(item, nested);
+            }
+        }
+        else {
+            await removeExcludePropertiesRecursive(value, nested);
+        }
+    }
+}
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+function hideProperty(data: AnyObject, key: string): void {
+    const currentDescriptor: PropertyDescriptor | undefined = Object.getOwnPropertyDescriptor(data, key);
+    if (currentDescriptor && currentDescriptor.enumerable !== true) {
+        return;
+    }
+    const value: unknown = data[key];
+    // eslint-disable-next-line typescript/no-dynamic-delete
+    delete data[key];
+    Object.defineProperty(data, key, {
+        enumerable: false,
+        configurable: true,
+        get(): unknown {
+            return Reflect.getMetadata(MetadataInjectionKeys.EXCLUDED_PROPERTY_VALUE, data, key);
+        },
+        set(v: unknown) {
+            Reflect.defineMetadata(MetadataInjectionKeys.EXCLUDED_PROPERTY_VALUE, v, data, key);
+        }
+    });
+    data[key] = value;
+}

package/src/global/model-registry/restore-exclude-properties.function.ts

@@ -0,0 +1,54 @@
+import { ExcludeDescriptor } from './exclude-descriptor';
+import { ModelRegistry } from './model.registry';
+import { AnyObject } from '../../entity/any-object.model';
+import { Newable } from '../../types/newable.type';
+
+/**
+ * Restores all excluded properties back to enumerable own properties before persisting.
+ * @param data - The data to restore properties on.
+ * @param entityClass - The entity class to get the exclude properties from.
+ */
+export function restoreExcludeProperties<Data, EntityClass>(
+    data: Data,
+    entityClass: Newable<EntityClass>
+): void {
+    if (data == undefined || typeof data !== 'object') {
+        return;
+    }
+    const descriptor: ExcludeDescriptor<EntityClass> = ModelRegistry.get(entityClass).excludeDescriptor;
+    restoreExcludePropertiesRecursive(data, descriptor);
+}
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+function restoreExcludePropertiesRecursive<Data, EntityClass>(
+    data: Data,
+    descriptor: ExcludeDescriptor<EntityClass>
+): void {
+    for (const [key] of descriptor.keys) {
+        const currentDescriptor: PropertyDescriptor | undefined = Object.getOwnPropertyDescriptor(data, key);
+        if (currentDescriptor && currentDescriptor.enumerable !== true && currentDescriptor.get) {
+            const value: unknown = (data as AnyObject)[key]; // triggers the getter
+            Object.defineProperty(data, key, {
+                value,
+                enumerable: true,
+                writable: true,
+                configurable: true
+            });
+        }
+    }
+
+    for (const [key, nested] of descriptor.nestedKeys) {
+        const value: unknown = (data as AnyObject)[key];
+        if (value == undefined) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                restoreExcludePropertiesRecursive(item, nested);
+            }
+        }
+        else {
+            restoreExcludePropertiesRecursive(value, nested);
+        }
+    }
+}

package/src/global/model-registry/set-default-values.function.ts

@@ -0,0 +1,56 @@
+import { DefaultDescriptor } from './default-descriptor';
+import { ModelRegistry } from './model.registry';
+import { AlsUtilities } from '../../context/als.utilities';
+import { HttpRequestContext } from '../../context/request/http-request.context';
+import { WebsocketRequestContext } from '../../context/request/websocket-request.context';
+import { AnyObject } from '../../entity/any-object.model';
+import { Newable } from '../../types/newable.type';
+
+/**
+ * Sets the default value resolved from the given entityClass on the given data.
+ * @param data - The data to set the default values on.
+ * @param entityClass - The entity class to get the default properties from.
+ */
+export async function setDefaultValues<Data, EntityClass>(
+    data: Data,
+    entityClass: Newable<EntityClass>
+): Promise<void> {
+    const context: HttpRequestContext | WebsocketRequestContext | undefined = AlsUtilities.getCurrentRequestContext();
+    const descriptor: DefaultDescriptor = ModelRegistry.get(entityClass).defaultDescriptor;
+    await setDefaultValuesRecursive(context, data, descriptor);
+}
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+async function setDefaultValuesRecursive<Data>(
+    context: HttpRequestContext | WebsocketRequestContext | undefined,
+    data: Data,
+    descriptor: DefaultDescriptor
+): Promise<void> {
+    if (data == undefined || typeof data !== 'object') {
+        return;
+    }
+
+    for (const [key, defaultValue] of descriptor.keys) {
+        if ((data as AnyObject)[key] !== undefined) {
+            continue;
+        }
+        (data as AnyObject)[key] = typeof defaultValue === 'function'
+            ? await defaultValue(data, context)
+            : defaultValue;
+    }
+
+    for (const [key, nested] of descriptor.nestedKeys) {
+        const value: unknown = (data as AnyObject)[key];
+        if (value == undefined) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                await setDefaultValuesRecursive(context, item, nested);
+            }
+        }
+        else {
+            await setDefaultValuesRecursive(context, value, nested);
+        }
+    }
+}

package/src/handlebars/handlebar.utilities.ts

@@ -2,6 +2,7 @@ import handlebars, { ParseOptions } from 'handlebars';
 
 import { AstProgram } from './ast.model';
 import { FsUtilities, FsPath } from '../utilities/fs.utilities';
+import { JsonUtilities } from '../utilities/json.utilities';
 import { MaskUtilities } from '../utilities/mask.utilities';
 import { toCamelCase } from '../utilities/to-camel-case.function';
 
@@ -18,7 +19,7 @@ export abstract class HandlebarUtilities {
      */
     static async init(H: typeof Handlebars, componentsDir: string): Promise<void> {
         this.H = H;
-        this.registerHelper('json', (context) => JSON.stringify(context));
+        this.registerHelper('json', (context) => JsonUtilities.stringify(context));
         this.registerHelper('concat', (...args: unknown[]) => {
             args.pop();
             return args.join('');