auth0-deploy-cli 7.5.2 → 7.7.1

package/lib/tools/auth0/handlers/rules.js

@@ -13,13 +13,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.schema = exports.excludeSchema = void 0;
-const ValidationError_1 = __importDefault(require("../../ValidationError"));
+const validationError_1 = __importDefault(require("../../validationError"));
 const utils_1 = require("../../utils");
 const default_1 = __importDefault(require("./default"));
 const logger_1 = __importDefault(require("../../logger"));
+const calculateChanges_1 = require("../../calculateChanges");
 exports.excludeSchema = {
     type: 'array',
-    items: { type: 'string' }
+    items: { type: 'string' },
 };
 exports.schema = {
     type: 'array',
@@ -29,38 +30,37 @@ exports.schema = {
         properties: {
             script: {
                 type: 'string',
-                description: 'A script that contains the rule\'s code',
-                default: ''
+                description: "A script that contains the rule's code",
+                default: '',
             },
             name: {
                 type: 'string',
-                description: 'The name of the rule. Can only contain alphanumeric characters, spaces and \'-\'. Can neither start nor end with \'-\' or spaces',
-                pattern: '^[^-\\s][a-zA-Z0-9-\\s]+[^-\\s]$'
+                description: "The name of the rule. Can only contain alphanumeric characters, spaces and '-'. Can neither start nor end with '-' or spaces",
+                pattern: '^[^-\\s][a-zA-Z0-9-\\s]+[^-\\s]$',
             },
             order: {
                 type: ['number', 'null'],
-                description: 'The rule\'s order in relation to other rules. A rule with a lower order than another rule executes first.',
-                default: null
+                description: "The rule's order in relation to other rules. A rule with a lower order than another rule executes first.",
+                default: null,
             },
             enabled: {
                 type: 'boolean',
                 description: 'true if the rule is enabled, false otherwise',
-                default: true
+                default: true,
             },
             stage: {
                 type: 'string',
-                description: 'The rule\'s execution stage',
+                description: "The rule's execution stage",
                 default: 'login_success',
-                enum: ['login_success', 'login_failure', 'pre_authorize']
-            }
+                enum: ['login_success', 'login_failure', 'pre_authorize'],
+            },
         },
-        required: ['name']
-    }
+        required: ['name'],
+    },
 };
 class RulesHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'rules', stripUpdateFields: ['stage'] // Fields not allowed in updates
-         }));
+        super(Object.assign(Object.assign({}, options), { type: 'rules', stripUpdateFields: ['stage'] }));
     }
     getType() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -84,17 +84,27 @@ class RulesHandler extends default_1.default {
                 existing = existing.filter((r) => !excludedRules.includes(r.name));
             }
             // Figure out what needs to be updated vs created
-            const { del, update, create, conflicts } = (0, utils_1.calcChanges)(this, rules, existing, ['id', 'name']);
+            const { del, update, create, conflicts } = (0, calculateChanges_1.calculateChanges)({
+                handler: this,
+                assets: rules,
+                existing,
+                identifiers: ['id', 'name'],
+                allowDelete: false, //TODO: actually pass in correct allowDelete value
+            });
             // Figure out the rules that need to be re-ordered
             const futureRules = [...create, ...update];
             const futureMaxOrder = Math.max(...futureRules.map((r) => r.order));
             const existingMaxOrder = Math.max(...existing.map((r) => r.order));
             let nextOrderNo = Math.max(futureMaxOrder, existingMaxOrder);
+            //@ts-ignore because we know reOrder is Asset[]
             const reOrder = futureRules.reduce((accum, r) => {
                 const conflict = existing.find((f) => r.order === f.order && r.name !== f.name);
-                if (conflict) {
+                if (conflict !== undefined) {
                     nextOrderNo += 1;
-                    accum.push(Object.assign(Object.assign({}, conflict), { order: nextOrderNo }));
+                    return [
+                        ...accum,
+                        Object.assign(Object.assign({}, conflict), { order: nextOrderNo }),
+                    ];
                 }
                 return accum;
             }, []);
@@ -103,7 +113,7 @@ class RulesHandler extends default_1.default {
                 update,
                 create,
                 reOrder,
-                conflicts
+                conflicts,
             };
         });
     }
