@contentstack/cli-migration 0.1.1-beta.1

package/src/modules/migration.js

@@ -0,0 +1,106 @@
+'use strict'
+
+const {map: _map, getCallsite, constants, safePromise} = require('../utils')
+const Listr = require('listr')
+const {waterfall} = require('async')
+const {requests} = constants
+
+// Properties
+const {getMapInstance, set, get} = _map
+
+const ContentType = require('./content-types')
+
+// Merge all classes containing migration methods into a single class
+const _Migration = _Class => class extends _Class { }
+
+/**
+ * Migration class
+ * @class Migration
+ */
+class Migration extends _Migration(ContentType) {
+  /**
+   * Adds custom task in migration to execute.
+   * @param {Object} taskDescription Task title and task function to execute
+   * @param {string} taskDescription.title Title for custom task
+   * @param {array} taskDescription.task async function to be executed
+   * @param {string} taskDescription.failMessage message to be printed when task fails
+   * @param {string} taskDescription.successMessage message to be printed when task succeeds
+   * @example
+   *
+   * let first = 'binding glue'
+   * let second = 'second glue'
+   * let tasks = {
+   *    title:'My First custom task',
+   *    successMessage: 'Custom success message',
+   *    failMessage: 'Custom fail message'
+   *    task: async (params)=>{
+   *        const {first, second} = params
+   *        const a = await stackSDKInstance.fetch();
+   *    },
+   * }
+   * migration.addTask(task)
+   */
+  addTask(taskDescription) {
+    const {title, failMessage, successMessage} = taskDescription
+    let {tasks, task} = taskDescription
+    const callsite = getCallsite()
+    const mapInstance = getMapInstance()
+    // eslint-disable-next-line no-warning-comments
+    // TODO: Make it better to accept only single task
+    if (tasks && !Array.isArray(tasks))
+      tasks = [tasks]
+    if (task && !Array.isArray(task)) {
+      tasks = [task]
+    }
+    this.contentTypeService.base.dispatch(callsite, null, null, tasks)
+    let _requests = get(requests, mapInstance)
+    const req = {
+      title: title,
+      failedTitle: failMessage || `Failed to execute task: ${title}`,
+      successTitle: successMessage || `Successfully executed task: ${title}`,
+      tasks,
+    }
+    _requests.push(req)
+    set(requests, mapInstance, _requests)
+  }
+
+  async run() {
+    const mapInstance = getMapInstance()
+    let _requests = get(requests, mapInstance)
+    // Make calls from here
+    const tasks = await this.getTasks(_requests)
+    const listr = new Listr(tasks)
+    await listr.run().catch(error => {
+      this.handleErrors(error)
+      // When the process is child, send error message to parent
+      if (process.send) process.send({errorOccurred: true})
+    })
+  }
+
+  async getTasks(requests) {
+    const _tasks = []
+    const results = []
+    for (let i = 0; i < requests.length; i++) {
+      let reqObj = requests[i]
+      const {title, failedTitle, successTitle, tasks} = reqObj
+      const task = {
+        title: title,
+        task: async (ctx, task) => {
+          const [err, result] = await safePromise(waterfall(tasks))
+          if (err) {
+            ctx.error = true
+            task.title = failedTitle
+            throw err
+          }
+          result && results.push(result)
+          task.title = successTitle
+          return result
+        },
+      }
+      _tasks.push(task)
+    }
+    return _tasks
+  }
+}
+
+module.exports = Migration

package/src/modules/parser.js

