kuzzle 2.49.1 → 2.50.0-beta.3

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

@@ -0,0 +1,132 @@
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2022 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+"use strict";
+const { NativeController } = require("./baseController");
+const actionEnum = require("../../core/realtime/actionEnum");
+const kerror = require("../../kerror");
+/**
+ * @class BulkController
+ */
+class BulkController extends NativeController {
+    constructor() {
+        super(["import", "write", "mWrite", "deleteByQuery", "updateByQuery"]);
+    }
+    /**
+     * Perform a bulk import
+     *
+     * @param {Request} request
+     * @returns {Promise}
+     */
+    async import(request) {
+        const userId = request.getKuid();
+        const { index, collection } = request.getIndexAndCollection();
+        const strict = request.getBoolean("strict");
+        const refresh = request.getRefresh();
+        const bulkData = request.getBodyArray("bulkData");
+        const options = {
+            refresh,
+            userId,
+        };
+        const { items, errors } = await this.ask("core:storage:public:document:bulk", index, collection, bulkData, options);
+        if (strict && errors.length) {
+            throw kerror.get("api", "process", "incomplete_multiple_request", "import", errors);
+        }
+        // @todo next major release: if (successes.length === 0) then throw (no matter strict value)
+        return {
+            errors,
+            successes: items,
+        };
+    }
+    /**
+     * Write a document without adding metadata or performing data validation.
+     */
+    async write(request) {
+        const { index, collection } = request.getIndexAndCollection();
+        const id = request.getId({ ifMissing: "ignore" });
+        const content = request.getBody();
+        const refresh = request.getRefresh();
+        const notify = request.getBoolean("notify");
+        const result = await this.ask("core:storage:public:document:createOrReplace", index, collection, id, content, { injectKuzzleMeta: false, refresh });
+        if (notify) {
+            await this.ask("core:realtime:document:notify", request, actionEnum.WRITE, result);
+        }
+        return {
+            _id: result._id,
+            _source: result._source,
+            _version: result._version,
+        };
+    }
+    /**
+     * Write several documents without adding metadata or performing data validation.
+     */
+    async mWrite(request) {
+        const { index, collection } = request.getIndexAndCollection();
+        const documents = request.getBodyArray("documents");
+        const strict = request.getBoolean("strict");
+        const refresh = request.getRefresh();
+        const notify = request.getBoolean("notify");
+        const { items, errors } = await this.ask("core:storage:public:document:mCreateOrReplace", index, collection, documents, { injectKuzzleMeta: false, limits: false, refresh });
+        if (strict && errors.length) {
+            throw kerror.get("api", "process", "incomplete_multiple_request", "write", errors);
+        }
+        // @todo next major release: if (successes.length === 0) then throw (no matter strict value)
+        if (notify) {
+            await global.kuzzle.ask("core:realtime:document:mNotify", request, actionEnum.WRITE, items);
+        }
+        const successes = items.map((item) => ({
+            _id: item._id,
+            _source: item._source,
+            _version: item._version,
+        }));
+        return {
+            errors,
+            successes,
+        };
+    }
+    /**
+     * Directly deletes every documents matching the search query without:
+     *  - applying max documents write limit
+     *  - fetching deleted documents
+     *  - triggering realtime notifications
+     */
+    async deleteByQuery(request) {
+        const { index, collection } = request.getIndexAndCollection();
+        const query = request.getBodyObject("query");
+        const refresh = request.getRefresh();
+        const { deleted } = await this.ask("core:storage:public:document:deleteByQuery", index, collection, query, { fetch: false, refresh, size: -1 });
+        return { deleted };
+    }
+    /**
+     * Directly update every document matching the search query without:
+     *  - Applying max documents write limit
+     *  - Injecting Kuzzle metadata
+     *  - Triggering realtime notifications
+     */
+    async updateByQuery(request) {
+        const { index, collection } = request.getIndexAndCollection();
+        const query = request.getBodyObject("query");
+        const changes = request.getBodyObject("changes");
+        const refresh = request.getRefresh();
+        return this.ask("core:storage:public:bulk:updateByQuery", index, collection, query, changes, { refresh });
+    }
+}
+module.exports = BulkController;
+//# sourceMappingURL=bulkController.js.map

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

@@ -0,0 +1,6 @@
+export = ClusterController;
+declare class ClusterController extends NativeController {
+    constructor();
+    status(): Promise<any>;
+}
+import { NativeController } from "./baseController";

package/{lib → dist/lib}/api/controllers/clusterController.js

