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

package/src/utils/logger.js

@@ -1,84 +1,74 @@
-'use strict'
+'use strict';
 
-const {createLogger, format, transports} = require('winston')
-const {resolve, join} = require('path')
-const {slice} = Array.prototype
-const {stringify} = JSON
+const { createLogger, format, transports } = require('winston');
+const { resolve, join } = require('path');
+const { slice } = Array.prototype;
+const { stringify } = JSON;
 
-const {combine, label, printf, colorize} = format
+const { combine, label, printf, colorize } = format;
 
 // FS helper
-const {makeDir} = require('./fs-helper')
+const { makeDir } = require('./fs-helper');
 
-const {NODE_ENV} = process.env
+const { NODE_ENV } = process.env;
 
 function getString(args) {
-  let str = ''
+  let str = '';
   if (args && args.length > 0) {
-    str = args.map(item =>
-      item && typeof item === 'object' ?
-        stringify(item) :
-        item
-    )
-    .join(' ')
-    .trim()
+    str = args
+      .map((item) => (item && typeof item === 'object' ? stringify(item) : item))
+      .join(' ')
+      .trim();
   }
-  return str
+  return str;
 }
 
-const customFormat = printf(({level, message}) => {
-  return `${level}: ${message}`
-})
+const customFormat = printf(({ level, message }) => {
+  return `${level}: ${message}`;
+});
 
 function init(logFileName) {
-  const logsDir = resolve('logs')
+  const logsDir = resolve('logs');
   // Create dir if does not exist
-  makeDir(logsDir)
+  makeDir(logsDir);
 
-  const logPath = join(logsDir, logFileName + '.log')
+  const logPath = join(logsDir, logFileName + '.log');
   const logger = createLogger({
-    format: combine(
-      colorize(),
-      label({label: 'Migration'}),
-      customFormat
-    ),
-    transports: [
-      new transports.File({filename: logPath}),
-      new transports.Console(),
-    ],
-  })
+    format: combine(colorize(), label({ label: 'Migration' }), customFormat),
+    transports: [new transports.File({ filename: logPath }), new transports.Console()],
+  });
 
-  let args
-  let logString
+  let args;
+  let logString;
 
   return {
     log: function () {
-      args = slice.call(arguments)
-      logString = getString(args)
-      logString && logger.log('info', logString)
+      args = slice.call(arguments);
+      logString = getString(args);
+      logString && logger.log('info', logString);
     },
     warn: function () {
-      args = slice.call(arguments)
-      logString = getString(args)
-      logString && logger.log('warn', logString)
+      args = slice.call(arguments);
+      logString = getString(args);
+      logString && logger.log('warn', logString);
     },
     error: function () {
-      args = slice.call(arguments)
-      logString = getString(args)
-      logString && logger.log('error', logString)
+      args = slice.call(arguments);
+      logString = getString(args);
+      logString && logger.log('error', logString);
     },
     debug: function () {
-      args = slice.call(arguments)
-      logString = getString(args)
-      logString && logger.log('debug', logString)
+      args = slice.call(arguments);
+      logString = getString(args);
+      logString && logger.log('debug', logString);
     },
-  }
+  };
 }
 
-exports.success = init('success').log
+exports.success = init('success').log;
 if (NODE_ENV === 'test') {
-  exports.error = init('warn').warn
+  exports.error = init('warn').warn;
 } else {
-  exports.error = init('error').error
+  exports.error = init('error').error;
 }
-exports.warn = init('warn').warn
+exports.warn = init('warn').warn;

package/src/utils/object-helper.js

@@ -1,9 +1,9 @@
-'use strict'
+'use strict';
 
 exports.getEntryObj = (fields, obj) => {
-  let entryObj = {}
-  fields.forEach(field => {
-    entryObj[field] = obj[field]
-  })
-  return entryObj
-}
+  let entryObj = {};
+  fields.forEach((field) => {
+    entryObj[field] = obj[field];
+  });
+  return entryObj;
+};

package/src/utils/safe-promise.js