@@ -0,0 +1,84 @@
+'use strict'
+
+const Migration = require('./migration')
+
+const {
+  CreateContentTypeValidator,
+  EditContentTypeValidator,
+  _TypeError,
+  FieldValidator,
+} = require('../validators')
+// eslint-disable-next-line no-warning-comments
+// TODO: Need a better way to combine classes
+const Base = require('./base')
+
+const {ActionList} = require('../actions')
+// Utils
+const {map: _map, constants} = require('../utils')
+// map properties
+const {getMapInstance, get} = _map
+// Constants
+const {actionMapper, MANAGEMENT_SDK, MANAGEMENT_TOKEN, AUTH_TOKEN, API_KEY, BRANCH} = constants
+
+class Parser {
+  async getMigrationParser(migrationFunc) {
+    const migration = new Migration()
+    const mapInstance = getMapInstance()
+    const parseResult = {}
+    const typeErrors = []
+    // migrations
+    try {
+      const stackSDKInstance = get(MANAGEMENT_SDK, mapInstance)
+      const managementToken = get(MANAGEMENT_TOKEN, mapInstance)
+      const authToken = get(AUTH_TOKEN, mapInstance)
+      const apiKey = get(API_KEY, mapInstance)
+      const branch = get(BRANCH, mapInstance)
+      await migrationFunc({migration, stackSDKInstance, managementToken, authToken, apiKey, branch})
+    } catch (error) {
+      if (error instanceof TypeError) {
+        if (error.message.includes('is not a function')) {
+          const base = new Base()
+          // eslint-disable-next-line
+          const [, filename, line] = error.stack.match(/\/([\/\w-_\.]+\.js):(\d*):(\d*)/);
+          const callsite = {
+            getFileName: () => `/${filename}`,
+            getLineNumber: () => line,
+          }
+          const errMsgString = error.message.split(' ')
+          const typeErrorFirstStr = errMsgString[0].split('.')
+          const typeErrorFunction = typeErrorFirstStr[typeErrorFirstStr.length - 1]
+          typeErrors.push(typeErrorFunction)
+          base.dispatch(callsite, null, {typeErrors}, 'typeError')
+        }
+      } else {
+        console.log(error)
+        // eslint-disable-next-line
+        const [, filename, line] = error.stack.match(/\/([\/\w-_\.]+\.js):(\d*):(\d*)/)
+        const callsite = {
+          getFileName: () => `/${filename}`,
+          getLineNumber: () => line,
+        }
+        const base = new Base()
+        let typeErrors = [error]
+        base.dispatch(callsite, null, {typeErrors}, 'typeError')
+      }
+    }
+    const actions = get(actionMapper, mapInstance)
+    const actionList = new ActionList(actions)
+
+    actionList.addValidators(new CreateContentTypeValidator())
+    actionList.addValidators(new FieldValidator())
+    actionList.addValidators(new _TypeError())
+    actionList.addValidators(new EditContentTypeValidator())
+
+    const hasErrors = actionList.validate()
+
+    if (hasErrors.length > 0) {
+      parseResult.hasErrors = hasErrors
+      return parseResult
+    }
+    return parseResult
+  }
+}
+
+module.exports = Parser

package/src/services/content-types.js

