kuzzle 2.19.2 → 2.19.3

package/lib/api/documentExtractor.js

@@ -19,22 +19,22 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const kerror = require('../kerror');
+const kerror = require("../kerror");
 
-const assertionError = kerror.wrap('api', 'assert');
+const assertionError = kerror.wrap("api", "assert");
 
-const extractors = ([
+const extractors = [
   {
     methods: {
-      extractFromRequest: request => [
+      extractFromRequest: (request) => [
         {
           _id: request.input.args._id,
           _source: request.input.body.fields,
         },
       ],
-      extractFromResult: request => [request.result],
+      extractFromResult: (request) => [request.result],
       insertInRequest: ([documents], request) => {
         request.input.args._id = documents._id;
         request.input.body.fields = documents._source;
@@ -45,12 +45,12 @@ const extractors = ([
         return request;
       },
     },
-    targets: [ 'deleteFields' ]
+    targets: ["deleteFields"],
   },
   {
     methods: {
-      extractFromRequest: request => [{ _id: request.input.args._id }],
-      extractFromResult: request => [request.result],
+      extractFromRequest: (request) => [{ _id: request.input.args._id }],
+      extractFromResult: (request) => [request.result],
       insertInRequest: (documents, request) => {
         request.input.args._id = documents[0] && documents[0]._id;
         return request;
@@ -58,39 +58,38 @@ const extractors = ([
       insertInResult: (documents, request) => {
         request.setResult(documents[0], { status: request.status });
         return request;
-      }
+      },
     },
-    targets: [ 'delete', 'get', 'exists' ]
+    targets: ["delete", "get", "exists"],
   },
   {
     methods: {
-      extractFromRequest: request => {
+      extractFromRequest: (request) => {
         let ids = [];
-        if ( request.input.body
-          && request.input.body.ids
-          && Object.keys(request.input.body.ids).length
+        if (
+          request.input.body &&
+          request.input.body.ids &&
+          Object.keys(request.input.body.ids).length
         ) {
           ids = request.input.body.ids;
-        }
-        else if (request.input.args.ids) {
+        } else if (request.input.args.ids) {
           if (Array.isArray(request.input.args.ids)) {
             ids = request.input.args.ids;
-          }
-          else if (typeof request.input.args.ids === 'string') {
+          } else if (typeof request.input.args.ids === "string") {
             // @deprecated Should be replaced with request.getArray('ids')
-            ids = request.getArrayLegacy('ids');
-          }
-          else {
+            ids = request.getArrayLegacy("ids");
+          } else {
             throw assertionError.get(
-              'invalid_type',
+              "invalid_type",
               request.input.args.ids,
-              'Array or String');
+              "Array or String"
+            );
           }
         }
-        return ids.map(_id => ({ _id }));
+        return ids.map((_id) => ({ _id }));
       },
-      extractFromResult: request => {
-        if (request.input.action === 'mGet') {
+      extractFromResult: (request) => {
+        if (request.input.action === "mGet") {
           return request.result.successes;
         }
 
@@ -104,30 +103,30 @@ const extractors = ([
       },
       insertInRequest: (documents, request) => {
         if (request.input.body && Object.keys(request.input.body).length) {
-          request.input.body.ids = documents.map(document => document._id);
-        }
-        else {
-          request.input.args.ids = documents.map(document => document._id);
+          request.input.body.ids = documents.map((document) => document._id);
+        } else {
+          request.input.args.ids = documents.map((document) => document._id);
         }
         return request;
       },
       insertInResult: (documents, request) => {
-        if (request.input.action === 'mGet') {
+        if (request.input.action === "mGet") {
           request.setResult(
             {
               errors: request.result.errors,
-              successes: documents
+              successes: documents,
             },
             {
-              status: request.status
-            });
+              status: request.status,
+            }
+          );
 
           return request;
         }
 
         const result = {
           errors: request.result.errors,
-          successes: []
+          successes: [],
         };
 
         for (let it = 0; it < documents.length; it++) {
@@ -137,32 +136,31 @@ const extractors = ([
         request.setResult(result, { status: request.status });
 
         return request;
-      }
+      },
     },
-    targets: [ 'mDelete', 'mGet', 'mExists' ]
+    targets: ["mDelete", "mGet", "mExists"],
   },
   {
     methods: {
-      extractFromRequest: request => {
+      extractFromRequest: (request) => {
         const documents = [];
 
         for (let it = 0; it < request.input.body.documents.length; it++) {
           const document = request.input.body.documents[it];
 
-          if (request.input.action === 'mUpsert') {
+          if (request.input.action === "mUpsert") {
             documents.push({
               _id: document._id,
               _source: document.changes,
             });
-          }
-          else {
+          } else {
             documents.push({ _id: document._id, _source: document.body });
           }
         }
 
         return documents;
       },
-      extractFromResult: request => request.result.successes,
+      extractFromResult: (request) => request.result.successes,
       insertInRequest: (documents, request) => {
         const tmpDocuments = request.input.body.documents;
 
@@ -171,14 +169,13 @@ const extractors = ([
         for (let it = 0; it < documents.length; it++) {
           const document = documents[it];
 
-          if (request.input.action === 'mUpsert') {
+          if (request.input.action === "mUpsert") {
             request.input.body.documents.push({
               _id: document._id,
               changes: document._source,
               default: tmpDocuments[it].default,
             });
-          }
-          else {
+          } else {
             request.input.body.documents.push({
               _id: document._id,
               body: document._source,
@@ -191,42 +188,48 @@ const extractors = ([
       insertInResult: (documents, request) => {
         const result = {
           errors: request.result.errors,
-          successes: documents
+          successes: documents,
         };
 
         request.setResult(result, { status: request.status });
 
         return request;
-      }
+      },
     },
-    targets: [ 'mCreate', 'mCreateOrReplace', 'mReplace', 'mUpdate', 'updateByQuery', 'mUpsert' ]
+    targets: [
+      "mCreate",
+      "mCreateOrReplace",
+      "mReplace",
+      "mUpdate",
+      "updateByQuery",
+      "mUpsert",
+    ],
   },
   {
     methods: {
       extractFromRequest: null, // not eligible for search queries
-      extractFromResult: request => {
+      extractFromResult: (request) => {
         return request.result.hits || request.result.documents;
       },
       insertInRequest: null, // not eligible for search queries
       insertInResult: (documents, request) => {
-        if (request.input.action === 'search') {
+        if (request.input.action === "search") {
           request.result.hits = documents;
-        }
-        else if (request.input.action === 'deleteByQuery') {
+        } else if (request.input.action === "deleteByQuery") {
           request.result.documents = documents;
         }
 
         return request;
       },
     },
-    targets: [ 'search', 'deleteByQuery', 'export' ],
+    targets: ["search", "deleteByQuery", "export"],
   },
   {
     methods: {
-      extractFromRequest: request => [
+      extractFromRequest: (request) => [
         { _id: request.input.args._id, _source: request.input.body },
       ],
-      extractFromResult: request => [request.result],
+      extractFromResult: (request) => [request.result],
       insertInRequest: (documents, request) => {
         request.input.args._id = documents[0] && documents[0]._id;
         request.input.body = documents[0] && documents[0]._source;
@@ -237,17 +240,17 @@ const extractors = ([
         return request;
       },
     },
-    targets: [ 'create', 'createOrReplace', 'replace', 'update' ],
+    targets: ["create", "createOrReplace", "replace", "update"],
   },
   {
     methods: {
-      extractFromRequest: request => [
+      extractFromRequest: (request) => [
         {
           _id: request.input.args._id,
           _source: request.input.body.changes,
         },
       ],
-      extractFromResult: request => [ request.result ],
+      extractFromResult: (request) => [request.result],
       insertInRequest: ([document], request) => {
         if (document) {
           request.input.args._id = document._id;
@@ -261,40 +264,44 @@ const extractors = ([
         return request;
       },
     },
-    targets: [ 'upsert' ],
+    targets: ["upsert"],
   },
-]).reduce((acc, extractor) => {
-  extractor.targets.forEach(target => {
+].reduce((acc, extractor) => {
+  extractor.targets.forEach((target) => {
     acc[target] = extractor.methods;
   });
   return acc;
 }, {});
 
 class DocumentExtractor {
-  constructor (request) {
+  constructor(request) {
     this.request = request;
 
     const extractor = extractors[request.input.action];
 
     if (extractor === undefined) {
-      throw kerror.get('core', 'fatal', 'assertion_failed', `no generic documents extractor for ${request.input.action}`);
+      throw kerror.get(
+        "core",
+        "fatal",
+        "assertion_failed",
+        `no generic documents extractor for ${request.input.action}`
+      );
     }
 
     if (request.result) {
       this.extractMethod = extractor.extractFromResult;
       this.insertMethod = extractor.insertInResult;
-    }
-    else {
+    } else {
       this.extractMethod = extractor.extractFromRequest;
       this.insertMethod = extractor.insertInRequest;
     }
   }
 
-  extract () {
+  extract() {
     return this.extractMethod(this.request);
   }
 
-  insert (documents) {
+  insert(documents) {
     return this.insertMethod(documents, this.request);
   }
 }