@@ -121,24 +131,30 @@ class RulesHandler extends default_1.default {
             const { update, create, del } = yield this.calcChanges(assets, true);
             // Include del rules which are actually not going to be deleted but are excluded
             // they can still muck up the ordering so we must take it into consideration.
-            const futureRules = [...create, ...update, ...del.filter((r) => excludedRules.includes(r.name))];
+            const futureRules = [
+                ...create,
+                ...update,
+                ...del.filter((r) => excludedRules.includes(r.name)),
+            ];
             // Detect rules with the same order
             const rulesSameOrder = (0, utils_1.duplicateItems)(futureRules, 'order');
             if (rulesSameOrder.length > 0) {
                 const formatted = rulesSameOrder.map((dups) => dups.map((d) => `${d.name}`));
-                throw new ValidationError_1.default(`There are multiple rules for the following stage-order combinations
-      ${(0, utils_1.dumpJSON)(formatted)}.
+                throw new validationError_1.default(`There are multiple rules for the following stage-order combinations
+      ${(0, utils_1.convertJsonToString)(formatted)}.
        Only one rule must be defined for the same order number in a stage.`);
             }
             // Detect Rules that are changing stage as it's not allowed.
             const existing = yield this.getType();
-            const stateChanged = futureRules.reduce((changed, rule) => ([
+            const stateChanged = futureRules
+                .reduce((changed, rule) => [
                 ...changed,
-                ...existing.filter((r) => rule.name.toLowerCase() === r.name.toLowerCase() && r.stage !== rule.stage)
-            ]), []).map((r) => r.name);
+                ...existing.filter((r) => rule.name.toLowerCase() === r.name.toLowerCase() && r.stage !== rule.stage),
+            ], [])
+                .map((r) => r.name);
             if (stateChanged.length > 0) {
-                throw new ValidationError_1.default(`The following rules changed stage which is not allowed:
-      ${(0, utils_1.dumpJSON)(stateChanged)}.
+                throw new validationError_1.default(`The following rules changed stage which is not allowed:
+      ${(0, utils_1.convertJsonToString)(stateChanged)}.
       Rename the rules to recreate them and avoid this error.`);
             }
             yield _super.validate.call(this, assets);
@@ -156,20 +172,27 @@ class RulesHandler extends default_1.default {
             // Figure out what needs to be updated vs created
             const changes = yield this.calcChanges(assets);
             // Temporally re-order rules with conflicting ordering
-            yield this.client.pool.addEachTask({
+            yield this.client.pool
+                .addEachTask({
                 data: changes.reOrder,
-                generator: (rule) => this.client.updateRule({ id: rule.id }, (0, utils_1.stripFields)(rule, this.stripUpdateFields)).then(() => {
+                generator: (rule) => this.client
+                    .updateRule({ id: rule.id }, (0, utils_1.stripFields)(rule, this.stripUpdateFields))
+                    .then(() => {
                     const updated = {
-                        name: rule.name, stage: rule.stage, order: rule.order, id: rule.id
+                        name: rule.name,
+                        stage: rule.stage,
+                        order: rule.order,
+                        id: rule.id,
                     };
-                    logger_1.default.info(`Temporally re-order Rule ${(0, utils_1.dumpJSON)(updated)}`);
-                })
-            }).promise();
+                    logger_1.default.info(`Temporally re-order Rule ${(0, utils_1.convertJsonToString)(updated)}`);
+                }),
+            })
+                .promise();
             yield _super.processChanges.call(this, assets, {
                 del: changes.del,
                 create: changes.create,
                 update: changes.update,
-                conflicts: changes.conflicts
+                conflicts: changes.conflicts,
             });
         });
     }

package/lib/tools/auth0/handlers/rulesConfigs.js

@@ -20,16 +20,16 @@ exports.schema = {
         type: 'object',
         properties: {
             key: { type: 'string', pattern: '^[A-Za-z0-9_-]*$' },
-            value: { type: 'string' }
+            value: { type: 'string' },
         },
-        required: ['key', 'value']
+        required: ['key', 'value'],
     },
