@contentstack/cli-migration 0.1.1-beta.1

package/src/modules/base.js

@@ -0,0 +1,95 @@
+'use strict'
+
+// Utils
+const {map: _map, constants} = require('../utils')
+// Actions
+const {actionCreators} = require('../actions')
+// Utils properties
+const {getMapInstance, get} = _map
+const {actionMapper} = constants
+
+/**
+ * Base class for module classes
+ * @class Base
+ * @ignore
+ */
+class Base {
+  constructor(id, action) {
+    this.id = id
+    this.action = action
+    this.actions = []
+  }
+
+  /**
+   * Chained function which takes value for title
+   * @param {string} value Title
+   * @returns {Base} current instance of inherited class
+   */
+  title(value) {
+    const mapInstance = getMapInstance()
+    const {id, action} = this
+
+    const contentType = get(id, mapInstance)
+
+    contentType[action].content_type.title = value
+
+    return this
+  }
+
+  /**
+   * Chained function which takes value for description
+   * @param {string} value Description
+   * @returns {Base} current instance of inherited class
+   */
+  description(value) {
+    const mapInstance = getMapInstance()
+    const {id, action} = this
+    const contentType = get(id, mapInstance)
+    contentType[action].content_type.description = value
+    return this
+  }
+
+  /**
+   * Chained function takes boolean value for force while deleting content type
+   * @param {boolean} value Force delete
+   * @returns {Base} current instance of inherited class
+   */
+  force(value) {
+    const mapInstance = getMapInstance()
+    const {id, action} = this
+
+    const contentType = get(id, mapInstance)
+
+    contentType[action].content_type.force = value
+
+    return this
+  }
+
+  /**
+   * Accumulates actions for validating user provided inputs
+   * @ignore
+   * @param {Object} callsite Gets the file location and file number of caller
+   * @param {string} id unique id of action type
+   * @param {Object} opts holds payload to be validated
+   * @param {string} method type of action
+   */
+  dispatch(callsite, id, opts, method) {
+    if (!id && !opts) {
+      let mapInstance = getMapInstance()
+      let actions = get(actionMapper, mapInstance) // Returns an array if empty
+      let action = actionCreators.customTasks(callsite, opts)
+      actions.push(action)
+    } else {
+      let mapInstance = getMapInstance()
+      let actions = get(actionMapper, mapInstance) // Returns an array if empty
+      let action = actionCreators.contentType[method](callsite, id, {...opts, id})
+      actions.push(action)
+    }
+  }
+
+  getActions() {
+    return this.actions
+  }
+}
+
+module.exports = Base

package/src/modules/content-types.js

