kuzzle 2.56.0 → 2.57.0-beta.2

package/dist/lib/api/controllers/documentController.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,13 +19,38 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const kerror = require("../../kerror");
-const { NativeController } = require("./baseController");
-const actionEnum = require("../../core/realtime/actionEnum");
-const { assertHasBody, assertHasIndexAndCollection, } = require("../../util/requestAssertions");
-const extractFields = require("../../util/extractFields");
-const { dumpCollectionDocuments } = require("../../util/dump-collection");
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const actionEnum = __importStar(require("../../core/realtime/actionEnum"));
+const kerror = __importStar(require("../../kerror"));
+const dump_collection_1 = require("../../util/dump-collection");
+const requestAssertions_1 = require("../../util/requestAssertions");
+const baseController_1 = require("./baseController");
+const extractFields_1 = __importDefault(require("../../util/extractFields"));
 /**
  * @description actions available on the document Controller (used by generic events)
  * @key actions
@@ -59,7 +85,7 @@ const actions = {
 /**
  * @class DocumentController
  */
-class DocumentController extends NativeController {
+class DocumentController extends baseController_1.NativeController {
     constructor() {
         super(Object.keys(actions));
     }
@@ -76,7 +102,9 @@ class DocumentController extends NativeController {
     async search(request) {
         const { from, size, scrollTTL, searchBody } = request.getSearchParams();
         const index = request.getIndex({ required: false });
-        const collection = request.getCollection({ required: false });
+        const collection = request.getCollection({
+            required: false,
+        });
         const targets = request.getArray("targets", []);
         const lang = request.getLangParam();
         if (!index && !collection && (!targets || targets.length === 0)) {
@@ -146,27 +174,8 @@ class DocumentController extends NativeController {
     /**
      * @param {Request} request
      */
-    async mExists(request) {
-        let ids;
-        if (request.input.body &&
-            request.input.body.ids &&
-            Object.keys(request.input.body.ids).length) {
-            ids = request.getBodyArray("ids");
-        }
-        else {
-            ids = request.getArray("ids");
-        }
-        const { index, collection } = request.getIndexAndCollection();
-        const strict = request.getBoolean("strict");
-        this.assertNotExceedMaxFetch(ids.length);
-        const { items, errors } = await this.ask("core:storage:public:document:mExists", index, collection, ids);
-        if (strict && errors.length) {
-            throw kerror.get("api", "process", "incomplete_multiple_request", "get", errors);
-        }
-        return {
-            errors,
-            successes: items,
-        };
+    mExists(request) {
+        return this._mFetch(request, "mExists");
     }
     async export(request) {
         const { index, collection } = request.getIndexAndCollection();
@@ -175,6 +184,7 @@ class DocumentController extends NativeController {
         const format = request.getString("format", "jsonl");
         const separator = request.getString("separator", ",");
         const query = request.getObjectFromBodyOrArgs("query", {});
+        const sort = getExportSort(request);
         const collapse = request.getObjectFromBodyOrArgs("collapse", {});
         const fields = request.getArrayFromBodyOrArgs("fields", []);
         const fieldsName = request.getObjectFromBodyOrArgs("fieldsName", {});
@@ -188,6 +198,9 @@ class DocumentController extends NativeController {
         if (lang === "koncorde") {
             searchBody.query = await this.translateKoncorde(searchBody.query || {});
         }
+        if (sort !== undefined) {
+            searchBody.sort = sort;
+        }
         let mimeType = "html/text";
         if (format.toLowerCase() === "csv") {
             mimeType = "text/csv";
@@ -198,7 +211,7 @@ class DocumentController extends NativeController {
                 "Content-Type": mimeType,
             },
         });
-        return dumpCollectionDocuments(index, collection, searchBody, format, fields, {
+        return (0, dump_collection_1.dumpCollectionDocuments)(index, collection, searchBody, format, fields, {
             fieldsName,
             lang,
             scroll: scrollTTL || "5s",
@@ -226,28 +239,9 @@ class DocumentController extends NativeController {
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    async mGet(request) {
-        let ids;
-        if (request.input.body &&
-            request.input.body.ids &&
-            Object.keys(request.input.body.ids).length) {
-            ids = request.getBodyArray("ids");
-        }
-        else {
-            ids = request.getArray("ids");
-        }
-        const { index, collection } = request.getIndexAndCollection();
-        const strict = request.getBoolean("strict");
-        this.assertNotExceedMaxFetch(ids.length);
-        const { items, errors } = await this.ask("core:storage:public:document:mGet", index, collection, ids);
-        if (strict && errors.length) {
-            throw kerror.get("api", "process", "incomplete_multiple_request", "get", errors);
-        }
+    mGet(request) {
         // @todo next major release: if (successes.length === 0) then throw (no matter strict value)
-        return {
-            errors,
-            successes: items,
-        };
+        return this._mFetch(request, "mGet");
     }
     /**
      * @param {Request} request
@@ -316,36 +310,8 @@ class DocumentController extends NativeController {
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    async createOrReplace(request) {
-        const id = request.getId();
-        const content = request.getBody();
-        const userId = request.getKuid();
-        const silent = request.getBoolean("silent");
-        const refresh = request.getString("refresh", "false");
-        const { index, collection } = request.getIndexAndCollection();
-        const modifiedRequest = await global.kuzzle.validation.validate(request, false);
-        // Add metadata
-        const pipeMetadataResult = await this.pipe("generic:document:injectMetadata", {
-            metadata: {
-                author: userId,
-                createdAt: Date.now(),
-                updatedAt: Date.now(),
-                updater: userId,
-            },
-            request,
-        });
-        const response = await this.ask("core:storage:public:document:createOrReplace", index, collection, id, {
-            ...content,
-            _kuzzle_info: pipeMetadataResult.metadata,
-        }, {
-            injectKuzzleMeta: false,
-            refresh,
-            userId,
-        });
-        if (!silent) {
-            await this.ask("core:realtime:document:notify", modifiedRequest, actionEnum.WRITE, response);
-        }
-        return response;
+    createOrReplace(request) {
+        return this._writeDocument(request, "createOrReplace");
     }
     /**
      * Create or replace the documents provided in the body
@@ -390,7 +356,7 @@ class DocumentController extends NativeController {
             retryOnConflict,
             userId,
         });
-        const _updatedFields = extractFields(content, {
+        const _updatedFields = (0, extractFields_1.default)(content, {
             fieldsToIgnore: ["_kuzzle_info"],
         });
         if (!silent) {
@@ -458,7 +424,7 @@ class DocumentController extends NativeController {
             await this.ask("core:realtime:document:notify", request, actionEnum.CREATE, updatedDocument._source);
         }
         else if (!silent) {
-            const _updatedFields = extractFields(content, {
+            const _updatedFields = (0, extractFields_1.default)(content, {
                 fieldsToIgnore: ["_kuzzle_info"],
             });
             await this.ask("core:realtime:document:notify", request, actionEnum.UPDATE, {
@@ -502,39 +468,8 @@ class DocumentController extends NativeController {
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    async replace(request) {
-        const id = request.getId();
-        const content = request.getBody();
-        const userId = request.getKuid();
-        const silent = request.getBoolean("silent");
-        const refresh = request.getString("refresh", "false");
-        const { index, collection } = request.getIndexAndCollection();
-        const modifiedRequest = await global.kuzzle.validation.validate(request, false);
-        // Add metadata
-        const pipeMetadataResult = await this.pipe("generic:document:injectMetadata", {
-            metadata: {
-                author: userId,
-                createdAt: Date.now(),
-                updatedAt: Date.now(),
-                updater: userId,
-            },
-            request,
-        });
-        const response = await this.ask("core:storage:public:document:replace", index, collection, id, {
-            ...content,
-            _kuzzle_info: pipeMetadataResult.metadata,
-        }, {
-            injectKuzzleMeta: false,
-            refresh,
-            userId,
-        });
-        if (!silent) {
-            await this.ask("core:realtime:document:notify", modifiedRequest, actionEnum.REPLACE, {
-                _id: modifiedRequest.input.args._id,
-                _source: modifiedRequest.input.body,
-            });
-        }
-        return response;
+    replace(request) {
+        return this._writeDocument(request, "replace");
     }
     /**
      * Replace the documents provided in the body
@@ -674,7 +609,7 @@ class DocumentController extends NativeController {
             await this.ask("core:realtime:document:mNotify", request, actionEnum.UPDATE, result.successes.map((doc) => ({
                 _id: doc._id,
                 _source: doc._source,
-                _updatedFields: extractFields(changes, {
+                _updatedFields: (0, extractFields_1.default)(changes, {
                     fieldsToIgnore: ["_kuzzle_info"],
                 }),
             })));
@@ -691,11 +626,88 @@ class DocumentController extends NativeController {
      * @returns {Promise<Object>}
      */
     validate(request) {
-        assertHasBody(request);
-        assertHasIndexAndCollection(request);
+        (0, requestAssertions_1.assertHasBody)(request);
+        (0, requestAssertions_1.assertHasIndexAndCollection)(request);
         // @todo validation service should not take request argument
         return global.kuzzle.validation.validate(request, true);
     }
+    /**
+     * Fetches documents by id (`mGet`) or checks their existence (`mExists`):
+     * the two actions take the same input and shape the same response, they only
+     * read through a different storage event.
+     *
+     * @param  {Request} request
+     * @param  {String} methodName storage method to ask for
+     * @returns {Promise.<Object>} { successes, errors }
+     */
+    async _mFetch(request, methodName) {
+        // `ids` may come either in the body or in the query string
+        const ids = request.input.body?.ids && Object.keys(request.input.body.ids).length
+            ? request.getBodyArray("ids")
+            : request.getArray("ids");
+        const { index, collection } = request.getIndexAndCollection();
+        const strict = request.getBoolean("strict");
+        this.assertNotExceedMaxFetch(ids.length);
+        const { items, errors } = await this.ask(`core:storage:public:document:${methodName}`, index, collection, ids);
+        if (strict && errors.length) {
+            throw kerror.get("api", "process", "incomplete_multiple_request", "get", errors);
+        }
+        return {
+            errors,
+            successes: items,
+        };
+    }
+    /**
+     * Writes a single document, either through `replace` (which requires it to
+     * exist) or `createOrReplace` (which does not). Both validate, inject
+     * metadata, write and then notify; they differ only in the storage event,
+     * the notification action, and what that notification carries.
+     *
+     * @param  {Request} request
+     * @param  {String} methodName storage method to ask for — it also decides
+     *                  the notification action and its payload, so the two can
+     *                  no longer disagree (TD-31)
+     * @returns {Promise.<Object>} the storage response
+     */
+    async _writeDocument(request, methodName) {
+        const action = methodName === "replace" ? actionEnum.REPLACE : actionEnum.WRITE;
+        const id = request.getId();
+        const content = request.getBody();
+        const userId = request.getKuid();
+        const silent = request.getBoolean("silent");
+        const refresh = request.getString("refresh", "false");
+        const { index, collection } = request.getIndexAndCollection();
+        const modifiedRequest = await global.kuzzle.validation.validate(request, false);
+        // Add metadata
+        const pipeMetadataResult = await this.pipe("generic:document:injectMetadata", {
+            metadata: {
+                author: userId,
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+                updater: userId,
+            },
+            request,
+        });
+        const response = await this.ask(`core:storage:public:document:${methodName}`, index, collection, id, {
+            ...content,
+            _kuzzle_info: pipeMetadataResult.metadata,
+        }, {
+            injectKuzzleMeta: false,
+            refresh,
+            userId,
+        });
+        if (!silent) {
+            // `replace` notifies the request's own payload rather than the storage
+            // response — kept as-is, the two actions have always differed here.
+            await this.ask("core:realtime:document:notify", modifiedRequest, action, methodName === "replace"
+                ? {
+                    _id: modifiedRequest.input.args._id,
+                    _source: modifiedRequest.input.body,
+                }
+                : response);
+        }
+        return response;
+    }
     /**
      * Applies a multi-document change request (create, update,
      * replace, createOrReplace, upsert)
@@ -729,12 +741,12 @@ class DocumentController extends NativeController {
                 successes: [],
             };
         }
-        for (let i = 0; i < documents.length; i++) {
-            if (documents[i]._source) {
+        for (const [i, document] of documents.entries()) {
+            if (document._source) {
                 throw kerror.get("api", "assert", "unexpected_argument", `documents[${i}]._source`, `documents[${i}].body`);
             }
-            if (documents[i].body?._kuzzle_info !== undefined) {
-                delete documents[i].body._kuzzle_info;
+            if (document.body?._kuzzle_info !== undefined) {
+                delete document.body._kuzzle_info;
             }
         }
         const response = await this.ask(`core:storage:public:document:${methodName}`, index, collection, documents, { refresh, retryOnConflict, source, userId });
@@ -751,7 +763,7 @@ class DocumentController extends NativeController {
             }, {});
             await this.ask("core:realtime:document:mNotify", request, action, response.items.map((item) => {
                 if (!item.created) {
-                    item._updatedFields = extractFields(documentsDictionnary[item._id], { fieldsToIgnore: ["_kuzzle_info"] });
+                    item._updatedFields = (0, extractFields_1.default)(documentsDictionnary[item._id], { fieldsToIgnore: ["_kuzzle_info"] });
                 }
                 return item;
             }));
@@ -768,5 +780,24 @@ class DocumentController extends NativeController {
 function hasMultiTargets(str) {
     return [",", "*", "+"].some((chr) => str.includes(chr)) || str === "_all";
 }
+/**
+ * `document:export`'s `sort`, in every form Elasticsearch takes — an object, a
+ * field name, or the array its documentation (and ours) shows — and forwarded
+ * as is, as `document:search` does. `getObjectFromBodyOrArgs` refused the array
+ * outside HTTP GET. An empty value means no sort.
+ */
+function getExportSort(request) {
+    const { misc, protocol } = request.context.connection;
+    const sort = protocol === "http" && misc.verb === "GET"
+        ? request.getObjectFromBodyOrArgs("sort", {})
+        : request.input.body?.sort;
+    if (sort === undefined ||
+        sort === null ||
+        (typeof sort === "object" && Object.keys(sort).length === 0) ||
+        sort === "") {
+        return undefined;
+    }
+    return sort;
+}
 module.exports = DocumentController;
 //# sourceMappingURL=documentController.js.map

package/dist/lib/api/controllers/index.d.ts

@@ -1,12 +1,27 @@
-export let AdminController: typeof import("./adminController");
-export let AuthController: typeof import("./authController");
-export let BulkController: typeof import("./bulkController");
-export let ClusterController: typeof import("./clusterController");
-export let CollectionController: typeof import("./collectionController");
-export let DebugController: typeof import("./debugController").DebugController;
-export let DocumentController: typeof import("./documentController");
-export let IndexController: typeof import("./indexController");
-export let MemoryStorageController: typeof import("./memoryStorageController");
-export let RealtimeController: typeof import("./realtimeController");
-export let SecurityController: typeof import("./securityController");
-export let ServerController: typeof import("./serverController");
+import AdminController from "./adminController";
+import AuthController from "./authController";
+import BulkController from "./bulkController";
+import ClusterController from "./clusterController";
+import CollectionController from "./collectionController";
+import DocumentController from "./documentController";
+import IndexController from "./indexController";
+import MemoryStorageController from "./memoryStorageController";
+import RealtimeController from "./realtimeController";
+import SecurityController from "./securityController";
+import ServerController from "./serverController";
+import { DebugController } from "./debugController";
+declare const _default: {
+    AdminController: typeof AdminController;
+    AuthController: typeof AuthController;
+    BulkController: typeof BulkController;
+    ClusterController: typeof ClusterController;
+    CollectionController: typeof CollectionController;
+    DebugController: typeof DebugController;
+    DocumentController: typeof DocumentController;
+    IndexController: typeof IndexController;
+    MemoryStorageController: typeof MemoryStorageController;
+    RealtimeController: typeof RealtimeController;
+    SecurityController: typeof SecurityController;
+    ServerController: typeof ServerController;
+};
+export = _default;

package/dist/lib/api/controllers/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,19 +19,33 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const adminController_1 = __importDefault(require("./adminController"));
+const authController_1 = __importDefault(require("./authController"));
+const bulkController_1 = __importDefault(require("./bulkController"));
+const clusterController_1 = __importDefault(require("./clusterController"));
+const collectionController_1 = __importDefault(require("./collectionController"));
+const documentController_1 = __importDefault(require("./documentController"));
+const indexController_1 = __importDefault(require("./indexController"));
+const memoryStorageController_1 = __importDefault(require("./memoryStorageController"));
+const realtimeController_1 = __importDefault(require("./realtimeController"));
+const securityController_1 = __importDefault(require("./securityController"));
+const serverController_1 = __importDefault(require("./serverController"));
+const debugController_1 = require("./debugController");
 module.exports = {
-    AdminController: require("./adminController"),
-    AuthController: require("./authController"),
-    BulkController: require("./bulkController"),
-    ClusterController: require("./clusterController"),
-    CollectionController: require("./collectionController"),
-    DebugController: require("./debugController").DebugController,
-    DocumentController: require("./documentController"),
-    IndexController: require("./indexController"),
-    MemoryStorageController: require("./memoryStorageController"),
-    RealtimeController: require("./realtimeController"),
-    SecurityController: require("./securityController"),
-    ServerController: require("./serverController"),
+    AdminController: adminController_1.default,
+    AuthController: authController_1.default,
+    BulkController: bulkController_1.default,
+    ClusterController: clusterController_1.default,
+    CollectionController: collectionController_1.default,
+    DebugController: debugController_1.DebugController,
+    DocumentController: documentController_1.default,
+    IndexController: indexController_1.default,
+    MemoryStorageController: memoryStorageController_1.default,
+    RealtimeController: realtimeController_1.default,
+    SecurityController: securityController_1.default,
+    ServerController: serverController_1.default,
 };
 //# sourceMappingURL=index.js.map

package/dist/lib/api/controllers/indexController.d.ts

@@ -1,4 +1,5 @@
-export = IndexController;
+import type { KuzzleRequest } from "../request";
+import { NativeController } from "./baseController";
 /**
  * @class IndexController
  */
@@ -14,7 +15,9 @@ declare class IndexController extends NativeController {
      *
      * @returns {Promise.<Object>}
      */
-    mDelete(request: Request): Promise<any>;
+    mDelete(request: KuzzleRequest): Promise<{
+        deleted: any;
+    }>;
     /**
      * Creates an index
      *
@@ -22,20 +25,25 @@ declare class IndexController extends NativeController {
      *
      * @returns {Promise}
      */
-    create(request: Request): Promise<any>;
+    create(request: KuzzleRequest): Promise<void>;
     /**
      * Deletes the index and associated collections
      *
      * @param {Request} request
      * @returns {Promise.<Object>}
      */
-    delete(request: Request): Promise<any>;
+    delete(request: KuzzleRequest): Promise<{
+        acknowledged: boolean;
+    }>;
     /**
      * Lists indexes
      *
      */
-    list(request: any): Promise<{
-        indexes: any;
+    list(request: KuzzleRequest): Promise<{
+        indexes: string[];
+        collections?: {
+            [index: string]: number;
+        } | undefined;
     }>;
     /**
      * Tells if an index exists
@@ -43,7 +51,7 @@ declare class IndexController extends NativeController {
      * @param {Request} request
      * @returns {Promise.<boolean>}
      */
-    exists(request: Request): Promise<boolean>;
+    exists(request: KuzzleRequest): Promise<any>;
     /**
      * Returns storage stats
      *
@@ -59,7 +67,6 @@ declare class IndexController extends NativeController {
      * @param {Request} request
      * @param {String[]} publicIndexes - Public indexes list
      */
-    _allowedIndexes(request: Request, publicIndexes: string[]): string[] | Promise<any[]>;
+    _allowedIndexes(request: KuzzleRequest, publicIndexes: string[]): string[] | Promise<string[]>;
 }
-import { NativeController } from "./baseController";
-import { Request } from "../request/kuzzleRequest";
+export = IndexController;

package/dist/lib/api/controllers/indexController.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,13 +19,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const { Request } = require("../request");
-const { NativeController } = require("./baseController");
+const request_1 = require("../request");
+const baseController_1 = require("./baseController");
 /**
  * @class IndexController
  */
-class IndexController extends NativeController {
+class IndexController extends baseController_1.NativeController {
     constructor() {
         super(["create", "delete", "exists", "list", "mDelete", "stats"]);
     }
@@ -79,11 +79,14 @@ class IndexController extends NativeController {
             indexes,
         };
         if (countCollection) {
-            response.collections = {};
+            // Through a local: `response.collections` is optional, and the narrowing
+            // the assignment gives does not reach inside the callbacks below.
+            const counts = {};
+            response.collections = counts;
             const promises = [];
             for (const index of indexes) {
                 promises.push(this.ask("core:storage:public:collection:list", index).then((collections) => {
-                    response.collections[index] = collections.length;
+                    counts[index] = collections.length;
                 }));
             }
             await Promise.all(promises);
@@ -118,15 +121,14 @@ class IndexController extends NativeController {
      * @param {String[]} publicIndexes - Public indexes list
      */
     _allowedIndexes(request, publicIndexes) {
-        if (request.getUser() === null) {
+        const user = request.getUser();
+        if (user === null) {
             return publicIndexes;
         }
         const allowedIndexes = [];
         const promises = publicIndexes.map((index) => {
-            const deleteIndexRequest = new Request({ action: "delete", controller: "index", index }, request.context);
-            return request.context.user
-                .isActionAllowed(deleteIndexRequest)
-                .then((isAllowed) => {
+            const deleteIndexRequest = new request_1.Request({ action: "delete", controller: "index", index }, request.context);
+            return user.isActionAllowed(deleteIndexRequest).then((isAllowed) => {
                 if (isAllowed) {
                     allowedIndexes.push(index);
                 }

package/dist/lib/api/controllers/memoryStorageController.d.ts

@@ -1,8 +1,5 @@
-export = MemoryStorageController;
-/**
- * @class MemoryStorageController
- */
+import { NativeController } from "./baseController";
 declare class MemoryStorageController extends NativeController {
     constructor();
 }
-import { NativeController } from "./baseController";
+export = MemoryStorageController;