cht-conf 3.11.0 → 3.13.0

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+# [3.13.0](https://github.com/medic/cht-conf/compare/v3.12.0...v3.13.0) (2022-07-12)
+
+
+### Features
+
+* **#479:** validate simple XPaths in forms ([#486](https://github.com/medic/cht-conf/issues/486)) ([9df4a63](https://github.com/medic/cht-conf/commit/9df4a630e4bf69d6f6d102c6ae538f9e0bf10282)), closes [#479](https://github.com/medic/cht-conf/issues/479) [#479](https://github.com/medic/cht-conf/issues/479)
+
+# [3.12.0](https://github.com/medic/cht-conf/compare/v3.11.1...v3.12.0) (2022-06-23)
+
+
+### Features
+
+* **#484:** add actions for validating forms ([f2a6a8e](https://github.com/medic/cht-conf/commit/f2a6a8ef75561426ce2a6b542cdf1a255c869c6e)), closes [#484](https://github.com/medic/cht-conf/issues/484) [#481](https://github.com/medic/cht-conf/issues/481)
+
+## [3.11.1](https://github.com/medic/cht-conf/compare/v3.11.0...v3.11.1) (2022-06-13)
+
+
+### Bug Fixes
+
+* **#482:** move-contacts usage docs ([5fa86c8](https://github.com/medic/cht-conf/commit/5fa86c8e98797d8920ee20f2e7f16c98aa969201)), closes [#482](https://github.com/medic/cht-conf/issues/482)
+
 # [3.11.0](https://github.com/medic/cht-conf/compare/v3.10.2...v3.11.0) (2022-04-19)
 
 

package/README.md

@@ -300,7 +300,6 @@ Execute `npm test` to run static analysis checks and the test suite. Requires Do
 1. Get the pull request reviewed and approved.
 1. When doing the squash and merge, make sure that your commit message is clear and readable and follows the strict format described in the commit format section below. If the commit message does not comply, automatic release will fail.
 1. In case you are planning to merge the pull request with a merge commit, make sure that every commit in your branch respects the format. 
