kuzzle 2.56.0 → 2.57.0-beta.2

package/dist/lib/kuzzle/kuzzleStateEnum.d.ts

@@ -1,12 +1,8 @@
-export = kuzzleStateEnum;
-type kuzzleStateEnum = number;
-/**
- * @typedef {number} kuzzleStateEnum
- */
 /**
- * Enum for Kuzzle's state
- * @readOnly
- * @enum {kuzzleStateEnum}
+ * Enum for Kuzzle's state.
+ *
+ * A frozen object rather than a TypeScript `enum`: the JavaScript exported a
+ * frozen one, and an `enum` emits an ordinary, mutable object.
  */
 declare const kuzzleStateEnum: Readonly<{
     NOT_ENOUGH_NODES: 4;
@@ -14,7 +10,15 @@ declare const kuzzleStateEnum: Readonly<{
     SHUTTING_DOWN: 3;
     STARTING: 1;
 }>;
-declare namespace kuzzleStateEnum {
-    export { kuzzleStateEnum };
-}
-type kuzzleStateEnum = number;
+/**
+ * The value and the type keep the same name, which is what lets `kuzzle.ts`
+ * write both `kuzzleStateEnum.RUNNING` and `get state(): kuzzleStateEnum` —
+ * the two spellings the JavaScript supported through a `@typedef`.
+ *
+ * Derived from the object rather than declared, so it cannot drift. It widens
+ * to `number`, which is exactly what `@typedef {number} kuzzleStateEnum` said:
+ * `Object.freeze` over a plain literal gives `Readonly<{ … : number }>`, not
+ * literal types, so no call site has to change.
+ */
+type kuzzleStateEnum = (typeof kuzzleStateEnum)[keyof typeof kuzzleStateEnum];
+export = kuzzleStateEnum;

package/dist/lib/kuzzle/kuzzleStateEnum.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,14 +19,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
 /**
- * @typedef {number} kuzzleStateEnum
- */
-/**
- * Enum for Kuzzle's state
- * @readOnly
- * @enum {kuzzleStateEnum}
+ * Enum for Kuzzle's state.
+ *
+ * A frozen object rather than a TypeScript `enum`: the JavaScript exported a
+ * frozen one, and an `enum` emits an ordinary, mutable object.
  */
 const kuzzleStateEnum = Object.freeze({
     NOT_ENOUGH_NODES: 4,

package/dist/lib/kuzzle/vault.d.ts

@@ -1,2 +1,6 @@
-export function load(vaultKey: any, secretsFile: any): Vault;
 import { Vault } from "kuzzle-vault";
+declare function load(vaultKey?: string, secretsFile?: string, useNewAlgorithm?: boolean): Vault;
+declare const _default: {
+    load: typeof load;
+};
+export = _default;

package/dist/lib/kuzzle/vault.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,42 +19,53 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const assert = require("assert");
-const fs = require("fs");
-const path = require("path");
-const _ = require("lodash");
-const { Vault } = require("kuzzle-vault");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const kuzzle_vault_1 = require("kuzzle-vault");
+const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
 // The Vault package remove the variable from env after reading it and we have
 // to instantiate the Vault two times with Kaaf (one before init and one after)
+//
+// `| undefined` is the truth until the first call assigns it. A module-scope
+// `let` escapes TypeScript's definite-assignment analysis, so `: string` passed
+// strict while being false for every read before that first assignment
+// (TD-57, #2760).
 let ENV_VAULT_KEY;
-function load(vaultKey, secretsFile) {
+function load(vaultKey, secretsFile, useNewAlgorithm = false) {
     // Using KaaF kuzzle is an npm package and is located under node_modules folder
     // We need to get back to root folder of the project to get the secret file
     const defaultEncryptedSecretsFile = __dirname.endsWith("/node_modules/kuzzle/lib/kuzzle")
-        ? path.resolve(`${__dirname}/../../../../config/secrets.enc.json`)
-        : path.resolve(`${__dirname}/../../config/secrets.enc.json`);
+        ? node_path_1.default.resolve(`${__dirname}/../../../../config/secrets.enc.json`)
+        : node_path_1.default.resolve(`${__dirname}/../../config/secrets.enc.json`);
     const encryptedSecretsFile = secretsFile ||
         process.env.KUZZLE_SECRETS_FILE ||
         defaultEncryptedSecretsFile;
     let key = vaultKey;
-    if (_.isEmpty(vaultKey) &&
-        (!_.isEmpty(process.env.KUZZLE_VAULT_KEY) || !_.isEmpty(ENV_VAULT_KEY))) {
+    if ((0, isEmpty_1.default)(vaultKey) &&
+        (!(0, isEmpty_1.default)(process.env.KUZZLE_VAULT_KEY) || !(0, isEmpty_1.default)(ENV_VAULT_KEY))) {
         // Keep the vault key value when reading it from the env
         key = ENV_VAULT_KEY = process.env.KUZZLE_VAULT_KEY || ENV_VAULT_KEY;
     }
-    const fileExists = fs.existsSync(encryptedSecretsFile);
+    const fileExists = node_fs_1.default.existsSync(encryptedSecretsFile);
     // Abort if a custom secrets file has been provided but Kuzzle can't load it
-    if (!_.isEmpty(process.env.KUZZLE_SECRETS_FILE) || !_.isEmpty(secretsFile)) {
-        assert(fileExists, `A secret file has been provided but Kuzzle cannot find it at "${encryptedSecretsFile}".`);
+    if (!(0, isEmpty_1.default)(process.env.KUZZLE_SECRETS_FILE) || !(0, isEmpty_1.default)(secretsFile)) {
+        (0, node_assert_1.default)(fileExists, `A secret file has been provided but Kuzzle cannot find it at "${encryptedSecretsFile}".`);
     }
     // Abort if a secret file is found (default or custom)
     // but no vault key has been provided
-    assert(!(fileExists && _.isEmpty(key)), "A secret file has been provided but Kuzzle cannot find the Vault key. Aborting.");
+    (0, node_assert_1.default)(!(fileExists && (0, isEmpty_1.default)(key)), "A secret file has been provided but Kuzzle cannot find the Vault key. Aborting.");
     // Abort if a vault key has been provided
     // but no secrets file can be loaded (default or custom)
-    assert(!(!_.isEmpty(key) && !fileExists), `A Vault key is present but Kuzzle cannot find the secret file at "${encryptedSecretsFile}". Aborting.`);
-    const vault = new Vault(key);
+    (0, node_assert_1.default)(!(!(0, isEmpty_1.default)(key) && !fileExists), `A Vault key is present but Kuzzle cannot find the secret file at "${encryptedSecretsFile}". Aborting.`);
+    const vault = new kuzzle_vault_1.Vault(key, {
+        cipher: useNewAlgorithm
+            ? kuzzle_vault_1.CryptonomiconCipher.AES_256_GCM
+            : kuzzle_vault_1.CryptonomiconCipher.AES_256_CBC,
+    });
     if (key) {
         vault.decrypt(encryptedSecretsFile);
     }

package/dist/lib/model/security/profile.d.ts

@@ -1,17 +1,32 @@
-import { Policy, OptimizedPolicy, OptimizedPolicyRestrictions } from "../../types/index";
-import { Role } from "./role";
-import { KuzzleRequest } from "../../../index";
+import type { Policy, OptimizedPolicy, OptimizedPolicyRestrictions } from "../../types/index";
+import type { Role } from "./role";
+import type { KuzzleRequest } from "../../../index";
 /** @internal */
 type InternalProfilePolicy = {
     role: Role;
+    /**
+     * Carried straight off the optimized policy, which may not have one.
+     * Declared as always present all the same, as v2.56.0 declared it: this
+     * reaches plugins through `getPolicies()`.
+     */
     restrictedTo: OptimizedPolicyRestrictions;
 };
 /**
  * @class Profile
  */
 export declare class Profile {
+    /**
+     * `null` until the profile is stored — see ADR-0001, TD-62. Declared
+     * `string` all the same, as v2.56.0 declared it (see `User._id`).
+     */
     _id: string;
     policies: Policy[];
+    /**
+     * Unset while the profile is persisted — `persistToDatabase` clears it so the
+     * derived form is never written — and the two readers below test for
+     * `undefined` (ADR-0001, TD-40 / TD-56). Declared as always present all the
+     * same, as v2.56.0 declared it.
+     */
     optimizedPolicies: OptimizedPolicy[];
     rateLimit: number;
     constructor();
@@ -40,7 +55,7 @@ export declare class Profile {
      * @returns {Promise}
      */
     validateDefinition({ strict }?: {
-        strict?: boolean;
+        strict?: boolean | undefined;
     }): Promise<boolean>;
     /**
      * Resolves an array of rights related to the profile's roles.
@@ -48,7 +63,21 @@ export declare class Profile {
      * @returns {Promise}
      */
     getRights(): Promise<{}>;
-    static _hash(): boolean;
+    /**
+     * Hashes a rights item into the key it is stored under.
+     *
+     * Placeholder on purpose: `profileRepository` replaces it with
+     * `global.kuzzle.hash` at startup, and the `false` returned here is exactly
+     * how that patching detects an un-patched class. The overload signature
+     * describes the patched function; the implementation is the stub.
+     *
+     * The patch is `global.kuzzle.hash`, which returns a **number** (`murmur.v3`)
+     * — hence `number | false` in practice. Declared `any`, v2.56.0's public
+     * type being `() => boolean`: code compiled against that reads a `boolean`
+     * back or assigns a `boolean`-returning stub, and no narrower type accepts
+     * both that and the patch.
+     */
+    static _hash(rightsItem?: unknown): any;
     validateRateLimit(): void;
 }
 export {};

package/dist/lib/model/security/profile.js

@@ -72,9 +72,9 @@ class Profile {
         if (!global.kuzzle) {
             throw kerror.get("security", "profile", "uninitialized", this._id);
         }
-        return bluebird_1.default.map(this.optimizedPolicies, async ({ restrictedTo, roleId }) => {
+        return bluebird_1.default.map(this.optimizedPolicies ?? [], async ({ restrictedTo, roleId }) => {
             const role = await global.kuzzle.ask("core:security:role:get", roleId);
-            return { restrictedTo, role };
+            return { restrictedTo: restrictedTo, role };
         });
     }
     /**
@@ -209,9 +209,10 @@ class Profile {
                                 value: actionRights,
                             };
                             const rightsObject = {
-                                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                                // @ts-ignore
-                                [this.constructor._hash(rightsItem)]: rightsItem,
+                                // `String()` is what the computed key does implicitly anyway
+                                // (`_hash` returns a number, or `false` while un-patched), and
+                                // it is what makes that return type legal here — see `_hash`.
+                                [String(this.constructor._hash(rightsItem))]: rightsItem,
                             };
                             lodash_1.default.assignWith(profileRights, rightsObject, rights_1.default.merge);
                         }

package/dist/lib/model/security/rights.d.ts

@@ -1,8 +1,16 @@
+interface PolicyRight {
+    value?: string | boolean;
+}
 /**
  * Merge function for policies rights
- * @param {Object} prev existing policies rights
- * @param {Object} cur new policies rights to merge
  *
- * @returns {Object} the merged policies rights
+ * @param prev existing policies rights
+ * @param cur new policies rights to merge
+ *
+ * @returns the merged policies rights
  */
-export function merge(prev: any, cur: any): any;
+declare function merge(prev: PolicyRight | undefined, cur: PolicyRight): PolicyRight;
+declare const _default: {
+    merge: typeof merge;
+};
+export = _default;

package/dist/lib/model/security/rights.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,16 +19,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-function isAllowed(obj) {
-    return obj && (obj.value === "allowed" || obj.value === true);
+function isAllowed(right) {
+    return Boolean(right && (right.value === "allowed" || right.value === true));
 }
 /**
  * Merge function for policies rights
- * @param {Object} prev existing policies rights
- * @param {Object} cur new policies rights to merge
  *
- * @returns {Object} the merged policies rights
+ * @param prev existing policies rights
+ * @param cur new policies rights to merge
+ *
+ * @returns the merged policies rights
  */
 function merge(prev, cur) {
     cur.value = isAllowed(cur) || isAllowed(prev) ? "allowed" : "denied";

package/dist/lib/model/security/role.d.ts

@@ -1,11 +1,15 @@
-import { ControllerRight, ControllerRights } from "../../types/controllers/ControllerRights";
-import { KuzzleRequest } from "../../../index";
-import { OptimizedPolicyRestrictions } from "../../types/PolicyRestrictions";
+import type { ControllerRight, ControllerRights } from "../../types/controllers/ControllerRights";
+import type { KuzzleRequest } from "../../../index";
+import type { OptimizedPolicyRestrictions } from "../../types/PolicyRestrictions";
 /**
  * @class Role
  */
 export declare class Role {
     controllers: ControllerRights;
+    /**
+     * The constructor does not set it; `RoleRepository` does, on the way out of
+     * the store. See ADR-0001, TD-62.
+     */
     _id: string;
     constructor();
     /**
@@ -23,7 +27,7 @@ export declare class Role {
      * @param {Map<string, string[]>} restrictedTo Restricted indexes
      * @returns {Boolean} resolves to a Boolean value
      */
-    checkRestrictions(index: string, collection: string, restrictedTo: OptimizedPolicyRestrictions): boolean;
+    checkRestrictions(index: string, collection: string, restrictedTo?: OptimizedPolicyRestrictions): boolean;
     /**
      * Verifies that a controller rights definition is correct
      *

package/dist/lib/model/security/role.js

@@ -75,7 +75,8 @@ class Role {
             (this.controllers.ms || this.controllers.memoryStorage)) {
             controllerRights = this.controllers.ms || this.controllers.memoryStorage;
         }
-        else if ((0, safeObject_1.has)(this.controllers, request.input.controller)) {
+        else if (request.input.controller !== null &&
+            (0, safeObject_1.has)(this.controllers, request.input.controller)) {
             controllerRights = this.controllers[request.input.controller];
         }
         else if (this.controllers["*"] !== undefined) {
@@ -84,11 +85,13 @@ class Role {
         else {
             return false;
         }
-        if (controllerRights.actions === undefined) {
+        if (controllerRights === undefined ||
+            controllerRights.actions === undefined) {
             return false;
         }
         let actionRights;
-        if ((0, safeObject_1.has)(controllerRights.actions, request.input.action)) {
+        if (request.input.action !== null &&
+            (0, safeObject_1.has)(controllerRights.actions, request.input.action)) {
             actionRights = controllerRights.actions[request.input.action];
         }
         else if (controllerRights.actions["*"] !== undefined) {
@@ -125,7 +128,10 @@ class Role {
      * @param {Map<string, string[]>} restrictedTo Restricted indexes
      * @returns {Boolean} resolves to a Boolean value
      */
-    checkRestrictions(index, collection, restrictedTo) {
+    checkRestrictions(index, collection, 
+    // Optional, and the first line already reads it as such: an optimized
+    // policy carries `restrictedTo` only when the profile restricted it.
+    restrictedTo) {
         // If no restrictions, we allow the action:
         if (!restrictedTo || restrictedTo.size === 0) {
             return true;
@@ -191,8 +197,8 @@ class Role {
      */
     canLogIn() {
         for (const controllerKey of ["auth", "*"]) {
-            if (this.controllers[controllerKey]) {
-                const controller = this.controllers[controllerKey];
+            const controller = this.controllers[controllerKey];
+            if (controller) {
                 for (const actionKey of ["login", "*"]) {
                     const action = controller.actions[actionKey];
                     if (typeof action === "boolean" && action) {

package/dist/lib/model/security/token.d.ts

@@ -17,6 +17,14 @@ export interface TokenContent {
  * Represents a token that identify an user.
  */
 export declare class Token implements TokenContent {
+    /**
+     * The constructor writes `null` for any of these five its `TokenContent`
+     * did not carry, and a `Token` is routinely built empty —
+     * `Token.Anonymous()` and the repository's cache miss both do it (ADR-0001,
+     * TD-62). They are declared non-nullable all the same, as v2.56.0 declared
+     * them: plugins read `request.context.token.userId` as a `string`, and
+     * `| null` broke that under `strict`.
+     */
     _id: string;
     expiresAt: number;
     ttl: number;

package/dist/lib/model/security/user.d.ts

@@ -1,9 +1,15 @@
-import { Profile } from "./profile";
-import { KuzzleRequest } from "../../../index";
+import type { Profile } from "./profile";
+import type { KuzzleRequest } from "../../../index";
 /**
  * @class User
  */
 export declare class User {
+    /**
+     * `null` until the user is stored — see ADR-0001, TD-62. Declared `string`
+     * all the same, as v2.56.0 declared it: `request.context.user._id` read as
+     * a `string` is everywhere in plugins and applications, and a
+     * `string | null` broke every one of them under `strict`.
+     */
     _id: string;
     profileIds: string[];
     strategies: any;

package/dist/lib/model/security/user.js

@@ -109,20 +109,23 @@ class User {
         const profilesPolicies = await Promise.all(profiles.map((profile) => profile.getAllowedPolicies(request)));
         // Every target must be allowed by at least one profile
         for (const target of targets) {
+            // Held in locals: the closures below lose the narrowing this guard gives
+            // the properties.
+            const { index, collections } = target;
             // Skip targets with no Index or Collection
-            if (!target.index || !target.collections) {
+            if (!index || !collections) {
                 continue;
             }
             // TODO: Support Wildcard
-            if (target.index.includes("*")) {
+            if (index.includes("*")) {
                 return false;
             }
-            for (const collection of target.collections) {
+            for (const collection of collections) {
                 // TODO: Support Wildcard
                 if (collection.includes("*")) {
                     return false;
                 }
-                const isTargetAllowed = profilesPolicies.some((policies) => policies.some((policy) => policy.role.checkRestrictions(target.index, collection, policy.restrictedTo)));
+                const isTargetAllowed = profilesPolicies.some((policies) => policies.some((policy) => policy.role.checkRestrictions(index, collection, policy.restrictedTo)));
                 if (!isTargetAllowed) {
                     return false;
                 }

package/dist/lib/model/storage/apiKey.d.ts

@@ -1,49 +1,78 @@
-export = ApiKey;
+import type { JSONObject } from "../../types/JSONObject";
+import type { KuzzleRequest } from "../../api/request";
+import BaseModel from "./baseModel";
+import type { User } from "../security/user";
+interface ApiKeyCreateOptions {
+    creatorId?: string | null;
+    apiKeyId?: string | null;
+    refresh?: boolean | string;
+    bypassMaxTTL?: boolean;
+}
 declare class ApiKey extends BaseModel {
+    userId: string;
+    description: string;
+    expiresAt: number;
+    ttl: number | string;
+    token: string;
+    fingerprint: string;
+    constructor(_source: JSONObject, _id?: string | null);
     /**
      * @override
      */
-    static override get collection(): string;
+    _afterDelete(): Promise<void>;
+    serialize({ includeToken }?: {
+        includeToken?: boolean;
+    }): {
+        _id: string | null;
+        _source: JSONObject;
+    };
     /**
      * @override
      */
-    static override get fields(): string[];
+    static get collection(): string;
+    /**
+     * @override
+     */
+    static get fields(): string[];
     /**
      * Creates a new API key for an user
      *
-     * @param {User} user
-     * @param {String} expiresIn - API key expiration date in ms format
-     * @param {String} description
-     * @param {Object} options - creatorId (null), apiKeyId (null), refresh (null), bypassMaxTTL (false)
-     *
-     * @returns {Promise<ApiKey>}
+     * @param user
+     * @param expiresIn - API key expiration date in ms format
+     * @param description
+     * @param options - creatorId (null), apiKeyId (null), refresh (null), bypassMaxTTL (false)
      */
-    static create(user: User, expiresIn: string, description: string, { creatorId, apiKeyId, refresh, bypassMaxTTL }?: any): Promise<ApiKey>;
+    static create(user: User, expiresIn: number | string, description: string, { creatorId, apiKeyId, refresh, bypassMaxTTL, }?: ApiKeyCreateOptions): Promise<ApiKey>;
     /**
      * Loads an user API key from the database
      *
-     * @param {String} userId - User ID
-     * @param {String} id - API key ID
-     *
-     * @returns {Promise<ApiKey>}
+     * @param userId - User ID
+     * @param id - API key ID
      */
     static load(userId: string, id: string): Promise<ApiKey>;
     /**
-     * Deletes API keys for an user
+     * Loads an user API key from the database by its fingerprint
      *
-     * @param {User} user
-     * @param {Object} options - refresh (null)
+     * @param userId - User ID
+     * @param fingerprint - API key fingerprint
+     */
+    static loadByFingerprint(userId: string, fingerprint: string): Promise<ApiKey>;
+    /**
+     * Loads a user's API key from a request, identified by its `_id`, its
+     * clear-text `key` or its `fingerprint` (in that order of precedence).
      *
-     * @returns {Promise}
+     * @param userId - User ID
+     * @param request - Request carrying the `_id`, `key` or `fingerprint` argument
      */
-    static deleteByUser(user: User, { refresh }?: any): Promise<any>;
-    constructor(_source: any, _id?: any);
+    static loadFromRequest(userId: string, request: KuzzleRequest): Promise<ApiKey>;
     /**
-     * @override
+     * Deletes API keys for an user
+     *
+     * @param user
+     * @param options - refresh (null)
      */
-    override _afterDelete(): Promise<void>;
-    serialize({ includeToken }?: {
-        includeToken?: boolean;
-    }): any;
+    static deleteByUser(user: User, { refresh }?: {
+        refresh?: boolean | string;
+    }): Promise<void>;
 }
-import BaseModel = require("./baseModel");
+export = ApiKey;