kuzzle 2.56.0 → 2.57.0-beta.2

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,18 +19,40 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/* eslint sort-keys: 0 */
-"use strict";
-const kerror = require("../../kerror").wrap("api", "assert");
-const { Request } = require("../request");
-const { NativeController } = require("./baseController");
-const kassert = require("../../util/requestAssertions");
-const { isPlainObject, has } = require("../../util/safeObject");
+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_1 = require("../../kerror");
+const request_1 = require("../request");
+const baseController_1 = require("./baseController");
+const kassert = __importStar(require("../../util/requestAssertions"));
+const safeObject_1 = require("../../util/safeObject");
+const kerror = (0, kerror_1.wrap)("api", "assert");
+// Stays a mutable top-level binding: the Mocha spec rewires it through
+// `__get__("mapping")` / `__set__({ mapping })` on the compiled CJS, which a
+// `const` would make impossible (assignment to a constant).
 let mapping;
-/**
- * @class MemoryStorageController
- */
-class MemoryStorageController extends NativeController {
+class MemoryStorageController extends baseController_1.NativeController {
     constructor() {
         super();
         initMapping();
@@ -43,13 +66,18 @@ class MemoryStorageController extends NativeController {
             }
             return async (request) => global.kuzzle.ask("core:cache:public:execute", command, ...extractArgumentsFromRequest(command, request));
         };
+        // Every Redis command in the table becomes an action method on the
+        // instance, installed here and looked up by name by the funnel. `command`
+        // is a runtime-built key, so a plain `this[command] = …` cannot be typed
+        // without opening the whole class to an index signature (TD-28, #2704);
+        // `Reflect.set` is the property-write counterpart already used for the
+        // same reason in `core/shared/sdk/impersonatedSdk`.
         for (const command of Object.keys(mapping)) {
             this._actions.add(command);
-            this[command] = buildCommandFn(command);
+            Reflect.set(this, command, buildCommandFn(command));
         }
     }
 }
-module.exports = MemoryStorageController;
 const scanMatchProperty = {
     skip: true,
     merge: true,
@@ -70,6 +98,15 @@ const scanCountProperty = {
         return ["COUNT", val];
     },
 };