-1. Announce the release on the [CHT forum](https://forum.communityhealthtoolkit.org), under the "Product - Releases" category.
 
 ### Commit format
 The commit format should follow this [conventional-changelog angular preset](https://github.com/conventional-changelog/conventional-changelog/tree/master/packages/conventional-changelog-angular). Examples are provided below.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cht-conf",
-  "version": "3.11.0",
+  "version": "3.13.0",
   "description": "Configure CHT deployments",
   "main": "./src/lib/main.js",
   "engines": {
@@ -11,7 +11,7 @@
     "eslint": "eslint 'src/**/*.js' test/*.js 'test/**/*.js'",
     "docker-start-couchdb": "npm run docker-stop-couchdb && docker run -d -p 6984:5984 --rm --name cht-conf-couchdb couchdb:2.3.1 && sh test/scripts/wait_for_response_code.sh 6984 200 CouchDB",
     "docker-stop-couchdb": "docker stop cht-conf-couchdb || true",
-    "test": "npm run eslint && npm run docker-start-couchdb && npm run clean && mkdir -p build/test && cp -r test/data build/test/data && cd build/test && nyc --reporter=html mocha --forbid-only ../../test/**/*.spec.js && cd ../.. && npm run docker-stop-couchdb",
+    "test": "npm run eslint && npm run docker-start-couchdb && npm run clean && mkdir -p build/test && cp -r test/data build/test/data && cd build/test && nyc --reporter=html mocha --forbid-only \"../../test/**/*.spec.js\" && cd ../.. && npm run docker-stop-couchdb",
     "semantic-release": "semantic-release"
   },
   "bin": {
@@ -38,6 +38,7 @@
     "@hapi/joi": "^16.1.8",
     "@medic/translation-checker": "^1.0.1",
     "@parcel/watcher": "^2.0.5",
+    "@xmldom/xmldom": "^0.8.2",
     "canonical-json": "0.0.4",
     "csv-parse": "^4.16.0",
     "dom-compare": "^0.6.0",
@@ -67,7 +68,7 @@
     "terser-webpack-plugin": "^1.4.3",
     "uuid": "^8.3.2",
     "webpack": "^4.46.0",
-    "xmldom": "^0.6.0"
+    "xpath": "0.0.32"
   },
   "devDependencies": {
     "@commitlint/cli": "^13.2.0",

package/src/cli/usage.js

@@ -63,6 +63,9 @@ ${bold('OPTIONS')}
   --skip-translation-check
     Skips checking message translations
 
+  --skip-validate
+    Skips form validation  
+
   --force
     CAN BE DANGEROUS! Passes yes to all commands and any where that would prompt to overwrite changes will overwrite automatically. 
 `);

package/src/fn/move-contacts.js

@@ -101,7 +101,7 @@ const parseExtraArgs = (projectDir, extraArgs = []) => {
 
   if (contactIds.length === 0) {
     usage();
-    throw Error('Action "move-contacts" is missing required list of contact_id to be moved');
+    throw Error('Action "move-contacts" is missing required list of contacts to be moved');
   }
 
   if (!args.parent) {
@@ -137,7 +137,7 @@ ${bold('cht-conf\'s move-contacts action')}
 When combined with 'upload-docs' this action effectively moves a contact from one place in the hierarchy to another.
 
 ${bold('USAGE')}
-cht --local move-contacts -- --contactIds=<id1>,<id2> --parent=<parent_id>
+cht --local move-contacts -- --contacts=<id1>,<id2> --parent=<parent_id>
 
 ${bold('OPTIONS')}
 --contacts=<id1>,<id2>

package/src/fn/validate-app-forms.js

@@ -0,0 +1,12 @@
+const validateForms = require('../lib/validate-forms');
+const environment = require('../lib/environment');
+
+const validateAppForms = (forms) => {
+  return validateForms(environment.pathToProject, 'app', { forms });
+};
+
+module.exports = {
+  requiresInstance: false,
+  validateAppForms,
+  execute: () => validateAppForms(environment.extraArgs)
+};

package/src/fn/validate-collect-forms.js

@@ -0,0 +1,12 @@
+const validateForms = require('../lib/validate-forms');
+const environment = require('../lib/environment');
+
+const validateCollectForms = (forms) => {
+  return validateForms(environment.pathToProject, 'collect', { forms });
+};
+
+module.exports = {
+  requiresInstance: false,
+  validateCollectForms,
+  execute: () => validateCollectForms(environment.extraArgs)
+};

package/src/fn/validate-contact-forms.js

@@ -0,0 +1,12 @@
+const validateForms = require('../lib/validate-forms');
+const environment = require('../lib/environment');
+
+const validateContactForms = (forms) => {
+  return validateForms(environment.pathToProject, 'contact', { forms });
+};
+
+module.exports = {
+  requiresInstance: false,
+  validateContactForms,
+  execute: () => validateContactForms(environment.extraArgs)
+};

package/src/fn/watch-project.js

@@ -5,6 +5,9 @@ const fs = require('fs');
 const { error, warn, info } = require('../lib/log');
 const Queue = require('queue-promise');
 const watcher = require('@parcel/watcher');
+const { validateAppForms } = require('./validate-app-forms');
+const { validateContactForms } = require('./validate-contact-forms');
+const { validateCollectForms } = require('./validate-collect-forms');
 const { uploadAppForms } = require('./upload-app-forms');
 const { uploadContactForms } = require('./upload-contact-forms');
 const { uploadCollectForms } = require('./upload-collect-forms');
@@ -25,8 +28,17 @@ const watcherEvents = {
     UpdateEvent: 'update'
 };
 
+const runValidation = (validation, forms) => {
+    if(environment.skipValidate) {
+        return;
+    }
+    return validation(forms);
+};
+
 const uploadInitialState = async (api) => {
     await uploadResources();
+    await runValidation(validateAppForms, environment.extraArgs);
+    await runValidation(validateContactForms, environment.extraArgs);
     await uploadAppForms(environment.extraArgs);
     await uploadContactForms(environment.extraArgs);
     await uploadCustomTranslations();
@@ -82,6 +94,7 @@ const processAppForm = (eventType, fileName) => {
     let form = uploadForms.formFileMatcher(fileName);
     if (form) {
         eventQueue.enqueue(async () => {
+            await runValidation(validateAppForms, [form]);
             await uploadAppForms([form]);
             return fileName;
         });
@@ -103,6 +116,7 @@ const processAppFormMedia = (formMediaDir, fileName) => {
     const form = uploadForms.formMediaMatcher(formMediaDir);
     if (form) {
         eventQueue.enqueue(async () => {
+            await runValidation(validateAppForms,[form]);
             await uploadAppForms([form]);
             return fileName;
         });
@@ -127,6 +141,7 @@ const processContactForm = (eventType, fileName) => {
     form = uploadForms.formFileMatcher(fileName);
     if (form) {
         eventQueue.enqueue(async () => {
+            await runValidation(validateContactForms,[form]);
             await uploadContactForms([form]);
             return fileName;
         });
@@ -142,6 +157,7 @@ const processCollectForm = (eventType, fileName) => {
     let form = uploadForms.formFileMatcher(fileName);
     if (form) {
         eventQueue.enqueue(async () => {
+            await runValidation(validateCollectForms,[form]);
             await uploadCollectForms([form]);
             return fileName;
         });

package/src/lib/environment.js

@@ -12,7 +12,8 @@ const initialize = (
   extraArgs,
   apiUrl,
   force,
-  skipTranslationCheck
+  skipTranslationCheck,
+  skipValidate
 ) => {
   if (state.initialized) {
     throw Error('environment is already initialized');
@@ -26,7 +27,8 @@ const initialize = (
     isArchiveMode,
     pathToProject,
     force,
-    skipTranslationCheck
+    skipTranslationCheck,
+    skipValidate
   });
 };
 
@@ -51,6 +53,7 @@ module.exports = {
   get apiUrl() { return getState('apiUrl'); },
   get force() { return getState('force'); },
   get skipTranslationCheck() { return getState('skipTranslationCheck'); },
+  get skipValidate() { return getState('skipValidate'); },
 
   /**
    * Return `true` if the environment **seems** to be production.

package/src/lib/forms-utils.js

@@ -1,5 +1,14 @@
+const xpath = require('xpath');
 const fs = require('./sync-fs');
 
+const XPATH_MODEL = '/h:html/h:head/model';
+
+const getNode = (currentNode, path) =>
+  xpath.parse(path).select1({ node: currentNode, allowAnyNamespaceForNoPrefix: true });
+
+const getNodes = (currentNode, path) =>
+  xpath.parse(path).select({ node: currentNode, allowAnyNamespaceForNoPrefix: true });
+
 module.exports = {
   /**
    * Get the full path of the form, or null if the path doesn't exist.
@@ -29,24 +38,53 @@ module.exports = {
     };
   },
 
-  // This isn't really how to parse XML, but we have fairly good control over the
-  // input and this code is working so far.  This may break with changes to the
-  // formatting of output from xls2xform.
+  /**
+   * Returns the node from the form XML specified by the given XPath.
+   * @param {Element} currentNode the current node in the form XML document
+   * @param {string} path the XPath expression
+   * @returns {Element} the selected node or `undefined` if not found
+   */
+  getNode,
+
+  /**
+   * Returns the nodes from the form XML specified by the given XPath.
+   * @param {Element} currentNode the current node in the form XML document
+   * @param {string} path the XPath expression
+   * @returns {Element} the selected nodes or an empty array if none are found
+   */
+  getNodes,
+
+  /**
+   * Returns the `bind` nodes for the given form XML.
+   * @param {Document} xmlDoc the form XML document
+   * @returns {Element}
+   */
+  getBindNodes: xmlDoc => getNodes(xmlDoc, `${XPATH_MODEL}/bind`),
+
+  /**
+   * Returns the primary (first) `instance` node for the given form XML.
+   * @param {Document} xmlDoc the form XML document
+   * @returns {Element}
+   */
+  getPrimaryInstanceNode: xmlDoc => getNode(xmlDoc, `${XPATH_MODEL}/instance`),
 
   /**
    * Check whether the XForm has the <instanceID/> tag.
-   * @param {string} xml the XML string
+   * @param {string} xmlDoc the XML document
    * @returns {boolean}
    */
-  formHasInstanceId: xml => xml.includes('<instanceID/>'),
+  formHasInstanceId: xmlDoc => getNode(xmlDoc, `//meta/instanceID`) !== undefined,
 
+  // This isn't really how to parse XML, but we have fairly good control over the
+  // input and this code is working so far.  This may break with changes to the
+  // formatting of output from xls2xform.
   /**
    * Get the title string inside the <h:title> tag
    * @param {string} xml the XML string
    * @returns {string}
    */
   readTitleFrom: xml =>
-      xml.substring(xml.indexOf('<h:title>') + 9, xml.indexOf('</h:title>')),
+    xml.substring(xml.indexOf('<h:title>') + 9, xml.indexOf('</h:title>')),
 
   /**
    * Get the ID of the form
@@ -54,7 +92,7 @@ module.exports = {
    * @returns {string}
    */
   readIdFrom: xml =>
-      xml.match(/<model>[^]*<\/model>/)[0]
-        .match(/<instance>[^]*<\/instance>/)[0]
-        .match(/id="([^"]*)"/)[1],
+    xml.match(/<model>[^]*<\/model>/)[0]
+      .match(/<instance>[^]*<\/instance>/)[0]
+      .match(/id="([^"]*)"/)[1],
 };

