kuzzle 2.56.0 → 2.57.0-beta.2

package/dist/lib/util/requestAssertions.d.ts

@@ -1,10 +1,30 @@
-export function assertArgsHasAttribute(request: Request, attribute: any): void;
-export function assertBodyAttributeType(request: Request, attribute: string, type: any): boolean;
-export function assertBodyHasAttribute(request: Request, attribute: string): void;
-export function assertBodyHasNotAttribute(request: Request, attribute: string): void;
-export function assertHasBody(request: Request): void;
-export function assertHasId(request: Request): void;
-export function assertHasIndex(request: Request): void;
-export function assertHasIndexAndCollection(request: Request): void;
-export function assertIsAuthenticated(anonymousId: any, request: Request): void;
-export function assertIsObject(value: any): void;
+import type { JSONObject } from "../types/JSONObject";
+import type { KuzzleRequest } from "../api/request";
+export declare function assertArgsHasAttribute(request: KuzzleRequest, attribute: string): void;
+/**
+ * Note: Assumes assertHasBody has been called first
+ */
+export declare function assertBodyAttributeType(request: KuzzleRequest, attribute: string, type: string): boolean;
+export declare function assertBodyHasAttribute(request: KuzzleRequest, attribute: string): void;
+export declare function assertBodyHasNotAttribute(request: KuzzleRequest, attribute: string): void;
+/**
+ * A request whose body this module has checked. `input.body` is
+ * `JSONObject | null` on every request — a GET carries none — and the
+ * controllers read it straight after asserting it, dozens of times per file.
+ * The assertion signature is what carries that check to those reads instead
+ * of each one restating it.
+ */
+export type RequestWithBody = KuzzleRequest & {
+    input: KuzzleRequest["input"] & {
+        body: JSONObject;
+    };
+};
+/**
+ * Note: Assumes content exists
+ */
+export declare function assertHasBody(request: KuzzleRequest): asserts request is RequestWithBody;
+export declare function assertHasId(request: KuzzleRequest): void;
+export declare function assertHasIndex(request: KuzzleRequest): void;
+export declare function assertHasIndexAndCollection(request: KuzzleRequest): void;
+export declare function assertIsAuthenticated(anonymousId: string, request: KuzzleRequest): void;
+export declare function assertIsObject(value: unknown): void;

package/dist/lib/util/requestAssertions.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,126 +19,129 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const _ = require("lodash");
-const { get, isPlainObject } = require("./safeObject");
-const kerror = require("../kerror");
-const assertionError = kerror.wrap("api", "assert");
-module.exports = {
-    /**
-     * @param {Request} request
-     */
-    assertArgsHasAttribute: (request, attribute) => {
-        if (_.isNil(get(request.input.args, attribute))) {
-            throw assertionError.get("missing_argument", attribute);
-        }
-    },
-    /**
-     * Note: Assumes assertHasBody has been called first
-     *
-     * @param {Request} request
-     * @param {string} attribute
-     */
-    assertBodyAttributeType: (request, attribute, type) => {
-        switch (type) {
-            case "number":
-            case "boolean":
-            case "string":
-                // The body should always be passed as JSON, we don't consider type conversion possibilities
-                if (typeof get(request.input.body, attribute) === type) {
-                    return true;
-                }
-                break;
-            case "array":
-                if (Array.isArray(get(request.input.body, attribute))) {
-                    return true;
-                }
-                break;
-            case "object":
-                if (isPlainObject(get(request.input.body, attribute))) {
-                    return true;
-                }
-                break;
-            default:
-                throw assertionError.get("unexpected_type_assertion", type, attribute);
-        }
-        throw assertionError.get("invalid_type", `body.${attribute}`, type);
-    },
-    /**
-     *
-     * @param {Request} request
-     * @param {string} attribute
-     */
-    assertBodyHasAttribute: (request, attribute) => {
-        if (_.isNil(get(request.input.body, attribute))) {
-            throw assertionError.get("missing_argument", `body.${attribute}`);
-        }
-    },
-    /**
-     * @param {Request} request
-     * @param {string} attribute
-     */
-    assertBodyHasNotAttribute: (request, attribute) => {
-        if (!_.isNil(get(request.input.body, attribute))) {
-            throw assertionError.get("forbidden_argument", `body.${attribute}`);
-        }
-    },
-    /**
-     * Note: Assumes content exists
-     *
-     * @param {Request} request
-     * @param {string} attribute
-     * @param {string} type
-     */
-    assertHasBody: (request) => {
-        if (_.isNil(request.input.body)) {
-            throw assertionError.get("body_required");
-        }
-    },
-    /**
-     * @param {Request} request
-     */
-    assertHasId: (request) => {
-        if (!request.input.args._id) {
-            throw assertionError.get("missing_argument", "_id");
-        }
-    },
-    /**
-     * @param {Request} request
-     */
-    assertHasIndex: (request) => {
-        if (!request.input.args.index) {
-            throw assertionError.get("missing_argument", "index");
-        }
-    },
-    /**
-     * @param {Request} request
-     */
-    assertHasIndexAndCollection: (request) => {
-        if (!request.input.args.index) {
-            throw assertionError.get("missing_argument", "index");
-        }
-        if (!request.input.args.collection) {
-            throw assertionError.get("missing_argument", "collection");
-        }
-    },
-    /**
-     * @param {Kuzzle} kuzzle
-     * @param {Request} request
-     */
-    assertIsAuthenticated: (anonymousId, request) => {
-        if (request.context.user._id === anonymousId) {
-            throw kerror.get("security", "rights", "unauthorized");
-        }
-    },
-    /**
-     * @param {Kuzzle} kuzzle
-     * @param {Request} request
-     */
-    assertIsObject: (value) => {
-        if (!isPlainObject(value)) {
-            throw assertionError.get("invalid_argument", value, "object");
-        }
-    },
+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 };
 };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertIsObject = exports.assertIsAuthenticated = exports.assertHasIndexAndCollection = exports.assertHasIndex = exports.assertHasId = exports.assertHasBody = exports.assertBodyHasNotAttribute = exports.assertBodyHasAttribute = exports.assertBodyAttributeType = exports.assertArgsHasAttribute = void 0;
