Add write and mWrite

features/kuzzle.feature

@@ -1,4 +1,28 @@
 Feature: Kuzzle functional tests
+  Scenario: Bulk mWrite
+    When I create a collection "kuzzle-test-index":"kuzzle-collection-test"
+    When I use bulk:mWrite action with
+    """
+    {
+      "documents": [
+        { "body": { "name": "Maedhros" } },
+        { "body": { "name": "Maglor" } },
+        { "body": { "name": "Celegorm" } },
+        { "body": { "name": "Caranthis" } },
+        { "body": { "name": "Curufin" } },
+        { "body": { "name": "Amrod" } },
+        { "body": { "name": "Amras" } }
+      ]
+    }
+    """
+    Then I count 7 documents
+    And The documents does not have kuzzle metadata
+
+  Scenario: Bulk write
+    When I use bulk:write action with '{ "name": "Feanor", "_kuzzle_info": { "author": "Tolkien" } }'
+    Then I count 1 documents
+    And The documents have the following kuzzle metadata '{ "author": "Tolkien" }'
+
   Scenario: Create a collection
     When I create a collection "kuzzle-test-index":"my-collection1"
     Then The mapping properties field of "kuzzle-test-index":"my-collection1" is "the default value"

features/step_definitions/bulk.js

@@ -1,4 +1,5 @@
 const
+  should = require('should'),
   {
     Then,
     When
@@ -116,3 +117,35 @@ When(/^I do a global bulk import$/, function (callback) {
     });
 });
 
+When('I use bulk:mWrite action with', function (bodyRaw) {
+  const body = JSON.parse(bodyRaw);
+
+  return this.api.bulkMWrite(this.index, this.collection, body);
+});
+
+When('I use bulk:write action with {string}', function (bodyRaw) {
+  const body = JSON.parse(bodyRaw);
+
+  return this.api.bulkWrite(this.index, this.collection, body);
+});
+
+
+Then('The documents does not have kuzzle metadata', function () {
+  return this.api.search({}, this.index, this.collection, { size: 100 })
+    .then(({ result }) => {
+      for (const hit of result.hits) {
+        should(hit._source._kuzzle_info).be.undefined();
+      }
+    });
+});
+
+Then('The documents have the following kuzzle metadata {string}', function (metadatRaw) {
+  const metadata = JSON.parse(metadatRaw);
+
+  return this.api.search({}, this.index, this.collection, { size: 100 })
+    .then(({ result }) => {
+      for (const hit of result.hits) {
+        should(hit._source._kuzzle_info).match(metadata);
+      }
+    });
+});

features/support/api/apiBase.js

@@ -41,6 +41,32 @@ class ApiBase {
     return this.send(msg);
   }
 
