cht-conf 3.12.0 → 3.15.0

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+# [3.15.0](https://github.com/medic/cht-conf/compare/v3.14.0...v3.15.0) (2022-08-19)
+
+
+### Features
+
+* **#500:** Validate deprecated appearances in forms ([#501](https://github.com/medic/cht-conf/issues/501)) ([1e52c0c](https://github.com/medic/cht-conf/commit/1e52c0c769fbd27ee6a764358ef2a0463ae3023f)), closes [#500](https://github.com/medic/cht-conf/issues/500)
+
+# [3.14.0](https://github.com/medic/cht-conf/compare/v3.13.0...v3.14.0) (2022-08-18)
+
+
+### Features
+
+* **#494:** validate notes are not required in forms ([#496](https://github.com/medic/cht-conf/issues/496)) ([a5a8e09](https://github.com/medic/cht-conf/commit/a5a8e096a478373a43e63f0f606a2919bade8982)), closes [#494](https://github.com/medic/cht-conf/issues/494)
+
+# [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)
 
 

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.12.0",
+  "version": "3.15.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/fn/initialise-project-layout.js

@@ -5,10 +5,15 @@ const fs = require('../lib/sync-fs');
 const { info } = require('../lib/log');
 
 const LAYOUT = {
-  'contact-summary.js': '',
+  'contact-summary.templated.js': `module.exports = {
+  fields: [],
+  cards: [],
+  context: {}
+};`,
   'privacy-policies.json': {},
   'privacy-policies': {},
   'resources.json': {},
+  'harness.defaults.json': {},
   resources: {},
   'targets.js': 'module.exports = [];',
   'tasks.js': 'module.exports = [];',
@@ -32,6 +37,12 @@ const LAYOUT = {
     'forms.json': {},
     'schedules.json': [],
   },
+  test: {
+    forms: {},
+    'contact-summary': {},
+    tasks: {},
+    targets: {}
+  }
 };
 
 function createRecursively(dir, layout) {

package/src/fn/upload-custom-translations.js

@@ -2,7 +2,7 @@ const semver = require('semver');
 
 const environment = require('../lib/environment');
 const pouch = require('../lib/db');
-const getApiVersion = require('../lib/get-api-version');
+const { getValidApiVersion } = require('../lib/get-api-version');
 const iso639 = require('iso-639-1');
 const log = require('../lib/log');
 const properties = require('properties');
@@ -168,9 +168,9 @@ function idFor(fileName) {
 }
 
 async function genericTranslationsStructure(db) {
-  const version = await getApiVersion();
+  const version = await getValidApiVersion();
 
-  if (semver.valid(version)) {
+  if (version) {
     return semver.gte(version, '3.4.0');
   }
 

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/get-api-version.js

@@ -1,3 +1,5 @@
+const semver = require('semver');
+
 const api = require('./api');
 const db = require('./db');
 
@@ -15,4 +17,8 @@ const getApiVersion = async () => {
   return version;
 };
 
-module.exports = getApiVersion;
+const getValidApiVersion = async () => {
+  return semver.valid(await getApiVersion());
+};
+
+module.exports = { getValidApiVersion };

package/src/lib/validate-forms.js

@@ -1,4 +1,6 @@
+const { DOMParser } = require('@xmldom/xmldom');
 const argsFormFilter = require('./args-form-filter');
+const { getValidApiVersion } = require('./get-api-version');
 const environment = require('./environment');
 const fs = require('./sync-fs');
 const log = require('./log');
@@ -7,6 +9,7 @@ const {
   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'))
@@ -41,6 +44,7 @@ module.exports = async (projectDir, subDirectory, options={}) => {
   }
 
   const instanceProvided = environment.apiUrl;
+  const apiVersion = instanceProvided ? await getValidApiVersion() : null;
   let validationSkipped = false;
 
   const fileNames = argsFormFilter(formsDir, '.xml', options);
@@ -52,7 +56,12 @@ module.exports = async (projectDir, subDirectory, options={}) => {
     const { xformPath } = getFormFilePaths(formsDir, fileName);
     const xml = fs.read(xformPath);
 
-    const valParams = { xformPath, xmlStr: xml };
+    const valParams = {
+      xformPath,
+      xmlStr: xml,
+      xmlDoc: domParser.parseFromString(xml),
+      apiVersion,
+    };
     for(const validation of validations) {
       if(validation.requiresInstance && !instanceProvided) {
         validationSkipped = true;

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

@@ -8,7 +8,7 @@ Their module should look something like this:
 module.exports = {
   requiresInstance: false,
   skipFurtherValidation: true,
-  execute: async ({ xformPath, xmlStr }) => {
+  execute: async ({ xformPath, xmlStr, xmlDoc, apiVersion }) => {
     ...
   }
 };
@@ -16,11 +16,11 @@ module.exports = {
 
 ## 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.                                                                                                                                          |
+| 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(opts)`         | Required                       | The function that is run when the validation is executed. The available ops are:<br>* `xformPath` - the file path to the form<br>* `xmlStr` - string value of the form XML<br>* `xmlDoc` - Document value of the form XML<br>* `apiVersion` - the version of the CHT instance (if connection information was provided) or `null`  |
 
 ## Result
 

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/deprecated-appearance.js

@@ -0,0 +1,87 @@
+const semver = require('semver');
+const { getNodes } = require('../../forms-utils');
+
+// Based on https://forum.getodk.org/t/spec-proposal-harmonize-compact-compact-n-horizontal-horizontal-compact-appearances/15565/32
+// Note the order of evaluation is important
+const getDeprecatedAppearances = (apiVersion) => [
+  {
+    match: appearance => appearance.match(/(?:^|\s)horizontal-compact(?:$|\s)/),
+    getReplacement: () => 'columns-pack',
+    versionDeprecated: '4.0.0'
+  },
+  {
+    match: appearance => appearance.match(/(?:^|\s)horizontal(?:$|\s)/),
+    getReplacement: () => 'columns',
+    versionDeprecated: '4.0.0'
+  },
+  {
+    match: appearance => appearance.match(/(?:^|\s)compact-(\d{1,2})(?:$|\s)/),
+    getReplacement: (match) => `columns-${match[1].trim()} no-buttons`,
+    versionDeprecated: '4.0.0'
+  },
+  {
+    match: appearance => appearance.match(/(?:^|\s)compact(?:$|\s)/),
+    getReplacement: () => 'columns-pack no-buttons',
+    versionDeprecated: '4.0.0'
+  },
+].filter(deprecatedAppearance => semver.gte(apiVersion, deprecatedAppearance.versionDeprecated));
+
+const getElementsWithAppearance = (xmlDoc) => getNodes(xmlDoc, '/h:html/h:body//*[@appearance]');
+
+const unpackDeprecationAttributes = element => ({
+  ref: element.getAttribute('ref'),
+  appearance: element.getAttribute('appearance'),
+});
+
+const hasAppearance = ({ appearance }) => appearance;
+
+const populateDeprecatedAppearance = deprecatedAppearances => ({ ref, appearance }) => ({
+  ref,
+  appearance,
+  // Only warning for the first deprecated appearance found for an element. This seems acceptable.
+  deprecatedAppearance: deprecatedAppearances.find(depAppearance => depAppearance.match(appearance))
+});
+
+const hasDeprecatedAppearance = ({ deprecatedAppearance }) => deprecatedAppearance;
+
+const createWarning = ({ ref, appearance, deprecatedAppearance }) => {
+  const match = deprecatedAppearance.match(appearance);
+  const originalAppearance = match[0].trim();
+  const newAppearance = deprecatedAppearance.getReplacement(match);
+  return `  - ${ref}: replace [${originalAppearance}] with [${newAppearance}]`;
+};
+
+const populateWarningHeader = (xformPath, warnings) => {
+  if (warnings.length) {
+    warnings.unshift(`Form at ${xformPath} contains fields with the deprecated \`horizontal\`/\`compact\` appearance. ` +
+      'These have been deprecated in favor of the `columns` appearance. Please update the following fields:');
+  }
+};
+
+const validateDeprecatedAppearances = async({ xformPath, xmlDoc, apiVersion }) => {
+  if (!apiVersion) {
+    return { warnings: [], errors: [], };
+  }
+
+  const deprecatedAppearances = getDeprecatedAppearances(apiVersion);
+  if (!deprecatedAppearances.length) {
+    return { warnings: [], errors: [], };
+  }
+
+  const warnings = getElementsWithAppearance(xmlDoc)
+    .map(unpackDeprecationAttributes)
+    .filter(hasAppearance)
+    .map(populateDeprecatedAppearance(deprecatedAppearances))
+    .filter(hasDeprecatedAppearance)
+    .map(createWarning);
+
+  populateWarningHeader(xformPath, warnings);
+
+  return { errors: [], warnings };
+};
+
+module.exports = {
+  requiresInstance: true,
+  skipFurtherValidation: false,
+  execute: validateDeprecatedAppearances
+};

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

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

package/src/lib/validation/form/no-required-notes.js

@@ -0,0 +1,23 @@
+const { getBindNodes } = require('../../forms-utils');
+
+module.exports = {
+  requiresInstance: false,
+  skipFurtherValidation: false,
+  execute: async({ xformPath, xmlDoc }) => {
+    const errors = [];
+
+    const requiredNotes = getBindNodes(xmlDoc)
+      .filter(bind => bind.getAttribute('readonly') === 'true()') // Notes will not be conditionally readonly
+      .filter(bind => {
+        const required = bind.getAttribute('required');
+        return required && required !== 'false()';
+      })
+      .filter(bind => bind.getAttribute('type') === 'string')
+      .filter(bind => !bind.getAttribute('calculate'))
+      .map(bind => bind.getAttribute('nodeset'));
+    if(requiredNotes.length) {
+      errors.push(`Form at ${xformPath} contains the following note fields with 'required' expressions: [${requiredNotes.join(', ')}]`);
+    }
+    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 = [