apn-app-manager 1.1.0 → 1.2.0-beta.2

package/README.md

@@ -2,6 +2,8 @@
 
 `apn-app-manager` is a command line tool for managing Appian applications.
 
+Test beta version
+
 ## Why?
 
 When app building you may want to do things in bulk that are easiest to do via an application's exported XML files and a re-import. This tool helps to automate some of those tasks.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apn-app-manager",
-  "version": "1.1.0",
+  "version": "1.2.0-beta.2",
   "description": "Appian App Manager",
   "license": "Apache-2.0",
   "preferGlobal": true,

package/src/actions/cloneAction.js

@@ -2,6 +2,7 @@ module.exports.main = main;
 
 // Dependency imports
 const path = require("path");
+const lodash = require("lodash");
 
 // Custom imports
 const util = require("../util");
@@ -14,62 +15,106 @@ const obMapsUpdates = require("../handlers/objectMapsUpdateHandler");
 const obModify = require("../handlers/objectModifyHandler");
 
 // Entry-point
-function main(curNamespace, newNamespace, callback) {
+function main(callback) {
   util.delFile(cons.outDir);
   fileSelect.getAppPackage(function (appZipPath) {
     util.unzipDir(appZipPath, cons.tempDir);
     fileSelect.selectSingleFile("Select import customization properties file", ["properties"], true, function (icfPath) {
-      promptNamespace("What is your current namespace?", function (curNamespace) {
-        promptNamespace("What is your new namespace?", function (newNamespace) {
-          executeClone(curNamespace, newNamespace, appZipPath, icfPath, callback);
-        });
-      });
+      executeClone(appZipPath, icfPath, callback);
     });
   });
 }
 
 // Executes all the steps of the clone
-function executeClone(curNamespace, newNamespace, appZipPath, icfPath, callback) {
-  const appName = path.basename(appZipPath, ".zip");
-  util.print(`\nCloning '${appName}' to namespace '${newNamespace}'`);
-
+function executeClone(appZipPath, icfPath, callback) {
   // Initialize variables based on the new namespace
-  const outZipPath = path.resolve(cons.outDir, `${newNamespace} - ${appName}.zip`);
+  const outZipPath = path.resolve(cons.outDir, path.basename(appZipPath));
   const outIcfPath = icfPath ? path.resolve(cons.outDir, path.basename(icfPath)) : null;
 
-  // Extract the name, uuid, etc. from each object file
+  // Extract the metadata including the namespace from each object file
   const objectMaps = {};
   const uuidCollector = { uuids: [] };
-  obExtract.buildObjectMaps(objectMaps, uuidCollector, cons.tempDir, obProps.usageTypes.CLONE);
-
-  // Update the object maps we are cloning based on the application prefix
-  obMapsUpdates.renameObjectMaps(objectMaps, uuidCollector, curNamespace, newNamespace, obProps.usageTypes.CLONE);
-
-  // These output files are helpful for debugging
-  util.writeJson(path.resolve(cons.outDir, `objects.json`), objectMaps);
-  util.writeJson(path.resolve(cons.outDir, `not-cloned-uuids.json`), uuidCollector);
-
-  // Modify the underlying object XML files
-  obModify.modifyObjectFiles(cons.tempDir, objectMaps, obProps.usageTypes.CLONE, []);
-
-  // Modify the ICF file
-  obModify.modifySingleFile(icfPath, outIcfPath, objectMaps, obProps.usageTypes.CLONE, []);
+  const namespaceCollector = {};
+  util.print(`Collecting all metadata from the objects...`);
+  obExtract.buildObjectMaps(objectMaps, uuidCollector, namespaceCollector, cons.tempDir, obProps.usageTypes.CLONE);
 
-  // Print warnings and output
-  if (uuidCollector["uuids"].length > 0) {
+  // Have the user map each namespace to its proper behavior
+  mapNamespaces(namespaceCollector, function onComplete() {
     util.printGap();
-    util.printWarning(
-      `WARNING: ${uuidCollector["uuids"].length} uuids were found in your zip but not parsed via cloning (see output file 'not-cloned-uuids.json'). Check the count of missing precedents from your app package in your source environment. If it is ${uuidCollector["uuids"].length} objects, then those are likely just the missing precedents, otherwise please reach out to the authors of this tool, since the XML structure of Appian objects has probably changed and this tool needs to be updated.`
-    );
-  }
-  util.print(`\nCloning of '${appName}' to namespace '${newNamespace}' complete`);
+    // Update the object maps we are cloning based on the application prefix
+    util.print(`Cloning the objects files...`);
+    obMapsUpdates.renameObjectMaps(objectMaps, uuidCollector, namespaceCollector, obProps.usageTypes.CLONE);
+
+    // These output files are helpful for debugging
+    util.writeJson(path.resolve(cons.outDir, `objects.json`), objectMaps);
+    util.writeJson(path.resolve(cons.outDir, `not-cloned-uuids.json`), uuidCollector);
+    util.writeJson(path.resolve(cons.outDir, `namespaces.json`), namespaceCollector);
+
+    // Modify the underlying object XML files & zip the package
+    obModify.modifyObjectFiles(cons.tempDir, objectMaps, obProps.usageTypes.CLONE, []);
+    util.zipDir(cons.tempDir, outZipPath, false);
+    obModify.renameSingleFile(outZipPath, objectMaps, obProps.usageTypes.CLONE, []);
+
+    // Modify the ICF file
+    obModify.modifySingleFile(icfPath, outIcfPath, objectMaps, obProps.usageTypes.CLONE, []);
+
+    // Print warnings and output
+    if (uuidCollector["uuids"].length > 0) {
+      util.printGap();
+      util.printWarning(
+        `WARNING: ${uuidCollector["uuids"].length} uuids were found in your zip but not parsed via cloning (see output file 'not-cloned-uuids.json'). Check the count of missing precedents from your app package in your source environment. If it is ${uuidCollector["uuids"].length} objects, then those are likely just the missing precedents, otherwise please reach out to the authors of this tool, since the XML structure of Appian objects has probably changed and this tool needs to be updated.`
+      );
+    }
+    util.printGap();
+    util.print(`Cloning complete. Output can be found in the '/out/' folder (${path.resolve(cons.outDir)}).`);
 
-  // Zip the package and log the output path
-  util.zipDir(cons.tempDir, outZipPath, false);
-  util.print(`Output can be found in the '/out/' folder (${path.resolve(cons.outDir)})`);
+    // Execute callback if passed
+    util.execCallback(callback, outZipPath);
+  });
+}
 
-  // Execute callback if passed
-  util.execCallback(callback, outZipPath);
+// Prompts the user to select a namespace
+function mapNamespaces(namespaceCollector, onComplete) {
+  let namespacesToChooseFrom = lodash.filter(obExtract.sortNamespaces(namespaceCollector), function (namespace) {
+    return namespaceCollector[namespace]["newNamespace"] == null;
+  });
+  let isFirstIteration = namespacesToChooseFrom.length == Object.keys(namespaceCollector).length;
+  if (namespacesToChooseFrom.length > 0) {
+    let message;
+    if (isFirstIteration) {
+      message = `After analyzing the objects, ${
+        Object.keys(namespaceCollector).length
+      } potential unique namespaces were found. For each namespace, select what behavior you would like (clone or keep as-is). There may be overlap with sub-prefixes, in which case selecting a shorter namespace that matches ones with more prefixes will result in that behavior applying to all longer matching namespaces. For objects without a namespace, a prefix will automatically be added if they will be cloned. All namespaces with more than 1 prefix are represented with '_' delimiters, although the proper delimiter will automatically be determined by the object type.`;
+    } else {
+      message = `Select another namespace`;
+    }
+    prompt.promptList(message, namespacesToChooseFrom, function (answer) {
+      let chosenNamespace = answer;
+      promptNamespace(
+        `Namespace: ${chosenNamespace}. Enter a new namespace to clone these objects. Enter nothing to keep them as-is.`,
+        function (answer) {
+          Object.keys(namespaceCollector).forEach(namespace => {
+            if (namespaceCollector[namespace]["newNamespace"] == null) {
+              if (namespace.startsWith(chosenNamespace)) {
+                if (namespace == chosenNamespace) {
+                  namespaceCollector[namespace]["newNamespace"] = answer;
+                } else {
+                  delete namespaceCollector[namespace];
+                }
+              }
+            }
+          });
+          mapNamespaces(namespaceCollector, onComplete);
+        }
+      );
+    });
+  } else {
+    util.print(`All namespaces accounted for. See details below.`);
+    obExtract.sortNamespaces(namespaceCollector).forEach(namespace => {
+      util.print(`   ${namespace} -> ${util.replaceBlank(namespaceCollector[namespace]["newNamespace"], `Will not clone`)}`, true);
+    });
+    onComplete();
+  }
 }
 
 // Prompts the user for a namespace
@@ -79,15 +124,6 @@ function promptNamespace(message, onAnswer) {
   });
 }
 