+const isNil_1 = __importDefault(require("lodash/isNil"));
+const kerror = __importStar(require("../kerror"));
+const safeObject_1 = require("./safeObject");
+const assertionError = kerror.wrap("api", "assert");
+function assertArgsHasAttribute(request, attribute) {
+    if ((0, isNil_1.default)((0, safeObject_1.get)(request.input.args, attribute))) {
+        throw assertionError.get("missing_argument", attribute);
+    }
+}
+exports.assertArgsHasAttribute = assertArgsHasAttribute;
+/**
+ * Note: Assumes assertHasBody has been called first
+ */
+function assertBodyAttributeType(request, attribute, type) {
+    switch (type) {
+        case "number":
+        case "boolean":
+        case "string":
+            // The body should always be passed as JSON, we don't consider type conversion possibilities
+            if (typeof (0, safeObject_1.get)(request.input.body, attribute) === type) {
+                return true;
+            }
+            break;
+        case "array":
+            if (Array.isArray((0, safeObject_1.get)(request.input.body, attribute))) {
+                return true;
+            }
+            break;
+        case "object":
+            if ((0, safeObject_1.isPlainObject)((0, safeObject_1.get)(request.input.body, attribute))) {
+                return true;
+            }
+            break;
+        default:
+            throw assertionError.get("unexpected_type_assertion", type, attribute);
+    }
+    throw assertionError.get("invalid_type", `body.${attribute}`, type);
+}
+exports.assertBodyAttributeType = assertBodyAttributeType;
+function assertBodyHasAttribute(request, attribute) {
+    if ((0, isNil_1.default)((0, safeObject_1.get)(request.input.body, attribute))) {
+        throw assertionError.get("missing_argument", `body.${attribute}`);
+    }
+}
+exports.assertBodyHasAttribute = assertBodyHasAttribute;
+function assertBodyHasNotAttribute(request, attribute) {
+    if (!(0, isNil_1.default)((0, safeObject_1.get)(request.input.body, attribute))) {
+        throw assertionError.get("forbidden_argument", `body.${attribute}`);
+    }
+}
+exports.assertBodyHasNotAttribute = assertBodyHasNotAttribute;
+/**
+ * Note: Assumes content exists
+ */
+function assertHasBody(request) {
+    if ((0, isNil_1.default)(request.input.body)) {
+        throw assertionError.get("body_required");
+    }
+}
+exports.assertHasBody = assertHasBody;
+function assertHasId(request) {
+    if (!request.input.args._id) {
+        throw assertionError.get("missing_argument", "_id");
+    }
+}
+exports.assertHasId = assertHasId;
+function assertHasIndex(request) {
+    if (!request.input.args.index) {
+        throw assertionError.get("missing_argument", "index");
+    }
+}
+exports.assertHasIndex = assertHasIndex;
+function assertHasIndexAndCollection(request) {
+    if (!request.input.args.index) {
+        throw assertionError.get("missing_argument", "index");
+    }
+    if (!request.input.args.collection) {
+        throw assertionError.get("missing_argument", "collection");
+    }
+}
+exports.assertHasIndexAndCollection = assertHasIndexAndCollection;
+function assertIsAuthenticated(anonymousId, request) {
+    // `context.user` is null until the request has been authenticated, which is
+    // precisely the case this assertion exists to reject — reading `_id` off it
+    // threw a TypeError instead of the intended error.
+    if (request.context.user === null ||
+        request.context.user._id === anonymousId) {
+        throw kerror.get("security", "rights", "unauthorized");
+    }
+}
+exports.assertIsAuthenticated = assertIsAuthenticated;
+function assertIsObject(value) {
+    if (!(0, safeObject_1.isPlainObject)(value)) {
+        throw assertionError.get("invalid_argument", value, "object");
+    }
+}
+exports.assertIsObject = assertIsObject;
 //# sourceMappingURL=requestAssertions.js.map

