kuzzle 2.56.0 → 2.57.0-beta.2

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,9 +19,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const { NativeController } = require("./baseController");
-class ClusterController extends NativeController {
+const baseController_1 = require("./baseController");
+class ClusterController extends baseController_1.NativeController {
     constructor() {
         super(["status"]);
     }

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

@@ -1,90 +1,120 @@
-export = CollectionController;
+import type { JSONObject } from "../../types/JSONObject";
+import type { KuzzleRequest } from "../request";
+import { NativeController } from "./baseController";
 /**
  * @class CollectionController
  */
 declare class CollectionController extends NativeController {
+    private readonly defaultScrollTTL;
     constructor();
-    defaultScrollTTL: string;
     /**
      * Updates the mapping of the collection
      *
      * @param {Request} request
      * @returns {Promise.<Object>}
      */
-    updateMapping(request: Request): Promise<any>;
+    updateMapping(request: KuzzleRequest): Promise<{
+        _meta: any;
+        dynamic: any;
+        properties: any;
+    }>;
     /**
      * Get the collection mapping
      *
      * @param {Request} request
      * @returns {Promise.<Object>}
      */
-    getMapping(request: Request): Promise<any>;
+    getMapping(request: KuzzleRequest): Promise<{
+        _meta: any;
+        dynamic: any;
+        properties: any;
+    }>;
     /**
      * Get the collection settings
      *
      * @param {Request} request
      * @returns {Promise.<Object>}
      */
-    getSettings(request: Request): Promise<any>;
+    getSettings(request: KuzzleRequest): Promise<any>;
     /**
      * Get the collection validation specifications
      *
      * @param {Request} request
      * @returns {Promise.<Object>}
      */
-    getSpecifications(request: Request): Promise<any>;
+    getSpecifications(request: KuzzleRequest): Promise<any>;
     /**
      * Search for collection validation specifications
      *
      * @param {Request} request
      * @returns {Promise.<Object>}
      */
-    searchSpecifications(request: Request): Promise<any>;
+    searchSpecifications(request: KuzzleRequest): Promise<{
+        hits: any;
+        scrollId: any;
+        total: any;
+    }>;
     /**
      * Scroll over a paginated search results
      *
      * @param {Request} request
      * @returns {Promise.<object>}
      */
-    scrollSpecifications(request: Request): Promise<object>;
+    scrollSpecifications(request: KuzzleRequest): Promise<{
+        hits: any;
+        scrollId: any;
+        total: any;
+    }>;
     /**
      * Replace the specifications of a collection
      *
      * @param {Request} request
      * @returns {Promise.<Object>}
      */
-    updateSpecifications(request: Request): Promise<any>;
+    updateSpecifications(request: KuzzleRequest): Promise<JSONObject>;
     /**
      * Add a specification collections
      *
      * @param {Request} request
      * @returns {Promise.<Object>}
      */
-    deleteSpecifications(request: Request): Promise<any>;
+    deleteSpecifications(request: KuzzleRequest): Promise<{
+        acknowledged: boolean;
+    }>;
     /**
      * Validate a specification
      *
      * @param {Request} request
      * @returns {Promise.<Object>}
      */
-    validateSpecifications(request: Request): Promise<any>;
+    validateSpecifications(request: KuzzleRequest): Promise<{
+        description: string;
+        details: string[] | undefined;
+        valid: boolean;
+    } | {
+        valid: boolean;
+        description?: undefined;
+        details?: undefined;
+    }>;
     /**
      * Reset a collection by removing all documents while keeping the existing mapping
      *
      * @param {KuzzleRequest} request
      * @returns {Promise.<Object>}
      */
-    truncate(request: KuzzleRequest): Promise<any>;
+    truncate(request: KuzzleRequest): Promise<{
+        acknowledged: boolean;
+    }>;
     /**
      * @param {Request} request
      * @returns {Promise.<Object>}
      */
-    list(request: Request): Promise<any>;
+    list(request: KuzzleRequest): Promise<JSONObject>;
     /**
      * @param {Request} request
      * @returns {Promise.<boolean>}
      */
-    exists(request: Request): Promise<boolean>;
+    exists(request: KuzzleRequest): Promise<any>;
     /**
      * Creates a new collection with the specifed mappings and settings.
      * Only update the mappings and settings if the collection exists.
@@ -92,21 +122,23 @@ declare class CollectionController extends NativeController {
      * @param {Request} request
      * @returns {Promise.<Object>}
      */
-    create(request: Request): Promise<any>;
+    create(request: KuzzleRequest): Promise<{
+        acknowledged: boolean;
+    }>;
     /**
      * Updates a collection mappings and settings.
      *
      * @param {Request} request
      * @returns {Promise.<Object>}
      */
-    update(request: Request): Promise<any>;
+    update(request: KuzzleRequest): Promise<null>;
     /**
      * Refresh a collection
      *
      * @param {Request} request
      * @returns {Promise.<null>}
      */
-    refresh(request: Request): Promise<null>;
+    refresh(request: KuzzleRequest): Promise<null>;
     /**
      * Deletes a collection
      *
@@ -115,7 +147,7 @@ declare class CollectionController extends NativeController {
      *
      * @returns {Promise.<null>}
      */
-    delete(request: any): Promise<null>;
+    delete(request: KuzzleRequest): Promise<null>;
     /**
      * Uses from and size to paginate response results
      * If type is "all", stored collections are prioritary
@@ -125,12 +157,16 @@ declare class CollectionController extends NativeController {
      * @param {Object} response
      * @returns {Object} { collections, from, size }
      */
-    _paginateCollections(from: number, size: number, response: any): any;
+    _paginateCollections(from: number, size: number, response: JSONObject): JSONObject;
     /**
      * Return only the mapping properties we want to output in our API
      * @param  {Object} mapping - raw ES mapping
      * @returns {Object}
      */
-    _filterMappingResponse(mapping: any): any;
+    _filterMappingResponse(mapping: JSONObject): {
+        _meta: any;
+        dynamic: any;
+        properties: any;
+    };
 }
-import { NativeController } from "./baseController";
+export = CollectionController;

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,14 +19,37 @@
  * 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");
+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;
+};
+const kerror = __importStar(require("../../kerror"));
+const errors_1 = require("../../kerror/errors");
+const safeObject_1 = require("../../util/safeObject");
+const baseController_1 = require("./baseController");
 /**
  * @class CollectionController
  */
-class CollectionController extends NativeController {
+class CollectionController extends baseController_1.NativeController {
     constructor() {
         super([
             "create",
@@ -108,7 +132,7 @@ class CollectionController extends NativeController {
      */
     async searchSpecifications(request) {
         const { from, size, scrollTTL, searchBody } = request.getSearchParams();
-        if (!isPlainObject(searchBody)) {
+        if (!(0, safeObject_1.isPlainObject)(searchBody)) {
             throw kerror.get("api", "assert", "invalid_type", "body.query", "object");
         }
         this.assertNotExceedMaxFetch(size - from);
@@ -142,7 +166,9 @@ class CollectionController extends NativeController {
         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- "));
+            throw kerror.get("validation", "assert", "invalid_specifications", 
+            // `validateFormat` answers errors only when it answers invalid.
+            (errors ?? []).join("\n\t- "));
         }
         await global.kuzzle.internalIndex.createOrReplace("validations", `${index}#${collection}`, {
             collection,
@@ -166,7 +192,7 @@ class CollectionController extends NativeController {
             await global.kuzzle.internalIndex.delete("validations", specificationsId);
         }
         catch (error) {
-            if (error.status === 404) {
+            if (error instanceof errors_1.KuzzleError && error.status === 404) {
                 return {
                     acknowledged: true,
                 };
@@ -321,16 +347,19 @@ class CollectionController extends NativeController {
      * @param {Object} response
      * @returns {Object} { collections, from, size }
      */
-    _paginateCollections(from, size, response) {
+    _paginateCollections(
+    // Both come from `request.getInteger`, so the `Number.parseInt` this
+    // used to run over them re-parsed a number.
+    from, size, response) {
         if (from || size) {
             if (from) {
-                response.from = Number.parseInt(from);
+                response.from = from;
             }
             else {
                 response.from = 0;
             }
             if (size) {
-                response.size = Number.parseInt(size);
+                response.size = size;
                 response.collections = response.collections.slice(response.from, response.from + response.size);
             }
             else {

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

@@ -1,4 +1,4 @@
-import { KuzzleRequest } from "../request";
+import type { KuzzleRequest } from "../request";
 import { NativeController } from "./baseController";
 /**
  * @class DebugController

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

@@ -1,53 +1,109 @@
-export = DocumentController;
+import * as actionEnum from "../../core/realtime/actionEnum";
+import type { KuzzleRequest } from "../request";
+import { NativeController } from "./baseController";
+/** One of `actionEnum`'s values — what a document notification reports. */
+type NotifyAction = (typeof actionEnum)[keyof typeof actionEnum];
+/** The two single-document writes `_writeDocument` serves. */
+type WriteMethod = "replace" | "createOrReplace";
+/** The two multi-document reads `_mFetch` serves. */
+type FetchMethod = "mGet" | "mExists";
+/** The five multi-document writes `_mChanges` serves. */
+type ChangeMethod = "mCreate" | "mCreateOrReplace" | "mUpdate" | "mUpsert" | "mReplace";
 /**
  * @class DocumentController
  */
 declare class DocumentController extends NativeController {
+    constructor();
     /**
      * @returns {Record<string, unknown>}
      */
-    static get actions(): Record<string, unknown>;
-    constructor();
+    static get actions(): {
+        count: string;
+        create: string;
+        createOrReplace: string;
+        delete: string;
+        deleteByQuery: string;
+        deleteFields: string;
+        exists: string;
+        export: string;
+        get: string;
+        mCreate: string;
+        mCreateOrReplace: string;
+        mDelete: string;
+        mExists: string;
+        mGet: string;
+        mReplace: string;
+        mUpdate: string;
+        mUpsert: string;
+        replace: string;
+        scroll: string;
+        search: string;
+        update: string;
+        updateByQuery: string;
+        upsert: string;
+        validate: string;
+    };
     /**
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    search(request: Request): Promise<any>;
+    search(request: KuzzleRequest): Promise<{
+        aggregations: any;
+        hits: any;
+        remaining: any;
+        scrollId: any;
+        suggest: any;
+        total: any;
+    }>;
     /**
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    scroll(request: Request): Promise<any>;
+    scroll(request: KuzzleRequest): Promise<{
+        hits: any;
+        remaining: any;
+        scrollId: any;
+        total: any;
+    }>;
     /**
      * @param {Request} request
      * @returns {Promise<Boolean>}
      */
-    exists(request: Request): Promise<boolean>;
+    exists(request: KuzzleRequest): Promise<any>;
     /**
      * @param {Request} request
      */
-    mExists(request: Request): Promise<{
+    mExists(request: KuzzleRequest): Promise<{
         errors: any;
         successes: any;
     }>;
-    export(request: any): Promise<import("../../..").HttpStream>;
+    export(request: KuzzleRequest): Promise<import("../../..").HttpStream>;
     /**
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    get(request: Request): Promise<any>;
+    get(request: KuzzleRequest): Promise<{
+        _id: any;
+        _source: any;
+        _version: any;
+    }>;
     /**
      * Get specific documents according to given ids
      *
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    mGet(request: Request): Promise<any>;
+    mGet(request: KuzzleRequest): Promise<{
+        errors: any;
+        successes: any;
+    }>;
     /**
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    count(request: Request): Promise<any>;
+    count(request: KuzzleRequest): Promise<{
+        count: any;
+    }>;
     /**
      * Create a new document
      *
@@ -62,14 +118,17 @@ declare class DocumentController extends NativeController {
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    mCreate(request: Request): Promise<any>;
+    mCreate(request: KuzzleRequest): Promise<{
+        errors: any;
+        successes: any;
+    }>;
     /**
      * Create a new document through the persistent layer. If it already exists, update it instead.
      *
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    createOrReplace(request: Request): Promise<any>;
+    createOrReplace(request: KuzzleRequest): Promise<any>;
     /**
      * Create or replace the documents provided in the body
      * Delegates the notification to createOrReplace action
@@ -77,14 +136,17 @@ declare class DocumentController extends NativeController {
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    mCreateOrReplace(request: Request): Promise<any>;
+    mCreateOrReplace(request: KuzzleRequest): Promise<{
+        errors: any;
+        successes: any;
+    }>;
     /**
      * Update a document through the persistent layer
      *
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    update(request: Request): Promise<any>;
+    update(request: KuzzleRequest): Promise<any>;
     /**
      * Applies a partial update to an existing document.
      * If the document doesn't already exist, a new document is created.
@@ -92,7 +154,7 @@ declare class DocumentController extends NativeController {
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    upsert(request: Request): Promise<any>;
+    upsert(request: KuzzleRequest): Promise<any>;
     /**
      * Update the documents provided in the body
      * Delegates the notification to update action
@@ -100,7 +162,10 @@ declare class DocumentController extends NativeController {
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    mUpdate(request: Request): Promise<any>;
+    mUpdate(request: KuzzleRequest): Promise<{
+        errors: any;
+        successes: any;
+    }>;
     /**
      * Applies a partial update to documents provided in the body.
      * If some of the documents don't already exist, they will be created.
@@ -108,14 +173,17 @@ declare class DocumentController extends NativeController {
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    mUpsert(request: Request): Promise<any>;
+    mUpsert(request: KuzzleRequest): Promise<{
+        errors: any;
+        successes: any;
+    }>;
     /**
      * Replace a document through the persistent layer. Throws an error if the document doesn't exist
      *
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    replace(request: Request): Promise<any>;
+    replace(request: KuzzleRequest): Promise<any>;
     /**
      * Replace the documents provided in the body
      * Delegates the notification to update action
@@ -123,14 +191,17 @@ declare class DocumentController extends NativeController {
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    mReplace(request: Request): Promise<any>;
+    mReplace(request: KuzzleRequest): Promise<{
+        errors: any;
+        successes: any;
+    }>;
     /**
      * Delete a document through the persistent layer
      *
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    delete(request: Request): Promise<any>;
+    delete(request: KuzzleRequest): Promise<any>;
     /**
      * Delete specific documents according to given ids
      * Delegates the notification to delete action
@@ -138,35 +209,70 @@ declare class DocumentController extends NativeController {
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    mDelete(request: Request): Promise<any>;
+    mDelete(request: KuzzleRequest): Promise<{
+        errors: any;
+        successes: any;
+    }>;
     /**
      * Delete several documents matching a query through the persistent layer
      *
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    deleteByQuery(request: Request): Promise<any>;
+    deleteByQuery(request: KuzzleRequest): Promise<{
+        documents: any;
+        ids: any;
+    }>;
     /**
      * Delete fields of a document. Throws an error if the document doesn't exist
      *
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    deleteFields(request: Request): Promise<any>;
+    deleteFields(request: KuzzleRequest): Promise<any>;
     /**
      * Update several documents matching a query through the persistent layer
      *
      * @param {Request} request
      * @returns {Promise<Object}
      */
-    updateByQuery(request: Request): Promise<any>;
+    updateByQuery(request: KuzzleRequest): Promise<any>;
     /**
      * Validate a document against collection validation specifications.
      *
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    validate(request: Request): Promise<any>;
+    validate(request: KuzzleRequest): Promise<{
+        errorMessages: import("../../core/validation/specification").VerboseErrorMessages;
+        valid: boolean;
+    }>;
+    /**
+     * 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 }
+     */
+    _mFetch(request: KuzzleRequest, methodName: FetchMethod): Promise<{
+        errors: any;
+        successes: any;
+    }>;
+    /**
+     * 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
+     */
+    _writeDocument(request: KuzzleRequest, methodName: WriteMethod): Promise<any>;
     /**
      * Applies a multi-document change request (create, update,
      * replace, createOrReplace, upsert)
@@ -176,6 +282,9 @@ declare class DocumentController extends NativeController {
      * @param  {notifyActionEnum} action performed on the documents
      * @returns {Promise.<Object>} { successes, errors }
      */
-    _mChanges(request: Request, methodName: string, action: notifyActionEnum): Promise<any>;
+    _mChanges(request: KuzzleRequest, methodName: ChangeMethod, action: NotifyAction): Promise<{
+        errors: any;
+        successes: any;
+    }>;
 }
-import { NativeController } from "./baseController";
+export = DocumentController;