@contentstack/cli-migration 0.1.1-beta.1

package/src/utils/schema-helper.js

@@ -0,0 +1,35 @@
+/* eslint-disable camelcase */
+'use strict'
+
+const {version, defaultDataType, actions} = require('./constants')
+
+exports.getSchema = (field, subAction) => {
+  const {EDIT_FIELD, DELETE_FIELD} = actions
+
+  const schema = {
+    display_name: field,
+    uid: this.getUid(field),
+    data_type: defaultDataType, // This will be overridden if user specifies data type
+    mandatory: this.getMandatoryVal(field),
+    unique: this.getUniqueVal(field),
+    field_metadata: this.getFieldMetaData(field),
+    non_localizable: false,
+    // isDelete: !!isDelete,
+    isDelete: subAction === DELETE_FIELD,
+    isEdit: subAction === EDIT_FIELD,
+  }
+  return schema
+}
+
+exports.getUid = data => data.split(' ').join('_').toLowerCase()
+
+exports.getMandatoryVal = data => data.toLowerCase() === 'title' || data.toLowerCase() === 'url'
+
+exports.getUniqueVal = data => data.toLowerCase() === 'title' || data.toLowerCase() === 'url'
+
+exports.getFieldMetaData = data => {
+  return {
+    _default: this.getMandatoryVal(data),
+    version,
+  }
+}

package/src/utils/success-handler.js

@@ -0,0 +1,12 @@
+'use strict'
+
+const {success} = require('./logger')
+const {successMessageHandler} = require('./constants')
+
+module.exports = (data, type, method) => {
+  if (data && type && method) {
+    //success(`Successfully ${successMessageHandler[method]} ${type}: ${data}`);
+  } else {
+    success(`${type} successfully completed`)
+  }
+}

package/src/validators/api-error.js

@@ -0,0 +1,18 @@
+'use strict'
+
+class ApiError {
+  validate(data) {
+    if (data.payload.apiError) {
+      return [{
+        ...data,
+        message: `${data.payload.apiError.error_message}`,
+      }]
+    }
+    return []
+  }
+
+  isApplicable(action) {
+    return action.type === 'apiError'
+  }
+}
+module.exports = ApiError

package/src/validators/base-validator.js

@@ -0,0 +1,39 @@
+'use strict'
+
+const {keys} = Object
+class BaseValidator {
+  commonValidate(properties, data) {
+    const errors = []
+    const opts = data.payload.options
+    const dataKeys = keys(opts)
+
+    for (let i = 0; i < properties.length; i++) {
+      let prop = properties[i]
+      // Check if property is mandatory but not present in user specified params
+      if (prop.mandatory && !dataKeys.includes(prop.name)) {
+        errors.push({...data, message: `${prop.name} is required.`})
+      }
+
+      if (prop.name in opts) {
+        const dataType = this.getDataType(opts[prop.name])
+        if (dataType !== prop.type) {
+          errors.push({...data, message: `${prop.name} is a ${dataType} type`})
+        }
+
+        if (prop.dependsOn && !(prop.dependsOn in opts) && opts[prop.name]) {
+          errors.push({...data, message: `${prop.dependsOn} is required with ${prop.name}`})
+        }
+      }
+    }
+
+    return errors
+  }
+
+  getDataType(data) {
+    if (Array.isArray(data)) {
+      return 'array'
+    }
+    return typeof data
+  }
+}
+module.exports = BaseValidator

package/src/validators/create-content-type-validator.js

@@ -0,0 +1,58 @@
+'use strict'
+
+const {keys} = Object
+// Utils
+const {map: _map, constants} = require('../utils')
+// Properties
+const {getMapInstance, get} = _map
+const {contentTypeProperties} = constants
+
+const mandatoryKeys = [
+  'uid',
+  'title',
+  'description',
+]
+
+class CreateContentTypeValidator {
+  constructor() {
+    // super();
+    this.errors = []
+  }
+
+  validate(data) {
+    // Validate the latest updated object in the global map object
+    const mapInstance = getMapInstance()
+    const mapObj = get(data.payload.contentTypeId, mapInstance)
+    const actionObj = mapObj[data.payload.action].content_type
+    const userProvidedFields = keys(actionObj)
+
+    for (const key of mandatoryKeys) {
+      if (!keys(actionObj).includes(key) || !actionObj[key]) {
+        data = {...data, message: `${key} is missing.`}
+        this.errors.push(data)
+      }
+    }
+
+    // TODO: Fix error messages
+    const propertyNames = this.getPropertyNames()
+
+    for (let i = 0; i < userProvidedFields.length; i++) {
+      let key = userProvidedFields[i]
+      if (!propertyNames.includes(key)) {
+        data = {...data, message: `${key} is not valid property.`}
+        this.errors.push(data)
+      }
+    }
+    return this.errors
+  }
+
+  isApplicable(action) {
+    return action.type === 'create'
+  }
+
+  getPropertyNames() {
+    return contentTypeProperties
+  }
+}
+
+module.exports = CreateContentTypeValidator

