@contentstack/cli-migration 0.1.1-beta.1 → 1.0.0

package/src/services/content-types.js

@@ -1,323 +1,320 @@
 /* eslint-disable unicorn/explicit-length-check */
 /* eslint-disable no-unused-expressions */
-'use strict'
+'use strict';
 
-const Base = require('../modules/base')
+const Base = require('../modules/base');
 // Utils
-const {map: _map, safePromise, successHandler, errorHandler, constants} = require('../utils')
+const { map: _map, safePromise, successHandler, errorHandler, constants } = require('../utils');
 // Map methods
-const {get, getMapInstance, getDataWithAction} = _map
-const mapInstance = getMapInstance()
-const {ContentType, MANAGEMENT_SDK, actions: _actions} = constants
+const { get, getMapInstance, getDataWithAction } = _map;
+const mapInstance = getMapInstance();
+const { ContentType, MANAGEMENT_SDK, actions: _actions } = constants;
 
 class ContentTypeService {
   constructor() {
     // Stores actions required for moveField function
-    this.moveFieldActions = []
-    this.base = new Base()
-    this.stackSDKInstance = get(MANAGEMENT_SDK, mapInstance)
+    this.moveFieldActions = [];
+    this.base = new Base();
+    this.stackSDKInstance = get(MANAGEMENT_SDK, mapInstance);
   }
 
   async fetchContentType(callsite, id) {
-    const method = 'GET'
+    const method = 'GET';
 
-    const [err, result] = await safePromise(this.stackSDKInstance.contentType(id).fetch())
+    const [err, result] = await safePromise(this.stackSDKInstance.contentType(id).fetch());
     if (err) {
-      errorHandler(id, ContentType, method, err)
-      this.base.dispatch(callsite, id, err, 'apiError')
-      throw err
+      errorHandler(id, ContentType, method, err);
+      this.base.dispatch(callsite, id, err, 'apiError');
+      throw err;
     }
-    successHandler(id, ContentType, method)
+    successHandler(id, ContentType, method);
 
-    return result || {}
+    return result || {};
   }
 
   async postContentTypes(callsite, id, action) {
-    const data = getDataWithAction(id, mapInstance, action)
-    const [err, result] = await safePromise(this.stackSDKInstance.contentType().create(data))
+    const data = getDataWithAction(id, mapInstance, action);
+    const [err, result] = await safePromise(this.stackSDKInstance.contentType().create(data));
     if (err) {
-      errorHandler(id, ContentType, 'POST', err)
-      this.base.dispatch(callsite, id, err, 'apiError')
-      throw err
+      errorHandler(id, ContentType, 'POST', err);
+      this.base.dispatch(callsite, id, err, 'apiError');
+      throw err;
     }
 
-    successHandler(id, ContentType, 'POST')
-    return result.content_type || {}
+    successHandler(id, ContentType, 'POST');
+    return result.content_type || {};
   }
 
   async editContentType(callsite, data) {
-    const d = getDataWithAction(data.uid, mapInstance, _actions.EDIT_CT)
-    data = {...data, ...d.content_type}
-    const method = 'PUT'
-    const [err, result] = await safePromise(data.update())
+    const d = getDataWithAction(data.uid, mapInstance, _actions.EDIT_CT);
+    data = { ...data, ...d.content_type };
+    const method = 'PUT';
+    const [err, result] = await safePromise(data.update());
     if (err) {
-      errorHandler(data.uid, ContentType, method, err)
-      this.base.dispatch(callsite, data.uid, err, 'apiError')
-      throw err
+      errorHandler(data.uid, ContentType, method, err);
+      this.base.dispatch(callsite, data.uid, err, 'apiError');
+      throw err;
     }
 
-    successHandler(data.uid, ContentType, method)
-    return result.content_type || {}
+    successHandler(data.uid, ContentType, method);
+    return result.content_type || {};
   }
 
   async deleteContentType(callsite) {
-    const {id} = this
-    const method = 'DELETE'
-    const [err, result] = await safePromise(this.stackSDKInstance.contentType(id).delete())
+    const { id } = this;
+    const method = 'DELETE';
+    const [err, result] = await safePromise(this.stackSDKInstance.contentType(id).delete());
 
     if (err) {
-      errorHandler(id, ContentType, method, err)
-      this.base.dispatch(callsite, id, err, 'apiError')
-      throw err
+      errorHandler(id, ContentType, method, err);
+      this.base.dispatch(callsite, id, err, 'apiError');
+      throw err;
     }
-    successHandler(id, ContentType, method)
-    return result.content_type || {}
+    successHandler(id, ContentType, method);
+    return result.content_type || {};
   }
 
   applyActionsOnFields(callsite, data, cb) {
-    const {schema} = data
-    const {moveFieldActions, mergeEditSchema} = this
-    let i = 0
-    let finalSchema
+    const { schema } = data;
+    const { moveFieldActions, mergeEditSchema } = this;
+    let i = 0;
+    let finalSchema;
     try {
-      finalSchema = mergeEditSchema.call(this, schema)
+      finalSchema = mergeEditSchema.call(this, schema);
     } catch (error) {
-      this.base.dispatch(callsite, null, error, 'field')
+      this.base.dispatch(callsite, null, error, 'field');
       // Call the callback with error
-      if (typeof cb === 'function') return cb(error)
+      if (typeof cb === 'function') return cb(error);
     }
-    data.schema = finalSchema
+    data.schema = finalSchema;
     // Handle for no move field action required
-    if (!moveFieldActions.length) return cb(null, data)
+    if (!moveFieldActions.length) return cb(null, data);
     // eslint-disable-next-line
     while (true) {
       /** VALIDATIONS */
-      const validResult = this.getValidated(finalSchema, moveFieldActions[i])
+      const validResult = this.getValidated(finalSchema, moveFieldActions[i]);
       if (!validResult.isValid) {
-        const error = {message: `${validResult.missingField} does not exist in schema.`}
-        this.base.dispatch(callsite, null, error, 'field')
+        const error = { message: `${validResult.missingField} does not exist in schema.` };
+        this.base.dispatch(callsite, null, error, 'field');
         // Call the callback with error
-        if (typeof cb === 'function') return cb(error)
+        if (typeof cb === 'function') return cb(error);
       }
 
-      finalSchema = this[moveFieldActions[i].action](finalSchema, moveFieldActions[i])
-      i++
-      if (!moveFieldActions[i]) break
+      finalSchema = this[moveFieldActions[i].action](finalSchema, moveFieldActions[i]);
+      i++;
+      if (!moveFieldActions[i]) break;
     }
-    data.schema = finalSchema
-    if (cb) return cb(null, data)
-    return data
+    data.schema = finalSchema;
+    if (cb) return cb(null, data);
+    return data;
   }
 
   getActions(action) {
-    this.moveFieldActions.push(action)
+    this.moveFieldActions.push(action);
   }
 
   // Sets id and action for this instance
   setIdAndAction(id, action) {
-    this.id = id
-    this.action = action
+    this.id = id;
+    this.action = action;
   }
 
   // Merges the user specified with new fields with existing schema
   mergeEditSchema(schema = []) {
-    const mapInstance = getMapInstance()
+    const _mapInstance = getMapInstance();
 
-    const {id, action} = this
+    const { id, action } = this;
 
-    const contentType = get(id, mapInstance)
+    const contentType = get(id, _mapInstance);
 
-    let contentTypeSchema = contentType[action].content_type.schema
-    contentTypeSchema = contentTypeSchema || []
+    let contentTypeSchema = contentType[action].content_type.schema;
+    contentTypeSchema = contentTypeSchema || [];
 
-    const indicesToRemoveFromNewSchema = []
-    const indicesToRemoveFromOldSchema = []
+    const indicesToRemoveFromNewSchema = [];
+    const indicesToRemoveFromOldSchema = [];
 
-    let isEditFieldValid = false
-    let isEditFieldPresent = false
-    let isDeleteFieldValid = false
-    let isDeleteFieldPresent = false
-    let fieldToRaiseExceptionAgainst
+    let isEditFieldValid = false;
+    let isEditFieldPresent = false;
+    let isDeleteFieldValid = false;
+    let isDeleteFieldPresent = false;
+    let fieldToRaiseExceptionAgainst;
 
-    if (contentTypeSchema.length > 0  && schema.length > 0) {
+    if (contentTypeSchema.length > 0 && schema.length > 0) {
       // If found a updated field replace the new field with the existing field
       contentTypeSchema.forEach((newSchema, i) => {
         schema.every((oldSchema, j) => {
           /** VALIDATIONS */
           if (newSchema.isEdit) {
-            isEditFieldPresent = true
-            fieldToRaiseExceptionAgainst = newSchema.uid
-            newSchema.uid === oldSchema.uid && (isEditFieldValid = true)
+            isEditFieldPresent = true;
+            fieldToRaiseExceptionAgainst = newSchema.uid;
+            newSchema.uid === oldSchema.uid && (isEditFieldValid = true);
           }
 
           if (newSchema.isDelete) {
-            isDeleteFieldPresent = true
-            fieldToRaiseExceptionAgainst = newSchema.uid
+            isDeleteFieldPresent = true;
+            fieldToRaiseExceptionAgainst = newSchema.uid;
 
-            newSchema.uid === oldSchema.uid && (isDeleteFieldValid = true)
+            newSchema.uid === oldSchema.uid && (isDeleteFieldValid = true);
           }
           /** VALIDATIONS ENDS */
 
           if (newSchema.uid === oldSchema.uid) {
-            let tempObj = newSchema
-            indicesToRemoveFromNewSchema.push(i)
+            let tempObj = newSchema;
+            indicesToRemoveFromNewSchema.push(i);
             // Handle delete action here
             if (newSchema.isDelete) {
-              indicesToRemoveFromOldSchema.push(j)
+              indicesToRemoveFromOldSchema.push(j);
             } else {
-              schema.splice(j, 1, tempObj) // Replace the new schema with old schema
+              schema.splice(j, 1, tempObj); // Replace the new schema with old schema
             }
             // break
-            return false
+            return false;
           }
           // continue
-          return true
-        })
-      })
+          return true;
+        });
+      });
     }
 
     // Raise exception if any of the following conditions are true
     if ((isEditFieldPresent && !isEditFieldValid) || (isDeleteFieldPresent && !isDeleteFieldValid)) {
-      throw {message: `${fieldToRaiseExceptionAgainst} does not exist in the schema. Please check again`}
+      throw { message: `${fieldToRaiseExceptionAgainst} does not exist in the schema. Please check again` };
     }
 