@@ -1,3 +1,3 @@
-'use strict'
+'use strict';
 
-module.exports = promise => promise.then(res => [null, res]).catch(err => [err])
+module.exports = (promise) => promise.then((res) => [null, res]).catch((err) => [err]);

package/src/utils/schema-helper.js

@@ -1,10 +1,10 @@
 /* eslint-disable camelcase */
-'use strict'
+'use strict';
 
-const {version, defaultDataType, actions} = require('./constants')
+const { version, defaultDataType, actions } = require('./constants');
 
 exports.getSchema = (field, subAction) => {
-  const {EDIT_FIELD, DELETE_FIELD} = actions
+  const { EDIT_FIELD, DELETE_FIELD } = actions;
 
   const schema = {
     display_name: field,
@@ -17,19 +17,19 @@ exports.getSchema = (field, subAction) => {
     // isDelete: !!isDelete,
     isDelete: subAction === DELETE_FIELD,
     isEdit: subAction === EDIT_FIELD,
-  }
-  return schema
-}
+  };
+  return schema;
+};
 
-exports.getUid = data => data.split(' ').join('_').toLowerCase()
+exports.getUid = (data) => data.split(' ').join('_').toLowerCase();
 
-exports.getMandatoryVal = data => data.toLowerCase() === 'title' || data.toLowerCase() === 'url'
+exports.getMandatoryVal = (data) => data.toLowerCase() === 'title' || data.toLowerCase() === 'url';
 
-exports.getUniqueVal = data => data.toLowerCase() === 'title' || data.toLowerCase() === 'url'
+exports.getUniqueVal = (data) => data.toLowerCase() === 'title' || data.toLowerCase() === 'url';
 
-exports.getFieldMetaData = data => {
+exports.getFieldMetaData = (data) => {
   return {
     _default: this.getMandatoryVal(data),
     version,
-  }
-}
+  };
+};

package/src/utils/success-handler.js

@@ -1,12 +1,12 @@
-'use strict'
+'use strict';
 
-const {success} = require('./logger')
-const {successMessageHandler} = require('./constants')
+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`)
+    success(`${type} successfully completed`);
   }
-}
+};

package/src/validators/api-error.js

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

package/src/validators/base-validator.js

@@ -1,39 +1,39 @@
-'use strict'
+'use strict';
 
-const {keys} = Object
+const { keys } = Object;
 class BaseValidator {
   commonValidate(properties, data) {
-    const errors = []
-    const opts = data.payload.options
-    const dataKeys = keys(opts)
+    const errors = [];
+    const opts = data.payload.options;
+    const dataKeys = keys(opts);
 
     for (let i = 0; i < properties.length; i++) {
-      let prop = properties[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.`})
+        errors.push({ ...data, message: `${prop.name} is required.` });
       }
 
       if (prop.name in opts) {
-        const dataType = this.getDataType(opts[prop.name])
+        const dataType = this.getDataType(opts[prop.name]);
         if (dataType !== prop.type) {
-          errors.push({...data, message: `${prop.name} is a ${dataType} 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}`})
+          errors.push({ ...data, message: `${prop.dependsOn} is required with ${prop.name}` });
         }
       }
     }
 
-    return errors
+    return errors;
   }
 
   getDataType(data) {
     if (Array.isArray(data)) {
-      return 'array'
+      return 'array';
     }
-    return typeof data
+    return typeof data;
   }
 }
-module.exports = BaseValidator
+module.exports = BaseValidator;

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

@@ -1,58 +1,54 @@
-'use strict'
+'use strict';
 
-const {keys} = Object
+const { keys } = Object;
 // Utils
-const {map: _map, constants} = require('../utils')
+const { map: _map, constants } = require('../utils');
 // Properties
-const {getMapInstance, get} = _map
-const {contentTypeProperties} = constants
+const { getMapInstance, get } = _map;
+const { contentTypeProperties } = constants;
 
