@researchdatabox/sails-ng-common 0.2.1 → 5.0.0-RC2

package/dist/src/validation/helpers.js

@@ -1,7 +1,4 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formValidatorLengthOrSize = formValidatorLengthOrSize;
 exports.formValidatorGetDefinitionItem = formValidatorGetDefinitionItem;
@@ -10,9 +7,18 @@ exports.formValidatorGetDefinitionNumber = formValidatorGetDefinitionNumber;
 exports.formValidatorGetDefinitionBoolean = formValidatorGetDefinitionBoolean;
 exports.formValidatorGetDefinitionRegexp = formValidatorGetDefinitionRegexp;
 exports.formValidatorGetDefinitionArray = formValidatorGetDefinitionArray;
-const lodash_1 = __importDefault(require("lodash"));
+exports.formValidatorGetDefinitionObject = formValidatorGetDefinitionObject;
+exports.formValidatorBuildError = formValidatorBuildError;
+const lodash_1 = require("lodash");
+const helpers_1 = require("../config/helpers");
+/**
+ * Extract the length property in case it's an array or a string.
+ * Extract the size property in case it's a set.
+ * Return null else.
+ * @param value Either an array, set or undefined.
+ */
 function formValidatorLengthOrSize(value) {
-    if (value == null) {
+    if (value === null || value === undefined) {
         return null;
     }
     else if (Array.isArray(value) || typeof value === "string") {
@@ -24,7 +30,7 @@ function formValidatorLengthOrSize(value) {
     return null;
 }
 function formValidatorGetDefinitionItem(config, key, defaultValue = undefined) {
-    const value = lodash_1.default.get(config ?? {}, key, defaultValue);
+    const value = (0, lodash_1.get)(config ?? {}, key, defaultValue);
     if (value === undefined) {
         throw new Error(`Must define '${key}' in validator config.`);
     }
@@ -38,18 +44,14 @@ function formValidatorGetDefinitionNumber(config, key, defaultValue = undefined)
     const value = formValidatorGetDefinitionItem(config, key, defaultValue);
     const valueString = value?.toString() ?? "";
     const valueNumber = parseFloat(valueString);
-    if (isNaN(valueNumber)) {
+    if (!Number.isFinite(valueNumber)) {
         throw new Error(`Invalid numeric value '${value}' for key '${key}' in validator config.`);
     }
     return valueNumber;
 }
 function formValidatorGetDefinitionBoolean(config, key, defaultValue = undefined) {
     const value = formValidatorGetDefinitionItem(config, key, defaultValue);
-    if (typeof value === "boolean") {
-        return value;
-    }
-    const valueString = value?.toString()?.toLowerCase() ?? "";
-    return ["true", "t", "1", "yes", "y"].includes(valueString);
+    return (0, helpers_1.toBoolean)(value);
 }
 function formValidatorGetDefinitionRegexp(config, key, defaultValue = undefined) {
     const value = formValidatorGetDefinitionItem(config, key, defaultValue);
@@ -65,4 +67,38 @@ function formValidatorGetDefinitionArray(config, key, defaultValue = undefined)
     }
     throw new Error(`Invalid array value '${value}' for key '${key}' in validator config.`);
 }
-//# sourceMappingURL=data:application/json;base64,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
+function formValidatorGetDefinitionObject(config, key, defaultValue = undefined) {
+    const value = formValidatorGetDefinitionItem(config, key, defaultValue);
+    if ((0, helpers_1.guessType)(value) === "object") {
+        return value;
+    }
+    throw new Error(`Invalid object value '${value}' for key '${key}' in validator config.`);
+}
+function formValidatorBuildError(config, params) {
+    const optionNameKey = "class";
+    const optionNameValue = formValidatorGetDefinitionString(config, optionNameKey);
+    const optionMessageKey = "message";
+    const optionMessageValue = formValidatorGetDefinitionString(config, optionMessageKey);
+    const optionTargetFieldKey = "targetField";
+    const optionTargetFieldValue = formValidatorGetDefinitionObject(config, optionTargetFieldKey, {});
+    // The error key is the validator class, unless a unique error key was assigned because the
+    // same class is used more than once on a control. Keying by a unique value lets Angular's
+    // error merging keep every instance instead of overwriting earlier ones.
+    const optionErrorKeyKey = "errorKey";
+    const optionErrorKeyValue = formValidatorGetDefinitionString(config, optionErrorKeyKey, optionNameValue);
+    const result = {
+        [optionErrorKeyValue]: {
+            [optionMessageKey]: optionMessageValue,
+            params: { ...params },
+        }
+    };
+    // Preserve the real class when the key differs, so the class can be recovered for display.
+    if (optionErrorKeyValue !== optionNameValue) {
+        result[optionErrorKeyValue][optionNameKey] = optionNameValue;
+    }
+    if (Object.keys(optionTargetFieldValue).length > 0) {
+        result[optionErrorKeyValue][optionTargetFieldKey] = optionTargetFieldValue;
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/validation/validators-support.d.ts

@@ -1,4 +1,41 @@
-import { FormValidatorBlock, FormValidatorDefinition, FormValidatorFn } from "./form.model";
+import { FormValidationGroups, FormValidatorComponentErrors, FormValidatorConfig, FormValidatorDefinition, FormValidatorErrors, FormValidatorFns, FormValidatorTargetFieldConfig } from "./form.model";
 export declare class ValidatorsSupport {
-    createFormValidatorInstances(definition: FormValidatorDefinition[] | null | undefined, config: FormValidatorBlock[] | null | undefined): FormValidatorFn[];
+    /**
+     * Create validator definition mapping from the validator definitions.
+     * @param definition The form validator definitions.
+     */
+    createValidatorDefinitionMapping(definition: FormValidatorDefinition[] | null | undefined): Map<string, FormValidatorDefinition>;
+    /**
+     * Create form validator instances from the validator definition mapping.
+     * @param defMap The validator definition mapping.
+     * @param config The form validator config blocks.
+     */
+    createFormValidatorInstancesFromMapping(defMap: Map<string, FormValidatorDefinition>, config: (FormValidatorConfig | FormValidatorTargetFieldConfig)[] | null | undefined): FormValidatorFns;
+    /**
+     * Get the form validator errors for a component's control.
+     * @param errors The control's errors.
+     */
+    getFormValidatorComponentErrors(errors: FormValidatorErrors | null): FormValidatorComponentErrors[];
+    checkValidationGroups(availableGroups: FormValidationGroups, enabledGroupNames: string[]): void;
+    /**
+     * Is the component model validator enabled?
+     * @param availableGroups All available validation groups in this form.
+     * @param enabledGroupNames The currently enabled validation groups.
+     * @param validator The validator config for a component's model.
+     */
+    isValidatorEnabled(availableGroups: FormValidationGroups, enabledGroupNames: string[], validator: FormValidatorConfig): boolean;
+    /**
+     * Assign the jsonata evaluator to each 'jsonata-expression' validator.
+     * This must be done before filtering the validators on the client, as the compiled templates are referenced by index.
+     * @param validators The validator configurations from the model config.
+     * @param callback The callback for each validator config with the index.
+     */
+    assignJsonataEvaluators(validators: FormValidatorConfig[], callback: (validator: FormValidatorConfig, index: number) => unknown): void;
+    /**
+     * Get the enabled validators.
+     * @param availableGroups All available validation groups in this form.
+     * @param enabledGroups The currently enabled validation groups.
+     * @param validators All available validators in this form.
+     */
+    enabledValidators(availableGroups: FormValidationGroups, enabledGroups: string[], validators: FormValidatorConfig[]): FormValidatorConfig[];
 }

package/dist/src/validation/validators-support.js

@@ -1,33 +1,183 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValidatorsSupport = void 0;
+const form_types_model_1 = require("../config/form-types.model");
 class ValidatorsSupport {
-    createFormValidatorInstances(definition, config) {
+    /**
+     * Create validator definition mapping from the validator definitions.
+     * @param definition The form validator definitions.
+     */
+    createValidatorDefinitionMapping(definition) {
         const defMap = new Map();
         for (const definitionItem of (definition ?? [])) {
-            const name = definitionItem?.name;
+            if (!(0, form_types_model_1.isTypeFormValidatorDefinition)(definitionItem)) {
+                throw new Error(`Validator definition does not have valid 'class', 'message', and 'create' properties: ${JSON.stringify(definitionItem)}`);
+            }
+            const validatorClass = definitionItem?.class;
             const message = definitionItem?.message;
-            if (defMap.has(name)) {
-                const messages = [message, defMap.get(name)?.message];
-                throw new Error(`Duplicate validator name '${name}' - the validator names must be unique. `
+            if (defMap.has(validatorClass)) {
+                const messages = [message, defMap.get(validatorClass)?.message];
+                throw new Error(`Duplicate validator class '${validatorClass}' - the validator classes must be unique. `
                     + `To help you find the duplicates, these are the messages of the duplicates: '${messages.join(", ")}'.`);
             }
-            defMap.set(name, definitionItem);
+            defMap.set(validatorClass, definitionItem);
         }
-        const result = [];
+        return defMap;
+    }
+    /**
+     * Create form validator instances from the validator definition mapping.
+     * @param defMap The validator definition mapping.
+     * @param config The form validator config blocks.
+     */
+    createFormValidatorInstancesFromMapping(defMap, config) {
+        const result = { syncDefs: [], asyncDefs: [] };
+        // Count how many times each class is used so we know which ones are duplicated.
+        // Duplicated classes need a unique error key so Angular's error merging keeps every
+        // instance instead of overwriting earlier ones (the merge key would otherwise collide).
+        const classCounts = new Map();
         for (const validatorConfigItem of (config ?? [])) {
-            const name = validatorConfigItem?.name;
-            const def = defMap.get(name);
+            const validatorClass = validatorConfigItem?.class;
+            classCounts.set(validatorClass, (classCounts.get(validatorClass) ?? 0) + 1);
+        }
+        const classOccurrences = new Map();
+        for (const validatorConfigItem of (config ?? [])) {
+            const validatorClass = validatorConfigItem?.class;
+            const def = defMap.get(validatorClass);
             if (!def) {
-                throw new Error(`No validator definition has name '${name}', `
+                throw new Error(`No validator definition with class '${validatorClass}', `
                     + `the available validators are: '${Array.from(defMap.keys()).sort().join(", ")}'.`);
             }
             const message = validatorConfigItem?.message ?? def.message;
-            const item = def.create({ name: name, message: message, ...(validatorConfigItem?.config ?? {}) });
+            const createConfig = {
+                ...validatorConfigItem?.config ?? {},
+                class: validatorClass,
+                message: message,
+            };
+            // Only assign a unique error key when the class is used more than once on this control.
+            // Single-use classes keep the class as the error key, so the error shape is unchanged.
+            const occurrence = (classOccurrences.get(validatorClass) ?? 0);
+            classOccurrences.set(validatorClass, occurrence + 1);
+            if ((classCounts.get(validatorClass) ?? 0) > 1) {
+                createConfig.errorKey = `${validatorClass}#${occurrence}`;
+            }
+            if ('targetField' in validatorConfigItem && validatorConfigItem.targetField !== undefined) {
+                createConfig.targetField = validatorConfigItem.targetField;
+            }
+            if ('create' in def) {
+                result.syncDefs.push(def.create(createConfig));
+            }
+            else if ('createAsync' in def) {
+                result.asyncDefs.push(def.createAsync(createConfig));
+            }
+            else {
+                throw new Error(`Invalid validator definition: must specify 'create' or 'createAsync' function. Definition is ${JSON.stringify(validatorConfigItem)}.`);
+            }
+        }
+        return result;
+    }
+    /**
+     * Get the form validator errors for a component's control.
+     * @param errors The control's errors.
+     */
+    getFormValidatorComponentErrors(errors) {
+        const result = [];
+        for (const [key, value] of Object.entries(errors ?? {})) {
+            const item = {
+                // The error key matches the class unless the class was duplicated on a control, in
+                // which case the real class is carried on the value so it can be recovered here.
+                class: value.class ?? key,
+                message: value.message ?? null,
+                params: { ...value.params },
+            };
+            if (value.targetField !== undefined) {
+                item.targetField = value.targetField;
+            }
             result.push(item);
         }
         return result;
     }
+    checkValidationGroups(availableGroups, enabledGroupNames) {
+        const availableGroupNames = Object.keys(availableGroups);
+        const unknownGroups = enabledGroupNames.filter(g => !availableGroupNames.includes(g));
+        if (unknownGroups.length > 0) {
+            throw new Error(`Unknown enabled validation groups ${JSON.stringify(unknownGroups)}.`);
+        }
+    }
+    /**
+     * Is the component model validator enabled?
+     * @param availableGroups All available validation groups in this form.
+     * @param enabledGroupNames The currently enabled validation groups.
+     * @param validator The validator config for a component's model.
+     */
+    isValidatorEnabled(availableGroups, enabledGroupNames, validator) {
+        if (Object.keys(availableGroups).length === 0) {
+            // If there are no validation groups, all validators are enabled.
+            return true;
+        }
+        if (enabledGroupNames.length === 0) {
+            // If there are no validation groups enabled, all validators are enabled.
+            return true;
+        }
+        this.checkValidationGroups(availableGroups, enabledGroupNames);
+        // Check each validation group to see if the validator is enabled.
+        // A validator must pass at least one of the group checks to be enabled.
+        const includes = validator?.groups?.include ?? [];
+        this.checkValidationGroups(availableGroups, includes);
+        const excludes = validator?.groups?.exclude ?? [];
+        this.checkValidationGroups(availableGroups, excludes);
+        for (const [groupKey, groupConfig] of Object.entries(availableGroups)) {
+            const membership = groupConfig?.initialMembership ?? "none";
+            if (!enabledGroupNames?.includes(groupKey)) {
+                // Group is not enabled, so move on.
+                continue;
+            }
+            if (excludes.includes(groupKey)) {
+                // Validator excludes this group, so move on.
+                continue;
+            }
+            if (membership === "all" && !excludes.includes(groupKey)) {
+                // Validator is enabled.
+                // Group is enabled, starts with all validators, and validator does not exclude it.
+                return true;
+            }
+            if (membership === "none" && includes.includes(groupKey)) {
+                // Validator is enabled.
+                // Group is enabled, starts with no validators, and validator includes it.
+                return true;
+            }
+        }
+        // Validator was not included in any group, so it is disabled.
+        return false;
+    }
+    /**
+     * Assign the jsonata evaluator to each 'jsonata-expression' validator.
+     * This must be done before filtering the validators on the client, as the compiled templates are referenced by index.
+     * @param validators The validator configurations from the model config.
+     * @param callback The callback for each validator config with the index.
+     */
+    assignJsonataEvaluators(validators, callback) {
+        validators.forEach((validator, index) => {
+            if (validator.class === "jsonata-expression") {
+                if (!validator.config) {
+                    validator.config = {};
+                }
+                const expr = validator?.config?.['expression']?.toString() ?? "";
+                const evaluator = validator.config?.['evaluator'];
+                if (validator.config && expr && !evaluator) {
+                    validator.config['evaluator'] = callback(validator, index);
+                }
+            }
+        });
+    }
+    /**
+     * Get the enabled validators.
+     * @param availableGroups All available validation groups in this form.
+     * @param enabledGroups The currently enabled validation groups.
+     * @param validators All available validators in this form.
+     */
+    enabledValidators(availableGroups, enabledGroups, validators) {
+        return (validators ?? []).filter(validator => this.isValidatorEnabled(availableGroups, enabledGroups, validator));
+    }
 }
 exports.ValidatorsSupport = ValidatorsSupport;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdG9ycy1zdXBwb3J0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3ZhbGlkYXRpb24vdmFsaWRhdG9ycy1zdXBwb3J0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUVBLE1BQWEsaUJBQWlCO0lBT3JCLDRCQUE0QixDQUNqQyxVQUF3RCxFQUN4RCxNQUErQztRQUUvQyxNQUFNLE1BQU0sR0FBRyxJQUFJLEdBQUcsRUFBbUMsQ0FBQztRQUMxRCxLQUFLLE1BQU0sY0FBYyxJQUFJLENBQUMsVUFBVSxJQUFJLEVBQUUsQ0FBQyxFQUFFLENBQUM7WUFDaEQsTUFBTSxJQUFJLEdBQUcsY0FBYyxFQUFFLElBQUksQ0FBQztZQUNsQyxNQUFNLE9BQU8sR0FBRyxjQUFjLEVBQUUsT0FBTyxDQUFDO1lBQ3hDLElBQUksTUFBTSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDO2dCQUNyQixNQUFNLFFBQVEsR0FBRyxDQUFDLE9BQU8sRUFBRSxNQUFNLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFLE9BQU8sQ0FBQyxDQUFDO2dCQUN0RCxNQUFNLElBQUksS0FBSyxDQUFDLDZCQUE2QixJQUFJLDBDQUEwQztzQkFDdkYsK0VBQStFLFFBQVEsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQzlHLENBQUM7WUFDRCxNQUFNLENBQUMsR0FBRyxDQUFDLElBQUksRUFBRSxjQUFjLENBQUMsQ0FBQztRQUNuQyxDQUFDO1FBRUQsTUFBTSxNQUFNLEdBQXNCLEVBQUUsQ0FBQztRQUNyQyxLQUFLLE1BQU0sbUJBQW1CLElBQUksQ0FBQyxNQUFNLElBQUksRUFBRSxDQUFDLEVBQUUsQ0FBQztZQUNqRCxNQUFNLElBQUksR0FBRyxtQkFBbUIsRUFBRSxJQUFJLENBQUM7WUFDdkMsTUFBTSxHQUFHLEdBQUcsTUFBTSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUM3QixJQUFJLENBQUMsR0FBRyxFQUFFLENBQUM7Z0JBQ1QsTUFBTSxJQUFJLEtBQUssQ0FBQyxxQ0FBcUMsSUFBSSxLQUFLO3NCQUMxRCxrQ0FBa0MsS0FBSyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQ3pGLENBQUM7WUFDRCxNQUFNLE9BQU8sR0FBRyxtQkFBbUIsRUFBRSxPQUFPLElBQUksR0FBRyxDQUFDLE9BQU8sQ0FBQztZQUM1RCxNQUFNLElBQUksR0FBRyxHQUFHLENBQUMsTUFBTSxDQUFDLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLEdBQUcsQ0FBQyxtQkFBbUIsRUFBRSxNQUFNLElBQUksRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDO1lBQ2xHLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDcEIsQ0FBQztRQUNELE9BQU8sTUFBTSxDQUFDO0lBQ2hCLENBQUM7Q0FDRjtBQXJDRCw4Q0FxQ0MifQ==
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/validation/validators.d.ts

@@ -0,0 +1,28 @@
+import { FormValidatorDefinition } from "./form.model";
+/**
+ * A regular expression for validating an email address.
+ *
+ * Based on the angular email validation regex. MIT-style license https://angular.dev/license
+ */
+export declare const FORM_VALIDATOR_EMAIL_REGEXP: RegExp;
+/**
+ * A regular expression for a bare DOI (without a doi.org resolver URL).
+ *
+ * This follows the Crossref-recommended broad DOI syntax and is intentionally
+ * case-insensitive for DOI suffixes.
+ */
+export declare const FORM_VALIDATOR_DOI_REGEXP: RegExp;
+/**
+ * Definitions of form validators.
+ *
+ * These can be used on both server-side and client-side.
+ * The server provides them to the client.
+ *
+ * Sails hooks can use these validators functions, but cannot extend or override them.
+ * Use the 'jsonata-expression' validator to create custom validator functions.
+ *
+ * The validators are based on:
+ * - angular built-in validators: https://github.com/angular/angular/blob/5105fd6f05f01f04873ab1c87d64079fd8519ad4/packages/forms/src/validators.ts
+ * - formly schema: https://github.com/ngx-formly/ngx-formly/blob/a2f7901b6c0895aee63b4b5fe748fc5ec0ad5475/src/core/src/lib/models/fieldconfig.ts
+ */
+export declare const formValidatorsSharedDefinitions: FormValidatorDefinition[];