-    contentTypeSchema = contentTypeSchema.filter((_, i) =>
-      !indicesToRemoveFromNewSchema.includes(i))
+    contentTypeSchema = contentTypeSchema.filter((_, i) => !indicesToRemoveFromNewSchema.includes(i));
 
-    schema = schema.filter((_, i) =>
-      !indicesToRemoveFromOldSchema.includes(i))
+    schema = schema.filter((_, i) => !indicesToRemoveFromOldSchema.includes(i));
 
-    schema = schema.concat(contentTypeSchema)
-    contentType[action].content_type.schema = schema
-    return schema
+    schema = schema.concat(contentTypeSchema);
+    contentType[action].content_type.schema = schema;
+    return schema;
   }
 
   toTheTop(schema, actionObj) {
-    const {fieldToMove} = actionObj
-    let i = 0
+    const { fieldToMove } = actionObj;
+    let i = 0;
     // eslint-disable-next-line
     while (true) {
       if (schema[i].uid === fieldToMove) {
-        let tempObj = schema[i]
-        schema.splice(i, 1)
-        schema.unshift(tempObj)
-        break
+        let tempObj = schema[i];
+        schema.splice(i, 1);
+        schema.unshift(tempObj);
+        break;
       }
-      i++
-      if (!schema[i]) break // Error handling required
+      i++;
+      if (!schema[i]) break; // Error handling required
     }
-    return schema
+    return schema;
   }
 
   toTheBottom(schema, actionObj) {
-    const {fieldToMove} = actionObj
+    const { fieldToMove } = actionObj;
 
-    let i = 0
+    let i = 0;
     // eslint-disable-next-line
     while (true) {
       if (schema[i].uid === fieldToMove) {
-        let tempObj = schema[i]
-        schema.splice(i, 1)
-        schema.push(tempObj)
-        break
+        let tempObj = schema[i];
+        schema.splice(i, 1);
+        schema.push(tempObj);
+        break;
       }
-      i++
-      if (!schema[i]) break
+      i++;
+      if (!schema[i]) break;
     }
-    return schema
+    return schema;
   }
 
   afterField(schema, actionObj) {
-    const {fieldToMove, against} = actionObj
-    let i = 0
-    let indexToMove = 0
-    let tempObj
-    let found = 0
+    const { fieldToMove, against } = actionObj;
+    let i = 0;
+    let indexToMove = 0;
+    let tempObj;
+    let found = 0;
     // eslint-disable-next-line
     while (true) {
       if (schema[i].uid === against) {
-        indexToMove = i
-        found++
+        indexToMove = i;
+        found++;
       }
       if (schema[i].uid === fieldToMove) {
-        tempObj = schema[i]
-        schema.splice(i, 1)
-        found++
+        tempObj = schema[i];
+        schema.splice(i, 1);
+        found++;
       }
-      i++
-      if (found === 2) break
-      if (!schema[i]) break
+      i++;
+      if (found === 2) break;
+      if (!schema[i]) break;
     }
     // TODO: Handle error
-    found === 2 && schema.splice(indexToMove + 1, null, tempObj)
-    return schema
+    found === 2 && schema.splice(indexToMove + 1, null, tempObj);
+    return schema;
   }
 
   beforeField(schema, actionObj) {
-    const {fieldToMove, against} = actionObj
+    const { fieldToMove, against } = actionObj;
 
-    let i = 0
-    let indexToMove = 0
-    let tempObj = 0
-    let found = 0
+    let i = 0;
+    let indexToMove = 0;
+    let tempObj = 0;
+    let found = 0;
     // eslint-disable-next-line
     while (true) {
       if (schema[i].uid === against) {
-        indexToMove = i
-        found++
+        indexToMove = i;
+        found++;
       }
       if (schema[i].uid === fieldToMove) {
-        tempObj = schema[i]
-        schema.splice(i, 1)
-        found++
+        tempObj = schema[i];
+        schema.splice(i, 1);
+        found++;
       }
-      i++
-      if (found === 2) break
-      if (!schema[i]) break
+      i++;
+      if (found === 2) break;
+      if (!schema[i]) break;
     }
-    found === 2 && schema.splice(indexToMove, null, tempObj)
-    return schema
+    found === 2 && schema.splice(indexToMove, null, tempObj);
+    return schema;
   }
 
   getValidated(schema, actionObj) {
-    let isValid = true
-    let found = 0
-    let missingField = ''
-    let i = 0
+    let isValid = true;
+    let found = 0;
+    let missingField = '';
+    let i = 0;
 
-    const {fieldToMove, against} = actionObj
-    const uids = []
+    const { fieldToMove, against } = actionObj;
+    const uids = [];
     // eslint-disable-next-line
     while (true) {
-
-      uids.push(schema[i].uid)
+      uids.push(schema[i].uid);
 
       if (schema[i].uid === fieldToMove) {
-        found++
+        found++;
       }
       if (against === schema[i].uid) {
-        found++
+        found++;
       }
-      i++
-      if (!schema[i]) break
+      i++;
+      if (!schema[i]) break;
     }
     // TODO: Need a better way to handle this
-    missingField = uids.includes(fieldToMove) ? null : fieldToMove
+    missingField = uids.includes(fieldToMove) ? null : fieldToMove;
 
     // against && (missingField = !uids.includes(against) ? against : null);
     if (!missingField && against) {
-      missingField = uids.includes(against) ? null : against
+      missingField = uids.includes(against) ? null : against;
     }
 
     // Handling both the scenarios
     if (found === 0) {
-      isValid = false
+      isValid = false;
     } else if (against && found === 1) {
-      isValid = false
+      isValid = false;
     }
 
-    return {isValid, missingField}
+    return { isValid, missingField };
   }
 }
 