@@ -0,0 +1,208 @@
+/* eslint-disable camelcase */
+'use strict'
+
+const Field = require('./fields')
+
+// Services
+const {ContentTypeService} = require('../services')
+
+// Config
+const {defaultOptions} = require('../config')
+
+// Utils
+const {map: _map, schemaHelper, constants, getCallsite} = require('../utils')
+
+// Base class
+const Base = require('./base')
+
+// Properties
+const {getMapInstance, set, get} = _map
+const {actions, validationAction} = constants
+const {getUid} = schemaHelper
+const {create, edit} = validationAction
+
+/**
+ * ContentType class
+ * @class ContentType
+ * @augments Base
+ */
+class ContentType extends Base {
+  constructor() {
+    super()
+    this.contentTypeService = new ContentTypeService()
+  }
+
+  /**
+   * Creates content type by passing content type name and options
+   * @param {string} id Content type UID
+   * @param {Object} opts Optional: Content type fields definition
+   * @returns {Field} instance of Field
+   * @example
+   * module.exports = {migrations} => {
+   *  const blog = migrations.createContentType('blog', {
+   *    title: 'blog'
+   *  })
+   * }
+   */
+  createContentType(id, opts = {}) {
+    const callsite = getCallsite()
+    // base class method
+    let options = {...defaultOptions, ...opts}
+    delete options.title
+    delete options.description
+    this.dispatch(callsite, id, opts, create)
+    const {title, description} = opts
+    const mapInstance = getMapInstance()
+
+    const {CREATE_CT} = actions
+    const uid = getUid(id)
+
+    const ctObj = {content_type: {title, uid, description, options}}
+
+    const ctActionObj = {[CREATE_CT]: ctObj}
+
+    const {contentTypeService} = this
+    // Sets data to post in map object
+    set(id, mapInstance, ctActionObj)
+    // Sets action and id in content type service
+    contentTypeService.setIdAndAction(id, CREATE_CT)
+    const tasks = [contentTypeService.postContentTypes.bind(contentTypeService, callsite, id, CREATE_CT)]
+    const req = {
+      title: `Adding content type: ${id}`,
+      failMessage: `Failed to create content type: ${id}`,
+      successMessage: `Successfully added content type: ${id}`,
+      tasks,
+    }
+    let field = new Field(id, CREATE_CT, contentTypeService, req)
+    // TODO: should find better way to attach content type level methods
+    field.singleton = this.singleton
+    field.isPage = this.isPage
+    return field
+  }
+
+  /**
+   * Set content type to singleton or multiple
+   * @param {boolean} value set value true to set content type as singleton default it is multiple
+   * @returns {ContentType} instance of ContentType for chaining
+   */
+  singleton(value) {
+    const mapInstance = getMapInstance()
+    const {id, action} = this
+    const contentType = get(id, mapInstance)
+
+    contentType[action].content_type.options.singleton = value
+    return this
+  }
+
+  /**
+   * Set content type to singleton or multiple
+   * @param {boolean} value set value false to set content type as content as block default true
+   * @returns {ContentType} instance of ContentType for chaining
+   */
+  isPage(value) {
+    const mapInstance = getMapInstance()
+    const {id, action} = this
+    const contentType = get(id, mapInstance)
+
+    contentType[action].content_type.options.is_page = value
+    return this
+  }
+
+  /**
+   * Edits content type by passing content type name and options
+   * @param {string} id Content type UID
+   * @param {Object} opts Optional: Content type fields definition
+   * @returns {Field} instance of Field
+   * @example
+   * module.exports = {migrations} => {
+   *  const blog = migrations.editContentType('blog', {
+   *    title: 'blog'
+   *  });
+   *  blog.description('Changed description');
+   * }
+   */
+  editContentType(id, opts = {}) {
+    let options = {...defaultOptions, ...opts}
+    delete options.title
+    delete options.description
+
+    const callsite = getCallsite()
+    // base class method
+    this.dispatch(callsite, id, {}, edit)
+    const {title, description} = opts
+    const mapInstance = getMapInstance()
+
+    const {EDIT_CT} = actions
+
+    const uid = id
+
+    const ctObj = {content_type: {title, uid, description, options}}
+    const ctActionObj = {[EDIT_CT]: ctObj}
+
+    const {contentTypeService} = this
+
+    // Sets data to update in map object
+    let ctAction = get(id, mapInstance)
+
+    set(id, mapInstance, {...ctActionObj, ...ctAction})
+    // Sets action and id in content type service
+    contentTypeService.setIdAndAction(id, EDIT_CT)
+    const tasks = [
+      contentTypeService.fetchContentType.bind(contentTypeService, callsite, id),
+      contentTypeService.applyActionsOnFields.bind(contentTypeService, callsite),
+      contentTypeService.editContentType.bind(contentTypeService, callsite),
+    ]
+
+    const req = {
+      title: `Editing content type: ${id}`,
+      failMessage: `Failed to edit content type: ${id}`,
+      successMessage: `Successfully updated content type: ${id}`,
+      tasks,
+    }
+
+    // Keeping the same instance of contentTypeService in Field class
+    let fieldI = new Field(id, EDIT_CT, contentTypeService, req)
+    // TODO: should find better way to attach content type level methods
+    fieldI.singleton = this.singleton
+    fieldI.isPage = this.isPage
+    return fieldI
+  }
+
+  /**
+   * Deletes content type by passing content type name
+   * @param {string} id Content type UID
+   * @returns {Field} instance of Field
+   * @example
+   * module.exports = {migrations} => {
+   *  const blog = migrations.deleteContentType('blog');
+   * }
+   */
+  deleteContentType(id) {
+    const callsite = getCallsite()
+
+    const mapInstance = getMapInstance()
+
+    const {DELETE_CT} = actions
+
+    const uid = getUid(id)
+
+    const ctObj = {content_type: {uid, force: false}} // keep by default false
+
+    const ctActionObj = {[DELETE_CT]: ctObj}
+
+    const {contentTypeService} = this
+
+    // Sets data to delete in map object
+    set(id, mapInstance, ctActionObj)
+    // Sets action and id in content type service
+    contentTypeService.setIdAndAction(id, DELETE_CT)
+
+    const tasks = [contentTypeService.deleteContentType.bind(contentTypeService, callsite)]
+
+    const req = {title: 'Deleting content type', tasks}
+
+    return new Field(id, DELETE_CT, contentTypeService, req)
+  }
+}
+
+module.exports = ContentType

package/src/modules/fields.js

