Merge pull request #51 from contentful/editor-interface-feature

Add Editor Interface Support

Author: Khaledgarbaya

lib/create-space-api.js

@@ -67,6 +67,7 @@ export default function createSpaceApi ({
   const {wrapRole, wrapRoleCollection} = entities.role
   const {wrapSpaceMembership, wrapSpaceMembershipCollection} = entities.spaceMembership
   const {wrapApiKey, wrapApiKeyCollection} = entities.apiKey
+  const {wrapEditorInterface} = entities.editorInterface
 
   /**
    * Space instances.
@@ -122,6 +123,20 @@ export default function createSpaceApi ({
     .then((response) => wrapContentType(http, response.data), errorHandler)
   }
 
+  /**
+   * Gets an EditorInterface for a ContentType
+   * @memberof ContentfulSpaceAPI
+   * @param  {string} contentTypeId
+   * @return {Promise<EditorInterface.EditorInterface>} Promise for an EditorInterface
+   * @example
+   * space.getEditorInterfaceForContentType('contentTypeId')
+   * .then(editorInterface => console.log(editorInterface))
+   */
+  function getEditorInterfaceForContentType (contentTypeId) {
+    return http.get('content_types/' + contentTypeId + '/editor_interface')
+    .then((response) => wrapEditorInterface(http, response.data), errorHandler)
+  }
+
   /**
    * Gets a collection of Content Types
    * @memberof ContentfulSpaceAPI
@@ -622,6 +637,7 @@ export default function createSpaceApi ({
     getContentTypes: getContentTypes,
     createContentType: createContentType,
     createContentTypeWithId: createContentTypeWithId,
+    getEditorInterfaceForContentType: getEditorInterfaceForContentType,
     getEntry: getEntry,
     getEntries: getEntries,
     createEntry: createEntry,

lib/entities/content-type.js

@@ -15,6 +15,8 @@ import {
   createUpdatedChecker,
   createDraftChecker
 } from '../instance-actions'
+import {wrapEditorInterface} from './editor-interface'
+import errorHandler from '../error-handler'
 
 /**
  * @memberof ContentType
@@ -90,6 +92,19 @@ function createContentTypeApi (http) {
       wrapperMethod: wrapContentType
     }),
 
+    /**
+     * get the editor interface for the object
+     * @memberof ContentType
+     * @func getEditorInterface
+     * @return {Promise<EditorInterface.EditorInterface>} Object returned from the server with the current editor interface.
+     * @example
+     * contentType.getEditorInterface()
+     * .then(editorInterface => console.log(editorInterface.controls))
+     */
+    getEditorInterface: function () {
+      return http.get('content_types/' + this.sys.id + '/editor_interface')
+      .then((response) => wrapEditorInterface(http, response.data), errorHandler)
+    },
     /**
      * Checks if the contentType is published. A published contentType might have unpublished changes (@see {ContentType.isUpdated})
      * @memberof ContentType

lib/entities/editor-interface.js

@@ -0,0 +1,64 @@
+/**
+ * Editor Interface instances
+ * @namespace EditorInterface
+ */
+
+import cloneDeep from 'lodash/cloneDeep'
+import freezeSys from 'contentful-sdk-core/freeze-sys'
+import enhanceWithMethods from '../enhance-with-methods'
+import mixinToPlainObject from 'contentful-sdk-core/mixins/to-plain-object'
+import omit from 'lodash/omit'
+import errorHandler from '../error-handler'
+
+function createEditorInterfaceApi (http) {
+  return {
+    /**
+     * Sends an update to the server with any changes made to the object's properties
+     * @memberof EditorInterface
+     * @func update
+     * @return {Promise<EditorInterface>} Object returned from the server with updated changes.
+     * @example
+     * editorInterface.controls[0] = { "fieldId": "title", "widgetId": "singleLine"}
+     * editorInterface.update()
+     * .then(editorInterface => console.log(editorInterface.controls))
+     */
+    update: function () {
+      const raw = this.toPlainObject()
+      const data = omit(raw, ['sys'])
+      return http.put(`content_types/${this.sys.contentType.sys.id}/editor_interface`,
+        data,
+        {
+          headers: {'X-Contentful-Version': this.sys.version}
+        }
+      )
+      .then((response) => wrapEditorInterface(http, response.data), errorHandler)
+    },
+    /**
+     * gets a control for a specific field
+     * @memberof EditorInterface
+     * @func getControlForField
+     * @return {?Object} control object for specific field.
+     * @example
+     * const control = editorInterface.getControlForField('fieldId')
+     * console.log(control)
+     */
+    getControlForField: function (fieldId) {
+      const result = this.controls.filter((control) => {
+        return control.fieldId === fieldId
+      })
+      return (result && result.length > 0) ? result[0] : null
+    }
+  }
+}
+
+/**
+* @private
+* @param {Object} http - HTTP client instance
+* @param {Object} data - Raw editor-interface data
+* @return {EditorInterface} Wrapped editor-interface data
+*/
+export function wrapEditorInterface (http, data) {
+  const editorInterface = mixinToPlainObject(cloneDeep(data))
+  enhanceWithMethods(editorInterface, createEditorInterfaceApi(http))
+  return freezeSys(editorInterface)
+}

lib/entities/index.js

@@ -2,6 +2,7 @@ import * as space from './space'
 import * as entry from './entry'
 import * as asset from './asset'
 import * as contentType from './content-type'
+import * as editorInterface from './editor-interface'
 import * as locale from './locale'
 import * as webhook from './webhook'
 import * as spaceMembership from './space-membership'
@@ -13,6 +14,7 @@ export default {
   entry,
   asset,
   contentType,
+  editorInterface,
   locale,
   webhook,
   spaceMembership,

package.json

@@ -13,7 +13,8 @@
   "tonicExampleFilename": "tonic-example.js",
   "scripts": {
     "clean": "rimraf dist && rimraf browser-dist && rimraf coverage && rimraf out",
-    "build": "npm run clean && npm run vendor:version && npm run build:dist && npm run build:standalone",
+    "build:ci": "npm run vendor:version && npm run build:dist && npm run build:standalone",
+    "build": "npm run clean && npm run build:ci",
     "build:dist": "babel lib --out-dir dist",
     "build:standalone": "webpack && webpack -p --output-filename contentful-management.min.js",
     "link-dev-deps": "mkdirp node_modules && ln -s ../../contentful-sdk-core/src node_modules/contentful-sdk-core",
@@ -31,7 +32,7 @@
     "test:browser-remote": "BABEL_ENV=test ./node_modules/.bin/karma start karma.conf.saucelabs.js",
     "vendor:version": "echo \"module.exports = '`cat package.json|json version`'\" > version.js",
     "browser-coverage": "npm run test:cover && opener coverage/lcov-report/index.html",
-    "prepublish": "in-publish && npm run build || not-in-publish",
+    "prepublish": "in-publish && npm run build:ci || not-in-publish",
     "postpublish": "npm run docs:publish && npm run clean",
     "pretest": "standard lib/*.js && standard lib/**/*.js && standard test/**/*.js",
     "test": "npm run test:cover && npm run test:integration && npm run test:browser-local",

test/integration/content-type-integration.js

@@ -21,8 +21,8 @@ export function contentTypeReadOnlyTests (t, space) {
 }
 
 export function contentTypeWriteTests (t, space) {
-  t.test('Create, update, publish, unpublish and delete content type', (t) => {
-    t.plan(7)
+  t.test('Create, update, publish, getEditorInterface, unpublish and delete content type', (t) => {
+    t.plan(10)
     return space.createContentType({name: 'testentity'})
     .then((contentType) => {
       t.ok(contentType.isDraft(), 'contentType is in draft')
@@ -38,10 +38,22 @@ export function contentTypeWriteTests (t, space) {
         .then((updatedContentType) => {
           t.ok(updatedContentType.isUpdated(), 'contentType is updated')
           t.equals(updatedContentType.fields[0].id, 'field', 'field id')
-          return updatedContentType.unpublish()
-          .then((unpublishedContentType) => {
-            t.ok(unpublishedContentType.isDraft(), 'contentType is back in draft')
-            return unpublishedContentType.delete()
+          t.ok(updatedContentType.getEditorInterface, 'updatedContentType.getEditorInterface')
+          return updatedContentType.publish()
+          .then((publishedContentType) => {
+            return publishedContentType.getEditorInterface()
+            .then((editorInterface) => {
+              t.ok(editorInterface.controls, 'editor interface controls')
+              t.ok(editorInterface.sys, 'editor interface sys')
+              return editorInterface.update()
+              .then((editorInterface) => {
+                return updatedContentType.unpublish()
+                .then((unpublishedContentType) => {
+                  t.ok(unpublishedContentType.isDraft(), 'contentType is back in draft')
+                  return unpublishedContentType.delete()
+                })
+              })
+            })
           })
         })
       })

test/integration/integration-tests.js

@@ -85,7 +85,7 @@ test('Create space for tests which create, change and delete data', (t) => {
   // Also comment the test.onFinish line below to avoid removing the space.
   // The below line also uses double quotes on purpose so it breaks the linter
   // in case someone forgets to comment this line again.
-  // client.getSpace("")
+  // client.getSpace('a3f19zbn5ldg')
   .then((space) => {
     return space.createLocale({
       name: 'German (Germany)',

test/unit/create-space-api-test.js

@@ -4,6 +4,7 @@ import mixinToPlainObject from 'contentful-sdk-core/mixins/to-plain-object'
 import createSpaceApi, {__RewireAPI__ as createSpaceApiRewireApi} from '../../lib/create-space-api'
 import {
   contentTypeMock,
+  editorInterfaceMock,
   assetMock,
   entryMock,
   localeMock,
@@ -157,6 +158,20 @@ test('API call createContentTypeWithId fails', (t) => {
   })
 })
 
+test('API call getEditorInterfaceForContentType', (t) => {
+  makeGetEntityTest(t, setup, teardown, {
+    entityType: 'editorInterface',
+    mockToReturn: editorInterfaceMock,
+    methodToTest: 'getEditorInterfaceForContentType'
+  })
+})
+
+test('API call getEditorInterfaceForContentType fails', (t) => {
+  makeEntityMethodFailingTest(t, setup, teardown, {
+    methodToTest: 'getEditorInterfaceForContentType'
+  })
+})
+
 test('API call getEntry', (t) => {
   makeGetEntityTest(t, setup, teardown, {
     entityType: 'entry',

test/unit/entities/content-type-test.js

@@ -88,6 +88,20 @@ test('ContentType unpublish fails', (t) => {
   })
 })
 
+test('ContentType getEditorInterface', (t) => {
+  return entityActionTest(t, setup, {
+    wrapperMethod: wrapContentType,
+    actionMethod: 'getEditorInterface'
+  })
+})
+
+test('ContentType getEditorInterface fails', (t) => {
+  return failingActionTest(t, setup, {
+    wrapperMethod: wrapContentType,
+    actionMethod: 'getEditorInterface'
+  })
+})
+
 test('ContentType isPublished', (t) => {
   isPublishedTest(t, setup, {wrapperMethod: wrapContentType})
 })

test/unit/entities/editor-interface-test.js

@@ -0,0 +1,47 @@
+import test from 'tape'
+import {cloneMock} from '../mocks/entities'
+import setupHttpMock from '../mocks/http'
+import {wrapEditorInterface} from '../../../lib/entities/editor-interface'
+import {
+  entityWrappedTest,
+  entityUpdateTest
+} from '../test-creators/instance-entity-methods'
+
+function setup (promise) {
+  return {
+    httpMock: setupHttpMock(promise),
+    entityMock: cloneMock('editorInterface')
+  }
+}
+
+test('Editor Interface is wrapped', (t) => {
+  return entityWrappedTest(t, setup, {
+    wrapperMethod: wrapEditorInterface
+  })
+})
+
+test('EditorInterface update', (t) => {
+  return entityUpdateTest(t, setup, {
+    wrapperMethod: wrapEditorInterface
+  })
+})
+
+test('EditorInterface getControlForField with an existing fieldId', (t) => {
+  t.plan(5)
+  const {httpMock, entityMock} = setup()
+  const editorInterface = wrapEditorInterface(httpMock, entityMock)
+  const control = editorInterface.getControlForField('fieldId')
+  t.ok(control, 'control object sould be there')
+  t.ok(control.fieldId, 'should have a fieldId')
+  t.ok(control.widgetId, 'should have a widgetId')
+  t.equals(control.fieldId, 'fieldId')
+  t.equals(control.widgetId, 'singleLine')
+})
+
+test('EditorInterface getControlForField without an existing fieldId', (t) => {
+  t.plan(1)
+  const {httpMock, entityMock} = setup()
+  const editorInterface = wrapEditorInterface(httpMock, entityMock)
+  const control = editorInterface.getControlForField('notThere')
+  t.equals(control, null)
+})