+  bulkMWrite (index, collection, body) {
+    const
+      msg = {
+        controller: 'bulk',
+        collection: collection || this.world.fakeCollection,
+        index: index || this.world.fakeIndex,
+        action: 'mWrite',
+        body
+      };
+
+    return this.send(msg);
+  }
+
+  bulkWrite (index, collection, body) {
+    const
+      msg = {
+        controller: 'bulk',
+        collection: collection || this.world.fakeCollection,
+        index: index || this.world.fakeIndex,
+        action: 'write',
+        body
+      };
+
+    return this.send(msg);
+  }
+
   collectionExists (index, collection) {
     return this.send({
       index,

features/support/api/http.js

@@ -158,6 +158,26 @@ class HttpApi {
     return this.callApi(options);
   }
 
+  bulkMWrite (index, collection, body) {
+    const options = {
+      url: this.apiPath(this.util.getIndex(index) + '/' + this.util.getCollection(collection) + '/_mWrite'),
+      method: 'POST',
+      body
+    };
+
+    return this.callApi(options);
+  }
+
+  bulkWrite (index, collection, body) {
+    const options = {
+      url: this.apiPath(this.util.getIndex(index) + '/' + this.util.getCollection(collection) + '/_write'),
+      method: 'POST',
+      body
+    };
+
+    return this.callApi(options);
+  }
+
   /**
    * @param options
    * @return {Promise.<IncomingMessage>}

lib/api/controllers/bulkController.js

@@ -23,16 +23,27 @@
 
 const
   BaseController = require('./controller'),
-  {errors: {PartialError}} = require('kuzzle-common-objects'),
-  {assertHasBody, assertBodyHasAttribute} = require('../../util/requestAssertions');
+  { PartialError } = require('kuzzle-common-objects').errors,
+  {
+    assertHasBody,
+    assertBodyHasAttribute,
+    assertHasIndexAndCollection,
+    assertBodyAttributeType,
+    assertIdStartsNotUnderscore
+  } = require('../../util/requestAssertions');
 
 /**
  * @class BulkController
  * @param {Kuzzle} kuzzle
  */
 class BulkController extends BaseController {
   constructor (kuzzle) {
-    super(kuzzle, ['import']);
+    super(kuzzle, [
+      'import',
+      'write',
+      'mWrite'
+    ]);
+
     this.engine = kuzzle.services.list.storageEngine;
   }
 
@@ -55,6 +66,62 @@ class BulkController extends BaseController {
         return response;
       });
   }
+
+  /**
+   * Write a document without adding metadata or performing data validation.
+   * @param {Request} request
+   * @returns {Promise<Object>}
+   */
+  write(request) {
+    assertHasBody(request);
+    assertHasIndexAndCollection(request);
+    assertIdStartsNotUnderscore(request);
+
+    const notify = this.ensureBooleanFlag(request, 'input.args.notify');
+
+    return this.engine.createOrReplace(request, false)
+      .then(response => {
+        this.kuzzle.indexCache.add(request.input.resource.index, request.input.resource.collection);
+
+        if (notify && response.created) {
+          this.kuzzle.notifier.notifyDocumentCreate(request, response);
+        }
+        else if (notify) {
+          this.kuzzle.notifier.notifyDocumentReplace(request);
+        }
+
+        return response;
+      });
+  }
+
+  /**
+   * Write several documents without adding metadata or performing data validation.
+   *
+   * @param {Request} request
+   * @returns {Promise<Object>}
+   */
+  mWrite(request) {
+    assertHasBody(request);
+    assertBodyHasAttribute(request, 'documents');
+    assertBodyAttributeType(request, 'documents', 'array');
+    assertHasIndexAndCollection(request);
+
+    const notify = this.ensureBooleanFlag(request, 'input.args.notify');
+
+    return this.engine.mcreateOrReplace(request, false)
+      .then(response => {
+        if (response.error.length > 0) {
+          request.setError(new PartialError('Some document creations failed', response.error));
+        }
+
+        if (notify) {
+          this.kuzzle.notifier.notifyDocumentMChanges(request, response.result, true);
+        }
+
+        return { hits: response.result, total: response.result.length };
+      });
+  }
+
 }
 
 module.exports = BulkController;

lib/api/controllers/controller.js

@@ -82,8 +82,11 @@ class BaseController {
       const booleanValue = flagValue !== undefined ? true : false;
 
       _.set(request, flagPath, booleanValue);
+
+      return booleanValue;
     }
 
+    return Boolean(flagValue);
   }
 }
 

lib/api/core/plugins/pluginContext.js