@@ -18,19 +18,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 "use strict";
-
 const { NativeController } = require("./baseController");
-
 class ClusterController extends NativeController {
-  constructor() {
-    super(["status"]);
-  }
-
-  async status() {
-    return global.kuzzle.ask("cluster:status:get");
-  }
+    constructor() {
+        super(["status"]);
+    }
+    async status() {
+        return global.kuzzle.ask("cluster:status:get");
+    }
 }
-
 module.exports = ClusterController;
+//# sourceMappingURL=clusterController.js.map

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

@@ -0,0 +1,136 @@
+export = CollectionController;
+/**
+ * @class CollectionController
+ */
+declare class CollectionController extends NativeController {
+    constructor();
+    defaultScrollTTL: string;
+    /**
+     * Updates the mapping of the collection
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    updateMapping(request: Request): Promise<any>;
+    /**
+     * Get the collection mapping
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    getMapping(request: Request): Promise<any>;
+    /**
+     * Get the collection settings
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    getSettings(request: Request): Promise<any>;
+    /**
+     * Get the collection validation specifications
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    getSpecifications(request: Request): Promise<any>;
+    /**
+     * Search for collection validation specifications
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    searchSpecifications(request: Request): Promise<any>;
+    /**
+     * Scroll over a paginated search results
+     *
+     * @param {Request} request
+     * @returns {Promise.<object>}
+     */
+    scrollSpecifications(request: Request): Promise<object>;
+    /**
+     * Replace the specifications of a collection
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    updateSpecifications(request: Request): Promise<any>;
+    /**
+     * Add a specification collections
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    deleteSpecifications(request: Request): Promise<any>;
+    /**
+     * Validate a specification
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    validateSpecifications(request: Request): Promise<any>;
+    /**
+     * Reset a collection by removing all documents while keeping the existing mapping
+     *
+     * @param {KuzzleRequest} request
+     * @returns {Promise.<Object>}
+     */
+    truncate(request: KuzzleRequest): Promise<any>;
+    /**
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    list(request: Request): Promise<any>;
+    /**
+     * @param {Request} request
+     * @returns {Promise.<boolean>}
+     */
+    exists(request: Request): Promise<boolean>;
+    /**
+     * Creates a new collection with the specifed mappings and settings.
+     * Only update the mappings and settings if the collection exists.
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    create(request: Request): Promise<any>;
+    /**
+     * Updates a collection mappings and settings.
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    update(request: Request): Promise<any>;
+    /**
+     * Refresh a collection
+     *
+     * @param {Request} request
+     * @returns {Promise.<null>}
+     */
+    refresh(request: Request): Promise<null>;
+    /**
+     * Deletes a collection
+     *
+     * @param {String} index
+     * @param {String} collection
+     *
+     * @returns {Promise.<null>}
+     */
+    delete(request: any): Promise<null>;
+    /**
+     * Uses from and size to paginate response results
+     * If type is "all", stored collections are prioritary
+     *
+     * @param {Number} from
+     * @param {Number} size
+     * @param {Object} response
+     * @returns {Object} { collections, from, size }
+     */
+    _paginateCollections(from: number, size: number, response: any): any;
+    /**
+     * Return only the mapping properties we want to output in our API
+     * @param  {Object} mapping - raw ES mapping
+     * @returns {Object}
+     */
+    _filterMappingResponse(mapping: any): any;
+}
+import { NativeController } from "./baseController";

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