@@ -0,0 +1,304 @@
+'use strict'
+
+const {keys} = Object
+// Utils
+const {map: _map, schemaHelper, constants} = require('../utils')
+
+// Utils Properties
+const {getMapInstance, get} = _map
+const {getSchema} = schemaHelper
+const {
+  data_type,
+  mandatory,
+  _default,
+  unique,
+  display_name,
+  field_metadata,
+  reference_to,
+  actions: _actions,
+} = constants
+
+// Base class
+const Base = require('./base')
+
+/**
+ * Field class
+ * @class Field
+ */
+class Field extends Base {
+  // prop, value
+  constructor(uid, action, contentTypeService, request) {
+    super(uid)
+    this.uid = uid
+    this.action = action
+    this.contentTypeService = contentTypeService
+    this.request = request
+  }
+
+  /**
+   * @typedef {Object} Task
+   * @param {string} title - Title for custom task
+   * @param {function[]} task - array of async function to be executed
+   * @param {string} failMessage message to be printed when task fails
+   * @param {string} successMessage - message to be printed when task succeeds
+  */
+
+  /**
+   * Creates a field with provided uid.
+   * @param {string} field Field name to be created
+   * @param {Object} opts Options to be passed
+   * @returns {Field} current instance of field object to chain further methods.
+   * @example
+   * module.exports =({ migration })=> {
+   *  const blog = migration.editContentType('blog');
+   *
+   *  blog.createField('author');
+   *   .display_name('Author')
+   *   .data_type('text')
+   *   .mandatory(false);
+   * };
+   */
+  createField(field, opts) {
+    this.updateContentTypeSchema(field)
+
+    // Build schema from options provided
+    if (opts && keys(opts).length) return this.getSchemaFromOptions(opts, field)
+    return this
+  }
+
+  /**
+   * Edits the field with provided uid.
+   * @param {string} field Field name to be edited
+   * @param {Object} opts Options to be passed
+   * @returns {Field} current instance of field object to chain further methods.
+   * @example
+   * module.exports =({ migration })=> {
+   * const blog = migration.editContentType('blog');
+   *
+   * blog.editField('uniqueid')
+   *   .display_name('Unique ID')
+   *   .mandatory(false);
+   * };
+   */
+  editField(field, opts) {
+    const {EDIT_FIELD} = _actions
+    this.updateContentTypeSchema(field, EDIT_FIELD)
+
+    // Build schema from options provided
+    if (opts && keys(opts).length) return this.getSchemaFromOptions(opts, field)
+    return this
+  }
+
+  /**
+   * Delete a field from the content type
+   * @param {string} field Field uid to be deleted
+   * @returns {Field} current instance of field object to chain further methods.
+   * @example
+   * module.exports =({ migration })=> {
+   *  const blog = migration.editContentType('blog');
+   *
+   *  blog.deleteField('uniqueid');
+   * };
+   */
+  deleteField(field) {
+    const {DELETE_FIELD} = _actions
+    this.updateContentTypeSchema(field, DELETE_FIELD)
+
+    return this
+  }
+
+  /**
+   * Move the field (position of the field in the editor)
+   * @param {string} field Field uid to be moved
+   * @returns {Field} current instance of field object to chain further methods.
+   * @example
+   * module.exports = ({migration}) => {
+   *  const blog = migration.editContentType('blog');
+   *
+   *  blog.createField('credits')
+   *    .display_name('Credits')
+   *    .data_type('text')
+   *    .mandatory(false);
+   *
+   *  blog.createField('references')
+   *    .display_name('References')
+   *    .data_type('text')
+   *    .mandatory(false);
+   *
+   *  blog.moveField('uniqueid').toTheBottom();
+   *  blog.moveField('references').beforeField('credits');
+   *  blog.moveField('author').toTheTop();
+   *  blog.moveField('url').afterField('author');
+   * };
+   */
+  moveField(field) {
+    this.fieldToMove = field
+    return this
+  }
+
+  updateContentTypeSchema(field, subAction) {
+    const mapInstance = getMapInstance()
+
+    const {uid, action} = this
+
+    const contentType = get(uid, mapInstance)
+
+    let contentTypeSchema = contentType[action].content_type.schema
+    contentTypeSchema = contentTypeSchema || []
+
+    const schemaObj = getSchema(field, subAction)
+    contentTypeSchema.push(schemaObj)
+
+    contentType[action].content_type.schema = contentTypeSchema
+
+    this.field = schemaObj.uid
+  }
+
+  // changeFieldId(currentId, newId) { }
+
+  /**
+   *
+   * @param {string} value set display name for the field
+   * @returns {Field} current instance of field object to chain further methods.
+   */
+  display_name(value) {
+    this.buildSchema(display_name, this.field, value)
+    return this
+  }
+
+  /**
+   *
+   * @param {string} value Set data type of the field e.g. text, json, boolean
+   * @returns {Field} current instance of field object to chain further methods.
+   */
+  data_type(value) {
+    this.buildSchema(data_type, this.field, value)
+    return this
+  }
+
+  /**
+   *
+   * @param {boolean} value set true when field is mandatory
+   * @returns {Field} current instance of field object to chain further methods.
+   */
+  mandatory(value) {
+    this.buildSchema(mandatory, this.field, value)
+    return this
+  }
+
+  /**
+   *
+   * @param {string|boolean|number} value set true when field is mandatory
+   * @returns {Field} current instance of field object to chain further methods.
+   */
+  default(value) {
+    this.buildSchema(_default, this.field, value)
+    return this
+  }
+
+  /**
+   *
+   * @param {boolean} value set true if field is unique
+   * @returns {Field} current instance of field object to chain further methods.
+   */
+  unique(value) {
+    this.buildSchema(unique, this.field, value)
+    return this
+  }
+
+  /**
+   *
+   * @param {string | string[]} value uid of reference content type set array if ref_multipleContentType true
+   * @see {@link ref_multipleContentType}
+   * @returns {Field} current instance of field object to chain further methods.
+   */
+  reference_to(value) {
+    this.buildSchema(reference_to, this.field, value)
+    return this
+  }
+
+  /**
+   *
+   * @param {string} value set true if accepts multiple entries as reference
+   * @returns {Field} current instance of field object to chain further methods.
+   */
+  ref_multiple(value) {
+    this.buildSchema(field_metadata, this.field, {ref_multiple: value, ref_multiple_content_types: true})
+    return this
+  }
+
+  /**
+   *
+   * @param {boolean} value set true if refer to multiple content types
+   * @returns {Field} current instance of field object to chain further methods.
+   */
+  ref_multipleContentType(value) {
+    this.buildSchema(field_metadata, this.field, {ref_multiple_content_types: value})
+    return this
+  }
+
+  toTheBottom() {
+    const {fieldToMove, contentTypeService} = this
+
+    if (!fieldToMove) throw new Error('Cannot access this method directly.')
+
+    contentTypeService.getActions({action: 'toTheBottom', fieldToMove})
+  }
+
+  toTheTop() {
+    const {fieldToMove, contentTypeService} = this
+    if (!fieldToMove) throw new Error('Cannot access this method directly.')
+
+    contentTypeService.getActions({action: 'toTheTop', fieldToMove})
+  }
+
+  afterField(field) {
+    const {fieldToMove, contentTypeService} = this
+
+    if (!fieldToMove) throw new Error('Cannot access this method directly.')
+
+    contentTypeService.getActions({action: 'afterField', fieldToMove, against: field})
+  }
+
+  beforeField(field) {
+    const {fieldToMove, contentTypeService} = this
+
+    if (!fieldToMove) throw new Error('Cannot access this method directly.')
+
+    contentTypeService.getActions({action: 'beforeField', fieldToMove, against: field})
+  }
+
+  buildSchema(prop, field, value) {
+    const mapInstance = getMapInstance()
+
+    const {uid, action} = this
+
+    const contentType = get(uid, mapInstance)
+
+    for (const _schema of contentType[action].content_type.schema) {
+      if (_schema.uid === field) {
+        _schema[prop] = value
+        break
+      }
+    }
+  }
+
+  /**
+   * Once you add the fields to content type you can call this method to get the task definition
+   * @returns {Task} This task definition is to pass to migration.addTask()
+   * @example
+   * migration.addTask(foo.getTaskDefinition())
+   */
+  getTaskDefinition() {
+    return this.request
+  }
+
+  getSchemaFromOptions(opts, field) {
+    const allKeys = keys(opts)
+    allKeys.forEach(_key => {
+      this.buildSchema(_key, field, opts[_key])
+    })
+  }
+}
+
+module.exports = Field

package/src/modules/index.js

@@ -0,0 +1,8 @@
+'use strict'
+
+module.exports = {
+  ContentType: require('./content-types'),
+  Field: require('./fields'),
+  Migration: require('./migration'),
+  Parser: require('./parser'),
+}

package/src/modules/locale.js

@@ -0,0 +1,33 @@
+'use strict'
+
+// Service
+const {LocaleService} = require('../services')
+
+// Config
+const {masterLocale} = require('../config')
+
+// Utils
+const {safePromise} = require('../utils')
+
+class Locale {
+  constructor() {
+    this.localeService = new LocaleService()
+  }
+
+  async fetchLocales(callback) {
+    let {master_locale} = masterLocale
+
+    let {localeService} = this
+    let [err, result] = await safePromise(localeService.getLocale())
+
+    if (err) throw new Error(err)
+
+    // Use default code, if no result is found
+    result = result.length ? result : [master_locale]
+
+    if (callback) return callback(null, result)
+    return result
+  }
+}
+
+module.exports = Locale