@@ -58,7 +58,7 @@ class PluginContext {
     const Kuzzle = require('../../kuzzle');
 
     this.accessors = {};
-    this.config = kuzzle.config;
+    this.config = JSON.parse(JSON.stringify(kuzzle.config));
     this.constructors = deprecateProperties({
       RequestContext,
       RequestInput,

lib/config/httpRoutes.js

@@ -153,7 +153,7 @@ module.exports = [
   {verb: 'post', url: '/credentials/:strategy/_me/_create', controller: 'auth', action: 'createMyCredentials'},
   {verb: 'post', url: '/credentials/:strategy/_me/_validate', controller: 'auth', action: 'validateMyCredentials'},
 
-  /* DEPRECATED - will be removed in v2 */  
+  /* DEPRECATED - will be removed in v2 */
   {verb: 'post', url: '/_validateSpecifications', controller: 'collection', action: 'validateSpecifications'},
 
   {verb: 'post', url: '/:index/:collection/_validateSpecifications', controller: 'collection', action: 'validateSpecifications'},
@@ -163,6 +163,9 @@ module.exports = [
   {verb: 'post', url: '/:index/_bulk', controller: 'bulk', action: 'import'},
   {verb: 'post', url: '/:index/:collection/_bulk', controller: 'bulk', action: 'import'},
 
+  {verb: 'post', url: '/:index/:collection/_mWrite', controller: 'bulk', action: 'mWrite'},
+  {verb: 'post', url: '/:index/:collection/_write', controller: 'bulk', action: 'write'},
+
   /* DEPRECATED - will be removed in v2 */
   {verb: 'post', url: '/_getStats', controller: 'server', action: 'getStats'},
 
@@ -296,7 +299,7 @@ module.exports = [
 
   /* DEPRECATED - will be removed in v2 */
   {verb: 'put', url: '/_specifications', controller: 'collection', action: 'updateSpecifications'},
-  
+
   {verb: 'put', url: '/:index/:collection/_specifications', controller: 'collection', action: 'updateSpecifications'},
 
   {verb: 'put', url: '/:index/:collection/:_id', controller: 'document', action: 'createOrReplace'},

lib/services/elasticsearch.js

@@ -339,12 +339,21 @@ class ElasticSearch extends Service {
    * Create a new document to ElasticSearch, or replace it if it already exist
    *
    * @param {Request} request
+   * @param {boolean} injectKuzzleMeta
    * @returns {Promise} resolve an object that contains _id
    */
-  createOrReplace(request) {
+  createOrReplace(request, injectKuzzleMeta = true) {
     const
       esRequest = initESRequest(request, ['refresh']),
-      userId = this._getUserId(request);
+      userId = this._getUserId(request),
+      kuzzleMeta = {
+        author: userId,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        updater: userId,
+        active: true,
+        deletedAt: null
+      };
 
     esRequest.id = request.input.resource._id;
     esRequest.body = request.input.body;
@@ -359,14 +368,37 @@ class ElasticSearch extends Service {
         }
 
         // Add metadata
-        esRequest.body._kuzzle_info = {
-          author: userId,
-          createdAt: Date.now(),
-          updatedAt: Date.now(),
-          updater: userId,
-          active: true,
-          deletedAt: null
-        };
+        if (injectKuzzleMeta) {
+          esRequest.body._kuzzle_info = kuzzleMeta;
+        }
+
+        return this.client.index(esRequest)
+          .then(result => this.refreshIndexIfNeeded(esRequest, _.extend(result, {_source: request.input.body})))
+          .catch(error => Bluebird.reject(this.esWrapper.formatESError(error)));
+      });
+  }
+
+  /**
+   * Create a new document to ElasticSearch, or replace it if it already exist.
+   * This method does not adds additional metadata.
+   *
+   * @param {Request} request
+   * @returns {Promise} resolve an object that contains _id
+   */
+  writeDocument(request) {
+    const esRequest = initESRequest(request, ['refresh']);
+
+    esRequest.id = request.input.resource._id;
+    esRequest.body = request.input.body;
+
+    assertNoRouting(esRequest);
+    assertWellFormedRefresh(esRequest);
+
+    return this.kuzzle.indexCache.exists(esRequest.index, esRequest.type)
+      .then(exists => {
+        if (! exists) {
+          throw new PreconditionError(`Index '${esRequest.index}' and/or collection '${esRequest.type}' does not exist`);
+        }
 
         return this.client.index(esRequest)
           .then(result => this.refreshIndexIfNeeded(esRequest, _.extend(result, {_source: request.input.body})))
@@ -1076,12 +1108,14 @@ class ElasticSearch extends Service {
    * Create or replace multiple documents at once.
    *
    * @param  {Request} request - Kuzzle API request
+   * @param  {boolean} injectKuzzleMeta
    * @return {Promise}
    */
-  mcreateOrReplace(request) {
-    const
-      esRequest = initESRequest(request, ['consistency', 'refresh', 'timeout', 'fields']),
-      extracted = extractMDocuments(request, {
+  mcreateOrReplace(request, injectKuzzleMeta = true) {
+    let kuzzleMeta = {};
+
+    if (injectKuzzleMeta) {
+      kuzzleMeta = {
         _kuzzle_info: {
           active: true,
           author: this._getUserId(request),
@@ -1090,12 +1124,17 @@ class ElasticSearch extends Service {
           deletedAt: null,
           createdAt: Date.now()
         }
-      });
+      };
+    }
+
+    const
+      esRequest = initESRequest(request, ['consistency', 'refresh', 'timeout', 'fields']),
+      extracted = extractMDocuments(request, kuzzleMeta);
 
     esRequest.body = [];
 
     let i; // NOSONAR
-    for(i = 0; i < extracted.documents.length; i++) {
+    for (i = 0; i < extracted.documents.length; i++) {
       esRequest.body.push({
         index: {
           _index: request.input.resource.index,
@@ -1300,7 +1339,7 @@ class ElasticSearch extends Service {
   }
 
   /**
-   * Execute an ES request prepared by mcreate, mupdate, mreplace or mdelete
+   * Execute an ES request prepared by mcreate, mupdate, mreplace, mdelete or mwriteDocuments
    * Returns a standardized ES response object, containing the list of
    * successfully performed operations, and the rejected ones
    *