ngx-material-entity 20.0.5 → 20.0.6

package/fesm2022/ngx-material-entity.mjs

@@ -2204,7 +2204,7 @@ class ValidationUtilities {
     static async getEntityValidationErrors(entity, injector, omit) {
         const res = [];
         for (const key of EntityUtilities.keysOf(entity, injector)) {
-            const err = await this.getPropertyValidationError(entity, key, omit);
+            const err = await this.getPropertyValidationError(entity, key, injector, omit);
             if (err) {
                 res.push(err);
             }
@@ -2231,177 +2231,180 @@ class ValidationUtilities {
      * Validates the property on the given entity with the given key.
      * @param entity - The entity on which the property to check is.
      * @param key - The key of the property to validate.
+     * @param injector - An angular environment injector.
      * @param omit - What keys not to check. An empty value means no keys are omitted.
      * @returns A validation error when the property is not valid, undefined otherwise.
      * @throws When the type of the property is not known.
      */
-    // eslint-disable-next-line sonar/cognitive-complexity
-    static async getPropertyValidationError(entity, key, omit) {
-        const type = EntityUtilities.getPropertyType(entity, key);
-        if (type == undefined) {
-            return undefined;
-        }
-        const metadata = EntityUtilities.getPropertyMetadata(entity, key, type);
-        // istanbul ignore next
-        if (metadata == undefined) {
-            return undefined;
-        }
-        if (metadata.omitForCreate && omit === 'create') {
-            return undefined;
-        }
-        if (metadata.omitForUpdate && omit === 'update') {
-            return undefined;
-        }
-        if (type !== DecoratorTypes.HAS_MANY && metadata.required(entity) && (entity[key] == undefined || entity[key] === '')) {
-            return {
-                property: metadata.displayName,
-                message: 'required'
-            };
-        }
-        if (!metadata.required(entity) && (entity[key] == undefined || entity[key] === '')) {
-            return undefined;
-        }
-        switch (type) {
-            case DecoratorTypes.BOOLEAN_DROPDOWN: {
-                // Because only valid values can be selected, this is always true when it has a value
+    static async getPropertyValidationError(entity, key, injector, omit) {
+        // eslint-disable-next-line sonar/cognitive-complexity
+        return runInInjectionContext(injector, async () => {
+            const type = EntityUtilities.getPropertyType(entity, key);
+            if (type == undefined) {
                 return undefined;
             }
-            case DecoratorTypes.BOOLEAN_CHECKBOX:
-            case DecoratorTypes.BOOLEAN_TOGGLE: {
-                const entityBoolean = entity[key];
-                const booleanMetadata = metadata;
-                return this.getBooleanValidationError(entity, entityBoolean, booleanMetadata);
-            }
-            case DecoratorTypes.STRING_DROPDOWN: {
-                // Because only valid values can be selected, this is always true when it has a value
+            const metadata = EntityUtilities.getPropertyMetadata(entity, key, type);
+            // istanbul ignore next
+            if (metadata == undefined) {
                 return undefined;
             }
-            case DecoratorTypes.STRING: {
-                const entityString = entity[key];
-                const stringMetadata = metadata;
-                return this.getStringValidationError(entityString, stringMetadata);
-            }
-            case DecoratorTypes.STRING_AUTOCOMPLETE: {
-                const entityAutocompleteString = entity[key];
-                // eslint-disable-next-line stylistic/max-len
-                const stringAutocompleteMetadata = metadata;
-                return this.getAutocompleteStringValidationError(entity, entityAutocompleteString, stringAutocompleteMetadata);
+            if (metadata.omitForCreate && omit === 'create') {
+                return undefined;
             }
-            case DecoratorTypes.STRING_TEXTBOX: {
-                const entityTextbox = entity[key];
-                const textboxMetadata = metadata;
-                return this.getTextboxValidationError(entityTextbox, textboxMetadata);
+            if (metadata.omitForUpdate && omit === 'update') {
+                return undefined;
             }
-            case DecoratorTypes.STRING_PASSWORD: {
-                const entityPassword = entity[key];
-                const passwordMetadata = metadata;
-                const confirmPassword = ReflectUtilities.getMetadata(EntityUtilities.CONFIRM_PASSWORD_KEY, entity, key);
-                return this.getPasswordValidationError(entityPassword, passwordMetadata, confirmPassword);
+            if (type !== DecoratorTypes.HAS_MANY && metadata.required(entity) && (entity[key] == undefined || entity[key] === '')) {
+                return {
+                    property: metadata.displayName,
+                    message: 'required'
+                };
             }
-            case DecoratorTypes.NUMBER_DROPDOWN: {
-                // Because only valid values can be selected, this is always true when it has a value
+            if (!metadata.required(entity) && (entity[key] == undefined || entity[key] === '')) {
                 return undefined;
             }
-            case DecoratorTypes.NUMBER:
-            case DecoratorTypes.NUMBER_SLIDER: {
-                const entityNumber = entity[key];
-                const numberMetadata = metadata;
-                return this.getNumberValidationError(entityNumber, numberMetadata);
-            }
-            case DecoratorTypes.OBJECT: {
-                const entityObject = entity[key];
-                for (const parameterKey in entityObject) {
-                    const value = entityObject[parameterKey];
-                    if (!metadata.omit.includes(parameterKey)
-                        && !(!metadata.required(entity) && (value == undefined || value == ''))) {
-                        const err = await this.getPropertyValidationError(entityObject, parameterKey, omit);
-                        if (err) {
-                            return {
-                                property: metadata.displayName,
-                                message: `${err.property} is invalid: ${err.message}`
-                            };
+            switch (type) {
+                case DecoratorTypes.BOOLEAN_DROPDOWN: {
+                    // Because only valid values can be selected, this is always true when it has a value
+                    return undefined;
+                }
+                case DecoratorTypes.BOOLEAN_CHECKBOX:
+                case DecoratorTypes.BOOLEAN_TOGGLE: {
+                    const entityBoolean = entity[key];
+                    const booleanMetadata = metadata;
+                    return this.getBooleanValidationError(entity, entityBoolean, booleanMetadata);
+                }
+                case DecoratorTypes.STRING_DROPDOWN: {
+                    // Because only valid values can be selected, this is always true when it has a value
+                    return undefined;
+                }
+                case DecoratorTypes.STRING: {
+                    const entityString = entity[key];
+                    const stringMetadata = metadata;
+                    return this.getStringValidationError(entityString, stringMetadata);
+                }
+                case DecoratorTypes.STRING_AUTOCOMPLETE: {
+                    const entityAutocompleteString = entity[key];
+                    // eslint-disable-next-line stylistic/max-len
+                    const stringAutocompleteMetadata = metadata;
+                    return this.getAutocompleteStringValidationError(entity, entityAutocompleteString, stringAutocompleteMetadata);
+                }
+                case DecoratorTypes.STRING_TEXTBOX: {
+                    const entityTextbox = entity[key];
+                    const textboxMetadata = metadata;
+                    return this.getTextboxValidationError(entityTextbox, textboxMetadata);
+                }
+                case DecoratorTypes.STRING_PASSWORD: {
+                    const entityPassword = entity[key];
+                    const passwordMetadata = metadata;
+                    const confirmPassword = ReflectUtilities.getMetadata(EntityUtilities.CONFIRM_PASSWORD_KEY, entity, key);
+                    return this.getPasswordValidationError(entityPassword, passwordMetadata, confirmPassword);
+                }
+                case DecoratorTypes.NUMBER_DROPDOWN: {
+                    // Because only valid values can be selected, this is always true when it has a value
+                    return undefined;
+                }
+                case DecoratorTypes.NUMBER:
+                case DecoratorTypes.NUMBER_SLIDER: {
+                    const entityNumber = entity[key];
+                    const numberMetadata = metadata;
+                    return this.getNumberValidationError(entityNumber, numberMetadata);
+                }
+                case DecoratorTypes.OBJECT: {
+                    const entityObject = entity[key];
+                    for (const parameterKey in entityObject) {
+                        const value = entityObject[parameterKey];
+                        if (!metadata.omit.includes(parameterKey)
+                            && !(!metadata.required(entity) && (value == undefined || value == ''))) {
+                            const err = await this.getPropertyValidationError(entityObject, parameterKey, injector, omit);
+                            if (err) {
+                                return {
+                                    property: metadata.displayName,
+                                    message: `${err.property} is invalid: ${err.message}`
+                                };
+                            }
                         }
                     }
+                    break;
                 }
-                break;
-            }
-            case DecoratorTypes.OBJECT_DROPDOWN: {
-                // Because only valid values can be selected, this is always true when it has a value
-                return undefined;
-            }
-            case DecoratorTypes.ARRAY_STRING_AUTOCOMPLETE_CHIPS: {
-                const stringAutocompleteArray = entity[key];
-                // eslint-disable-next-line stylistic/max-len
-                const stringAutocompleteArrayMetadata = metadata;
-                // eslint-disable-next-line stylistic/max-len
-                return await this.getArrayStringAutocompleteChipsValidationError(entity, stringAutocompleteArrayMetadata, stringAutocompleteArray);
-            }
-            case DecoratorTypes.ARRAY_STRING_DROPDOWN: {
-                const stringDropdownArray = entity[key];
-                // eslint-disable-next-line stylistic/max-len
-                const stringDropdownArrayMetadata = metadata;
-                return await this.getArrayStringDropdownValidationError(entity, stringDropdownArrayMetadata, stringDropdownArray);
-            }
-            case DecoratorTypes.ARRAY_STRING_CHIPS:
-            case DecoratorTypes.ARRAY_DATE:
-            case DecoratorTypes.ARRAY_DATE_TIME:
-            case DecoratorTypes.ARRAY_DATE_RANGE:
-            case DecoratorTypes.ARRAY:
-            case DecoratorTypes.REFERENCES_MANY: {
-                const entityArray = entity[key];
-                // eslint-disable-next-line stylistic/max-len
-                const arrayMetadata = metadata;
-                if (arrayMetadata.required(entity) && !entityArray.length) {
-                    return {
-                        property: metadata.displayName,
-                        // eslint-disable-next-line sonar/no-duplicate-string
-                        message: 'no items in array'
-                    };
+                case DecoratorTypes.OBJECT_DROPDOWN: {
+                    // Because only valid values can be selected, this is always true when it has a value
+                    return undefined;
                 }
-                break;
-            }
-            case DecoratorTypes.DATE: {
-                const entityDate = new Date(entity[key]);
-                const dateMetadata = metadata;
-                return this.getDateValidationError(entityDate, dateMetadata);
-            }
-            case DecoratorTypes.DATE_RANGE: {
-                const entityDateRange = LodashUtilities.cloneDeep(entity[key]);
-                const dateRangeMetadata = metadata;
-                return this.getDateRangeValidationError(entity, entityDateRange, dateRangeMetadata);
-            }
-            case DecoratorTypes.DATE_TIME: {
-                const entityDateTime = new Date(entity[key]);
-                const dateTimeMetadata = metadata;
-                const hasTime = ReflectUtilities.hasMetadata(EntityUtilities.TIME_KEY, entity, key);
-                return this.getDateTimeValidationError(entityDateTime, dateTimeMetadata, hasTime);
-            }
-            case DecoratorTypes.FILE_DEFAULT:
-            case DecoratorTypes.FILE_IMAGE: {
-                const entityFile = entity[key];
-                const entityFileMetadata = metadata;
-                return this.getFileDataValidationError(entityFile, entityFileMetadata);
-            }
-            case DecoratorTypes.REFERENCES_ONE:
-            case DecoratorTypes.HAS_MANY: {
-                break;
-            }
-            case DecoratorTypes.CUSTOM: {
-                // eslint-disable-next-line typescript/no-explicit-any, stylistic/max-len
-                const customMetadata = metadata;
-                if (!customMetadata.isValid(entity[key], omit)) {
-                    return {
-                        property: metadata.displayName,
-                        message: 'invalid'
-                    };
+                case DecoratorTypes.ARRAY_STRING_AUTOCOMPLETE_CHIPS: {
+                    const stringAutocompleteArray = entity[key];
+                    // eslint-disable-next-line stylistic/max-len
+                    const stringAutocompleteArrayMetadata = metadata;
+                    // eslint-disable-next-line stylistic/max-len
+                    return await this.getArrayStringAutocompleteChipsValidationError(entity, stringAutocompleteArrayMetadata, stringAutocompleteArray);
+                }
+                case DecoratorTypes.ARRAY_STRING_DROPDOWN: {
+                    const stringDropdownArray = entity[key];
+                    // eslint-disable-next-line stylistic/max-len
+                    const stringDropdownArrayMetadata = metadata;
+                    return await this.getArrayStringDropdownValidationError(entity, stringDropdownArrayMetadata, stringDropdownArray);
+                }
+                case DecoratorTypes.ARRAY_STRING_CHIPS:
+                case DecoratorTypes.ARRAY_DATE:
+                case DecoratorTypes.ARRAY_DATE_TIME:
+                case DecoratorTypes.ARRAY_DATE_RANGE:
+                case DecoratorTypes.ARRAY:
+                case DecoratorTypes.REFERENCES_MANY: {
+                    const entityArray = entity[key];
+                    // eslint-disable-next-line stylistic/max-len
+                    const arrayMetadata = metadata;
+                    if (arrayMetadata.required(entity) && !entityArray.length) {
+                        return {
+                            property: metadata.displayName,
+                            // eslint-disable-next-line sonar/no-duplicate-string
+                            message: 'no items in array'
+                        };
+                    }
+                    break;
+                }
+                case DecoratorTypes.DATE: {
+                    const entityDate = new Date(entity[key]);
+                    const dateMetadata = metadata;
+                    return this.getDateValidationError(entityDate, dateMetadata);
+                }
+                case DecoratorTypes.DATE_RANGE: {
+                    const entityDateRange = LodashUtilities.cloneDeep(entity[key]);
+                    const dateRangeMetadata = metadata;
+                    return this.getDateRangeValidationError(entity, entityDateRange, dateRangeMetadata);
+                }
+                case DecoratorTypes.DATE_TIME: {
+                    const entityDateTime = new Date(entity[key]);
+                    const dateTimeMetadata = metadata;
+                    const hasTime = ReflectUtilities.hasMetadata(EntityUtilities.TIME_KEY, entity, key);
+                    return this.getDateTimeValidationError(entityDateTime, dateTimeMetadata, hasTime);
+                }
+                case DecoratorTypes.FILE_DEFAULT:
+                case DecoratorTypes.FILE_IMAGE: {
+                    const entityFile = entity[key];
+                    const entityFileMetadata = metadata;
+                    return this.getFileDataValidationError(entityFile, entityFileMetadata);
+                }
+                case DecoratorTypes.REFERENCES_ONE:
+                case DecoratorTypes.HAS_MANY: {
+                    break;
+                }
+                case DecoratorTypes.CUSTOM: {
+                    // eslint-disable-next-line typescript/no-explicit-any, stylistic/max-len
+                    const customMetadata = metadata;
+                    if (!customMetadata.isValid(entity[key], omit)) {
+                        return {
+                            property: metadata.displayName,
+                            message: 'invalid'
+                        };
+                    }
+                    break;
+                }
+                default: {
+                    throw new Error(`Could not validate the input because the DecoratorType ${type} is not known`);
                 }
-                break;
-            }
-            default: {
-                throw new Error(`Could not validate the input because the DecoratorType ${type} is not known`);
             }
-        }
-        return undefined;
+            return undefined;
+        });
     }
     static async getArrayStringAutocompleteChipsValidationError(entity, metadata, stringAutocompleteArray) {
         if (metadata.required(entity) && !stringAutocompleteArray.length) {