auth0-deploy-cli 7.3.6 → 7.5.0

package/lib/tools/utils.js

@@ -1,289 +1,293 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.keywordReplace = keywordReplace;
-exports.convertClientNameToId = convertClientNameToId;
-exports.convertClientNamesToIds = convertClientNamesToIds;
-exports.loadFile = loadFile;
-exports.flatten = flatten;
-exports.dumpJSON = dumpJSON;
-exports.calcChanges = calcChanges;
-exports.stripFields = stripFields;
-exports.getEnabledClients = getEnabledClients;
-exports.duplicateItems = duplicateItems;
-exports.filterExcluded = filterExcluded;
-exports.areArraysEquals = areArraysEquals;
-
-var _path = require("path");
-
-var _path2 = _interopRequireDefault(_path);
-
-var _fs = require("fs");
-
-var _fs2 = _interopRequireDefault(_fs);
-
-var _dotProp = require("dot-prop");
-
-var _dotProp2 = _interopRequireDefault(_dotProp);
-
-var _lodash = require("lodash");
-
-var _lodash2 = _interopRequireDefault(_lodash);
-
-var _logger = require("./logger");
-
-var _logger2 = _interopRequireDefault(_logger);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function keywordReplace(input, mappings) {
-  if (mappings && Object.keys(mappings).length > 0) {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areArraysEquals = exports.filterExcluded = exports.duplicateItems = exports.getEnabledClients = exports.stripFields = exports.calcChanges = exports.processChangedObjectFields = exports.dumpJSON = exports.flatten = exports.loadFileAndReplaceKeywords = exports.convertClientNamesToIds = exports.convertClientNameToId = exports.keywordReplace = exports.keywordStringReplace = exports.keywordArrayReplace = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const dot_prop_1 = __importDefault(require("dot-prop"));
+const lodash_1 = __importDefault(require("lodash"));
+const logger_1 = __importDefault(require("./logger"));
+function keywordArrayReplace(input, mappings) {
     Object.keys(mappings).forEach(function (key) {
-      const re = new RegExp(`##${key}##`, 'g');
-      input = input.replace(re, mappings[key]);
+        // Matching against two sets of patterns because a developer may provide their array replacement keyword with or without wrapping quotes. It is not obvious to the developer which to do depending if they're operating in YAML or JSON.
+        const pattern = `@@${key}@@`;
+        const patternWithQuotes = `"${pattern}"`;
+        const regex = new RegExp(`${patternWithQuotes}|${pattern}`, 'g');
+        input = input.replace(regex, JSON.stringify(mappings[key]));
     });
+    return input;
+}
+exports.keywordArrayReplace = keywordArrayReplace;
+function keywordStringReplace(input, mappings) {
     Object.keys(mappings).forEach(function (key) {
-      const re = new RegExp(`@@${key}@@`, 'g');
-      input = input.replace(re, JSON.stringify(mappings[key]));
+        const regex = new RegExp(`##${key}##`, 'g');
+        input = input.replace(regex, mappings[key]);
     });
-  }
-
-  return input;
+    return input;
 }
-
+exports.keywordStringReplace = keywordStringReplace;
+function keywordReplace(input, mappings) {
+    // Replace keywords with mappings within input.
+    if (mappings && Object.keys(mappings).length > 0) {
+        input = keywordStringReplace(input, mappings);
+        input = keywordArrayReplace(input, mappings);
+    }
+    return input;
+}
+exports.keywordReplace = keywordReplace;
 function convertClientNameToId(name, clients) {
-  const found = clients.find(c => c.name === name);
-  return found && found.client_id || name;
+    const found = clients.find((c) => c.name === name);
+    return (found && found.client_id) || name;
 }
-
+exports.convertClientNameToId = convertClientNameToId;
 function convertClientNamesToIds(names, clients) {
-  const resolvedNames = names.map(name => ({
-    name,
-    resolved: false
-  }));
-  const result = clients.reduce((acc, client) => {
-    if (names.includes(client.name)) {
-      const index = resolvedNames.findIndex(item => item.name === client.name);
-      resolvedNames[index].resolved = true;
-      acc.push(client.client_id);
-    }
-
-    return acc;
-  }, []);
-  const unresolved = resolvedNames.filter(item => !item.resolved).map(item => item.name);
-  return [...unresolved, ...result];
+    const resolvedNames = names.map((name) => ({ name, resolved: false }));
+    const result = clients.reduce((acc, client) => {
+        if (names.includes(client.name)) {
+            const index = resolvedNames.findIndex((item) => item.name === client.name);
+            resolvedNames[index].resolved = true;
+            acc.push(client.client_id);
+        }
+        return acc;
+    }, []);
+    const unresolved = resolvedNames.filter((item) => !item.resolved).map((item) => item.name);
+    return [...unresolved, ...result];
 }
-
-function loadFile(file, mappings) {
-  const f = _path2.default.resolve(file);
-
-  try {
-    _fs2.default.accessSync(f, _fs2.default.F_OK);
-
-    if (mappings) {
-      return keywordReplace(_fs2.default.readFileSync(f, 'utf8'), mappings);
+exports.convertClientNamesToIds = convertClientNamesToIds;
+function loadFileAndReplaceKeywords(file, mappings) {
+    // Load file and replace keyword mappings
+    const f = path_1.default.resolve(file);
+    try {
+        fs_1.default.accessSync(f, fs_1.default.F_OK);
+        if (mappings) {
+            return keywordReplace(fs_1.default.readFileSync(f, 'utf8'), mappings);
+        }
+        return fs_1.default.readFileSync(f, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`Unable to load file ${f} due to ${error}`);
     }
-
-    return _fs2.default.readFileSync(f, 'utf8');
-  } catch (error) {
-    throw new Error(`Unable to load file ${f} due to ${error}`);
-  }
 }
-
+exports.loadFileAndReplaceKeywords = loadFileAndReplaceKeywords;
 function flatten(list) {
-  return list.reduce((a, b) => a.concat(Array.isArray(b) ? flatten(b) : b), []);
+    // Flatten an multiple arrays to single array
+    return list.reduce((a, b) => a.concat(Array.isArray(b) ? flatten(b) : b), []);
 }
-
+exports.flatten = flatten;
 function dumpJSON(obj, spacing = 0) {
-  return JSON.stringify(obj, null, spacing);
+    return JSON.stringify(obj, null, spacing);
 }
-
-function processChangedObjectFields(handler, desiredAssetState, currentAssetState, objectFields = [], allowDelete = false) {
-  const desiredAssetStateWithChanges = { ...desiredAssetState
-  };
-
-  for (const fieldName of objectFields) {
-    if (desiredAssetState[fieldName] && Object.keys(desiredAssetState[fieldName]).length) {
-      if (currentAssetState[fieldName]) {
-        for (const currentObjectFieldPropertyName of Object.keys(currentAssetState[fieldName])) {
-          if (desiredAssetState[fieldName][currentObjectFieldPropertyName] === undefined) {
-            if (allowDelete) {
-              desiredAssetStateWithChanges[fieldName][currentObjectFieldPropertyName] = null;
-            } else {
-              _logger2.default.warn(`Detected that the ${fieldName} of the following ${handler.name} should be deleted. Doing so may be destructive.\nYou can enable deletes by setting 'AUTH0_ALLOW_DELETE' to true in the config\n${handler.objString(currentAssetState)}`);
+exports.dumpJSON = dumpJSON;
+/**
+ * @template T
+ * @param {typeof import('./auth0/handlers/default').default} handler
+ * @param {T} desiredAssetState
+ * @param {T} currentAssetState
+ * @param {string[]} [objectFields=[]]
+ * @param {boolean} [allowDelete=false]
+ * @returns T
+ */
+function processChangedObjectFields({ handler, desiredAssetState, currentAssetState, allowDelete = false }) {
+    const desiredAssetStateWithChanges = Object.assign({}, desiredAssetState);
+    // eslint-disable-next-line no-restricted-syntax
+    for (const fieldName of handler.objectFields) {
+        const areDesiredStateAndCurrentStateEmpty = Object.keys(desiredAssetState[fieldName] || {}).length === 0 && Object.keys(currentAssetState[fieldName] || {}).length === 0;
+        if (areDesiredStateAndCurrentStateEmpty) {
+            // If both the desired state and current state for a given object is empty, it is a no-op and can skip
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        // A desired state that omits the objectField OR that has it as an empty object should
+        // signal that all fields should be removed (subject to ALLOW_DELETE).
+        if (desiredAssetState[fieldName] && Object.keys(desiredAssetState[fieldName]).length) {
+            // Both the current and desired state have the object field. Here's where we need to map
+            // to the APIv2 protocol of setting `null` values for deleted fields.
+            // For new and modified properties of the object field, we can just pass them through to
+            // APIv2.
+            if (currentAssetState[fieldName]) {
+                // eslint-disable-next-line no-restricted-syntax
+                for (const currentObjectFieldPropertyName of Object.keys(currentAssetState[fieldName])) {
+                    // Loop through each object property that exists currently
+                    if (desiredAssetState[fieldName][currentObjectFieldPropertyName] === undefined) {
+                        // If the object has a property that exists now but doesn't exist in the proposed state
+                        if (allowDelete) {
+                            desiredAssetStateWithChanges[fieldName][currentObjectFieldPropertyName] = null;
+                        }
+                        else {
+                            // If deletes aren't allowed, do outright delete the property within the object
+                            logger_1.default.warn(`Detected that the ${fieldName} of the following ${handler.name || handler.id || ''} should be deleted. Doing so may be destructive.\nYou can enable deletes by setting 'AUTH0_ALLOW_DELETE' to true in the config\n${handler.objString(currentAssetState)}`);
+                        }
+                    }
+                }
             }
-          }
         }
-      }
-    } else if (allowDelete) {
-      desiredAssetStateWithChanges[fieldName] = {};
-    } else {
-      delete desiredAssetStateWithChanges[fieldName];
-
-      _logger2.default.warn(`Detected that the ${fieldName} of the following ${handler.name} should be emptied. Doing so may be destructive.\nYou can enable deletes by setting 'AUTH0_ALLOW_DELETE' to true in the config\n${handler.objString(currentAssetState)}`);
+        else if (allowDelete) {
+            // If the desired state does not have the object field and the current state does, we
+            // should mark *all* properties for deletion by specifying an empty object.
+            //
+            // See: https://auth0.com/docs/users/metadata/manage-metadata-api#delete-user-metadata
+            desiredAssetStateWithChanges[fieldName] = {};
+        }
+        else {
+            delete desiredAssetStateWithChanges[fieldName];
+            logger_1.default.warn(`Detected that the ${fieldName} of the following ${handler.name || handler.id || ''} should be emptied. Doing so may be destructive.\nYou can enable deletes by setting 'AUTH0_ALLOW_DELETE' to true in the config\n${handler.objString(currentAssetState)}`);
+        }
     }
-  }
-
-  return desiredAssetStateWithChanges;
+    return desiredAssetStateWithChanges;
 }
-
-function calcChanges(handler, assets, existing, identifiers = ['id', 'name'], objectFields = [], allowDelete = false) {
-  const update = [];
-  let del = [...existing];
-  let create = [...assets];
-  const conflicts = [];
-
-  const findByKeyValue = (key, value, arr) => arr.find(e => {
-    if (Array.isArray(key)) {
-      const values = key.map(k => e[k]);
-
-      if (values.every(v => v)) {
-        return value === values.join('-');
-      }
-    } else {
-      return e[key] === value;
-    }
-
-    return false;
-  });
-
-  const processAssets = (id, arr) => {
-    arr.forEach(asset => {
-      let assetIdValue;
-
-      if (Array.isArray(id)) {
-        const values = id.map(i => asset[i]);
-
-        if (values.every(v => v)) {
-          assetIdValue = values.join('-');
-        }
-      } else {
-        assetIdValue = asset[id];
-      }
-
-      if (assetIdValue) {
-        const found = findByKeyValue(id, assetIdValue, del);
-
-        if (found) {
-          del = del.filter(e => e !== found);
-          create = create.filter(e => e !== asset);
-          update.push({ ...identifiers.reduce((obj, i) => {
-              if (found[i]) obj[i] = found[i];
-              return obj;
-            }, {}),
-            ...(objectFields.length ? processChangedObjectFields(handler, asset, found, objectFields, allowDelete) : asset)
-          });
+exports.processChangedObjectFields = processChangedObjectFields;
+function calcChanges(handler, assets, existing, identifiers = ['id', 'name'], allowDelete = false) {
+    // Calculate the changes required between two sets of assets.
+    const update = [];
+    let del = [...existing];
+    let create = [...assets];
+    const conflicts = [];
+    const findByKeyValue = (key, value, arr) => arr.find((e) => {
+        if (Array.isArray(key)) {
+            const values = key.map((k) => e[k]);
+            if (values.every((v) => v)) {
+                return value === values.join('-');
+            }
         }
-      }
-    });
-  };
-
-  for (const id of identifiers) {
-    processAssets(id, [...create]);
-  }
-
-  if (identifiers.includes('name')) {
-    const uniqueID = identifiers[0];
-    const futureAssets = [...create, ...update];
-    futureAssets.forEach(a => {
-      const inDeleted = del.filter(e => e.name === a.name && e[uniqueID] !== a[uniqueID])[0];
-
-      if (!inDeleted) {
-        const conflict = existing.filter(e => e.name === a.name && e[uniqueID] !== a[uniqueID])[0];
-
-        if (conflict) {
-          const temp = Math.random().toString(36).substr(2, 5);
-          conflicts.push({ ...conflict,
-            name: `${conflict.name}-${temp}`
-          });
+        else {
+            return e[key] === value;
         }
-      }
+        return false;
     });
-  }
-
-  return {
-    del,
-    update,
-    conflicts,
-    create
-  };
+    const processAssets = (id, arr) => {
+        arr.forEach((asset) => {
+            let assetIdValue;
+            if (Array.isArray(id)) {
+                const values = id.map((i) => asset[i]);
+                if (values.every((v) => v)) {
+                    assetIdValue = values.join('-');
+                }
+            }
+            else {
+                assetIdValue = asset[id];
+            }
+            if (assetIdValue) {
+                const found = findByKeyValue(id, assetIdValue, del);
+                if (found) {
+                    // Delete from existing
+                    del = del.filter((e) => e !== found);
+                    // Delete from create as it's an update
+                    create = create.filter((e) => e !== asset);
+                    // Append identifiers to asset
+                    update.push(Object.assign(Object.assign({}, identifiers.reduce((obj, i) => {
+                        if (found[i])
+                            obj[i] = found[i];
+                        return obj;
+                    }, {})), (handler.objectFields.length
+                        ? processChangedObjectFields({
+                            handler, desiredAssetState: asset, currentAssetState: found, allowDelete
+                        })
+                        : asset)));
+                }
+            }
+        });
+    };
+    // Loop through identifiers (in order) to try match assets to existing
+    // If existing then update if not create
+    // The remainder will be deleted
+    for (const id of identifiers) { // eslint-disable-line
+        processAssets(id, [...create]);
+    }
+    // Check if there are assets with names that will conflict with existing names during the update process
+    // This will rename those assets to a temp random name first
+    // This assumes the first identifiers is the unique identifier
+    if (identifiers.includes('name')) {
+        const uniqueID = identifiers[0];
+        const futureAssets = [...create, ...update];
+        futureAssets.forEach((a) => {
+            // If the conflicting item is going to be deleted then skip
+            const inDeleted = del.filter((e) => e.name === a.name && e[uniqueID] !== a[uniqueID])[0];
+            if (!inDeleted) {
+                const conflict = existing.filter((e) => e.name === a.name && e[uniqueID] !== a[uniqueID])[0];
+                if (conflict) {
+                    const temp = Math.random().toString(36).substr(2, 5);
+                    conflicts.push(Object.assign(Object.assign({}, conflict), { name: `${conflict.name}-${temp}` }));
+                }
+            }
+        });
+    }
+    return {
+        del,
+        update,
+        conflicts,
+        create
+    };
 }
-
+exports.calcChanges = calcChanges;
 function stripFields(obj, fields) {
-  const stripped = [];
-  const newObj = { ...obj
-  };
-  fields.forEach(f => {
-    if (_dotProp2.default.get(newObj, f) !== undefined) {
-      _dotProp2.default.delete(newObj, f);
-
-      stripped.push(f);
+    // Strip object fields supporting dot notation (ie: a.deep.field)
+    const stripped = [];
+    const newObj = Object.assign({}, obj);
+    fields.forEach((f) => {
+        if (dot_prop_1.default.get(newObj, f) !== undefined) {
+            dot_prop_1.default.delete(newObj, f);
+            stripped.push(f);
+        }
+    });
+    if (stripped) {
+        const name = ['id', 'client_id', 'template', 'name'].reduce((n, k) => newObj[k] || n, '');
+        logger_1.default.debug(`Stripping "${name}" read-only fields ${JSON.stringify(stripped)}`);
     }
-  });
-
-  if (stripped) {
-    const name = ['id', 'client_id', 'template', 'name'].reduce((n, k) => newObj[k] || n, '');
-
-    _logger2.default.debug(`Stripping "${name}" read-only fields ${JSON.stringify(stripped)}`);
-  }
-
-  return newObj;
+    return newObj;
 }
-
+exports.stripFields = stripFields;
 function getEnabledClients(assets, connection, existing, clients) {
-  const excludedClientsByNames = assets.exclude && assets.exclude.clients || [];
-  const excludedClients = convertClientNamesToIds(excludedClientsByNames, clients);
-  const enabledClients = [...convertClientNamesToIds(connection.enabled_clients || [], clients).filter(item => ![...excludedClientsByNames, ...excludedClients].includes(item))];
-  existing.forEach(conn => {
-    if (conn.name === connection.name) {
-      excludedClients.forEach(excludedClient => {
-        if (conn.enabled_clients.includes(excludedClient)) {
-          enabledClients.push(excludedClient);
+    // Convert enabled_clients by name to the id
+    const excludedClientsByNames = (assets.exclude && assets.exclude.clients) || [];
+    const excludedClients = convertClientNamesToIds(excludedClientsByNames, clients);
+    const enabledClients = [
+        ...convertClientNamesToIds(connection.enabled_clients || [], clients).filter((item) => ![...excludedClientsByNames, ...excludedClients].includes(item))
+    ];
+    // If client is excluded and in the existing connection this client is enabled, it should keep enabled
+    // If client is excluded and in the existing connection this client is disabled, it should keep disabled
+    existing.forEach((conn) => {
+        if (conn.name === connection.name) {
+            excludedClients.forEach((excludedClient) => {
+                if (conn.enabled_clients.includes(excludedClient)) {
+                    enabledClients.push(excludedClient);
+                }
+            });
         }
-      });
-    }
-  });
-  return enabledClients;
+    });
+    return enabledClients;
 }
-
+exports.getEnabledClients = getEnabledClients;
 function duplicateItems(arr, key) {
-  const duplicates = arr.reduce((accum, obj) => {
-    const keyValue = obj[key];
-
-    if (keyValue) {
-      if (!(keyValue in accum)) accum[keyValue] = [];
-      accum[keyValue].push(obj);
-    }
-
-    return accum;
-  }, {});
-  return Object.values(duplicates).filter(g => g.length > 1);
+    // Find duplicates objects within array that have the same key value
+    const duplicates = arr.reduce((accum, obj) => {
+        const keyValue = obj[key];
+        if (keyValue) {
+            if (!(keyValue in accum))
+                accum[keyValue] = [];
+            accum[keyValue].push(obj);
+        }
+        return accum;
+    }, {});
+    return Object.values(duplicates).filter((g) => g.length > 1);
 }
-
+exports.duplicateItems = duplicateItems;
 function filterExcluded(changes, exclude) {
-  const {
-    del,
-    update,
-    create,
-    conflicts
-  } = changes;
-
-  if (!exclude.length) {
-    return changes;
-  }
-
-  const filter = list => list.filter(item => !exclude.includes(item.name));
-
-  return {
-    del: filter(del),
-    update: filter(update),
-    create: filter(create),
-    conflicts: filter(conflicts)
-  };
+    const { del, update, create, conflicts } = changes;
+    if (!exclude.length) {
+        return changes;
+    }
+    const filter = (list) => list.filter((item) => !exclude.includes(item.name));
+    return {
+        del: filter(del),
+        update: filter(update),
+        create: filter(create),
+        conflicts: filter(conflicts)
+    };
 }
-
+exports.filterExcluded = filterExcluded;
 function areArraysEquals(x, y) {
-  return _lodash2.default.isEqual(x && x.sort(), y && y.sort());
-}
+    return lodash_1.default.isEqual(x && x.sort(), y && y.sort());
+}
+exports.areArraysEquals = areArraysEquals;