kuzzle 2.56.0 → 2.57.0-beta.2

package/dist/lib/core/shared/ObjectRepository.d.ts

@@ -1,18 +1,59 @@
-import { JSONObject } from "kuzzle-sdk";
+import type { JSONObject } from "../../types/JSONObject";
 import { cacheDbEnum } from "../cache/cacheDbEnum";
+/**
+ * What `formatSearchResults` builds out of a raw store answer, and what
+ * `truncate`'s recursion reads back.
+ */
+export interface RepositorySearchResult<TObject> {
+    aggregations?: JSONObject;
+    hits: TObject[];
+    scrollId?: string;
+    total: number;
+}
+/**
+ * What `search` and `scroll` are declared to answer: v2.56.0's shape, kept
+ * for compatibility — what they build is a {@link RepositorySearchResult},
+ * but typed members break code compiled against this one (reading
+ * `aggregations.x` under `strict`, assigning `hits` to its own type). Read
+ * the answer into a `RepositorySearchResult<T>` to get the types back.
+ */
+export type ObjectRepositorySearchAnswer = {
+    aggregations?: any;
+    hits: any[];
+    scrollId: any;
+    total: any;
+};
+/**
+ * `_id` is nullable because the models are: `User`, `Profile` and `Token` are
+ * all constructed empty and get their id on the way out of the store
+ * (ADR-0001, TD-62). The repository only ever reads it off an object it
+ * loaded, which has one.
+ */
 export declare class ObjectRepository<TObject extends {
-    _id: string;
+    _id: string | null;
 }> {
     protected ttl: number;
     protected index: string;
+    /**
+     * Set by every subclass's own constructor — the `= null` this used to carry
+     * was never read (ADR-0001, TD-62).
+     */
     protected collection: string;
     protected ObjectConstructor: any;
     protected store: any;
     protected cacheDb: cacheDbEnum;
-    constructor({ cache, store }?: {
+    /**
+     * `store` is declared `unknown`, as v2.56.0's `any` accepted anything; only
+     * its `index` is read here.
+     */
+    constructor(options?: {
         cache?: cacheDbEnum;
-        store?: any;
+        store?: unknown;
     });
+    /**
+     * Resolves `null` when the document does not carry an `_id` — declared
+     * `Promise<TObject>` all the same: see `load()`.
+     */
     loadOneFromDatabase(id: string): Promise<TObject>;
     loadMultiFromDatabase(ids: string[]): Promise<TObject[]>;
     /**
@@ -21,22 +62,16 @@ export declare class ObjectRepository<TObject extends {
      * @param {object} searchBody
      * @param {object} [options] - optional search arguments (from, size, scroll)
      * @returns {Promise}
+     *
+     * The public signature is v2.56.0's — see {@link ObjectRepositorySearchAnswer}.
      */
-    search(searchBody: any, options?: {}): Promise<{
-        aggregations: any;
-        hits: any[];
-        scrollId: any;
-        total: any;
-    }>;
+    search(searchBody: unknown, options?: unknown): Promise<ObjectRepositorySearchAnswer>;
     /**
      * Scroll over a paginated search request
+     *
+     * The public signature is v2.56.0's — see {@link ObjectRepositorySearchAnswer}.
      */
-    scroll(scrollId: string, ttl?: string | number): Promise<{
-        aggregations: any;
-        hits: any[];
-        scrollId: any;
-        total: any;
-    }>;
+    scroll(scrollId: string, ttl?: string | number): Promise<ObjectRepositorySearchAnswer>;
     /**
      * Loads an object from Cache. Returns a promise that resolves either to the
      * retrieved object of null in case it is not found.
@@ -56,6 +91,13 @@ export declare class ObjectRepository<TObject extends {
      * Returns a promise that resolves either to the
      * retrieved object of null in case it is not found.
      *
+     * All three of `load`, `loadFromCache` and `loadOneFromDatabase` have
+     * always had a `return null` path, and are declared `Promise<TObject>` all
+     * the same (the `null!`s): that is what v2.56.0 declared, and plugins and
+     * applications subclass this — `(await this.load(id)).name` compiled
+     * against it under `strict`. Stating the `| null` (ADR-0001, TD-40, #2727)
+     * broke them; a caller that can meet the `null` checks for it.
+     *
      * If the object is not found in Cache and found in the Database,
      * it will be written to cache also.
      *
@@ -134,12 +176,30 @@ export declare class ObjectRepository<TObject extends {
     /**
      * Serializes the object before being persisted to the database.
      *
+     * v2.56.0 declared it `Omit<TObject, "_id">`, which subclasses do not
+     * honour (RoleRepository also drops `restrictedTo`), and which code
+     * compiled against it assigns to or overrides with. Only `any` accepts both
+     * that and the `JSONObject` Kuzzle's own subclasses answer.
+     *
      * @param object - The object to serialize
      */
-    serializeToDatabase(object: TObject): Omit<TObject, "_id">;
+    serializeToDatabase(object: TObject): any;
     /**
      * @param {string} id
      */
+    /**
+     * The id of an object being written, removed or expired.
+     *
+     * A model carries `null` until it has been stored (ADR-0001, TD-62), and
+     * every path that calls this already holds one that has. Building a cache
+     * key out of a `null` would silently address `repos/<index>/<collection>/null`,
+     * which is the failure this replaces.
+     *
+     * @throws {PreconditionError} when the object has no id
+     */
+    protected idOf(object: {
+        _id: string | null;
+    }): string;
     getCacheKey(id: string): string;
     /**
      * @param {object} dto
@@ -157,8 +217,10 @@ export declare class ObjectRepository<TObject extends {
      * @param {object} options - ES options (refresh)
      * @param {object} part
      * @returns {Promise<integer>} total deleted objects
+     *
+     * The public signature is v2.56.0's: untyped options, an `any` answer.
      */
-    truncate(options: any): Promise<any>;
+    truncate(options: unknown): Promise<any>;
     /**
      * Do not override this: this function calls itself.
      */

package/dist/lib/core/shared/ObjectRepository.js

@@ -46,22 +46,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectRepository = void 0;
 const kerror = __importStar(require("../../kerror"));
 const cacheDbEnum_1 = require("../cache/cacheDbEnum");
+/**
+ * `_id` is nullable because the models are: `User`, `Profile` and `Token` are
+ * all constructed empty and get their id on the way out of the store
+ * (ADR-0001, TD-62). The repository only ever reads it off an object it
+ * loaded, which has one.
+ */
 class ObjectRepository {
-    constructor({ cache = cacheDbEnum_1.cacheDbEnum.INTERNAL, store = null } = {}) {
+    constructor({ cache = cacheDbEnum_1.cacheDbEnum.INTERNAL, store = null, } = {}) {
         this.ttl = global.kuzzle.config.repositories.common.cacheTTL;
-        this.collection = null;
         this.ObjectConstructor = null;
         this.store = store;
         this.index = store ? store.index : global.kuzzle.internalIndex.index;
         this.cacheDb = cache;
     }
+    /**
+     * Resolves `null` when the document does not carry an `_id` — declared
+     * `Promise<TObject>` all the same: see `load()`.
+     */
     async loadOneFromDatabase(id) {
         let response;
         try {
             response = await this.store.get(this.collection, id);
         }
         catch (error) {
-            if (error.status === 404) {
+            if (error instanceof Error && "status" in error && error.status === 404) {
                 throw kerror.get("services", "storage", "not_found", id);
             }
             throw error;
@@ -93,20 +102,10 @@ class ObjectRepository {
         const objects = await Promise.all(promises);
         return objects;
     }
-    /**
-     * Search in database corresponding repository according to a query
-     *
-     * @param {object} searchBody
-     * @param {object} [options] - optional search arguments (from, size, scroll)
-     * @returns {Promise}
-     */
     async search(searchBody, options = {}) {
         const response = await this.store.search(this.collection, searchBody, options);
         return this.formatSearchResults(response);
     }
-    /**
-     * Scroll over a paginated search request
-     */
     async scroll(scrollId, ttl) {
         const response = await this.store.scroll(scrollId, ttl);
         return this.formatSearchResults(response);
@@ -133,7 +132,7 @@ class ObjectRepository {
             return await this.fromDTO({ ...JSON.parse(response) });
         }
         catch (err) {
-            throw kerror.get("services", "cache", "read_failed", err.message);
+            throw kerror.get("services", "cache", "read_failed", err instanceof Error ? err.message : String(err));
         }
     }
     /**
@@ -141,6 +140,13 @@ class ObjectRepository {
      * Returns a promise that resolves either to the
      * retrieved object of null in case it is not found.
      *
+     * All three of `load`, `loadFromCache` and `loadOneFromDatabase` have
+     * always had a `return null` path, and are declared `Promise<TObject>` all
+     * the same (the `null!`s): that is what v2.56.0 declared, and plugins and
+     * applications subclass this — `(await this.load(id)).name` compiled
+     * against it under `strict`. Stating the `| null` (ADR-0001, TD-40, #2727)
+     * broke them; a caller that can meet the `null` checks for it.
+     *
      * If the object is not found in Cache and found in the Database,
      * it will be written to cache also.
      *
@@ -193,10 +199,10 @@ class ObjectRepository {
     async delete(object, options = {}) {
         const promises = [];
         if (this.cacheDb !== cacheDbEnum_1.cacheDbEnum.NONE) {
-            promises.push(this.deleteFromCache(object._id, options));
+            promises.push(this.deleteFromCache(this.idOf(object), options));
         }
         if (this.store) {
-            promises.push(this.deleteFromDatabase(object._id, options));
+            promises.push(this.deleteFromDatabase(this.idOf(object), options));
         }
         await Promise.all(promises);
     }
@@ -214,7 +220,7 @@ class ObjectRepository {
      * @param options.ttl - if provided, overrides the default ttl set on the repository for the current operation
      */
     async persistToCache(object, options = {}) {
-        const key = options.key || this.getCacheKey(object._id);
+        const key = options.key || this.getCacheKey(this.idOf(object));
         const value = JSON.stringify(this.serializeToCache(object));
         const ttl = options.ttl ?? this.ttl;
         await global.kuzzle.ask(`core:cache:${this.cacheDb}:store`, key, value, {
@@ -261,7 +267,7 @@ class ObjectRepository {
      * @param options.key - if provided, stores the object to the given key instead of the default one (<collection>/<id>)
      */
     async expireFromCache(object, options = {}) {
-        const key = options.key || this.getCacheKey(object._id);
+        const key = options.key || this.getCacheKey(this.idOf(object));
         await global.kuzzle.ask(`core:cache:${this.cacheDb}:expire`, key, -1);
     }
     /**
@@ -275,8 +281,14 @@ class ObjectRepository {
     /**
      * Serializes the object before being persisted to the database.
      *
+     * v2.56.0 declared it `Omit<TObject, "_id">`, which subclasses do not
+     * honour (RoleRepository also drops `restrictedTo`), and which code
+     * compiled against it assigns to or overrides with. Only `any` accepts both
+     * that and the `JSONObject` Kuzzle's own subclasses answer.
+     *
      * @param object - The object to serialize
      */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- v2.56.0's public type, kept for compatibility
     serializeToDatabase(object) {
         const dto = this.toDTO(object);
         delete dto._id;
@@ -285,6 +297,22 @@ class ObjectRepository {
     /**
      * @param {string} id
      */
+    /**
+     * The id of an object being written, removed or expired.
+     *
+     * A model carries `null` until it has been stored (ADR-0001, TD-62), and
+     * every path that calls this already holds one that has. Building a cache
+     * key out of a `null` would silently address `repos/<index>/<collection>/null`,
+     * which is the failure this replaces.
+     *
+     * @throws {PreconditionError} when the object has no id
+     */
+    idOf(object) {
+        if (object._id === null) {
+            throw kerror.get("services", "storage", "missing_argument", "_id");
+        }
+        return object._id;
+    }
     getCacheKey(id) {
         return `repos/${this.index}/${this.collection}/${id}`;
     }
@@ -304,13 +332,6 @@ class ObjectRepository {
     toDTO(o) {
         return { ...o };
     }
-    /**
-     * Recursively delete all objects in repository with a scroll
-     *
-     * @param {object} options - ES options (refresh)
-     * @param {object} part
-     * @returns {Promise<integer>} total deleted objects
-     */
     async truncate(options) {
         // Allows safe overrides, as _truncate is called recursively
         return this._truncate(options);
@@ -322,7 +343,10 @@ class ObjectRepository {
         if (part === null) {
             const objects = await this.search({}, { refresh: options.refresh, scroll: "5s", size: 100 });
             const deleted = await this.truncatePart(objects, options);
-            if (objects.hits.length < objects.total) {
+            // A page that holds back hits always answers a scroll id; without one
+            // there is no next page to walk, and calling `scroll(undefined)` is how
+            // that used to be discovered.
+            if (objects.hits.length < objects.total && objects.scrollId) {
                 const total = await this._truncate(options, {
                     fetched: objects.hits.length,
                     scrollId: objects.scrollId,
@@ -335,7 +359,7 @@ class ObjectRepository {
         const objects = await this.scroll(part.scrollId, "5s");
         const deleted = await this.truncatePart(objects, options);
         part.fetched += objects.hits.length;
-        if (part.fetched < part.total) {
+        if (part.fetched < part.total && objects.scrollId) {
             part.scrollId = objects.scrollId;
             const total = await this._truncate(options, part);
             return deleted + total;
@@ -355,10 +379,14 @@ class ObjectRepository {
             const protectedObjects = ["profiles", "roles"].indexOf(this.collection) !== -1
                 ? ["admin", "default", "anonymous"]
                 : [];
-            if (protectedObjects.indexOf(object._id) !== -1) {
+            const id = this.idOf(object);
+            if (protectedObjects.includes(id)) {
+                return 0;
+            }
+            const loaded = await this.load(id);
+            if (loaded === null) {
                 return 0;
             }
-            const loaded = await this.load(object._id);
             await this.delete(loaded, options);
             return 1;
         };

package/dist/lib/core/shared/abstractManifest.d.ts

@@ -1,4 +1,5 @@
-export = AbstractManifest;
+import type { JSONObject } from "../../types/JSONObject";
+import "../../types/Global";
 /**
  * Abstract class used to load a manifest.json file.
  * Used as a base for plugins and protocols.
@@ -7,13 +8,24 @@ export = AbstractManifest;
  * @param {string} pluginPath   - Absolute path to the plugin directory
  */
 declare class AbstractManifest {
-    constructor(pluginPath: any);
-    path: any;
+    path: string;
     manifestPath: string;
-    name: any;
-    kuzzleVersion: any;
-    raw: any;
-    load(): void;
+    name: string | null;
+    kuzzleVersion: string | null;
+    raw: JSONObject | null;
+    constructor(pluginPath: string);
+    /**
+     * Reads and validates the manifest, and answers the two fields it
+     * establishes.
+     *
+     * Returning them is what lets a caller use them as strings: the fields stay
+     * nullable because they are null until this runs, and `plugin.ts` reads
+     * them through `?.` for exactly that reason.
+     */
+    load(): {
+        kuzzleVersion: string;
+        name: string;
+    };
     /**
      * This object can be stringified and exported, most notably by the
      * server:info API action
@@ -23,5 +35,6 @@ declare class AbstractManifest {
      *
      * @returns {Object}
      */
-    toJSON(): any;
+    toJSON(): JSONObject;
 }
+export = AbstractManifest;

package/dist/lib/core/shared/abstractManifest.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,11 +19,35 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const _ = require("lodash");
-const path = require("path");
-const semver = require("semver");
-const kerror = require("../../kerror").wrap("plugin", "manifest");
+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 lodash_1 = require("lodash");
+const path = __importStar(require("node:path"));
+const semver = __importStar(require("semver"));
+const kerror_1 = require("../../kerror");
+require("../../types/Global");
+const kerror = (0, kerror_1.wrap)("plugin", "manifest");
 /**
  * Abstract class used to load a manifest.json file.
  * Used as a base for plugins and protocols.
@@ -38,31 +63,46 @@ class AbstractManifest {
         this.kuzzleVersion = null;
         this.raw = null;
     }
+    /**
+     * Reads and validates the manifest, and answers the two fields it
+     * establishes.
+     *
+     * Returning them is what lets a caller use them as strings: the fields stay
+     * nullable because they are null until this runs, and `plugin.ts` reads
+     * them through `?.` for exactly that reason.
+     */
     load() {
+        // Read into a local: `this.raw` is the nullable field, and the six checks
+        // below each re-read it.
+        let raw;
         try {
-            this.raw = require(this.manifestPath);
+            // The manifest of a plugin or protocol loaded from disk: the path is
+            // only known at runtime.
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            raw = require(this.manifestPath);
         }
         catch (e) {
             throw kerror.get("cannot_load", this.manifestPath, e.message);
         }
-        if (_.isNil(this.raw.kuzzleVersion)) {
+        this.raw = raw;
+        if ((0, lodash_1.isNil)(raw.kuzzleVersion)) {
             throw kerror.get("missing_version", this.manifestPath);
         }
-        this.kuzzleVersion = this.raw.kuzzleVersion;
-        if (!semver.satisfies(global.kuzzle.config.version, this.kuzzleVersion, {
+        const kuzzleVersion = raw.kuzzleVersion;
+        this.kuzzleVersion = kuzzleVersion;
+        if (!semver.satisfies(global.kuzzle.config.version, kuzzleVersion, {
             includePrerelease: true,
         })) {
-            throw kerror.get("version_mismatch", this.path, global.kuzzle.config.version, this.kuzzleVersion);
+            throw kerror.get("version_mismatch", this.path, global.kuzzle.config.version, kuzzleVersion);
         }
-        if (!_.isNil(this.raw.name)) {
-            if (typeof this.raw.name !== "string" || this.raw.name.length === 0) {
-                throw kerror.get("invalid_name_type", this.manifestPath);
-            }
-            this.name = this.raw.name;
-        }
-        else {
+        if ((0, lodash_1.isNil)(raw.name)) {
             throw kerror.get("missing_name", this.manifestPath);
         }
+        if (typeof raw.name !== "string" || raw.name.length === 0) {
+            throw kerror.get("invalid_name_type", this.manifestPath);
+        }
+        this.name = raw.name;
+        return { kuzzleVersion, name: raw.name };
     }
     /**
      * This object can be stringified and exported, most notably by the

package/dist/lib/core/shared/sdk/embeddedSdk.d.ts

@@ -1,4 +1,6 @@
-import { RealtimeController, Notification, JSONObject, ScopeOption, UserOption, Kuzzle, ResponsePayload, BaseRequest } from "kuzzle-sdk";
+import type { RealtimeController, Notification, ScopeOption, UserOption, ResponsePayload, BaseRequest } from "kuzzle-sdk";
+import type { JSONObject } from "../../../types/JSONObject";
+import { Kuzzle } from "kuzzle-sdk";
 interface EmbeddedRealtime extends RealtimeController {
     /**
      * Subscribes by providing a set of filters: messages, document changes

package/dist/lib/core/shared/sdk/embeddedSdk.js

@@ -112,14 +112,15 @@ class EmbeddedSDK extends kuzzle_sdk_1.Kuzzle {
         if ((0, safeObject_1.isPlainObject)(request) &&
             request.controller === "realtime" &&
             request.action === "subscribe") {
-            // @ts-expect-error
-            request.propagate =
-                options.propagate === undefined || options.propagate === null
-                    ? false
-                    : options.propagate;
+            // `propagate` is not part of BaseRequest: it is a Kuzzle-internal flag
+            // read back by the realtime controller. Written with `Reflect.set`, like
+            // `__kuid__` and `__checkRights__` below, rather than suppressed.
+            Reflect.set(request, "propagate", options.propagate === undefined || options.propagate === null
+                ? false
+                : options.propagate);
         }
-        if (forbiddenEmbeddedActions[request.controller] !== undefined &&
-            forbiddenEmbeddedActions[request.controller].has(request.action)) {
+        const forbiddenActions = forbiddenEmbeddedActions[request.controller];
+        if (forbiddenActions?.has(request.action)) {
             throw kerror.get("api", "process", "forbidden_embedded_sdk_action", request.controller, request.action, ", use user impersonation or security controller instead");
         }
         const warning = lodash_1.default.get(warnEmbeddedActions, [

package/dist/lib/core/shared/sdk/funnelProtocol.d.ts

@@ -1,4 +1,5 @@
-import { KuzzleEventEmitter, RequestPayload } from "kuzzle-sdk";
+import type { RequestPayload } from "kuzzle-sdk";
+import { KuzzleEventEmitter } from "kuzzle-sdk";
 export declare class FunnelProtocol extends KuzzleEventEmitter {
     private id;
     private connectionId;

package/dist/lib/core/shared/sdk/funnelProtocol.js

@@ -68,12 +68,21 @@ class FunnelProtocol extends kuzzle_sdk_1.KuzzleEventEmitter {
      *  Hydrate the user and execute SDK query
      */
     async query(request) {
-        if (!this.connectionId) {
-            this.connectionId = await global.kuzzle.ask("core:network:internal:connectionId:get");
+        // Through a local: the field is nullable and the narrowing an `if` on it
+        // gives does not survive the `await` below.
+        let connectionId = this.connectionId;
+        if (connectionId === null) {
+            // `ask` answers `any`; `InternalProtocol` registers this one as
+            // `() => this.connection.id`, a string.
+            const id = await global.kuzzle.ask("core:network:internal:connectionId:get");
+            connectionId = id;
+            this.connectionId = id;
         }
+        // Annotated, because the initialiser alone infers `user: null` and every
+        // read below is then a read off `never`.
         const requestOptions = {
             connection: {
-                id: this.connectionId,
+                id: connectionId,
                 protocol: this.id,
             },
             user: null,

package/dist/lib/core/shared/sdk/impersonatedSdk.d.ts

@@ -1,7 +1,13 @@
-export = ImpersonatedSDK;
+import type { BaseRequest } from "kuzzle-sdk";
+import type { JSONObject } from "../../../types/JSONObject";
+import "../../../types/Global";
+interface ImpersonationOptions {
+    checkRights?: boolean;
+}
 declare class ImpersonatedSDK {
-    constructor(kuid: any, options?: {});
-    kuid: any;
-    checkRights: any;
-    query(request: any, options?: {}): Promise<import("kuzzle-sdk").ResponsePayload<import("kuzzle-sdk").JSONObject>>;
+    kuid: string;
+    checkRights: boolean;
+    constructor(kuid: string, options?: ImpersonationOptions);
+    query(request: BaseRequest, options?: JSONObject): Promise<import("kuzzle-sdk").ResponsePayload<JSONObject>>;
 }
+export = ImpersonatedSDK;

package/dist/lib/core/shared/sdk/impersonatedSdk.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,13 +19,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const nativeControllers = require("../../../api/controllers");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+// The controllers barrel ships `export = { ... }`. A NAMED import cannot
+// target that (TS2497), but a DEFAULT one can under `esModuleInterop` — and
+// unlike `import x = require(...)` it also loads under vitest, which resolves
+// `lib/` as ESM (step 07, PR G2).
+const controllers_1 = __importDefault(require("../../../api/controllers"));
+require("../../../types/Global");
 class ImpersonatedSDK {
     constructor(kuid, options = {}) {
         this.kuid = kuid;
         this.checkRights = options.checkRights || false;
-        for (const controller of Object.keys(nativeControllers)) {
+        for (const controller of Object.keys(controllers_1.default)) {
             // @todo in the future, native controller names should be normalized to sdk naming
             const controllerName = controller
                 .replace("Controller", "")
@@ -38,11 +46,14 @@ class ImpersonatedSDK {
             Reflect.defineProperty(this, controllerName, {
                 get: () => {
                     // If the requested controller has not yet been proxied
-                    if (!this[controllerProxy]) {
+                    if (!Reflect.get(this, controllerProxy)) {
                         // Create a proxy object to inject our local 'query' behaviour
                         // in the underlying base 'sdk' action methods so we can send
                         // impersonation configuration (kuid & checkRights) to the funnel
-                        this[controllerProxy] = new Proxy(global.app.sdk[controllerName], {
+                        // `Reflect.set`, not `this[controllerProxy] =`: the key is a
+                        // runtime-built string, which a plain index access cannot type.
+                        // Behaviour is identical — same receiver, same string key.
+                        Reflect.set(this, controllerProxy, new Proxy(global.app.sdk[controllerName], {
                             get: (controllerInstance, actionName) => {
                                 const customContext = {
                                     kuzzle: global.app.sdk,
@@ -63,16 +74,18 @@ class ImpersonatedSDK {
                                 // containing our 'query' method and any original local methods
                                 return controllerInstance[actionName].bind(customContext);
                             },
-                        });
+                        }));
                     }
-                    return this[controllerProxy];
+                    return Reflect.get(this, controllerProxy);
                 },
             });
         }
     }
     query(request, options = {}) {
-        request.__kuid__ = this.kuid;
-        request.__checkRights__ = this.checkRights;
+        // Both are read back by the funnel to apply the impersonation; they are
+        // not part of the SDK's declared request shape, hence the index writes.
+        Reflect.set(request, "__kuid__", this.kuid);
+        Reflect.set(request, "__checkRights__", this.checkRights);
         return global.app.sdk.query(request, options);
     }
 }