Fb/code validation through config (#24)

* remember new todo

* wip 1

* wip 2

* wip 3

* wip 4

* wip 5

* wip 6

* wip 7

* wip 8

* wip 9

* wip 10

* wip 11

* wip 12

* wip 13

* wip 14

* wip 15

* make scopes a validation too

* make scopes a validation too 2

* remaining TODOs

* small polish stuff

* small polish stuff 2

* small polish stuff 3

* small polish stuff 4

* small polish stuff 5

* small polish stuff 6

Author: rlindner81

example-cap-server/srv/feature/features.yaml

@@ -3,11 +3,15 @@
 /check/priority:
   type: number
   fallbackValue: 0
-  validation: '^\d+$'
-  allowedScopes: [user, tenant]
+  validations:
+    - scopes: [user, tenant]
+    - regex: '^\d+$'
+    - { module: "$CONFIG_DIR/validators.js", call: validateTenantScope }
 
 # info: memory statistics logging interval (in milliseconds); 0 means disabled
 /memory/logInterval:
   type: number
   fallbackValue: 0
-  validation: '^\d+$'
+  validations:
+    - regex: '^\d+$'
+    - { module: "./srv/feature/validators.js", call: validateTenantScope }

example-cap-server/srv/feature/validators.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const TENANT_SCOPE_REGEX = /^(people|pets)$/;
+
+const validateTenantScope = (newValue, scopeMap) => {
+  const tenant = scopeMap?.tenant;
+  if (tenant && !TENANT_SCOPE_REGEX.test(tenant)) {
+    return {
+      errorMessage: 'tenant scope is invalid, only people and pets are allowed: "{0}"',
+      errorMessageValues: [tenant],
+    };
+  }
+};
+
+module.exports = {
+  validateTenantScope,
+};

src/featureToggles.js

@@ -12,7 +12,8 @@
 "use strict";
 
 // TODO locale for validation messages
-// TODO custom validation should be configurable in yaml file
+// TODO document all validations scopes, regex, and module and remove allowedScopes
+// TODO document clearSubScopes option
 
 const { promisify } = require("util");
 const path = require("path");
@@ -24,7 +25,7 @@ const { REDIS_INTEGRATION_MODE } = redis;
 const { Logger } = require("./logger");
 const { isOnCF, cfEnv } = require("./env");
 const { HandlerCollection } = require("./shared/handlerCollection");
-const { ENV, isObject } = require("./shared/static");
+const { ENV, isObject, tryRequire } = require("./shared/static");
 const { promiseAllDone } = require("./shared/promiseAllDone");
 const { LimitedLazyCache } = require("./shared/cache");
 
@@ -42,21 +43,19 @@ const SCOPE_ROOT_KEY = "//";
 const CONFIG_KEY = Object.freeze({
   TYPE: "TYPE",
   ACTIVE: "ACTIVE",
-  VALIDATION: "VALIDATION",
-  VALIDATION_REG_EXP: "VALIDATION_REG_EXP",
+  VALIDATIONS: "VALIDATIONS",
+  VALIDATIONS_SCOPES_MAP: "VALIDATIONS_SCOPES_MAP",
+  VALIDATIONS_REG_EXP: "VALIDATIONS_REG_EXP",
   APP_URL: "APP_URL",
   APP_URL_ACTIVE: "APP_URL_ACTIVE",
-  ALLOWED_SCOPES: "ALLOWED_SCOPES",
-  ALLOWED_SCOPES_CHECK_MAP: "ALLOWED_SCOPES_CHECK_MAP",
 });
 
 const CONFIG_INFO_KEY = {
   [CONFIG_KEY.TYPE]: true,
   [CONFIG_KEY.ACTIVE]: true,
-  [CONFIG_KEY.VALIDATION]: true,
+  [CONFIG_KEY.VALIDATIONS]: true,
   [CONFIG_KEY.APP_URL]: true,
   [CONFIG_KEY.APP_URL_ACTIVE]: true,
-  [CONFIG_KEY.ALLOWED_SCOPES]: true,
 };
 
 const COMPONENT_NAME = "/FeatureToggles";
@@ -121,11 +120,11 @@ class FeatureToggles {
   /**
    * Populate this.__config.
    */
-  _processConfig(config) {
+  _processConfig(config, configFilepath) {
     const { uris: cfAppUris } = cfEnv.cfApp;
 
     const configEntries = Object.entries(config);
-    for (const [featureKey, { type, active, appUrl, validation, fallbackValue, allowedScopes }] of configEntries) {
+    for (const [featureKey, { type, active, appUrl, validations, fallbackValue }] of configEntries) {
       this.__featureKeys.push(featureKey);
       this.__fallbackValues[featureKey] = fallbackValue;
       this.__config[featureKey] = {};
@@ -138,9 +137,76 @@ class FeatureToggles {
         this.__config[featureKey][CONFIG_KEY.ACTIVE] = active;
       }
 
-      if (validation) {
-        this.__config[featureKey][CONFIG_KEY.VALIDATION] = validation;
-        this.__config[featureKey][CONFIG_KEY.VALIDATION_REG_EXP] = new RegExp(validation);
+      if (validations) {
+        this.__config[featureKey][CONFIG_KEY.VALIDATIONS] = validations;
+
+        const workingDir = process.cwd();
+        const configDir = configFilepath ? path.dirname(configFilepath) : __dirname;
+        const { validationsScopesMap, validationsRegExp, validationsCode } = validations.reduce(
+          (acc, validation) => {
+            if (Array.isArray(validation.scopes)) {
+              for (const scope of validation.scopes) {
+                acc.validationsScopesMap[scope] = true;
+              }
+              return acc;
+            }
+
+            if (validation.regex) {
+              acc.validationsRegExp.push(new RegExp(validation.regex));
+              return acc;
+            }
+
+            if (validation.module) {
+              let modulePath = validation.module.replace("$CONFIG_DIR", configDir);
+              if (!path.isAbsolute(modulePath)) {
+                modulePath = path.join(workingDir, modulePath);
+              }
+              let validator = tryRequire(modulePath);
+
+              if (validation.call) {
+                validator = validator?.[validation.call];
+              }
+
+              const validatorType = typeof validator;
+              if (validatorType === "function") {
+                acc.validationsCode.push(validator);
+              } else {
+                logger.warning(
+                  new VError(
+                    {
+                      name: VERROR_CLUSTER_NAME,
+                      info: {
+                        featureKey,
+                        validation: JSON.stringify(validation),
+                        modulePath,
+                        validatorType,
+                      },
+                    },
+                    "could not load module validation"
+                  )
+                );
+              }
+              return acc;
+            }
+
+            throw new VError(
+              {
+                name: VERROR_CLUSTER_NAME,
+                info: {
+                  featureKey,
+                  validation: JSON.stringify(validation),
+                },
+              },
+              "found invalid validation, only scopes, regex, and module validations are supported"
+            );
+          },
+          { validationsScopesMap: {}, validationsRegExp: [], validationsCode: [] }
+        );
+        this.__config[featureKey][CONFIG_KEY.VALIDATIONS_SCOPES_MAP] = validationsScopesMap;
+        this.__config[featureKey][CONFIG_KEY.VALIDATIONS_REG_EXP] = validationsRegExp;
+        for (const validator of validationsCode) {
+          this.registerFeatureValueValidation(featureKey, validator);
+        }
       }
 
       if (appUrl) {
@@ -151,14 +217,6 @@ class FeatureToggles {
           !Array.isArray(cfAppUris) ||
           cfAppUris.reduce((accumulator, cfAppUri) => accumulator && appUrlRegex.test(cfAppUri), true);
       }
-
-      if (Array.isArray(allowedScopes)) {
-        this.__config[featureKey][CONFIG_KEY.ALLOWED_SCOPES] = allowedScopes;
-        this.__config[featureKey][CONFIG_KEY.ALLOWED_SCOPES_CHECK_MAP] = allowedScopes.reduce((acc, scope) => {
-          acc[scope] = true;
-          return acc;
-        }, {});
-      }
     }
 
     this.__isConfigProcessed = true;
@@ -287,7 +345,7 @@ class FeatureToggles {
           },
         ];
       }
-      const allowedScopesCheckMap = this.__config[featureKey][CONFIG_KEY.ALLOWED_SCOPES_CHECK_MAP];
+      const validationsScopesMap = this.__config[featureKey][CONFIG_KEY.VALIDATIONS_SCOPES_MAP];
       for (const [scope, value] of Object.entries(scopeMap)) {
         if (!FeatureToggles._isValidScopeMapValue(value)) {
           return [
@@ -298,7 +356,7 @@ class FeatureToggles {
             },
           ];
         }
-        if (allowedScopesCheckMap && !allowedScopesCheckMap[scope]) {
+        if (validationsScopesMap && !validationsScopesMap[scope]) {
           return [
             {
               featureKey,
@@ -359,16 +417,19 @@ class FeatureToggles {
       ];
     }
 
-    const validationRegExp = this.__config[featureKey][CONFIG_KEY.VALIDATION_REG_EXP];
-    if (validationRegExp && !validationRegExp.test(value)) {
-      return [
-        {
-          featureKey,
-          ...(scopeKey && { scopeKey }),
-          errorMessage: 'value "{0}" does not match validation regular expression {1}',
-          errorMessageValues: [value, this.__config[featureKey][CONFIG_KEY.VALIDATION]],
-        },
-      ];
+    const validationsRegExp = this.__config[featureKey][CONFIG_KEY.VALIDATIONS_REG_EXP];
+    if (Array.isArray(validationsRegExp) && validationsRegExp.length > 0) {
+      const failingRegExp = validationsRegExp.find((validationRegExp) => !validationRegExp.test(value));
+      if (failingRegExp) {
+        return [
+          {
+            featureKey,
+            ...(scopeKey && { scopeKey }),
+            errorMessage: 'value "{0}" does not match validation regular expression {1}',
+            errorMessageValues: [value, failingRegExp.toString()],
+          },
+        ];
+      }
     }
 
     const validators = this.__featureValueValidators.getHandlers(featureKey);
@@ -609,7 +670,7 @@ class FeatureToggles {
 
     let toggleCount;
     try {
-      toggleCount = this._processConfig(config);
+      toggleCount = this._processConfig(config, configFilepath);
     } catch (err) {
       throw new VError(
         {

test/__snapshots__/featureToggles.test.js.snap

@@ -40,11 +40,15 @@ exports[`feature toggles test basic apis getFeaturesInfos 1`] = `
   },
   "test/feature_aa": {
     "config": {
-      "ALLOWED_SCOPES": [
-        "tenant",
-        "user",
-      ],
       "TYPE": "boolean",
+      "VALIDATIONS": [
+        {
+          "scopes": [
+            "tenant",
+            "user",
+          ],
+        },
+      ],
     },
     "fallbackValue": false,
   },
@@ -63,21 +67,33 @@ exports[`feature toggles test basic apis getFeaturesInfos 1`] = `
   "test/feature_d": {
     "config": {
       "TYPE": "boolean",
-      "VALIDATION": "^(?:true)$",
+      "VALIDATIONS": [
+        {
+          "regex": "^(?:true)$",
+        },
+      ],
     },
     "fallbackValue": true,
   },
   "test/feature_e": {
     "config": {
       "TYPE": "number",
-      "VALIDATION": "^\\d{1}$",
+      "VALIDATIONS": [
+        {
+          "regex": "^\\d{1}$",
+        },
+      ],
     },
     "fallbackValue": 5,
   },
   "test/feature_f": {
     "config": {
       "TYPE": "string",
-      "VALIDATION": "^(?:best|worst)$",
+      "VALIDATIONS": [
+        {
+          "regex": "^(?:best|worst)$",
+        },
+      ],
     },
     "fallbackValue": "best",
   },
@@ -105,15 +121,20 @@ exports[`feature toggles test basic apis initializeFeatureToggles 1`] = `
     "TYPE": "boolean",
   },
   "test/feature_aa": {
-    "ALLOWED_SCOPES": [
-      "tenant",
-      "user",
+    "TYPE": "boolean",
+    "VALIDATIONS": [
+      {
+        "scopes": [
+          "tenant",
+          "user",
+        ],
+      },
     ],
-    "ALLOWED_SCOPES_CHECK_MAP": {
+    "VALIDATIONS_REG_EXP": [],
+    "VALIDATIONS_SCOPES_MAP": {
       "tenant": true,
       "user": true,
     },
-    "TYPE": "boolean",
   },
   "test/feature_b": {
     "TYPE": "number",
@@ -123,18 +144,39 @@ exports[`feature toggles test basic apis initializeFeatureToggles 1`] = `
   },
   "test/feature_d": {
     "TYPE": "boolean",
-    "VALIDATION": "^(?:true)$",
-    "VALIDATION_REG_EXP": /\\^\\(\\?:true\\)\\$/,
+    "VALIDATIONS": [
+      {
+        "regex": "^(?:true)$",
+      },
+    ],
+    "VALIDATIONS_REG_EXP": [
+      /\\^\\(\\?:true\\)\\$/,
+    ],
+    "VALIDATIONS_SCOPES_MAP": {},
   },
   "test/feature_e": {
     "TYPE": "number",
-    "VALIDATION": "^\\d{1}$",
-    "VALIDATION_REG_EXP": /\\^\\\\d\\{1\\}\\$/,
+    "VALIDATIONS": [
+      {
+        "regex": "^\\d{1}$",
+      },
+    ],
+    "VALIDATIONS_REG_EXP": [
+      /\\^\\\\d\\{1\\}\\$/,
+    ],
+    "VALIDATIONS_SCOPES_MAP": {},
   },
   "test/feature_f": {
     "TYPE": "string",
-    "VALIDATION": "^(?:best|worst)$",
-    "VALIDATION_REG_EXP": /\\^\\(\\?:best\\|worst\\)\\$/,
+    "VALIDATIONS": [
+      {
+        "regex": "^(?:best|worst)$",
+      },
+    ],
+    "VALIDATIONS_REG_EXP": [
+      /\\^\\(\\?:best\\|worst\\)\\$/,
+    ],
+    "VALIDATIONS_SCOPES_MAP": {},
   },
   "test/feature_g": {
     "ACTIVE": false,