-module.exports = ContentTypeService
+module.exports = ContentTypeService;

package/src/services/index.js

@@ -1,6 +1,6 @@
-'use strict'
+'use strict';
 
 module.exports = {
   ContentTypeService: require('./content-types'),
   LocaleService: require('./locales'),
-}
+};

package/src/services/locales.js

@@ -1,74 +1,72 @@
-'use strict'
+'use strict';
 
 // Utils
-const {safePromise, constants, map: _map} = require('../utils')
-const {MANAGEMENT_SDK} = constants
-const {get, getMapInstance} = _map
-const mapInstance = getMapInstance()
-this.stackSDKInstance = get(MANAGEMENT_SDK, mapInstance)
+const { safePromise, constants, map: _map } = require('../utils');
+const { MANAGEMENT_SDK } = constants;
+const { get, getMapInstance } = _map;
+const mapInstance = getMapInstance();
+this.stackSDKInstance = get(MANAGEMENT_SDK, mapInstance);
 
 class LocaleService {
   constructor() {
-    this.stackSDKInstance = get(MANAGEMENT_SDK, mapInstance)
+    this.stackSDKInstance = get(MANAGEMENT_SDK, mapInstance);
   }
 
   async getLocale() {
-    const [err, result] = await safePromise(
-      this.stackSDKInstance.locale().query().find()
-    )
-    if (err) throw err
-    let orderedResult = this.getOrderedResult(result)
-    return orderedResult
+    const [err, result] = await safePromise(this.stackSDKInstance.locale().query().find());
+    if (err) throw err;
+    let orderedResult = this.getOrderedResult(result);
+    return orderedResult;
   }
 
   getOrderedResult(result) {
     if (result && result.items) {
-      const locales = result.items
+      const locales = result.items;
 
-      let i = 0
-      let noEventTookPlace = 0 // counter which tracks if the list is sorted by fallback language
-      let len = locales.length
+      let i = 0;
+      let noEventTookPlace = 0; // counter which tracks if the list is sorted by fallback language
+      let len = locales.length;
 
       // Circular loop (Time complexity => Order of n^2, complexity of splice op is ignored)
       do {
-        i = i % len + 1
-        noEventTookPlace++
+        i = (i % len) + 1;
+        noEventTookPlace++;
 
-        let correctedI = i - 1
+        let correctedI = i - 1;
 
-        let a = locales[correctedI]
+        let a = locales[correctedI];
 
         if (a.fallback_locale) {
-          let fallbackLangIndex = 0
-          let currentLangIndex = 0
+          let fallbackLangIndex = 0;
+          let currentLangIndex = 0;
 
           for (let x = 0; x < len; x++) {
             if (locales[x].code === a.code) {
-              currentLangIndex = x
+              currentLangIndex = x;
             }
             if (locales[x].code === a.fallback_locale) {
-              fallbackLangIndex = x
+              fallbackLangIndex = x;
             }
           }
 
           // if index of fallback langauge is smaller no operation is required, it might be sorted
           if (currentLangIndex > fallbackLangIndex) {
-            continue
+            continue;
           }
-          let temp = a
+          let temp = a;
           // remove the object
-          locales.splice(correctedI, 1)
+          locales.splice(correctedI, 1);
           // add the object at fallbackLangIndex cus size of locales is decremented
-          locales.splice(fallbackLangIndex, 0, temp)
-          i--
-          noEventTookPlace--
+          locales.splice(fallbackLangIndex, 0, temp);
+          i--;
+          noEventTookPlace--;
         }
-      } while (noEventTookPlace < len)
+      } while (noEventTookPlace < len);
 
-      return locales
+      return locales;
     }
-    throw {message: 'Something went wrong.'}
+    throw { message: 'Something went wrong.' };
   }
 }
 