@@ -0,0 +1,323 @@
+/* eslint-disable unicorn/explicit-length-check */
+/* eslint-disable no-unused-expressions */
+'use strict'
+
+const Base = require('../modules/base')
+// 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
+
+class ContentTypeService {
+  constructor() {
+    // Stores actions required for moveField function
+    this.moveFieldActions = []
+    this.base = new Base()
+    this.stackSDKInstance = get(MANAGEMENT_SDK, mapInstance)
+  }
+
+  async fetchContentType(callsite, id) {
+    const method = 'GET'
+
+    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
+    }
+    successHandler(id, ContentType, method)
+
+    return result || {}
+  }
+
+  async postContentTypes(callsite, id, action) {
+    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
+    }
+
+    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())
+    if (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 || {}
+  }
+
+  async deleteContentType(callsite) {
+    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
+    }
+    successHandler(id, ContentType, method)
+    return result.content_type || {}
+  }
+
+  applyActionsOnFields(callsite, data, cb) {
+    const {schema} = data
+    const {moveFieldActions, mergeEditSchema} = this
+    let i = 0
+    let finalSchema
+    try {
+      finalSchema = mergeEditSchema.call(this, schema)
+    } catch (error) {
+      this.base.dispatch(callsite, null, error, 'field')
+      // Call the callback with error
+      if (typeof cb === 'function') return cb(error)
+    }
+    data.schema = finalSchema
+    // Handle for no move field action required
+    if (!moveFieldActions.length) return cb(null, data)
+    // eslint-disable-next-line
+    while (true) {
+      /** VALIDATIONS */
+      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')
+        // Call the callback with error
+        if (typeof cb === 'function') return cb(error)
+      }
+
+      finalSchema = this[moveFieldActions[i].action](finalSchema, moveFieldActions[i])
+      i++
+      if (!moveFieldActions[i]) break
+    }
+    data.schema = finalSchema
+    if (cb) return cb(null, data)
+    return data
+  }
+
+  getActions(action) {
+    this.moveFieldActions.push(action)
+  }
+
+  // Sets id and action for this instance
+  setIdAndAction(id, action) {
+    this.id = id
+    this.action = action
+  }
+
+  // Merges the user specified with new fields with existing schema
+  mergeEditSchema(schema = []) {
+    const mapInstance = getMapInstance()
+
+    const {id, action} = this
+
+    const contentType = get(id, mapInstance)
+
+    let contentTypeSchema = contentType[action].content_type.schema
+    contentTypeSchema = contentTypeSchema || []
+
+    const indicesToRemoveFromNewSchema = []
+    const indicesToRemoveFromOldSchema = []
+
+    let isEditFieldValid = false
+    let isEditFieldPresent = false
+    let isDeleteFieldValid = false
+    let isDeleteFieldPresent = false
+    let fieldToRaiseExceptionAgainst
+
+    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)
+          }
+
+          if (newSchema.isDelete) {
+            isDeleteFieldPresent = true
+            fieldToRaiseExceptionAgainst = newSchema.uid
+
+            newSchema.uid === oldSchema.uid && (isDeleteFieldValid = true)
+          }
+          /** VALIDATIONS ENDS */
+
+          if (newSchema.uid === oldSchema.uid) {
+            let tempObj = newSchema
+            indicesToRemoveFromNewSchema.push(i)
+            // Handle delete action here
+            if (newSchema.isDelete) {
+              indicesToRemoveFromOldSchema.push(j)
+            } else {
+              schema.splice(j, 1, tempObj) // Replace the new schema with old schema
+            }
+            // break
+            return false
+          }
+          // continue
+          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`}
+    }
+
+    contentTypeSchema = contentTypeSchema.filter((_, i) =>
+      !indicesToRemoveFromNewSchema.includes(i))
+
+    schema = schema.filter((_, i) =>
+      !indicesToRemoveFromOldSchema.includes(i))
+
+    schema = schema.concat(contentTypeSchema)
+    contentType[action].content_type.schema = schema
+    return schema
+  }
+
+  toTheTop(schema, actionObj) {
+    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
+      }
+      i++
+      if (!schema[i]) break // Error handling required
+    }
+    return schema
+  }
+
+  toTheBottom(schema, actionObj) {
+    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.push(tempObj)
+        break
+      }
+      i++
+      if (!schema[i]) break
+    }
+    return schema
+  }
+
+  afterField(schema, actionObj) {
+    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++
+      }
+      if (schema[i].uid === fieldToMove) {
+        tempObj = schema[i]
+        schema.splice(i, 1)
+        found++
+      }
+      i++
+      if (found === 2) break
+      if (!schema[i]) break
+    }
+    // TODO: Handle error
+    found === 2 && schema.splice(indexToMove + 1, null, tempObj)
+    return schema
+  }
+
+  beforeField(schema, actionObj) {
+    const {fieldToMove, against} = actionObj
+
+    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++
+      }
+      if (schema[i].uid === fieldToMove) {
+        tempObj = schema[i]
+        schema.splice(i, 1)
+        found++
+      }
+      i++
+      if (found === 2) break
+      if (!schema[i]) break
+    }
+    found === 2 && schema.splice(indexToMove, null, tempObj)
+    return schema
+  }
+
+  getValidated(schema, actionObj) {
+    let isValid = true
+    let found = 0
+    let missingField = ''
+    let i = 0
+
+    const {fieldToMove, against} = actionObj
+    const uids = []
+    // eslint-disable-next-line
+    while (true) {
+
+      uids.push(schema[i].uid)
+
+      if (schema[i].uid === fieldToMove) {
+        found++
+      }
+      if (against === schema[i].uid) {
+        found++
+      }
+      i++
+      if (!schema[i]) break
+    }
+    // TODO: Need a better way to handle this
+    missingField = uids.includes(fieldToMove) ? null : fieldToMove
+
+    // against && (missingField = !uids.includes(against) ? against : null);
+    if (!missingField && against) {
+      missingField = uids.includes(against) ? null : against
+    }
+
+    // Handling both the scenarios
+    if (found === 0) {
+      isValid = false
+    } else if (against && found === 1) {
+      isValid = false
+    }
+
+    return {isValid, missingField}
+  }
+}
+
+module.exports = ContentTypeService

package/src/services/index.js

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

package/src/services/locales.js

@@ -0,0 +1,74 @@
+'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)
+
+class LocaleService {
+  constructor() {
+    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
+  }
+
+  getOrderedResult(result) {
+    if (result && 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
+
+      // Circular loop (Time complexity => Order of n^2, complexity of splice op is ignored)
+      do {
+        i = i % len + 1
+        noEventTookPlace++
+
+        let correctedI = i - 1
+
+        let a = locales[correctedI]
+
+        if (a.fallback_locale) {
+          let fallbackLangIndex = 0
+          let currentLangIndex = 0
+
+          for (let x = 0; x < len; x++) {
+            if (locales[x].code === a.code) {
+              currentLangIndex = x
+            }
+            if (locales[x].code === a.fallback_locale) {
+              fallbackLangIndex = x
+            }
+          }
+
+          // if index of fallback langauge is smaller no operation is required, it might be sorted
+          if (currentLangIndex > fallbackLangIndex) {
+            continue
+          }
+          let temp = a
+          // remove the object
+          locales.splice(correctedI, 1)
+          // add the object at fallbackLangIndex cus size of locales is decremented
+          locales.splice(fallbackLangIndex, 0, temp)
+          i--
+          noEventTookPlace--
+        }
+      } while (noEventTookPlace < len)
+
+      return locales
+    }
+    throw {message: 'Something went wrong.'}
+  }
+}
+
+module.exports = LocaleService

package/src/utils/auto-retry.js

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

package/src/utils/callsite.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const getCallsites = require('callsites')
+const {parse, resolve} = require('path')
+
+function getFileDirectory(path) {
+  const parentPath = resolve(path, '../') // Assuming that will be 2 folders up
+  return parse(parentPath).dir
+}
+
+module.exports = () => {
+  const thisDir = getFileDirectory(__filename)
+  const callsites = getCallsites()
+
+  const externalFile = callsites.find(callsite => {
+    const currentDir = getFileDirectory(callsite.getFileName())
+    const isNotThisDir = thisDir !== currentDir
+    return isNotThisDir
+  })
+
+  return externalFile
+}