@@ -0,0 +1,356 @@
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2022 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+"use strict";
+const kerror = require("../../kerror");
+const { isPlainObject } = require("../../util/safeObject");
+const { NativeController } = require("./baseController");
+/**
+ * @class CollectionController
+ */
+class CollectionController extends NativeController {
+    constructor() {
+        super([
+            "create",
+            "delete",
+            "deleteSpecifications",
+            "exists",
+            "getMapping",
+            "getSettings",
+            "getSpecifications",
+            "list",
+            "refresh",
+            "scrollSpecifications",
+            "searchSpecifications",
+            "truncate",
+            "update",
+            "updateMapping",
+            "updateSpecifications",
+            "validateSpecifications",
+        ]);
+        this.defaultScrollTTL =
+            global.kuzzle.config.services.storageEngine.defaults.scrollTTL;
+    }
+    /**
+     * Updates the mapping of the collection
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    async updateMapping(request) {
+        request.addDeprecation("2.1.0", 'This action has been deprecated since Kuzzle version 2.1.0. This feature might be removed in a future major version. To update a collection, use this API action instead: "collection:update".');
+        const { index, collection } = request.getIndexAndCollection();
+        const mappings = request.getBody();
+        const updated = await this.ask("core:storage:public:mappings:update", index, collection, mappings);
+        return this._filterMappingResponse(updated);
+    }
+    /**
+     * Get the collection mapping
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    async getMapping(request) {
+        const { index, collection } = request.getIndexAndCollection(), includeKuzzleMeta = request.getBoolean("includeKuzzleMeta");
+        const mapping = await this.ask("core:storage:public:mappings:get", index, collection, { includeKuzzleMeta });
+        return this._filterMappingResponse(mapping);
+    }
+    /**
+     * Get the collection settings
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    async getSettings(request) {
+        const { index, collection } = request.getIndexAndCollection();
+        return this.ask("core:storage:public:collection:settings:get", index, collection, {});
+    }
+    /**
+     * Get the collection validation specifications
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    getSpecifications(request) {
+        const { index, collection } = request.getIndexAndCollection();
+        return global.kuzzle.internalIndex
+            .get("validations", `${index}#${collection}`)
+            .then((response) => response._source)
+            .catch((error) => {
+            if (error.status === 404) {
+                throw kerror.getFrom(error, "validation", "assert", "not_found", index, collection);
+            }
+            throw error;
+        });
+    }
+    /**
+     * Search for collection validation specifications
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    async searchSpecifications(request) {
+        const { from, size, scrollTTL, searchBody } = request.getSearchParams();
+        if (!isPlainObject(searchBody)) {
+            throw kerror.get("api", "assert", "invalid_type", "body.query", "object");
+        }
+        this.assertNotExceedMaxFetch(size - from);
+        const { hits, scrollId, total } = await global.kuzzle.internalIndex.search("validations", searchBody, { from, scroll: scrollTTL, size });
+        return { hits, scrollId, total };
+    }
+    /**
+     * Scroll over a paginated search results
+     *
+     * @param {Request} request
+     * @returns {Promise.<object>}
+     */
+    async scrollSpecifications(request) {
+        const ttl = request.getString("scroll", this.defaultScrollTTL), id = request.getString("scrollId");
+        return global.kuzzle.internalIndex
+            .scroll(id, ttl)
+            .then(({ scrollId, hits, total }) => ({
+            hits,
+            scrollId,
+            total,
+        }));
+    }
+    /**
+     * Replace the specifications of a collection
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    async updateSpecifications(request) {
+        const { index, collection } = request.getIndexAndCollection();
+        const specifications = request.getBody();
+        const { isValid, errors } = await global.kuzzle.validation.validateFormat(index, collection, specifications, true);
+        if (!isValid) {
+            throw kerror.get("validation", "assert", "invalid_specifications", errors.join("\n\t- "));
+        }
+        await global.kuzzle.internalIndex.createOrReplace("validations", `${index}#${collection}`, {
+            collection,
+            index,
+            validation: specifications,
+        });
+        await global.kuzzle.internalIndex.refreshCollection("validations");
+        await global.kuzzle.validation.curateSpecification();
+        return specifications;
+    }
+    /**
+     * Add a specification collections
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    async deleteSpecifications(request) {
+        const { index, collection } = request.getIndexAndCollection();
+        const specificationsId = `${index}#${collection}`;
+        try {
+            await global.kuzzle.internalIndex.delete("validations", specificationsId);
+        }
+        catch (error) {
+            if (error.status === 404) {
+                return {
+                    acknowledged: true,
+                };
+            }
+            throw error;
+        }
+        await global.kuzzle.internalIndex.refreshCollection("validations");
+        await global.kuzzle.validation.curateSpecification();
+        return {
+            acknowledged: true,
+        };
+    }
+    /**
+     * Validate a specification
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    validateSpecifications(request) {
+        const { index, collection } = request.getIndexAndCollection(), specifications = request.getBody();
+        return global.kuzzle.validation
+            .validateFormat(index, collection, specifications, true)
+            .then(({ isValid, errors }) => {
+            if (!isValid) {
+                return {
+                    description: "Some errors with provided specifications.",
+                    details: errors,
+                    valid: false,
+                };
+            }
+            return {
+                valid: true,
+            };
+        });
+    }
+    /**
+     * Reset a collection by removing all documents while keeping the existing mapping
+     *
+     * @param {KuzzleRequest} request
+     * @returns {Promise.<Object>}
+     */
+    async truncate(request) {
+        const { index, collection } = request.getIndexAndCollection();
+        await this.ask("core:storage:public:collection:truncate", index, collection);
+        return {
+            acknowledged: true,
+        };
+    }
+    /**
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    async list(request) {
+        const index = request.getIndex();
+        const from = request.getInteger("from", 0);
+        const size = request.getInteger("size", 0);
+        const type = request.getString("type", "all");
+        if (!["all", "stored", "realtime"].includes(type)) {
+            throw kerror.get("api", "assert", "invalid_argument", '"all", "stored", "realtime"');
+        }
+        if (request.input.args.type) {
+            request.addDeprecation("2.10.2", 'The "type" argument and this route returning a list of realtime collections have both been deprecated since Kuzzle version 2.10.1. This feature might be removed in a future major version. To get a list of realtime collections, use this API action instead: "realtime:list".');
+        }
+        let collections = [];
+        if (type === "realtime" || type === "all") {
+            const list = await this.ask("core:realtime:collections:get", index);
+            collections = list.map((name) => ({ name, type: "realtime" }));
+        }
+        if (type !== "realtime") {
+            const publicCollections = await this.ask("core:storage:public:collection:list", index);
+            collections = collections.concat(publicCollections.map((name) => ({ name, type: "stored" })));
+        }
+        collections.sort((a, b) => {
+            if (a.name === b.name) {
+                return 0;
+            }
+            return a.name < b.name ? -1 : 1;
+        });
+        return this._paginateCollections(from, size, { collections, type });
+    }
+    /**
+     * @param {Request} request
+     * @returns {Promise.<boolean>}
+     */
+    exists(request) {
+        const { index, collection } = request.getIndexAndCollection();
+        return this.ask("core:storage:public:collection:exist", index, collection);
+    }
+    /**
+     * Creates a new collection with the specifed mappings and settings.
+     * Only update the mappings and settings if the collection exists.
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    async create(request) {
+        const body = request.getBody({});
+        const { index, collection } = request.getIndexAndCollection();
+        let config = {};
+        // @deprecated sending directly the mappings is deprecated since 2.1.0
+        if (body.properties || body.dynamic || body._meta) {
+            config.mappings = body;
+            request.addDeprecation("2.1.0", 'Using "properties", "dynamic" or "_meta" fields in the body has been deprecated since Kuzzle version 2.1.0. This feature might be removed in a future major version. Use "settings" and "mappings" fields instead');
+        }
+        else {
+            config = body;
+        }
+        await this.ask("core:storage:public:collection:create", index, collection, config);
+        return { acknowledged: true };
+    }
+    /**
+     * Updates a collection mappings and settings.
+     *
+     * @param {Request} request
+     * @returns {Promise.<Object>}
+     */
+    async update(request) {
+        const config = request.getBody({}), { index, collection } = request.getIndexAndCollection();
+        await this.ask("core:storage:public:collection:update", index, collection, config);
+        return null;
+    }
+    /**
+     * Refresh a collection
+     *
+     * @param {Request} request
+     * @returns {Promise.<null>}
+     */
+    async refresh(request) {
+        const { index, collection } = request.getIndexAndCollection();
+        await this.ask("core:storage:public:collection:refresh", index, collection);
+        return null;
+    }
+    /**
+     * Deletes a collection
+     *
+     * @param {String} index
+     * @param {String} collection
+     *
+     * @returns {Promise.<null>}
+     */
+    async delete(request) {
+        const { index, collection } = request.getIndexAndCollection();
+        await this.ask("core:storage:public:collection:delete", index, collection);
+        return null;
+    }
+    /**
+     * Uses from and size to paginate response results
+     * If type is "all", stored collections are prioritary
+     *
+     * @param {Number} from
+     * @param {Number} size
+     * @param {Object} response
+     * @returns {Object} { collections, from, size }
+     */
+    _paginateCollections(from, size, response) {
+        if (from || size) {
+            if (from) {
+                response.from = Number.parseInt(from);
+            }
+            else {
+                response.from = 0;
+            }
+            if (size) {
+                response.size = Number.parseInt(size);
+                response.collections = response.collections.slice(response.from, response.from + response.size);
+            }
+            else {
+                response.collections = response.collections.slice(response.from);
+            }
+        }
+        return response;
+    }
+    /**
+     * Return only the mapping properties we want to output in our API
+     * @param  {Object} mapping - raw ES mapping
+     * @returns {Object}
+     */
+    _filterMappingResponse(mapping) {
+        return {
+            _meta: mapping._meta,
+            dynamic: mapping.dynamic,
+            properties: mapping.properties,
+        };
+    }
+}
+module.exports = CollectionController;
+//# sourceMappingURL=collectionController.js.map