-    additionalProperties: false
+    additionalProperties: false,
 };
 class RulesConfigsHandler extends default_1.default {
     constructor(options) {
         super(Object.assign(Object.assign({}, options), { type: 'rulesConfigs', id: 'key', functions: {
-                update: 'set' // Update or Creation of a ruleConfig is via set not update
+                update: 'set', // Update or Creation of a ruleConfig is via set not update
             } }));
     }
     getType() {
@@ -45,12 +45,18 @@ class RulesConfigsHandler extends default_1.default {
             const { rulesConfigs } = assets;
             // Do nothing if not set
             if (!rulesConfigs || !rulesConfigs.length)
-                return {};
+                return {
+                    del: [],
+                    update: [],
+                    create: [],
+                    conflicts: [],
+                };
             // Intention is to not delete/cleanup old configRules, that needs to be handled manually.
             return {
                 del: [],
                 update: rulesConfigs,
-                create: []
+                create: [],
+                conflicts: [],
             };
         });
     }

package/lib/tools/auth0/handlers/tenant.js

@@ -42,14 +42,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.schema = void 0;
-const ValidationError_1 = __importDefault(require("../../ValidationError"));
+const validationError_1 = __importDefault(require("../../validationError"));
 const default_1 = __importStar(require("./default"));
 const pages_1 = require("./pages");
 const utils_1 = require("../../utils");
 exports.schema = {
-    type: 'object'
+    type: 'object',
 };
-const blockPageKeys = [...Object.keys(pages_1.pageNameMap), ...Object.values(pages_1.pageNameMap), ...pages_1.supportedPages];
+const blockPageKeys = [
+    ...Object.keys(pages_1.pageNameMap),
+    ...Object.values(pages_1.pageNameMap),
+    ...pages_1.supportedPages,
+];
 class TenantHandler extends default_1.default {
     constructor(options) {
         super(Object.assign(Object.assign({}, options), { type: 'tenant' }));
@@ -72,7 +76,7 @@ class TenantHandler extends default_1.default {
                 return;
             const pageKeys = Object.keys(tenant).filter((k) => blockPageKeys.includes(k));
             if (pageKeys.length > 0) {
-                throw new ValidationError_1.default(`The following pages ${(0, utils_1.dumpJSON)(pageKeys)} were found in tenant settings. Pages should be set separately. Please refer to the documentation.`);
+                throw new validationError_1.default(`The following pages ${(0, utils_1.convertJsonToString)(pageKeys)} were found in tenant settings. Pages should be set separately. Please refer to the documentation.`);
             }
         });
     }

package/lib/tools/auth0/handlers/triggers.js