+/**
+ * The table entry for a command this module handles itself: one that takes no
+ * argument at all, or one an `extractArgumentsFromRequestFor*` function reads.
+ *
+ * Named rather than a bare `null` in the literal: with the table inferred
+ * through `satisfies`, `noImplicitAny` reads a lone `null` property as `any`
+ * — ten of them, which is what the implicit-any ratchet counts.
+ */
+const NO_MAPPING = null;
 const zrangebyscoreOptionsProperty = {
     skip: true,
     merge: true,
@@ -83,7 +120,13 @@ const zrangebyscoreLimitProperty = {
     path: ["args", "limit"],
 };
 function initMapping() {
-    mapping = {
+    // `satisfies`, not an annotation: the table is checked against
+    // `RedisCommandMapping` — which is what contextually types the `map`
+    // closures below — while keeping its literal type, so the aliases at the
+    // bottom read entries the compiler knows are there. Annotated, every
+    // `mapping.mget` was `CommandArguments | undefined` and sixteen aliases
+    // could not be assigned from one.
+    const table = {
         append: {
             key: ["resource", "_id"],
             value: ["body", "value"],
@@ -104,7 +147,7 @@ function initMapping() {
             start: { skip: true, path: ["args", "start"] },
             end: { skip: true, path: ["args", "end"] },
         },
-        dbsize: null,
+        dbsize: NO_MAPPING,
         decrby: {
             key: ["resource", "_id"],
             value: ["body", "value"],
@@ -120,7 +163,7 @@ function initMapping() {
             key: ["resource", "_id"],
             timestamp: ["body", "timestamp"],
         },
-        flushdb: null,
+        flushdb: NO_MAPPING,
         geoadd: {
             key: { path: ["resource", "_id"] },
             points: {
@@ -128,10 +171,12 @@ function initMapping() {
                     const result = [];
                     kassert.assertBodyHasAttribute(request, "points");
                     kassert.assertBodyAttributeType(request, "points", "array");
-                    if (val.length === 0) {
+                    // The assert above is what makes the array shape safe to assume.
+                    const points = val;
+                    if (points.length === 0) {
                         throw kerror.get("empty_argument", "points");
                     }
-                    val.forEach((v) => {
+                    points.forEach((v) => {
                         if (typeof v !== "object" || !v.lon || !v.lat || !v.name) {
                             throw kerror.get("invalid_argument", "points", "<array of geopoints>");
                         }
@@ -331,13 +376,13 @@ function initMapping() {
             key: ["resource", "_id"],
             sources: { skip: true, merge: true, path: ["body", "sources"] },
         },
-        ping: null,
+        ping: NO_MAPPING,
         psetex: {
             key: ["resource", "_id"],
             milliseconds: ["body", "milliseconds"],
             value: ["body", "value"],
         },
-        randomkey: null,
+        randomkey: NO_MAPPING,
         rename: {
             key: ["resource", "_id"],
             newkey: ["body", "newkey"],
@@ -372,7 +417,7 @@ function initMapping() {
             key: ["resource", "_id"],
             keys: { merge: true, path: ["body", "keys"] },
         },
-        set: null, // handled by extractArgumentsFromRequestForSet
+        set: NO_MAPPING, // handled by extractArgumentsFromRequestForSet
         setex: {
             key: ["resource", "_id"],
             seconds: ["body", "seconds"],
@@ -395,7 +440,7 @@ function initMapping() {
             destination: ["body", "destination"],
             member: ["body", "member"],
         },
-        sort: null, // handled by extractArgumentsFromRequestForSort
+        sort: NO_MAPPING, // handled by extractArgumentsFromRequestForSort
         spop: {
             key: ["resource", "_id"],
             count: { skip: true, path: ["body", "count"] },
@@ -425,11 +470,11 @@ function initMapping() {
             destination: ["body", "destination"],
             keys: { merge: true, path: ["body", "keys"] },
         },
-        time: null,
+        time: NO_MAPPING,
         touch: {
             keys: { merge: true, path: ["body", "keys"] },
         },
-        zadd: null, // handled by extractArgumentsFromRequestForZAdd
+        zadd: NO_MAPPING, // handled by extractArgumentsFromRequestForZAdd
         zcount: {
             key: ["resource", "_id"],
             min: ["args", "min"],
@@ -440,7 +485,7 @@ function initMapping() {
             value: ["body", "value"],
             member: ["body", "member"],
         },
-        zinterstore: null, // handled by extractArgumentsFromRequestForZInterstore
+        zinterstore: NO_MAPPING, // handled by extractArgumentsFromRequestForZInterstore
         zlexcount: {
             key: ["resource", "_id"],
             min: ["args", "min"],
@@ -516,8 +561,9 @@ function initMapping() {
             key: ["resource", "_id"],
             member: ["args", "member"],
         },
-        zunionstore: null, // handled by extractArgumentsFromRequestForZInterstore
+        zunionstore: NO_MAPPING, // handled by extractArgumentsFromRequestForZInterstore
     };
+    mapping = table;
     // unique argument key
     mapping.decr =
         mapping.get =
@@ -546,82 +592,92 @@ function initMapping() {
                     key: ["resource", "_id"],
                     value: ["body", "value"],
                 };
-    mapping.pfcount = mapping.sinter = mapping.mget;
-    mapping.incrby = mapping.incrbyfloat = mapping.decrby;
-    mapping.geopos = mapping.geohash;
-    mapping.hget = mapping.hexists;
-    mapping.hsetnx = mapping.hset;
-    mapping.msetnx = mapping.mset;
-    mapping.rpush = mapping.lpush;
-    mapping.hincrbyfloat = mapping.hincrby;
-    mapping.zrevrange = mapping.zrange;
-    mapping.zscore = mapping.zrank = mapping.zrevrank;
-    mapping.hscan = mapping.zscan = mapping.sscan;
-    mapping.exists = mapping.mget;
+    mapping.pfcount = mapping.sinter = table.mget;
+    mapping.incrby = mapping.incrbyfloat = table.decrby;
+    mapping.geopos = table.geohash;
+    mapping.hget = table.hexists;
+    mapping.hsetnx = table.hset;
+    mapping.msetnx = table.mset;
+    mapping.rpush = table.lpush;
+    mapping.hincrbyfloat = table.hincrby;
+    mapping.zrevrange = table.zrange;
+    mapping.zscore = mapping.zrank = table.zrevrank;
+    mapping.hscan = mapping.zscan = table.sscan;
+    mapping.exists = table.mget;
 }
 /**
  * @param {string} command
  * @param {Request} request
  * @returns {*}
  */
-function extractArgumentsFromRequest(command, request) {
-    let args = [];
-    // Dealing with exceptions
-    if (command === "set") {
-        return extractArgumentsFromRequestForSet(request);
+/**
+ * Commands whose arguments a dedicated function reads, because the table
+ * cannot describe them. The six `if`s this replaces were the bulk of
+ * `extractArgumentsFromRequest`'s cognitive complexity.
+ */
+const SPECIAL_EXTRACTORS = {
+    mexecute: (request) => extractArgumentsFromRequestForMExecute(request),
+    set: (request) => extractArgumentsFromRequestForSet(request),
+    sort: (request) => extractArgumentsFromRequestForSort(request),
+    zadd: (request) => extractArgumentsFromRequestForZAdd(request),
+    zinterstore: (request) => extractArgumentsFromRequestForZInterstore(request),
+    zunionstore: (request) => extractArgumentsFromRequestForZInterstore(request),
+};
+/**
+ * Reads one of a command's arguments out of the request and appends it to the
+ * argument list.
+ */
+function appendArgument(args, key, data, request) {
+    const path = Array.isArray(data) ? data : data.path;
+    const toMerge = !Array.isArray(data) && data.merge === true;
+    const map = !Array.isArray(data) && data.map;
+    const skip = !Array.isArray(data) && data.skip === true;
+    let value = path.reduce((previousValue, currentValue) => {
+        // Indexing `undefined` throws, as it did before: no path in the table
+        // is deeper than the two levels the request always has.
+        const next = previousValue[currentValue];
+        return next ?? undefined;
+    }, request.input);
+    if (value === undefined) {
+        if (skip) {
+            return;
+        }
+        throw kerror.get("missing_argument", key);
     }
-    if (command === "sort") {
-        return extractArgumentsFromRequestForSort(request);
+    if (map) {
+        value = map(value, request);
     }
-    if (command === "zadd") {
-        return extractArgumentsFromRequestForZAdd(request);
+    if (value === undefined) {
+        return;
     }
-    if (command === "zinterstore") {
-        return extractArgumentsFromRequestForZInterstore(request);
+    if (toMerge && Array.isArray(value)) {
+        for (const item of value) {
+            args.push(item);
+        }
     }
-    if (command === "zunionstore") {
-        return extractArgumentsFromRequestForZInterstore(request);
+    else {
+        args.push(value);
     }
-    if (command === "mexecute") {
-        return extractArgumentsFromRequestForMExecute(request);
+}
+function extractArgumentsFromRequest(command, request) {
+    const special = SPECIAL_EXTRACTORS[command];
+    if (special) {
+        return special(request);
     }
-    if (!mapping[command]) {
+    const commandArguments = mapping[command];
+    // One lookup, and the `null` entries — the commands that take no argument —
+    // are the same answer as an unknown command. The table was read twice, the
+    // second time without the guard the first had just applied.
+    if (!commandArguments) {
         return [];
     }
     if (!request.input.body) {
         request.input.body = {};
     }
-    Object.keys(mapping[command]).forEach((key) => {
-        const data = mapping[command][key];
-        const path = Array.isArray(data) ? data : data.path;
-        const toMerge = !Array.isArray(data) && data.merge === true;
-        const map = !Array.isArray(data) && data.map;
-        const skip = !Array.isArray(data) && data.skip === true;
-        let value = path.reduce((previousValue, currentValue, currentIndex, array) => {
-            if (previousValue[array[currentIndex]] !== undefined &&
-                previousValue[array[currentIndex]] !== null) {
-                return previousValue[array[currentIndex]];
-            }
-            return undefined;
-        }, request.input);
-        if (value === undefined) {
-            if (skip) {
-                return;
-            }
-            throw kerror.get("missing_argument", key);
-        }
-        if (map) {
-            value = data.map(value, request);
-        }
-        if (value !== undefined) {
-            if (toMerge && Array.isArray(value)) {
-                args = args.concat(value);
-            }
-            else {
-                args.push(value);
-            }
-        }
-    });
+    const args = [];
+    for (const [key, data] of Object.entries(commandArguments)) {
+        appendArgument(args, key, data, request);
+    }
     return args;
 }
 /**
@@ -632,7 +688,7 @@ function extractArgumentsFromRequestForSet(request) {
     const args = [request.input.args._id];
     kassert.assertHasId(request);
     kassert.assertHasBody(request);
-    if (["undefined", "boolean", "object"].indexOf(typeof request.input.body.value) !== -1) {
+    if (["undefined", "boolean", "object"].includes(typeof request.input.body.value)) {
         throw kerror.get("invalid_type", "value", "string, number");
     }
     if (request.input.body.nx && request.input.body.xx) {
@@ -663,36 +719,36 @@ function extractArgumentsFromRequestForSet(request) {
 function extractArgumentsFromRequestForSort(request) {
     const args = [request.input.args._id];
     kassert.assertHasId(request);
-    if (request.input.body) {
-        if (request.input.body.alpha) {
-            args.push("ALPHA");
-        }
-        if (request.input.body.direction !== undefined) {
-            const direction = request.input.body.direction.toUpperCase();
-            if (["ASC", "DESC"].indexOf(direction) === -1) {
-                throw kerror.get("invalid_argument", "direction", '"ASC", "DESC"');
-            }
-            args.push(direction);
-        }
-        if (request.input.body.by !== undefined) {
-            args.push("BY", request.input.body.by);
-        }
-        if (request.input.body.limit !== undefined) {
-            kassert.assertBodyAttributeType(request, "limit", "array");
-            assertInt(request, "limit.offset", request.input.body.limit[0]);
-            assertInt(request, "limit.count", request.input.body.limit[1]);
-            args.push("LIMIT", request.input.body.limit[0], request.input.body.limit[1]);
-        }
-        if (request.input.body.get !== undefined) {
-            kassert.assertBodyAttributeType(request, "get", "array");
-            request.input.body.get.forEach((pattern) => {
-                args.push("GET");
-                args.push(pattern);
-            });
-        }
-        if (request.input.body.store !== undefined) {
-            args.push("STORE", request.input.body.store);
+    if (!request.input.body) {
+        return args;
+    }
+    if (request.input.body.alpha) {
+        args.push("ALPHA");
+    }
+    if (request.input.body.direction !== undefined) {
+        const direction = request.input.body.direction.toUpperCase();
+        if (!["ASC", "DESC"].includes(direction)) {
+            throw kerror.get("invalid_argument", "direction", '"ASC", "DESC"');
         }
+        args.push(direction);
+    }
+    if (request.input.body.by !== undefined) {
+        args.push("BY", request.input.body.by);
+    }
+    if (request.input.body.limit !== undefined) {
+        kassert.assertBodyAttributeType(request, "limit", "array");
+        assertInt(request, "limit.offset", request.input.body.limit[0]);
+        assertInt(request, "limit.count", request.input.body.limit[1]);
+        args.push("LIMIT", request.input.body.limit[0], request.input.body.limit[1]);
+    }
+    if (request.input.body.get !== undefined) {
+        kassert.assertBodyAttributeType(request, "get", "array");
+        request.input.body.get.forEach((pattern) => {
+            args.push("GET", pattern);
+        });
+    }
+    if (request.input.body.store !== undefined) {
+        args.push("STORE", request.input.body.store);
     }
     return args;
 }
@@ -706,22 +762,22 @@ function extractArgumentsFromRequestForMExecute(request) {
     kassert.assertBodyAttributeType(request, "actions", "array");
     const actions = request.input.body.actions;
     return actions.map((command) => {
-        if (!has(command, "action")) {
+        if (!(0, safeObject_1.has)(command, "action")) {
             throw kerror.get("missing_argument", "action");
         }
-        if (!has(command, "args")) {
+        if (!(0, safeObject_1.has)(command, "args")) {
             throw kerror.get("missing_argument", "args");
         }
-        if (!isPlainObject(command.args)) {
+        if (!(0, safeObject_1.isPlainObject)(command.args)) {
             throw kerror.get("invalid_type", "args", "object");
         }
         if (command.action === "mexecute") {
             throw kerror.get("forbidden_argument", "mexecute");
         }
-        if (!has(mapping, command.action)) {
+        if (!(0, safeObject_1.has)(mapping, command.action)) {
             throw kerror.get("forbidden_argument", command.action);
         }
-        const subRequest = new Request(command.args);
+        const subRequest = new request_1.Request(command.args);
         const extractedArguments = extractArgumentsFromRequest(command.action, subRequest);
         return [command.action, ...extractedArguments];
     });
@@ -758,15 +814,14 @@ function extractArgumentsFromRequestForZAdd(request) {
         throw kerror.get("too_many_arguments", "elements");
     }
     request.input.body.elements.forEach((element, index) => {
-        if (!isPlainObject(element)) {
+        if (!(0, safeObject_1.isPlainObject)(element)) {
             throw kerror.get("invalid_argument", "elements", "<array of objects>");
         }
         if (!element.member) {
             throw kerror.get("missing_argument", `elements[${index}].member`);
         }
         assertFloat(request, "score", element.score);
-        args.push(element.score);
-        args.push(element.member);
+        args.push(element.score, element.member);
     });
     return args;
 }
@@ -795,7 +850,7 @@ function extractArgumentsFromRequestForZInterstore(request) {
     if (request.input.body.aggregate) {
         kassert.assertBodyAttributeType(request, "aggregate", "string");
         const aggregate = request.input.body.aggregate.toUpperCase();
-        if (["SUM", "MIN", "MAX"].indexOf(aggregate) === -1) {
+        if (!["SUM", "MIN", "MAX"].includes(aggregate)) {
             throw kerror.get("invalid_argument", "aggregate", '"SUM", "MIN" or "MAX"');
         }
         args.push("AGGREGATE", aggregate);
@@ -813,7 +868,8 @@ function extractArgumentsFromRequestForZInterstore(request) {
  */
 function assertFloat(request, name, value) {
     // Number.parseXxx computes the 1st member of an array if one is provided
-    if (Array.isArray(value) || Number.isNaN(Number.parseFloat(value))) {
+    if (Array.isArray(value) ||
+        Number.isNaN(Number.parseFloat(scalarToString(value)))) {
         throw kerror.get("invalid_type", name, "number");
     }
 }
@@ -828,10 +884,23 @@ function assertFloat(request, name, value) {
  */
 function assertInt(request, name, value) {
     // Number.parseXxx computes the 1st member of an array if one is provided
-    if (Array.isArray(value) || Number.isNaN(Number.parseInt(value))) {
+    if (Array.isArray(value) ||
+        Number.isNaN(Number.parseInt(scalarToString(value)))) {
         throw kerror.get("invalid_type", name, "integer");
     }
 }
+/**
+ * The string `Number.parse*` would have coerced its argument to. Anything that
+ * is not a scalar parses to NaN either way, so returning "" for it preserves
+ * the behaviour without stringifying an object.
+ */
+function scalarToString(value) {
+    return typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean"
+        ? String(value)
+        : "";
+}
 /**
  * Deal with arguments being either an array or a string: return the array
  * intact if it's the former, and convert it to an array if it's a string
@@ -839,6 +908,8 @@ function assertInt(request, name, value) {
  * @returns {Array}
  */
 function toArray(arg) {
+    // Anything that is neither a string nor an array used to be handed to Redis
+    // unchanged, and still is — the command itself rejects it.
     return typeof arg === "string" ? arg.split(",") : arg;
 }
 /**
@@ -848,7 +919,7 @@ function toArray(arg) {
  */
 function sanitizeArrayArgument(arg) {
     const result = toArray(arg);
-    return result.map((v) => (typeof v === "string" ? v.toUpperCase() : v));
+    return result.map((v) => typeof v === "string" ? v.toUpperCase() : v);
 }
 /**
  * Parse a LIMIT argument and throws if not a valid LIMIT parameter
@@ -864,4 +935,5 @@ function processLimit(arg) {
     }
     return result;
 }
+module.exports = MemoryStorageController;
 //# sourceMappingURL=memoryStorageController.js.map

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

@@ -1,4 +1,5 @@
-export = RealtimeController;
+import { NativeController } from "./baseController";
+import type { KuzzleRequest } from "../request";
 /**
  * @class RealtimeController
  */
@@ -8,40 +9,49 @@ declare class RealtimeController extends NativeController {
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    subscribe(request: Request): Promise<any>;
+    subscribe(request: KuzzleRequest): Promise<any>;
     /**
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    join(request: Request): Promise<any>;
+    join(request: KuzzleRequest): Promise<any>;
     /**
      * @param {Request} request
      * @returns {Promise<String>}
      */
-    unsubscribe(request: Request): Promise<string>;
+    unsubscribe(request: KuzzleRequest): Promise<{
+        roomId: string;
+    }>;
     /**
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    count(request: Request): Promise<any>;
+    count(request: KuzzleRequest): Promise<{
+        count: any;
+    }>;
     /**
      * @param {Request} request
      * @returns {Promise.<Object>}
      */
-    list(request: Request): Promise<any>;
+    list(request: KuzzleRequest): Promise<any>;
     /**
      * Publish a realtime message
      *
      * @param {Request} request
      * @returns {Promise<Object>}
      */
-    publish(request: Request): Promise<any>;
+    publish(request: KuzzleRequest): Promise<{
+        published: boolean;
+    }>;
     /**
      * 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;
+    }>;
 }
-import { NativeController } from "./baseController";
+export = RealtimeController;

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,12 +19,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const { NativeController } = require("./baseController");
+const baseController_1 = require("./baseController");
 /**
  * @class RealtimeController
  */
-class RealtimeController extends NativeController {
+class RealtimeController extends baseController_1.NativeController {
     constructor() {
         super([
             "count",
@@ -107,7 +107,11 @@ class RealtimeController extends NativeController {
         request.getBody();
         request.getIndexAndCollection();
         const newRequest = await global.kuzzle.validation.validate(request, false);
-        newRequest.input.body._kuzzle_info = {
+        // `getBody` rather than `input.body`: the body is nullable on the request
+        // and this line has always required it. The assertion is the same one
+        // `request.getBody()` made above, on the same object — `validate` answers
+        // the request it was handed.
+        newRequest.getBody()._kuzzle_info = {
             author: request.getKuid(),
             createdAt: Date.now(),
         };