package/src/validators/edit-content-type-validator.js

@@ -0,0 +1,56 @@
+'use strict'
+
+const {keys} = Object
+
+// Utils
+const {map: _map, constants} = require('../utils')
+// Properties
+const {getMapInstance, get} = _map
+const {contentTypeProperties} = constants
+
+const mandatoryKeys = [
+  'uid',
+  'title',
+]
+
+class EditContentTypeValidator {
+  constructor() {
+    this.errors = []
+  }
+
+  validate(data) {
+    // Validate the latest updated object in the global map object
+    const mapInstance = getMapInstance()
+    const mapObj = get(data.payload.contentTypeId, mapInstance)
+    const actionObj = mapObj[data.payload.action].content_type
+    const userProvidedFields = keys(actionObj)
+
+    for (const key of mandatoryKeys) {
+      if (!userProvidedFields.includes(key)) {
+        data = {...data, message: `${key} is missing.`}
+        this.errors.push(data)
+      }
+    }
+    // TODO: Fix error messages
+    const propertyNames = this.getPropertyNames()
+
+    for (let i = 0; i < userProvidedFields.length; i++) {
+      let key = userProvidedFields[i]
+      if (!propertyNames.includes(key)) {
+        data = {...data, message: `${key} is not valid property.`}
+        this.errors.push(data)
+      }
+    }
+    return this.errors
+  }
+
+  isApplicable(action) {
+    return action.type === 'edit'
+  }
+
+  getPropertyNames() {
+    return contentTypeProperties
+  }
+}
+
+module.exports = EditContentTypeValidator

package/src/validators/field-validator.js

@@ -0,0 +1,19 @@
+'use strict'
+
+class FieldValidator {
+  validate(data) {
+    if (data.payload.field) {
+      return [{
+        ...data,
+        message: data.payload.field.message,
+      }]
+    }
+    return []
+  }
+
+  isApplicable(action) {
+    return action.type === 'field'
+  }
+}
+
+module.exports = FieldValidator

package/src/validators/index.js

@@ -0,0 +1,11 @@
+'use strict'
+
+module.exports = {
+  CreateContentTypeValidator: require('./create-content-type-validator'),
+  EditContentTypeValidator: require('./edit-content-type-validator'),
+  SchemaValidator: require('./schema-validator'),
+  FieldValidator: require('./field-validator'),
+  _TypeError: require('./type-error'),
+  ApiError: require('./api-error'),
+  MigrationError: require('./migration-error'),
+}

package/src/validators/migration-error.js

@@ -0,0 +1,18 @@
+'use strict'
+
+class MigrationError {
+  validate(data) {
+    if (data.payload.migrationError) {
+      return [{
+        ...data,
+        message: `${data.payload.migrationError.migrationError.message}`,
+      }]
+    }
+  }
+
+  isApplicable(action) {
+    return action.type === 'migrationError'
+  }
+}
+
+module.exports = MigrationError

package/src/validators/schema-validator.js

@@ -0,0 +1,21 @@
+'use strict'
+
+class SchemaValidator {
+  validate(data) {
+    const {fromField, toField, toReferenceField, deriveField} = data.payload
+    // const fieldsToValidate = [payload]
+    if (fromField || toField || toReferenceField || deriveField) {
+      return [{
+        ...data,
+        message: `${fromField || toField || toReferenceField || deriveField} does not exist on schema.`,
+      }]
+    }
+    return []
+  }
+
+  isApplicable(action) {
+    return action.type === 'schema'
+  }
+}
+
+module.exports = SchemaValidator

package/src/validators/type-error.js

@@ -0,0 +1,21 @@
+'use strict'
+
+class _TypeError {
+  constructor() {
+  }
+
+  validate(data) {
+    if (data.payload.typeErrors) {
+      return [{
+        ...data,
+        message: `${data.payload.typeErrors[0]} is not a valid function`,
+      }]
+    }
+    return []
+  }
+
+  isApplicable(action) {
+    return action.type === 'typeError'
+  }
+}
+module.exports = _TypeError