-module.exports = LocaleService
+module.exports = LocaleService;

package/src/utils/auto-retry.js

@@ -1,10 +1,12 @@
-'use strict'
+'use strict';
 
-const {MAX_RETRY} = require('./constants')
+const { MAX_RETRY } = require('./constants');
 
 const __safePromise = (promise, data) => {
-  return promise(data).then(res => [null, res]).catch(err => [err])
-}
+  return promise(data)
+    .then((res) => [null, res])
+    .catch((err) => [err]);
+};
 
 async function autoRetry(promise, retryCount = 0) {
   /**
@@ -12,19 +14,19 @@ async function autoRetry(promise, retryCount = 0) {
    * whereas for content types it fetches request params from global map object,
    * thus the handling
    */
-  let data
-  this && (data = this.data)
+  let data;
+  this && (data = this.data);
 
-  const [error, result] = await __safePromise(promise, data)
+  const [error, result] = await __safePromise(promise, data);
 
   if (error) {
-    retryCount++
+    retryCount++;
     if (retryCount === MAX_RETRY) {
-      throw error
+      throw error;
     }
-    return await autoRetry(promise, retryCount)
+    return await autoRetry(promise, retryCount);
   }
-  return result
+  return result;
 }
 
-module.exports = autoRetry
+module.exports = autoRetry;