-// Returns the module properties
-function getModuleProps() {
-  if (util.fileExists(cons.modulePropsPath)) {
-    return util.readJson(cons.modulePropsPath);
-  } else {
-    return null;
-  }
-}
-
 // Utility function to differenciate between debug logging and real logging
 function debug(input) {
   console.log(input);

package/src/cons.js

@@ -33,6 +33,9 @@ module.exports = {
   //  -- rather than an UUID that is a reference, or connected system third-party id, or just referenced in a code block, or commented out
   uuidRegex: /(?<=>|")[A-Za-z0-9-_]{10,}[0-9][A-Za-z0-9-_]{1,}-[A-Za-z0-9-_]{10,}(?=<|")/g,
 
+  noNamespace: "Objects with no found namespace",
+  namespaceDelimiterRegex: "[:|_| |\\.|-]",
+
   xmlEscapedChars: [
     {
       from: `&`,
@@ -40,7 +43,5 @@ module.exports = {
     },
   ],
 
-  namespaceDelimiterRegexString: "([:|_| |\\.|-]?)",
-
   appianUrlRegex: /^https:\/\/.*\/suite/g,
 };

package/src/handlers/objectExtractHandler.js

@@ -6,20 +6,21 @@ const path = require("path");
 const util = require("../util");
 const cons = require("../cons");
 const obProps = require("../objectProps");
+const { split } = require("lodash");
 
 // Exports
 module.exports = {
   // Builds the objectMaps object from the application
-  buildObjectMaps: function (objectMaps, uuidCollector, appDir, usageType) {
+  buildObjectMaps: function (objectMaps, uuidCollector, namespaceCollector, appDir, usageType) {
     let fileCount = { count: 0 };
     initObjectMaps(objectMaps);
     // Extract the name, uuid, etc. from each object file
     util.handleDirFiles(appDir, ["xml", "xsd"], 2, 2, function (obPath) {
-      extractObProps(objectMaps, uuidCollector, fileCount, obPath, usageType);
+      extractObProps(objectMaps, uuidCollector, namespaceCollector, fileCount, obPath, usageType);
     });
     // Set the datatype UUIDs from their name & namespace
     updateDatatypeUuids(objectMaps);
-    util.print(`${retriveObjectMapCount(objectMaps)} of ${fileCount.count} object files mapped`);
+    util.print(`${retrieveObjectMapCount(objectMaps)} of ${fileCount.count} object files collected`);
   },
 
   // Sets the datatype UUIDs from their name & namespace
@@ -28,7 +29,17 @@ module.exports = {
   },
 
   // Returns the count of all objects in the objectMap
-  retriveObjectMapCount: retriveObjectMapCount,
+  retrieveObjectMapCount: retrieveObjectMapCount,
+
+  // Sorts the namespaces by their relative lengths
+  sortNamespaces: function (namespaceCollector) {
+    return lodash.flatten([
+      Object.keys(namespaceCollector).indexOf(cons.noNamespace) >= 0 ? cons.noNamespace : [],
+      lodash.sortBy(lodash.difference(Object.keys(namespaceCollector), [cons.noNamespace]).sort(), function (namespace) {
+        return namespace.split("_").length;
+      }),
+    ]);
+  },
 };
 
 // ---------------------------------------------------
@@ -43,7 +54,7 @@ function initObjectMaps(objectMaps) {
 }
 
 // Extracts the name, uuid, etc. from a single object file
-function extractObProps(objectMaps, uuidCollector, fileCount, obPath, usageType) {
+function extractObProps(objectMaps, uuidCollector, namespaceCollector, fileCount, obPath, usageType) {
   fileCount.count = fileCount.count + 1;
   const obType = util.getFolderName(obPath);
   let isParsed = false;
@@ -56,20 +67,28 @@ function extractObProps(objectMaps, uuidCollector, fileCount, obPath, usageType)
       // Collect all uuids from the file content
       uuidCollector["uuids"] = lodash.union(uuidCollector["uuids"], util.regexMatches(fileContent, cons.uuidRegex));
 
+      // Collect all metadata from the object
       const builder = {};
       haulType.fields.forEach(haulField => {
         if (lodash.includes(haulField.usage, usageType)) {
           const xpath = util.replaceKeys(haulField.xpath, { "{OBTYPE}": obType });
           let result = util.xpath(xpath, fileContent, haulField.isArray, obProps.xmlNamespaces);
           if (!util.isBlank(haulField.extractRegex) && !util.isBlank(result)) {
-            let matches = result.match(haulField.extractRegex);
-            result = !util.isBlank(matches) ? matches[0] : "";
+            result = util.firstMatch(result, haulField.extractRegex, "");
           }
           builder[haulField.fieldName] = result;
         }
       });
-      objectMaps[haulType.haulName].push({ current: builder });
 
+      // Get the namespace of the object
+      let objectName = builder[obProps.fieldNames.NAME];
+      let objectNamespace = extractObjectNamespace(objectName);
+      if (Object.keys(namespaceCollector).indexOf(objectNamespace) == -1) {
+        namespaceCollector[objectNamespace] = { newNamespace: null };
+      }
+
+      // Set the object metadata in the objectMaps
+      objectMaps[haulType.haulName].push({ current: builder });
       isParsed = true;
     }
   });
@@ -85,7 +104,8 @@ function updateDatatypeUuids(objectMaps) {
   obProps.haulTypes.forEach(haulType => {
     if (lodash.includes(haulType.obs, obProps.obTypes.DATATYPE)) {
       objectMaps[haulType.haulName].forEach(function (objectMap, objectMapIndex) {
-        Object.keys(objectMap).forEach(key => {
+        let keysToProcess = lodash.intersection(["current", "new"], Object.keys(objectMap));
+        keysToProcess.forEach(key => {
           const cdtUuid = util.buildCdtUuid(objectMap[key][obProps.fieldNames.CDT_NAMESPACE], objectMap[key][obProps.fieldNames.NAME]);
           objectMaps[haulType.haulName][objectMapIndex][key][obProps.fieldNames.UUID] = cdtUuid;
           objectMaps[haulType.haulName][objectMapIndex][key][obProps.fieldNames.CDT_UUID_ENCODED] = util.encodeCdtUuid(cdtUuid);
@@ -96,7 +116,7 @@ function updateDatatypeUuids(objectMaps) {
 }
 
 // Returns the count of all objects in the objectMap
-function retriveObjectMapCount(objectMaps) {
+function retrieveObjectMapCount(objectMaps) {
   let count = 0;
   Object.keys(objectMaps).forEach(key => {
     count = count + objectMaps[key].length;
@@ -104,6 +124,18 @@ function retriveObjectMapCount(objectMaps) {
   return count;
 }
 
+// Returns the namespace from an object name
+function extractObjectNamespace(objectName) {
+  // See regex here with test cases: https://regexr.com/6trnd
+  let namespaceRegex = new RegExp(`^(?:[A-Z0-9]*${cons.namespaceDelimiterRegex}?){0,3}(?=${cons.namespaceDelimiterRegex})`, "g");
+  let namespaceMatch = util.firstMatch(objectName, namespaceRegex, null);
+  if (namespaceMatch) {
+    return namespaceMatch.replace(new RegExp(cons.namespaceDelimiterRegex, "g"), "_");
+  } else {
+    return cons.noNamespace;
+  }
+}
+
 // Utility function to differenciate between debug logging and real logging
 function debug(input) {
   console.log(input);

package/src/handlers/objectMapsUpdateHandler.js

@@ -11,9 +11,9 @@ const { remove } = require("fs-extra");
 // Exports
 module.exports = {
   // Goes through all of the objectMaps and creates new name, uuid, etc.
-  renameObjectMaps: function (objectMaps, uuidCollector, curNamespace, newNamespace, usageType) {
+  renameObjectMaps: function (objectMaps, uuidCollector, namespaceCollector, usageType) {
     // Update all objectMaps with new names
-    renameObjectMaps(objectMaps, uuidCollector, curNamespace, newNamespace, usageType);
+    renameObjectMaps(objectMaps, uuidCollector, namespaceCollector, usageType);
   },
 };
 
@@ -22,27 +22,41 @@ module.exports = {
 // ---------------------------------------------------
 
 // Goes through all of the objectMaps and creates new name, uuid, etc.
-function renameObjectMaps(objectMaps, uuidCollector, curNamespace, newNamespace, usageType) {
+function renameObjectMaps(objectMaps, uuidCollector, namespaceCollector, usageType) {
   obProps.haulTypes.forEach(haulType => {
     objectMaps[haulType.haulName].forEach(function (objectMap, objectMapIndex) {
-      objectMaps[haulType.haulName][objectMapIndex] = { current: objectMap["current"], new: {} };
-      haulType.fields.forEach(haulField => {
-        if (lodash.includes(haulField.usage, usageType)) {
-          let newValue;
-          let curValue = objectMap["current"][haulField.fieldName];
-          removeFoundUuids(uuidCollector, haulField, curValue);
-          if (haulField.isArray) {
-            let newValueArray = [];
-            curValue.forEach(curValueIter => {
-              newValueArray.push(renameObjectProp(curValueIter, haulField, curNamespace, newNamespace));
-            });
-            newValue = newValueArray;
-          } else {
-            newValue = renameObjectProp(curValue, haulField, curNamespace, newNamespace);
+      let curNamespaceForObject = findNamespaceForObject(objectMap["current"][obProps.fieldNames.NAME], namespaceCollector);
+      let newNamespaceForObject = namespaceCollector[curNamespaceForObject]["newNamespace"];
+      if (util.isBlank(newNamespaceForObject)) {
+        // Object will not be cloned
+        objectMaps[haulType.haulName][objectMapIndex]["new"] = objectMap["current"];
+        haulType.fields.forEach(haulField => {
+          if (lodash.includes(haulField.usage, usageType)) {
+            let curValue = objectMap["current"][haulField.fieldName];
+            removeFoundUuids(uuidCollector, haulField, curValue);
           }
-          objectMaps[haulType.haulName][objectMapIndex]["new"][haulField.fieldName] = newValue;
-        }
-      });
+        });
+      } else {
+        // Object will be cloned
+        objectMaps[haulType.haulName][objectMapIndex]["new"] = {};
+        haulType.fields.forEach(haulField => {
+          if (lodash.includes(haulField.usage, usageType)) {
+            let newValue;
+            let curValue = objectMap["current"][haulField.fieldName];
+            removeFoundUuids(uuidCollector, haulField, curValue);
+            if (haulField.isArray) {
+              let newValueArray = [];
+              curValue.forEach(curValueIter => {
+                newValueArray.push(renameObjectProp(curValueIter, haulField, curNamespaceForObject, newNamespaceForObject));
+              });
+              newValue = newValueArray;
+            } else {
+              newValue = renameObjectProp(curValue, haulField, curNamespaceForObject, newNamespaceForObject);
+            }
+            objectMaps[haulType.haulName][objectMapIndex]["new"][haulField.fieldName] = newValue;
+          }
+        });
+      }
     });
   });
   // Set UUIDs on the Datatypes
@@ -54,13 +68,23 @@ function renameObjectProp(curVal, haulField, curNamespace, newNamespace) {
   if (util.isBlank(curVal)) {
     return "";
   } else {
-    let replacementRegexMap = util.buildNamespaceReplacementRegex(curNamespace, newNamespace, "gi");
+    let replacementRegexMap = buildNamespaceReplacementRegex(curNamespace, newNamespace, "gi");
+    let nampespaceReplacement;
     switch (haulField.type) {
+      // UUIDs - just append the new namespace
       case obProps.propTypes.UUID:
         return `${curVal}-${util.toLower(newNamespace)}`;
+      // URL_STUBs - attempt a replacement, but fall back to prefixing if unchanged to ensure they are unique
       case obProps.propTypes.URL_STUB:
         nampespaceReplacement = curVal.replace(replacementRegexMap.from, util.toLower(replacementRegexMap.to));
         return nampespaceReplacement != curVal ? nampespaceReplacement : `${util.toLower(newNamespace)}-${nampespaceReplacement}`;
+      // NAMEs - attempt a replacement, but fall back to prefixing if unchanged to ensure they are unique
+      case obProps.propTypes.NAME:
+        nampespaceReplacement = curVal.replace(replacementRegexMap.from, replacementRegexMap.to);
+        return nampespaceReplacement != curVal
+          ? nampespaceReplacement
+          : `${newNamespace}${util.firstMatch(curVal, new RegExp(cons.namespaceDelimiterRegex, "g"), "_")}${nampespaceReplacement}`;
+      // TEXTs - just do a replacement, they do not need to be unique
       case obProps.propTypes.TEXT:
         return curVal.replace(replacementRegexMap.from, replacementRegexMap.to);
     }
@@ -74,6 +98,46 @@ function removeFoundUuids(uuidCollector, haulField, uuids) {
   }
 }
 
+// Creates the regex replacement for a namespace
+function buildNamespaceReplacementRegex(curNamespace, newNamespace, regexTags) {
+  if (curNamespace == cons.noNamespace) {
+    return { from: "", to: "" };
+  } else {
+    // See regex examples here:
+    // 1 prefix -> 1 prefix: regexr.com/6t509
+    // 1 prefix -> 2 prefix: regexr.com/6t50f
+    // 1 prefix -> 3 prefix: regexr.com/6t50i
+    // 2 prefix -> 1 prefix: regexr.com/6t50u
+    // 2 prefix -> 2 prefix: regexr.com/6t511
+    // 2 prefix -> 3 prefix: regexr.com/6t514
+    // 3 prefix -> 1 prefix: regexr.com/6t51d
+    // 3 prefix -> 2 prefix: regexr.com/6t51j
+    // 3 prefix -> 3 prefix: regexr.com/6t51p
+
+    let namespaceDelimiterRegexStringGrouped = `(${cons.namespaceDelimiterRegex}?)`;
+    let findRegex = new RegExp(
+      namespaceDelimiterRegexStringGrouped +
+        curNamespace.split("_").join(namespaceDelimiterRegexStringGrouped) +
+        namespaceDelimiterRegexStringGrouped,
+      regexTags
+    );
+    let curNamespaceLevelCount = curNamespace.split("_").length;
+    let replaceStringGroupDelim = curNamespaceLevelCount == 1 ? "$1$2" : "$2";
+    let replaceString = "$1" + newNamespace.split("_").join(replaceStringGroupDelim) + "$" + (curNamespaceLevelCount + 1);
+    return { from: findRegex, to: replaceString };
+  }
+}
+
+// Returns the namespace for an object
+function findNamespaceForObject(objectName, namespaceCollector) {
+  for (const namespace of obExtract.sortNamespaces(namespaceCollector).reverse()) {
+    if (objectName.replace(new RegExp(cons.namespaceDelimiterRegex, "g"), "_").startsWith(namespace)) {
+      return namespace;
+    }
+  }
+  return cons.noNamespace;
+}
+
 // Utility function to differenciate between debug logging and real logging
 function debug(input) {
   console.log(input);

package/src/handlers/objectModifyHandler.js

@@ -9,13 +9,13 @@ const obProps = require("../objectProps");
 const obExtract = require("../handlers/objectExtractHandler");
 const { fstat } = require("fs");
 
+// Global variables
+const progressToShow = [0.05, 0.25, 0.5, 0.75, 0.95];
+
 // Exports
 module.exports = {
   // Actually modifies all of the objects based on the objectMaps
-  modifyObjectFiles: function (appDir, objectMaps, usageType, additionalReplacementMaps) {
-    // Modify the object files
-    modifyObjectFiles(appDir, objectMaps, usageType, additionalReplacementMaps);
-  },
+  modifyObjectFiles: modifyObjectFiles,
 
   // Modify a single file
   modifySingleFile: function (filePath, outPath, objectMaps, usageType, additionalReplacementMaps) {
@@ -28,6 +28,16 @@ module.exports = {
       modifyObjectFile(replacementMaps, null, outPath, false);
     }
   },
+
+  // Renames a single file
+  renameSingleFile: function (filePath, objectMaps, usageType, additionalReplacementMaps) {
+    if (filePath) {
+      // Convert the extracted names & uuids to a flat replacement array
+      let replacementMaps = buildReplacementMaps(objectMaps, usageType, additionalReplacementMaps);
+      // Actually modify the file
+      renameObjectFile(replacementMaps, filePath);
+    }
+  },
 };
 
 // ---------------------------------------------------
@@ -39,7 +49,11 @@ function modifyObjectFiles(appDir, objectMaps, usageType, additionalReplacementM
   // Convert the extracted names & uuids to a flat replacement array
   let replacementMaps = buildReplacementMaps(objectMaps, usageType, additionalReplacementMaps);
   // Replace all object files with the new names & uuids
-  let fileCount = { count: 0 };
+  let fileCount = {
+    count: 0,
+    total: obExtract.retrieveObjectMapCount(objectMaps),
+    nextProgress: progressToShow[0],
+  };
   util.handleDirFiles(appDir, ["xml", "xsd", "properties"], 3, 2, function (obPath) {
     modifyObjectFile(replacementMaps, fileCount, obPath, true);
   });
@@ -76,9 +90,6 @@ function buildReplacementMaps(objectMaps, usageType, additionalReplacementMaps)
     });
   });
   replacementMaps = lodash.compact(replacementMaps);
-  replacementMaps = lodash.filter(replacementMaps, function (replacementMap) {
-    return !(replacementMap.from == replacementMap.to);
-  });
   if (!util.isBlank(additionalReplacementMaps)) {
     additionalReplacementMaps.forEach(map => {
       replacementMaps.push(map);
@@ -111,7 +122,10 @@ function modifyObjectFile(replacementMaps, fileCount, obPath, trackProgress) {
   renameObjectFile(replacementMaps, obPath);
   if (trackProgress) {
     fileCount.count = fileCount.count + 1;
-    util.print(`${fileCount.count} object files cloned`, true);
+    if (fileCount.count / fileCount.total > fileCount.nextProgress) {
+      util.print(`${fileCount.nextProgress * 100}% complete`, true);
+      fileCount.nextProgress = progressToShow[progressToShow.indexOf(fileCount.nextProgress) + 1];
+    }
   }
 }
 

package/src/objectProps.js

@@ -3,6 +3,7 @@
 // ---------------------------------------------------
 
 const propTypes = {
+  NAME: "NAME",
   UUID: "UUID",
   TEXT: "TEXT",
   URL_STUB: "URL_STUB",
@@ -84,7 +85,7 @@ const haulTypes = [
       {
         fieldName: fieldNames.NAME,
         xpath: `xsd:schema/xsd:complexType/@name`,
-        type: propTypes.TEXT,
+        type: propTypes.NAME,
         usage: [usageTypes.CLONE, usageTypes.BUILD, usageTypes.RENAME],
       },
       {
@@ -135,7 +136,7 @@ const haulTypes = [
       {
         fieldName: fieldNames.NAME,
         xpath: `dataStoreHaul/*[contains(name(), '')]/name/node()`,
-        type: propTypes.TEXT,
+        type: propTypes.NAME,
         usage: [usageTypes.CLONE, usageTypes.BUILD, usageTypes.RENAME],
       },
       {
@@ -187,7 +188,7 @@ const haulTypes = [
       {
         fieldName: fieldNames.NAME,
         xpath: `processModelHaul/*[local-name()='process_model_port']/*[local-name()='pm']/*[local-name()='meta']/*[local-name()='name']/*[local-name()='string-map']/*[local-name()='pair']/*[local-name()='value']/node()`,
-        type: propTypes.TEXT,
+        type: propTypes.NAME,
         usage: [usageTypes.CLONE, usageTypes.BUILD, usageTypes.RENAME],
       },
       {
@@ -239,7 +240,7 @@ const haulTypes = [
       {
         fieldName: fieldNames.NAME,
         xpath: `recordTypeHaul/recordType/@name`,
-        type: propTypes.TEXT,
+        type: propTypes.NAME,
         usage: [usageTypes.CLONE, usageTypes.BUILD, usageTypes.RENAME],
       },
       {
@@ -346,7 +347,7 @@ const haulTypes = [
       {
         fieldName: fieldNames.NAME,
         xpath: `applicationHaul/application/name/node()`,
-        type: propTypes.TEXT,
+        type: propTypes.NAME,
         usage: [usageTypes.CLONE, usageTypes.BUILD, usageTypes.RENAME],
       },
       {
@@ -398,7 +399,7 @@ const haulTypes = [
       {
         fieldName: fieldNames.NAME,
         xpath: `{OBTYPE}Haul/{OBTYPE}/@name`,
-        type: propTypes.TEXT,
+        type: propTypes.NAME,
         usage: [usageTypes.CLONE, usageTypes.BUILD, usageTypes.RENAME],
       },
       {
@@ -443,7 +444,7 @@ const haulTypes = [
       {
         fieldName: fieldNames.NAME,
         xpath: `{OBTYPE}Haul/*[contains(name(), '')]/name/node()`,
-        type: propTypes.TEXT,
+        type: propTypes.NAME,
         usage: [usageTypes.CLONE, usageTypes.BUILD, usageTypes.RENAME],
       },
       {