apn-app-manager 1.0.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.
@@ -39,6 +41,7 @@ Used to duplicate all objects of an application, which replaces the namespace of
 1. Run the command `apn` in a folder containing your exported application zip.
 1. Select `clone` for "What would you like to do?".
 1. Select your application zip.
+1. Select your import customization properties file, if you have one.
 1. Enter your current namespace.
    - For example, an application with objects such as `SMP APP Artifacts` and `SMP_APP_displayUser` would have a namespace of `SMP_APP`
 1. Enter your new namespace.
@@ -49,7 +52,7 @@ Used to duplicate all objects of an application, which replaces the namespace of
 1. Always inspect your cloned zip before importing to verify that what will be imported matches what you'd expect.
 1. The cloning tool is idempotent meaning it will always return the same output zip run against the same input. This also means you can develop an application, clone it, then enhance the original application, re-clone it, and that second clone will deploy over the first clone with objects being recognized as "Changed" as if you had just modified the clone directly.
 1. It is highly recommended that all objects in your application have the same prefix (including objects that generally aren't prefixed such as applications, groups, process models, etc). Otherwise, the cloning tool will not be able to generate a unique name for these objects, and certain objects are required to have unique names.
-1. Import properties files and SQL files for your application are not supported for cloning at this time. These artifacts will have to be adjusted manually to align with the cloned objects (i.e. swapping UUID or name references).
+1. SQL files for your application are not supported for cloning at this time. SQL scripts will have to be adjusted manually to align with the cloned objects (i.e. changing table name references).
 1. There are two other document generated in the `/out/` folder after cloning:
    - `objects.json` - This contains every attribute of collected metadata from every object in the package, including its current value and new value.
    - `not-cloned-uuids.json` - Warnings may appear during cloning about UUIDs in the package that the tool didn't know how to handle, which will be listed in this file. If no warnings appeared, this file will be empty. Generally these can be ignored if your inspection looks good, however these may be actual issues that come up due to XML structure changes in future Appian platform releases. Please reach out to the authors of this tool if you have any questions about this.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apn-app-manager",
-  "version": "1.0.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,68 +15,106 @@ const obMapsUpdates = require("../handlers/objectMapsUpdateHandler");
 const obModify = require("../handlers/objectModifyHandler");
 
 // Entry-point
-function main(curNamespace, newNamespace, callback) {
-  const moduleProps = getModuleProps();
+function main(callback) {
   util.delFile(cons.outDir);
-  if (!util.isBlank(moduleProps)) {
-    // Inside of the module repository
-    // util.print(`\nCloning '${moduleProps.name}' version ${moduleProps.version}`);
-    if (util.validateNamespace(util.translateNamespace(newNamespace)) === true) {
-      executeClone(moduleProps.namespace, util.translateNamespace(newNamespace), callback);
-    } else {
-      promptNamespace("What is your new namespace?", function (newNamespace) {
-        executeClone(moduleProps.namespace, newNamespace, cons.cloneAppDir, moduleProps.name, callback);
-      });
-    }
-  } else {
-    // Cloning a regular ZIP package
-    fileSelect.getAppPackage(function (appZipPath) {
-      util.unzipDir(appZipPath, cons.tempDir);
-      promptNamespace("What is your current namespace?", function (curNamespace) {
-        promptNamespace("What is your new namespace?", function (newNamespace) {
-          executeClone(curNamespace, newNamespace, cons.tempDir, path.basename(appZipPath, ".zip"), callback);
-        });
-      });
+  fileSelect.getAppPackage(function (appZipPath) {
+    util.unzipDir(appZipPath, cons.tempDir);
+    fileSelect.selectSingleFile("Select import customization properties file", ["properties"], true, function (icfPath) {
+      executeClone(appZipPath, icfPath, callback);
     });
-  }
+  });
 }
 
 // Executes all the steps of the clone
-function executeClone(curNamespace, newNamespace, appDir, appName, callback) {
-  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, appDir, obProps.usageTypes.CLONE);
+  const namespaceCollector = {};
+  util.print(`Collecting all metadata from the objects...`);
+  obExtract.buildObjectMaps(objectMaps, uuidCollector, namespaceCollector, 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);
+  // Have the user map each namespace to its proper behavior
+  mapNamespaces(namespaceCollector, function onComplete() {
+    util.printGap();
+    // 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
-  obModify.modifyObjectFiles(cons.tempDir, objectMaps, obProps.usageTypes.CLONE, []);
+    // 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, []);
 
-  // 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 ICF file
+    obModify.modifySingleFile(icfPath, outIcfPath, objectMaps, obProps.usageTypes.CLONE, []);
 
-  if (uuidCollector["uuids"].length > 0) {
+    // 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.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(`Cloning complete. Output can be found in the '/out/' folder (${path.resolve(cons.outDir)}).`);
 
-  util.print(`\nCloning of '${appName}' to namespace '${newNamespace}' complete`);
-  // Zip the package
-  util.zipDir(cons.tempDir, outZipPath, false);
-  util.print(`Output to '${outZipPath}'`);
+    // 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
@@ -85,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

@@ -25,6 +25,7 @@ module.exports = {
   },
 
   yesNo: ["Yes", "No"],
+  none: "None",
 
   // Testing of this regex can be found here: https://regexr.com/6sgu6
   // Note that we can assume any UUID that "must be cloned" must be wrapped in either >uuid< or "uuid"
@@ -32,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: `&`,
@@ -39,7 +43,5 @@ module.exports = {
     },
   ],
 
-  namespaceDelimiterRegexString: "([:|_| |\\.|-]?)",
-
   appianUrlRegex: /^https:\/\/.*\/suite/g,
 };

package/src/handlers/fileSelectHandler.js

@@ -11,16 +11,26 @@ const prompt = require("./promptHandler");
 module.exports = {
   // Prompts for the application package
   getAppPackage: function (callback) {
-    let zipFiles = [];
-    util.handleDirFiles(cons.curDir, ["zip"], 1, 1, function (zipPath) {
-      zipFiles.push(path.basename(zipPath));
-    });
-    prompt.promptList("Select application ZIP", zipFiles, function (answer) {
-      util.execCallback(callback, path.resolve(cons.curDir, answer));
-    });
+    selectFile("Select application zip", ["zip"], false, callback);
+  },
+
+  // Prompts for any generic file type
+  selectSingleFile: function (promptText, fileTypes, optional, callback) {
+    selectFile(promptText, fileTypes, optional, callback);
   },
 };
 
+function selectFile(promptText, fileTypes, optional, callback) {
+  let files = optional ? [cons.none] : [];
+  util.handleDirFiles(cons.curDir, fileTypes, 1, 1, function (filePath) {
+    files.push(path.basename(filePath));
+  });
+  prompt.promptList(promptText, files, function (answer) {
+    let answerPath = answer == cons.none ? null : path.resolve(cons.curDir, answer);
+    util.execCallback(callback, answerPath);
+  });
+}
+
 // ---------------------------------------------------
 // Functions not for export
 // ---------------------------------------------------

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,31 +68,29 @@ function renameObjectProp(curVal, haulField, curNamespace, newNamespace) {
   if (util.isBlank(curVal)) {
     return "";
   } else {
+    let replacementRegexMap = buildNamespaceReplacementRegex(curNamespace, newNamespace, "gi");
+    let nampespaceReplacement;
     switch (haulField.type) {
+      // UUIDs - just append the new namespace
       case obProps.propTypes.UUID:
-        return renameUuidOrUrlStub(curVal, curNamespace, newNamespace, false);
+        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:
-        return renameUuidOrUrlStub(curVal, curNamespace, newNamespace, true);
+        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:
-        let replacementRegexMap = util.buildNamespaceReplacementRegex(curNamespace, newNamespace, "g");
         return curVal.replace(replacementRegexMap.from, replacementRegexMap.to);
     }
   }
 }
 
-// The logic for URL replacement for a UUID or URL stub
-function renameUuidOrUrlStub(curVal, curNamespace, newNamespace, appendToStart) {
-  let replacementRegexMap = util.buildNamespaceReplacementRegex(curNamespace, newNamespace, "gi");
-  let nampespaceReplacement = curVal.replace(replacementRegexMap.from, util.toLower(replacementRegexMap.to));
-  if (nampespaceReplacement != curVal) {
-    return nampespaceReplacement;
-  } else if (appendToStart) {
-    return `${util.toLower(newNamespace)}-${nampespaceReplacement}`;
-  } else {
-    return `${nampespaceReplacement}-${util.toLower(newNamespace)}`;
-  }
-}
-
 // Remove UUID from the collector if found
 function removeFoundUuids(uuidCollector, haulField, uuids) {
   if (haulField.type == obProps.propTypes.UUID) {
@@ -86,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);