@@ -56,15 +56,15 @@ exports.schema = {
                 type: 'object',
                 properties: {
                     action_name: { type: 'string', enum: constants_1.default.ACTIONS_TRIGGERS },
-                    display_name: { type: 'string', default: '' }
-                }
-            }
-        }
-    }
+                    display_name: { type: 'string', default: '' },
+                },
+            },
+        },
+    },
 };
 function isActionsDisabled(err) {
     const errorBody = lodash_1.default.get(err, 'originalError.response.body') || {};
-    return (err.statusCode === 403 && errorBody.errorCode === 'feature_not_enabled');
+    return err.statusCode === 403 && errorBody.errorCode === 'feature_not_enabled';
 }
 class TriggersHandler extends default_1.default {
     constructor(options) {
@@ -76,8 +76,7 @@ class TriggersHandler extends default_1.default {
                 return this.existing;
             }
             // in case client version does not support actions
-            if (!this.client.actions
-                || typeof this.client.actions.getAllTriggers !== 'function') {
+            if (!this.client.actions || typeof this.client.actions.getAllTriggers !== 'function') {
                 return [];
             }
             const triggerBindings = {};
@@ -87,12 +86,12 @@ class TriggersHandler extends default_1.default {
                 for (let i = 0; i < triggers.length; i++) {
                     const triggerId = triggers[i];
                     const { bindings } = yield this.client.actions.getTriggerBindings({
-                        trigger_id: triggerId
+                        trigger_id: triggerId,
                     });
                     if (bindings.length > 0) {
                         triggerBindings[triggerId] = bindings.map((binding) => ({
                             action_name: binding.action.name,
-                            display_name: binding.display_name
+                            display_name: binding.display_name,
                         }));
                     }
                 }
@@ -123,9 +122,9 @@ class TriggersHandler extends default_1.default {
                 const bindings = data.map((binding) => ({
                     ref: {
                         type: 'action_name',
-                        value: binding.action_name
+                        value: binding.action_name,
                     },
-                    display_name: binding.display_name
+                    display_name: binding.display_name,
                 }));
                 yield this.client.actions.updateTriggerBindings({ trigger_id: name }, { bindings });
                 this.didUpdate({ trigger_id: name });

package/lib/tools/auth0/index.js

@@ -1,27 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -38,12 +15,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ajv_1 = __importDefault(require("ajv/lib/ajv"));
 const client_1 = __importDefault(require("./client"));
 const schema_1 = __importDefault(require("./schema"));
-const handlers = __importStar(require("./handlers"));
-const defaultOrder = 50;
+const handlers_1 = __importDefault(require("./handlers"));
 function sortByOrder(toSort, stage) {
+    const defaultOrder = 50;
     const sorted = [...toSort];
     sorted.sort((a, b) => {
+        //@ts-ignore because this doesn't actually work. TODO: apply stage order
         const aOrder = a[stage].order || defaultOrder;
+        //@ts-ignore because this doesn't actually work. TODO: apply stage order
         const bOrder = b[stage].order || defaultOrder;
         return aOrder - bOrder;
     });
@@ -54,19 +33,24 @@ class Auth0 {
         this.client = (0, client_1.default)(client);
         this.config = config;
         this.assets = assets;
-        this.handlers = [];
-        Object.values(handlers).forEach((h) => {
-            const handler = new h.default({ client: this.client, config });
-            this.handlers.push(handler);
+        this.handlers = Object.values(handlers_1.default)
+            .map((handler) => {
+            //@ts-ignore because class expects `type` property but gets directly injected into class constructors
+            return new handler.default({ client: this.client, config: this.config });
+        })
+            .filter((handler) => {
+            const excludedAssetTypes = config('AUTH0_EXCLUDED') || [];
+            return !excludedAssetTypes.includes(handler.type);
         });
     }
     runStage(stage) {
         return __awaiter(this, void 0, void 0, function* () {
             // Sort by priority
-            for (const handler of sortByOrder(this.handlers, stage)) { // eslint-disable-line
+            for (const handler of sortByOrder(this.handlers, stage)) {
+                // eslint-disable-line
                 try {
                     const stageFn = Object.getPrototypeOf(handler)[stage];
-                    this.assets = Object.assign(Object.assign({}, this.assets), (yield stageFn.apply(handler, [this.assets])) || {});
+                    this.assets = Object.assign(Object.assign({}, this.assets), ((yield stageFn.apply(handler, [this.assets])) || {}));
                 }
                 catch (err) {
                     err.type = handler.type;

package/lib/tools/auth0/schema.js

@@ -1,34 +1,14 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const handlers = __importStar(require("./handlers"));
-const typesSchema = Object.entries(handlers).reduce((map, [name, obj]) => {
+const handlers_1 = __importDefault(require("./handlers"));
+const typesSchema = Object.entries(handlers_1.default).reduce((map, [name, obj]) => {
     map[name] = obj.schema; //eslint-disable-line
     return map;
 }, {});
-const excludeSchema = Object.entries(handlers).reduce((map, [name, obj]) => {
+const excludeSchema = Object.entries(handlers_1.default).reduce((map, [name, obj]) => {
     if (obj.excludeSchema) {
         map[name] = obj.excludeSchema;
     }
@@ -40,7 +20,7 @@ exports.default = {
     properties: Object.assign(Object.assign({}, typesSchema), { exclude: {
             type: 'object',
             properties: Object.assign({}, excludeSchema),
-            default: {}
+            default: {},
         } }),
-    additionalProperties: false
+    additionalProperties: false,
 };

package/lib/tools/calculateChanges.js

@@ -0,0 +1,149 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateChanges = exports.processChangedObjectFields = void 0;
+const logger_1 = __importDefault(require("./logger"));
+/**
+ * @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) {
+            // 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;
+}
+exports.processChangedObjectFields = processChangedObjectFields;
+function calculateChanges({ handler, assets, existing, identifiers = ['id', 'name'], allowDelete, }) {
+    // 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('-');
+            }
+        }
+        return e[key] === value;
+    });
+    const processAssets = (id, arr) => {
+        arr.forEach((asset) => {
+            const assetIdValue = (() => {
+                if (Array.isArray(id)) {
+                    const values = id.map((i) => asset[i]);
+                    if (values.every((v) => v)) {
+                        return values.join('-');
+                    }
+                }
+                return asset[id];
+            })();
+            if (assetIdValue !== undefined) {
+                const found = findByKeyValue(id, assetIdValue, del);
+                if (found !== undefined) {
+                    // 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.calculateChanges = calculateChanges;