package/dist/lib/util/safeObject.d.ts

@@ -1,3 +1,3 @@
-export function get(o: any, prop: any): any;
-export function has(o: any, prop: any): any;
-export function isPlainObject(o: any): boolean;
+export declare function has(o: unknown, prop: PropertyKey): boolean;
+export declare function get(o: unknown, prop: PropertyKey): unknown;
+export declare function isPlainObject(o: unknown): o is Record<string, unknown>;

package/dist/lib/util/safeObject.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,19 +19,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlainObject = exports.get = exports.has = void 0;
 // Simple utility functions for safe (and fast) object manipulations
 function has(o, prop) {
-    return Object.prototype.hasOwnProperty.call(o, prop);
+    return Object.hasOwn(o, prop);
 }
+exports.has = has;
 function get(o, prop) {
     if (has(o, prop)) {
         return o[prop];
     }
     return undefined;
 }
+exports.get = get;
 function isPlainObject(o) {
     return Object.prototype.toString.call(o) === "[object Object]";
 }
-module.exports = { get, has, isPlainObject };
+exports.isPlainObject = isPlainObject;
 //# sourceMappingURL=safeObject.js.map

package/dist/lib/util/stackTrace.d.ts

@@ -1,3 +1,4 @@
+import "../types/Global";
 /**
  * Hilight user code
  *
@@ -8,12 +9,19 @@
  * >>>>  at init (/home/aschen/projets/app/test.ts:8:3)
  *       at Module._compile (internal/modules/cjs/loader.js:1133:30)
  */
-export function hilightUserCode(line: any): any;
+export declare function hilightUserCode(line: string): string;
+interface SerializedRequestResponse {
+    content?: {
+        error?: {
+            stack?: string;
+        };
+    };
+}
 /**
  * utility method: must be invoked by all protocols to remove stack traces
  * from payloads before sending them
- * @param  {Error|Object} data - expected: plain error object or serialized
- *                               request response
- * @returns {*} return the data minus the stack trace
+ * @param data - expected: plain error object or serialized request response
+ * @returns return the data minus the stack trace
  */
-export function removeStacktrace(data: Error | any): any;
+export declare function removeStacktrace<T extends Error | SerializedRequestResponse>(data: T): T;
+export {};