-const mandatoryKeys = [
-  'uid',
-  'title',
-  'description',
-]
+const mandatoryKeys = ['uid', 'title', 'description'];
 
 class CreateContentTypeValidator {
   constructor() {
     // super();
-    this.errors = []
+    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)
+    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)
+        data = { ...data, message: `${key} is missing.` };
+        this.errors.push(data);
       }
     }
 
     // TODO: Fix error messages
-    const propertyNames = this.getPropertyNames()
+    const propertyNames = this.getPropertyNames();
 
     for (let i = 0; i < userProvidedFields.length; i++) {
-      let key = userProvidedFields[i]
+      let key = userProvidedFields[i];
       if (!propertyNames.includes(key)) {
-        data = {...data, message: `${key} is not valid property.`}
-        this.errors.push(data)
+        data = { ...data, message: `${key} is not valid property.` };
+        this.errors.push(data);
       }
     }
-    return this.errors
+    return this.errors;
   }
 
   isApplicable(action) {
-    return action.type === 'create'
+    return action.type === 'create';
   }
 
   getPropertyNames() {
-    return contentTypeProperties
+    return contentTypeProperties;
   }
 }
 
-module.exports = CreateContentTypeValidator
+module.exports = CreateContentTypeValidator;

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

@@ -1,56 +1,53 @@
-'use strict'
+'use strict';
 
-const {keys} = Object
+const { keys } = Object;
 
 // Utils
-const {map: _map, constants} = require('../utils')
+const { map: _map, constants } = require('../utils');
 // Properties
-const {getMapInstance, get} = _map
-const {contentTypeProperties} = constants
+const { getMapInstance, get } = _map;
+const { contentTypeProperties } = constants;
 
-const mandatoryKeys = [
-  'uid',
-  'title',
-]
+const mandatoryKeys = ['uid', 'title'];
 
 class EditContentTypeValidator {
   constructor() {
-    this.errors = []
+    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)
+    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)
+        data = { ...data, message: `${key} is missing.` };
+        this.errors.push(data);
       }
     }
     // TODO: Fix error messages
-    const propertyNames = this.getPropertyNames()
+    const propertyNames = this.getPropertyNames();
 
     for (let i = 0; i < userProvidedFields.length; i++) {
-      let key = userProvidedFields[i]
+      let key = userProvidedFields[i];
       if (!propertyNames.includes(key)) {
-        data = {...data, message: `${key} is not valid property.`}
-        this.errors.push(data)
+        data = { ...data, message: `${key} is not valid property.` };
+        this.errors.push(data);
       }
     }
-    return this.errors
+    return this.errors;
   }
 
   isApplicable(action) {
-    return action.type === 'edit'
+    return action.type === 'edit';
   }
 
   getPropertyNames() {
-    return contentTypeProperties
+    return contentTypeProperties;
   }
 }
 
-module.exports = EditContentTypeValidator
+module.exports = EditContentTypeValidator;

package/src/validators/field-validator.js

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

package/src/validators/index.js

@@ -1,4 +1,4 @@
-'use strict'
+'use strict';
 
 module.exports = {
   CreateContentTypeValidator: require('./create-content-type-validator'),
@@ -8,4 +8,4 @@ module.exports = {
   _TypeError: require('./type-error'),
   ApiError: require('./api-error'),
   MigrationError: require('./migration-error'),
-}
+};

package/src/validators/migration-error.js

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

package/src/validators/schema-validator.js

@@ -1,21 +1,23 @@
-'use strict'
+'use strict';
 
 class SchemaValidator {
   validate(data) {
-    const {fromField, toField, toReferenceField, deriveField} = data.payload
+    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 [
+        {
+          ...data,
+          message: `${fromField || toField || toReferenceField || deriveField} does not exist on schema.`,
+        },
+      ];
     }
-    return []
+    return [];
   }
 
   isApplicable(action) {
-    return action.type === 'schema'
+    return action.type === 'schema';
   }
 }
 
-module.exports = SchemaValidator
+module.exports = SchemaValidator;

package/src/validators/type-error.js

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