@contentstack/cli-migration 1.10.3 → 1.11.0

package/src/modules/parser.js

@@ -1,105 +0,0 @@
-'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, fsHelper } = require('../utils');
-// map properties
-const { getMapInstance, get } = _map;
-// Constants
-const {
-  actionMapper,
-  MANAGEMENT_SDK,
-  MANAGEMENT_TOKEN,
-  AUTH_TOKEN,
-  API_KEY,
-  BRANCH,
-  MANAGEMENT_CLIENT,
-  SOURCE_BRANCH,
-} = constants;
-
-class Parser {
-  async getMigrationParser(migrationFunc) {
-    const migration = new Migration();
-    const mapInstance = getMapInstance();
-    const parseResult = {};
-    let 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);
-      const managementAPIClient = get(MANAGEMENT_CLIENT, mapInstance);
-      const externalConfigPath = get('config-path', mapInstance);
-      const externalConfig = get('config', mapInstance);
-      let externalFileConfig;
-      if (typeof externalConfigPath == 'string') {
-        externalFileConfig = await fsHelper.readJSONFile(externalConfigPath);
-      }
-      const config = Object.assign({}, externalFileConfig, externalConfig);
-      await migrationFunc({
-        migration,
-        stackSDKInstance,
-        managementAPIClient,
-        managementToken,
-        authToken,
-        apiKey,
-        branch,
-        config,
-      });
-    } 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', 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();
-        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

@@ -1,317 +0,0 @@
-/* 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, errorHelper } = 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) {
-      errorHelper(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) {
-      errorHelper(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) {
-      errorHelper(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) {
-      errorHelper(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;
-
-    if (!missingField && against) {
-      missingField = uids.includes(against) ? null : against;
-    }
-
-    // Handling both the scenarios
-    if (found === 0 || (against && found === 1)) {
-      isValid = false;
-    }
-
-    return { isValid, missingField };
-  }
-}
-
-module.exports = ContentTypeService;

package/src/services/index.js

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

package/src/services/locales.js

@@ -1,71 +0,0 @@
-'use strict';
-
-// Utils
-const { safePromise, constants, map: _map } = require('../utils');
-const { MANAGEMENT_SDK } = constants;
-const { get, getMapInstance } = _map;
-const mapInstance = getMapInstance();
-
-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

@@ -1,32 +0,0 @@
-'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

@@ -1,23 +0,0 @@
-'use strict';
-
-const getCallsites = require('callsites');
-const { parse, resolve } = require('path');
-const { pathValidator, sanitizePath } = require('@contentstack/cli-utilities');
-
-function getFileDirectory(path) {
-  const parentPath = pathValidator(resolve(sanitizePath(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;
-};