package/src/lib/main.js

@@ -21,6 +21,9 @@ const defaultActions = [
   'convert-app-forms',
   'convert-collect-forms',
   'convert-contact-forms',
+  'validate-app-forms',
+  'validate-collect-forms',
+  'validate-contact-forms',
   'backup-all-forms',
   'delete-all-forms',
   'upload-app-forms',
@@ -38,6 +41,9 @@ const defaultArchiveActions = [
   'convert-app-forms',
   'convert-collect-forms',
   'convert-contact-forms',
+  'validate-app-forms',
+  'validate-collect-forms',
+  'validate-contact-forms',
   'upload-app-forms',
   'upload-collect-forms',
   'upload-contact-forms',
@@ -123,19 +129,40 @@ module.exports = async (argv, env) => {
   // Build up actions
   //
   let actions = cmdArgs._;
-  if (!actions.length) {
+  if (actions.length) {
+    const unsupported = actions.filter(a => !supportedActions.includes(a));
+    if(unsupported.length) {
+      throw new Error(`Unsupported action(s): ${unsupported.join(' ')}`);
+    }
+  } else {
     actions = !cmdArgs.archive ? defaultActions : defaultArchiveActions;
   }
 
-  const unsupported = actions.filter(a => !supportedActions.includes(a));
-  if(unsupported.length) {
-    throw new Error(`Unsupported action(s): ${unsupported.join(' ')}`);
-  }
-
   if (cmdArgs['skip-git-check']) {
     actions = actions.filter(a => a !== 'check-git');
   }
 
+  const skipValidate = cmdArgs['skip-validate'];
+  if(skipValidate) {
+    warn('Skipping all form validation.');
+    const validateActions = [
+      'validate-app-forms',
+      'validate-collect-forms',
+      'validate-contact-forms'
+    ];
+    actions = actions.filter(action => !validateActions.includes(action));
+  } else {
+    const addFormValidationIfNecessary = (formType) => {
+      const updateFormsIndex = actions.indexOf(`upload-${formType}-forms`);
+      if (updateFormsIndex >= 0 && actions.indexOf(`validate-${formType}-forms`) < 0) {
+        actions.splice(updateFormsIndex, 0, `validate-${formType}-forms`);
+      }
+    };
+    addFormValidationIfNecessary('app');
+    addFormValidationIfNecessary('collect');
+    addFormValidationIfNecessary('contact');
+  }
+
   actions = actions.map(actionName => {
     const action = require(`../fn/${actionName}`);
 
@@ -157,9 +184,9 @@ module.exports = async (argv, env) => {
   //
   const projectName = fs.path.basename(pathToProject);
 
-  let apiUrl;
-  if (actions.some(action => action.requiresInstance)) {
-    apiUrl = getApiUrl(cmdArgs, env);
+  const apiUrl = getApiUrl(cmdArgs, env);
+  const requiresInstance = actions.some(action => action.requiresInstance);
+  if (requiresInstance) {
     if (!apiUrl) {
       throw new Error('Failed to obtain a url to the API');
     }
@@ -177,10 +204,11 @@ module.exports = async (argv, env) => {
     extraArgs,
     apiUrl,
     cmdArgs.force,
-    cmdArgs['skip-translation-check']
+    cmdArgs['skip-translation-check'],
+    skipValidate
   );
 
-  if (apiUrl) {
+  if (requiresInstance && apiUrl) {
     await api().available();
   }
 

package/src/lib/upload-forms.js

@@ -13,7 +13,6 @@ const {
   readTitleFrom,
   readIdFrom
 } = require('./forms-utils');
-const validateForms = require('./validate-forms');
 
 const SUPPORTED_PROPERTIES = ['context', 'icon', 'title', 'xml2sms', 'subject_key', 'hidden_fields'];
 const FORM_EXTENSTION = '.xml';
@@ -40,7 +39,6 @@ const formMediaMatcher = (formMediaDir) => {
 };
 
 const execute = async (projectDir, subDirectory, options) => {
-  await validateForms(projectDir, subDirectory, options);
   const db = pouch();
   if (!options) options = {};
   const formsDir = getFormDir(projectDir, subDirectory);

package/src/lib/validate-forms.js

@@ -1,64 +1,84 @@
-const api = require('./api');
+const { DOMParser } = require('@xmldom/xmldom');
 const argsFormFilter = require('./args-form-filter');
+const environment = require('./environment');
 const fs = require('./sync-fs');
 const log = require('./log');
 const {
   getFormDir,
-  getFormFilePaths,
-  formHasInstanceId
+  getFormFilePaths
 } = require('./forms-utils');
 
+const domParser = new DOMParser();
+const VALIDATIONS_PATH = fs.path.resolve(__dirname, './validation/form');
+const validations = fs.readdir(VALIDATIONS_PATH)
+  .filter(name => name.endsWith('.js'))
+  .map(validationName => {
+    const validation = require(fs.path.join(VALIDATIONS_PATH, validationName));
+    validation.name = validationName;
+    if(!Object.hasOwnProperty.call(validation, 'requiresInstance')) {
+      validation.requiresInstance = true;
+    }
+    if(!Object.hasOwnProperty.call(validation, 'skipFurtherValidation')) {
+      validation.skipFurtherValidation = false;
+    }
+
+    return validation;
+  })
+  .sort((a, b) => {
+    if(a.skipFurtherValidation && !b.skipFurtherValidation) {
+      return -1;
+    }
+    if(!a.skipFurtherValidation && b.skipFurtherValidation) {
+      return 1;
+    }
+    return a.name.localeCompare(b.name);
+  });
+
 module.exports = async (projectDir, subDirectory, options={}) => {
 
   const formsDir = getFormDir(projectDir, subDirectory);
   if(!formsDir) {
-    log.info(`Forms dir not found: ${formsDir}`);
+    log.info(`Forms dir not found: ${projectDir}/forms/${subDirectory}`);
     return;
   }
 
-  let idValidationsPassed = true;
-  let validateFormsPassed = true;
+  const instanceProvided = environment.apiUrl;
+  let validationSkipped = false;
 
   const fileNames = argsFormFilter(formsDir, '.xml', options);
-  for (const fileName of fileNames) {
+
+  let errorFound = false;
+  for(const fileName of fileNames) {
     log.info(`Validating form: ${fileName}…`);
 
-    const { xformPath, filePath } = getFormFilePaths(formsDir, fileName);
+    const { xformPath } = getFormFilePaths(formsDir, fileName);
     const xml = fs.read(xformPath);
 
-    if(!formHasInstanceId(xml)) {
-      log.error(`Form at ${xformPath} appears to be missing <meta><instanceID/></meta> node. This form will not work on CHT webapp.`);
-      idValidationsPassed = false;
-      continue;
-    }
-    try {
-      await _formsValidate(xml);
-    } catch (err) {
-      log.error(`Error found while validating "${filePath}". Validation response: ${err.message}`);
-      validateFormsPassed = false;
+    const valParams = { xformPath, xmlStr: xml, xmlDoc: domParser.parseFromString(xml) };
+    for(const validation of validations) {
+      if(validation.requiresInstance && !instanceProvided) {
+        validationSkipped = true;
+        continue;
+      }
+
+      const output = await validation.execute(valParams);
+      if(output.warnings) {
+        output.warnings.forEach(warnMsg => log.warn(warnMsg));
+      }
+      if(output.errors && output.errors.length) {
+        output.errors.forEach(errorMsg => log.error(errorMsg));
+        errorFound = true;
+        if(validation.skipFurtherValidation) {
+          break;
+        }
+      }
     }
   }
-  // Once all the fails were checked raise an exception if there were errors
-  let errors = [];
-  if (!validateFormsPassed) {
-    errors.push('One or more forms appears to have errors found by the API validation endpoint.');
-  }
-  if (!idValidationsPassed) {
-    errors.push('One or more forms appears to be missing <meta><instanceID/></meta> node.');
-  }
-  if (errors.length) {
-    // the blank spaces are a trick to align the errors in the log ;)
-    throw new Error(errors.join('\n             '));
-  }
-};
 
-let validateEndpointNotFoundLogged = false;
-const _formsValidate = async (xml) => {
-  const resp = await api().formsValidate(xml);
-  if (resp.formsValidateEndpointFound === false && !validateEndpointNotFoundLogged) {
-    log.warn('Form validation endpoint not found in your version of CHT Core, ' +
-      'no form will be checked before push');
-    validateEndpointNotFoundLogged = true; // Just log the message once
+  if(validationSkipped) {
+    log.warn('Some validations have been skipped because they require a CHT instance.');
+  }
+  if(errorFound) {
+    throw new Error('One or more forms have failed validation.');
   }
-  return resp;
 };

package/src/lib/validation/form/README.md

@@ -0,0 +1,32 @@
+# Form validations
+
+Form validations should be added to this directory.
+
+Their module should look something like this:
+
+```js
+module.exports = {
+  requiresInstance: false,
+  skipFurtherValidation: true,
+  execute: async ({ xformPath, xmlStr }) => {
+    ...
+  }
+};
+```
+
+## Module Exports
+
+| Field                   | Required                       | Notes                                                                                                                                                                                                                                                        |
+|-------------------------|--------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `requiresInstance`      | Optional, defaults to `true`   | The validation needs the user to have provided a instance location, e.g. via `--local` or `--instance`                                                                                                                                                       |
+| `skipFurtherValidation` | Optional, defaults to `false`  | When `true`, additional validations will not be performed on a form that fails the current validation. The goal is to avoid unnecessary noise in the validation log for forms that are grossly invalid (e.g. XML files that are not actually xForms at all). |
+| `execute`               | Required                       | The function that is run when the validation is executed. The provided input argument contains the form XML string.                                                                                                                                          |
+
+## Result
+
+The result has the following format:
+
+| Field    | Notes                                                                                              |
+|----------|----------------------------------------------------------------------------------------------------|
+| warnings | Array containing the descriptions of any warnings.                                                 |
+| errors   | Array containing the descriptions of any errors. If this is empty, the form has passed validation. |

package/src/lib/validation/form/can-generate-xform.js

@@ -0,0 +1,18 @@
+const api = require('../../api');
+
+module.exports = {
+  execute: async ({ xformPath, xmlStr }) => {
+    const warnings = [];
+    const errors = [];
+    try {
+      const resp = await api().formsValidate(xmlStr);
+      if (resp.formsValidateEndpointFound === false) {
+        warnings.push('Form validation endpoint not found in your version of CHT Core, no form will be checked before push');
+      }
+    } catch (err) {
+      errors.push(`Error found while validating "${xformPath}". Validation response: ${err.message}`);
+    }
+
+    return { errors, warnings };
+  }
+};

package/src/lib/validation/form/check-xpaths-exist.js

@@ -0,0 +1,121 @@
+/*
+An XPath expression that evaluates to an empty result (e.g. no node is found in the document that matches the
+expression) is technically "valid" (in the sense that it is a properly formatted XPath expression).
+
+However, if there is a "simple" XPath expression (one that just references a node via an absolute/relative path and does
+not contain any dynamic processing) in a form that does not evaluate to an actual node in the form, that is almost
+certainly an error (since it could never return any other result). This validation checks the simple XPaths in a form's
+calculate, constraint, readonly, relevant, and required expressions and returns an error for any simple XPaths that
+point to a non-existant node. More complex dynamic XPath expressions are not validated (since their results could vary
+at runtime depending on the data in the form).
+
+https://github.com/medic/cht-conf/issues/479
+*/
+
+const { getNode, getBindNodes, getPrimaryInstanceNode } = require('../../forms-utils');
+
+// Characters used in simple XPaths
+const SUPPORTED_CHAR = '[/\\w.-]';
+// Special characters used in complex XPaths
+const UNSUPPORTED_CHAR = '[*@:[\\]]';
+const XPATH_CHAR = `(${SUPPORTED_CHAR}|${UNSUPPORTED_CHAR})`;
+// Some XPaths lookup nodes in separate instances (e.g. instance('contact-summary')/context/pregnancy_uuid)
+const INSTANCE = `instance\\([\\w-'"]+\\)`;
+// Look ahead and make sure there are an even number of quotes following the match (this means that the match itself is not in quotes).
+const LOOK_AHEADS_FOR_EVEN_QUOTES = `(?=([^"]*"[^"]*")*[^"]*$)(?=([^']*'[^']*')*[^']*$)`;
+// Matches on all possible XPaths (simple and complex) not in quotes. May start with an instance reference. Must include a slash.
+const XPATH_PATTERN = new RegExp(`(${INSTANCE}|)${XPATH_CHAR}*\\/${XPATH_CHAR}+${LOOK_AHEADS_FOR_EVEN_QUOTES}`, 'g');
+// Matches on XPaths containing complex calculations (note that '//' indicates a deep lookup, which we do not validate)
+const UNSUPPORTED_XPATH_PATTERN = new RegExp(`\\/\\/|${UNSUPPORTED_CHAR}|${INSTANCE}`, 'g');
+
+const extractSimpleXpaths = (expression) => {
+  /*
+  "Simple" XPaths look a lot like subsections of complex XPaths. To ensure that we never accidentally extract part of a
+  complex XPath, we first just match on all possible XPaths (simple and complex). Then we do a second pass to filter the
+  list down to just the XPaths that have a supported beginning section (since that is a cheep check). Finally, we filter
+  out any complex XPaths (with unsupported characters).
+   */
+  return (expression.match(XPATH_PATTERN) || [])
+    .filter(xpath => xpath.startsWith('/') || xpath.startsWith('./') || xpath.startsWith('../'))
+    .filter(xpath => !xpath.match(UNSUPPORTED_XPATH_PATTERN));
+};
+
+const isValidXpath = (nodeset, xpathToValidate, instance) => {
+  if(xpathToValidate.startsWith('/')) {
+    // Absolute XPath. Evaluate it relative to the instance
+    return getNode(instance, xpathToValidate.substring(1));
+  }
+  // Relative XPath. Evaluate it relative to the current node
+  const currentNode = getNode(instance, nodeset.substring(1));
+  if(!currentNode) {
+    throw new Error(`Could not find model node referenced by bind nodeset: ${nodeset}`);
+  }
+  return getNode(currentNode, xpathToValidate);
+};
+
+const extractInvalidXPaths = (nodeset, expression, instance) => {
+  return extractSimpleXpaths(expression)
+    .filter(xpath => !isValidXpath(nodeset, xpath, instance));
+};
+
+const getField = (bind, instance) => {
+  const nodeset = bind.getAttribute('nodeset');
+  const getInvalidXPaths = (expression) => extractInvalidXPaths(nodeset, expression, instance);
+  return {
+    nodeset,
+    calculate: getInvalidXPaths(bind.getAttribute('calculate')),
+    constraint: getInvalidXPaths(bind.getAttribute('constraint')),
+    readonly: getInvalidXPaths(bind.getAttribute('readonly')),
+    relevant: getInvalidXPaths(bind.getAttribute('relevant')),
+    required: getInvalidXPaths(bind.getAttribute('required')),
+  };
+};
+
+const keepFieldsWithXPaths = (field) => {
+  return field.calculate.length ||
+    field.constraint.length ||
+    field.readonly.length ||
+    field.relevant.length ||
+    field.required.length;
+};
+
+const getFieldsWithInvalidXPaths = (xmlDoc) => {
+  const instance = getPrimaryInstanceNode(xmlDoc);
+  if(!instance) {
+    throw new Error('No instance found in form XML.');
+  }
+  return getBindNodes(xmlDoc)
+    .map(bind => getField(bind, instance))
+    .filter(field => keepFieldsWithXPaths(field));
+};
+
+module.exports = {
+  requiresInstance: false,
+  skipFurtherValidation: false,
+  execute: async({ xformPath, xmlDoc }) => {
+    const errors = [];
+    try {
+      const fields = getFieldsWithInvalidXPaths(xmlDoc);
+      if(fields.length) {
+        errors.push(`Form at ${xformPath} contains invalid XPath expressions (absolute or relative paths that refer to a non-existant node):`);
+
+        fields.forEach(field => {
+          const recordError = (expressionName) => {
+            const xpaths = field[expressionName];
+            if(xpaths.length) {
+              errors.push(`  - ${expressionName} for ${field.nodeset} contains [${xpaths.join(', ')}]`);
+            }
+          };
+          recordError('calculate');
+          recordError('constraint');
+          recordError('readonly');
+          recordError('relevant');
+          recordError('required');
+        });
+      }
+    } catch(e) {
+      errors.push(`Error encountered while validating XPaths in form at ${xformPath}: ${e.message}`);
+    }
+    return { errors, warnings: [] };
+  }
+};

package/src/lib/validation/form/has-instance-id.js

@@ -0,0 +1,14 @@
+const { formHasInstanceId } = require('../../forms-utils');
+
+module.exports = {
+  requiresInstance: false,
+  skipFurtherValidation: true,
+  execute: async({ xformPath, xmlDoc }) => {
+    const errors = [];
+    if(!formHasInstanceId(xmlDoc)) {
+      errors.push(`Form at ${xformPath} appears to be missing <meta><instanceID/></meta> node. This form will not work on CHT webapp.`);
+    }
+
+    return { errors, warnings: [] };
+  }
+};

package/src/lib/warn-upload-overwrite.js

@@ -8,7 +8,7 @@ const path = require('path');
 const log = require('./log');
 const environment = require('./environment');
 const { compare, GroupingReporter } = require('dom-compare');
-const DOMParser = require('xmldom').DOMParser;
+const DOMParser = require('@xmldom/xmldom').DOMParser;
 
 const question = 'You are trying to modify a configuration that has been modified since your last upload. Do you want to?';
 const responseChoicesWithoutDiff = [