package/dist/lib/util/stackTrace.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,8 +19,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const util = require("util");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeStacktrace = exports.hilightUserCode = void 0;
+require("../types/Global");
 const MARKER = ">";
 const PADDING = "  ";
 /**
@@ -48,23 +50,29 @@ function hilightUserCode(line) {
     // hilight user code
     return MARKER + line;
 }
+exports.hilightUserCode = hilightUserCode;
 /**
  * utility method: must be invoked by all protocols to remove stack traces
  * from payloads before sending them
- * @param  {Error|Object} data - expected: plain error object or serialized
- *                               request response
- * @returns {*} return the data minus the stack trace
+ * @param data - expected: plain error object or serialized request response
+ * @returns return the data minus the stack trace
  */
 function removeStacktrace(data) {
-    if (util.types.isNativeError(data)) {
+    if (data instanceof Error) {
         if (global.NODE_ENV !== "development") {
             data.stack = undefined;
         }
         else {
-            data.stack = data.stack.split("\n").map(hilightUserCode).join("\n");
+            // `KuzzleError` sets `stack` to undefined in its own constructor before
+            // deciding what to put there, so an Error with no stack is not a
+            // hypothetical here — the branch below already spelled this out for the
+            // serialized-response case.
+            data.stack = data.stack
+                ? data.stack.split("\n").map(hilightUserCode).join("\n")
+                : undefined;
         }
     }
-    else if (data && data.content && data.content.error) {
+    else if (data?.content?.error) {
         // @todo v3: stack should be removed only for "production" env
         if (global.NODE_ENV !== "development") {
             data.content.error.stack = undefined;
@@ -77,8 +85,5 @@ function removeStacktrace(data) {
     }
     return data;
 }
-module.exports = {
-    hilightUserCode,
-    removeStacktrace,
-};
+exports.removeStacktrace = removeStacktrace;
 //# sourceMappingURL=stackTrace.js.map

package/dist/lib/util/thrown.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Whatever was thrown, as an `Error`.
+ *
+ * `catch` answers `unknown`, and a plugin may throw or reject with anything.
+ * The message is the thrown value's own `message`, read the way the
+ * JavaScript read it: `{ message: "x" }` gives "x", and a value without one
+ * (a string, a number, `null`) gives "undefined" — where the JavaScript
+ * crashed on `null`.
+ *
+ * Never `util.inspect`: this message ends up in the error a client receives,
+ * and inspecting a plugin's object would copy its whole content there.
+ */
+export declare function causeOf(thrown: unknown): Error;

package/dist/lib/util/thrown.js

@@ -0,0 +1,46 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.causeOf = void 0;
+/**
+ * Whatever was thrown, as an `Error`.
+ *
+ * `catch` answers `unknown`, and a plugin may throw or reject with anything.
+ * The message is the thrown value's own `message`, read the way the
+ * JavaScript read it: `{ message: "x" }` gives "x", and a value without one
+ * (a string, a number, `null`) gives "undefined" — where the JavaScript
+ * crashed on `null`.
+ *
+ * Never `util.inspect`: this message ends up in the error a client receives,
+ * and inspecting a plugin's object would copy its whole content there.
+ */
+function causeOf(thrown) {
+    if (thrown instanceof Error) {
+        return thrown;
+    }
+    const message = thrown === null || thrown === undefined
+        ? undefined
+        : Reflect.get(Object(thrown), "message");
+    return new Error(String(message));
+}
+exports.causeOf = causeOf;
+//# sourceMappingURL=thrown.js.map

package/dist/package.json

@@ -1,24 +1,30 @@
 {
     "name": "kuzzle",
     "author": "The Kuzzle Team <support@kuzzle.io>",
-    "version": "2.56.0",
+    "version": "2.57.0-beta.2",
     "description": "Kuzzle is an open-source solution that handles all the data management through a secured API, with a large choice of protocols.",
     "scripts": {
-        "build": "rm -Rf ./dist && tsc && node ./bin/copy-binaries.js",
+        "build": "rm -Rf ./dist && tsc && node -r ts-node/register/transpile-only ./bin/copy-binaries.ts",
         "cucumber": "cucumber.js --fail-fast",
         "dev": "tsx watch start-kuzzle-dev.ts",
         "doc-error-codes": "node -r ts-node/register doc/build-error-codes",
-        "prepublishOnly": "npm run build",
-        "prettier": "prettier ./lib ./test ./features --write",
+        "prepublishOnly": "npm run build && ./.ci/scripts/check-build-payload.sh",
+        "prettier": "prettier ./lib ./tests ./features ./features-legacy --write",
+        "prettier:check": "prettier ./lib ./tests ./features ./features-legacy --check",
+        "ratchet": "npm run ratchet:js && npm run ratchet:any && npm run ratchet:casts && npm run ratchet:cpd-exclusions",
+        "ratchet:any": "bash scripts/ratchet.sh any",
+        "ratchet:casts": "bash scripts/ratchet.sh casts",
+        "ratchet:cpd-exclusions": "bash scripts/ratchet.sh cpd-exclusions",
+        "ratchet:js": "bash scripts/ratchet.sh js",
         "test:functional:legacy:http": "cucumber-js --format progress-bar --profile httpLegacy --config cucumber.config.cjs",
         "test:functional:legacy:mqtt": "cucumber-js --format progress-bar --profile mqttLegacy --config cucumber.config.cjs",
         "test:functional:legacy:websocket": "cucumber-js --format progress-bar --profile websocketLegacy --config cucumber.config.cjs",
         "test:functional:http": "KUZZLE_PROTOCOL=http cucumber-js --profile http --config cucumber.config.cjs",
         "test:functional:websocket": "KUZZLE_PROTOCOL=websocket cucumber-js --profile websocket --config cucumber.config.cjs",
         "test:unit:vitest": "vitest run --fileParallelism false --coverage --bail=1 --passWithNoTests",
-        "test:unit:mocha": "mocha --exit",
-        "test:unit:mocha:coverage": "c8 --reporter=lcov --report-dir=coverage mocha --exit",
-        "test:lint": "eslint ./lib ./test ./bin ./features"
+        "test:lint": "eslint ./lib ./tests ./bin ./features ./features-legacy",
+        "typecheck:tests": "tsc -p tsconfig.tests.json",
+        "typecheck:typings": "tsc -p tests/typings/tsconfig.json && tsc -p tests/typings/tsconfig.loose.json"
     },
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
@@ -33,18 +39,18 @@
         "debug": "4.4.3",
         "denque": "2.1.0",
         "didyoumean": "1.2.2",
-        "dumpme": "2.0.0",
+        "dumpme": "2.1.0-dev.1",
         "eventemitter3": "5.0.1",
         "inquirer": "13.1.0",
         "ioredis": "5.8.2",
         "json-stable-stringify": "1.3.0",
         "json2yaml": "1.1.0",
         "jsonwebtoken": "9.0.3",
-        "koncorde": "4.7.0",
+        "koncorde": "4.8.0-beta.2",
         "kuzzle-logger": "1.4.0",
         "kuzzle-plugin-auth-passport-local": "6.4.1",
-        "kuzzle-sdk": ">=7.17.1",
-        "kuzzle-vault": "2.1.0",
+        "kuzzle-sdk": ">=7.17.1 <8.0.0",
+        "kuzzle-vault": "2.2.0",
         "lodash": "4.17.21",
         "long": "5.3.2",
         "moment": "2.30.1",
@@ -59,6 +65,7 @@
         "pino-transport-ecs": "1.1.0",
         "protobufjs": "7.5.4",
         "rc": "1.2.8",
+        "redis-semaphore": "5.8.0",
         "sdk-es7": "npm:@elastic/elasticsearch@7.13.0",
         "sdk-es8": "npm:@elastic/elasticsearch@8.17.1",
         "semver": "7.7.3",
@@ -75,29 +82,29 @@
     },
     "devDependencies": {
         "@cucumber/cucumber": "12.5.0",
+        "@types/async": "^3.2.24",
         "@types/bluebird": "3.5.42",
         "@types/cookie": "1.0.0",
         "@types/lodash": "4.17.21",
-        "@types/mocha": "10.0.10",
         "@types/passport": "1.0.17",
+        "@types/validator": "^13.15.10",
+        "@types/yargs": "17.0.35",
         "@vitest/coverage-v8": "4.0.16",
         "async": "3.2.6",
-        "c8": "^11.0.0",
-        "eslint-plugin-kuzzle": "0.0.15",
-        "mocha": "11.7.5",
-        "mock-require": "3.0.3",
+        "eslint": "10.10.0",
+        "eslint-plugin-kuzzle": "2.0.0",
+        "ioredis-mock": "8.13.1",
         "mqtt": "5.14.1",
+        "prettier": "3.9.7",
         "request-promise": "4.2.6",
-        "rewire": "5.0.0",
         "semantic-release-config-kuzzle": "1.3.0",
         "should": "13.2.3",
-        "should-sinon": "0.0.6",
-        "sinon": "21.0.0",
         "strip-json-comments": "https://github.com/sindresorhus/strip-json-comments/archive/refs/tags/v3.1.1.tar.gz",
         "ts-node": "10.9.2",
         "tsx": "4.21.0",
         "typescript": "5.4.5",
         "vitest": "4.0.16",
+        "ws": "^8.18.3",
         "yaml": "2.8.2"
     },
     "engines": {