kuzzle 2.56.0 → 2.57.0-beta.2

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

@@ -1,39 +1,54 @@
-import { StoreCollectionsDefinition } from "../../types";
-import { storeScopeEnum } from "../storage/storeScopeEnum";
+import type { StoreCollectionsDefinition } from "../../types";
+import type { storeScopeEnum } from "../storage/storeScopeEnum";
+type StoreAskMethod = (...args: any[]) => Promise<any>;
 /**
  * Wrapper around the document store.
  * Once instantiated, this class can only access the index passed in the
  * constructor
  */
 export declare class Store {
-    count: (...args: any[]) => Promise<any>;
-    create: (...args: any[]) => Promise<any>;
-    createCollection: (...args: any[]) => Promise<any>;
-    createOrReplace: (...args: any[]) => Promise<any>;
-    delete: (...args: any[]) => Promise<any>;
-    deleteByQuery: (...args: any[]) => Promise<any>;
-    deleteCollection: (...args: any[]) => Promise<any>;
-    deleteFields: (...args: any[]) => Promise<any>;
-    deleteIndex: (...args: any[]) => Promise<any>;
-    exists: (...args: any[]) => Promise<any>;
-    get: (...args: any[]) => Promise<any>;
-    getMapping: (...args: any[]) => Promise<any>;
-    getSettings: (...args: any[]) => Promise<any>;
-    mExecute: (...args: any[]) => Promise<any>;
-    mGet: (...args: any[]) => Promise<any>;
-    multiSearch: (...args: any[]) => Promise<any>;
-    refreshCollection: (...args: any[]) => Promise<any>;
-    replace: (...args: any[]) => Promise<any>;
-    search: (...args: any[]) => Promise<any>;
-    scroll: (...args: any[]) => Promise<any>;
-    truncateCollection: (...args: any[]) => Promise<any>;
-    update: (...args: any[]) => Promise<any>;
-    updateByQuery: (...args: any[]) => Promise<any>;
-    updateCollection: (...args: any[]) => Promise<any>;
-    updateMapping: (...args: any[]) => Promise<any>;
+    /**
+     * Every member below up to `updateMapping` is written by the constructor
+     * through `Reflect.set` over `INDEXED_ASK_SUFFIXES`, which no annotation
+     * makes visible to the compiler — hence the definite-assignment assertions.
+     * Adding a name here without adding it there yields `undefined is not a
+     * function` at the first call, which is what the shared suffix map exists to
+     * make unlikely.
+     */
+    count: StoreAskMethod;
+    create: StoreAskMethod;
+    createCollection: StoreAskMethod;
+    createOrReplace: StoreAskMethod;
+    delete: StoreAskMethod;
+    deleteByQuery: StoreAskMethod;
+    deleteCollection: StoreAskMethod;
+    deleteFields: StoreAskMethod;
+    deleteIndex: StoreAskMethod;
+    exists: StoreAskMethod;
+    get: StoreAskMethod;
+    getMapping: StoreAskMethod;
+    getSettings: StoreAskMethod;
+    mExecute: StoreAskMethod;
+    mGet: StoreAskMethod;
+    refreshCollection: StoreAskMethod;
+    replace: StoreAskMethod;
+    search: StoreAskMethod;
+    truncateCollection: StoreAskMethod;
+    update: StoreAskMethod;
+    updateByQuery: StoreAskMethod;
+    updateCollection: StoreAskMethod;
+    updateMapping: StoreAskMethod;
+    multiSearch: StoreAskMethod;
+    scroll: StoreAskMethod;
     index: string;
     scope: storeScopeEnum;
-    private readonly logger;
+    /**
+     * `protected`, and not `readonly`: `InternalIndexHandler` has always
+     * replaced it with a child logger of its own in its constructor. The
+     * JavaScript could do that through a `private` declaration; saying so is
+     * what lets the subclass compile.
+     */
+    protected logger: import("../../kuzzle/Logger").Logger;
     constructor(index: string, scope: storeScopeEnum);
     /**
      * Initialize the index, and creates provided collections
@@ -47,6 +62,7 @@ export declare class Store {
      * @returns {Promise}
      */
     createCollections(collections: StoreCollectionsDefinition, { indexCacheOnly }?: {
-        indexCacheOnly?: boolean;
+        indexCacheOnly?: boolean | undefined;
     }): Promise<any>;
 }
+export {};

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

@@ -48,6 +48,41 @@ const kerror = __importStar(require("../../kerror"));
 const async_1 = require("../../util/async");
 const esRequest_1 = require("../../util/esRequest");
 const mutex_1 = require("../../util/mutex");
+/**
+ * The store methods that are nothing but an ask on a
+ * `core:storage:<scope>:<suffix>` event taking the index as its first
+ * argument, mapped to that suffix.
+ *
+ * The constructor's loop is driven by this map, so the 23 `core:storage:` event
+ * strings are written once rather than once per method. `multiSearch` and
+ * `scroll` are deliberately absent: they are the two that do not take the
+ * index, and the constructor assigns them by hand.
+ */
+const INDEXED_ASK_SUFFIXES = {
+    count: "document:count",
+    create: "document:create",
+    createCollection: "collection:create",
+    createOrReplace: "document:createOrReplace",
+    delete: "document:delete",
+    deleteByQuery: "document:deleteByQuery",
+    deleteCollection: "collection:delete",
+    deleteFields: "document:deleteFields",
+    deleteIndex: "index:delete",
+    exists: "document:exist",
+    get: "document:get",
+    getMapping: "mappings:get",
+    getSettings: "collection:settings:get",
+    mExecute: "document:mExecute",
+    mGet: "document:mGet",
+    refreshCollection: "collection:refresh",
+    replace: "document:replace",
+    search: "document:search",
+    truncateCollection: "collection:truncate",
+    update: "document:update",
+    updateByQuery: "document:updateByQuery",
+    updateCollection: "collection:update",
+    updateMapping: "mappings:update",
+};
 /**
  * Wrapper around the document store.
  * Once instantiated, this class can only access the index passed in the
@@ -55,36 +90,22 @@ const mutex_1 = require("../../util/mutex");
  */
 class Store {
     constructor(index, scope) {
+        /**
+         * `protected`, and not `readonly`: `InternalIndexHandler` has always
+         * replaced it with a child logger of its own in its constructor. The
+         * JavaScript could do that through a `private` declaration; saying so is
+         * what lets the subclass compile.
+         */
         this.logger = global.kuzzle.log.child("core:shared:store");
         this.index = index;
         this.scope = scope;
-        const methodsMapping = {
-            count: `core:storage:${scope}:document:count`,
-            create: `core:storage:${scope}:document:create`,
-            createCollection: `core:storage:${scope}:collection:create`,
-            createOrReplace: `core:storage:${scope}:document:createOrReplace`,
-            delete: `core:storage:${scope}:document:delete`,
-            deleteByQuery: `core:storage:${scope}:document:deleteByQuery`,
-            deleteCollection: `core:storage:${scope}:collection:delete`,
-            deleteFields: `core:storage:${scope}:document:deleteFields`,
-            deleteIndex: `core:storage:${scope}:index:delete`,
-            exists: `core:storage:${scope}:document:exist`,
-            get: `core:storage:${scope}:document:get`,
-            getMapping: `core:storage:${scope}:mappings:get`,
-            getSettings: `core:storage:${scope}:collection:settings:get`,
-            mExecute: `core:storage:${scope}:document:mExecute`,
-            mGet: `core:storage:${scope}:document:mGet`,
-            refreshCollection: `core:storage:${scope}:collection:refresh`,
-            replace: `core:storage:${scope}:document:replace`,
-            search: `core:storage:${scope}:document:search`,
-            truncateCollection: `core:storage:${scope}:collection:truncate`,
-            update: `core:storage:${scope}:document:update`,
-            updateByQuery: `core:storage:${scope}:document:updateByQuery`,
-            updateCollection: `core:storage:${scope}:collection:update`,
-            updateMapping: `core:storage:${scope}:mappings:update`,
-        };
-        for (const [method, event] of Object.entries(methodsMapping)) {
-            this[method] = (...args) => global.kuzzle.ask(event, this.index, ...args);
+        for (const [method, suffix] of Object.entries(INDEXED_ASK_SUFFIXES)) {
+            const event = `core:storage:${scope}:${suffix}`;
+            // `method` is a runtime key over the mapping above, so a plain
+            // `this[method] = ...` cannot be typed without an index signature that
+            // would swallow every real member — the trade-off TD-28 settled with
+            // `Reflect.set` in `memoryStorageController` and `baseController`.
+            Reflect.set(this, method, (...args) => global.kuzzle.ask(event, this.index, ...args));
         }
         // the scroll and multiSearch method are special: they doesn't need an index parameter
         // we keep them for ease of use

package/dist/lib/core/statistics/statistics.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { Request, RequestContext } from "../../api/request";
+import type { Request, RequestContext } from "../../api/request";
 type StatsMaps = {
     completedRequests: Map<string, number>;
     connections: Map<string, number>;

package/dist/lib/core/storage/clientAdapter.d.ts

@@ -1,29 +1,43 @@
-export = ClientAdapter;
+import type { JSONObject } from "../../types/JSONObject";
+import { Elasticsearch } from "../../service/storage/Elasticsearch";
+import { IndexCache } from "./indexCache";
+import type { storeScopeEnum } from "./storeScopeEnum";
+import "../../types/Global";
+/** Where `createIndex` / `createCollection` / `loadMappings` write, and whether
+ * the change is broadcast to the rest of the cluster. */
+interface WriteScopeOptions {
+    indexCacheOnly?: boolean;
+    propagate?: boolean;
+}
+interface LoadMappingsOptions extends WriteScopeOptions {
+    rawMappings?: boolean;
+    refresh?: boolean;
+}
+/** `{ index: { collection: payload } }`, as the fixtures and mappings
+ * import payloads are shaped. */
+type ImportPayload = Record<string, Record<string, JSONObject>>;
 /**
  * Storage client adapter to perform validation on index/collection existence
  * and to maintain the index/collection cache.
  */
 declare class ClientAdapter {
+    es: Elasticsearch;
     /**
-     * @param {storeScopeEnum} scope
+     * The version-specific ES service (ES7 or ES8). Its type is whatever
+     * `Elasticsearch` exposes — which is `any` today, and is tracked there as
+     * TD-13; referencing it rather than re-writing `any` keeps that one hole
+     * counted once, at its source.
      */
-    constructor(scope: storeScopeEnum);
-    es: Elasticsearch;
-    client: any;
+    client: Elasticsearch["client"];
     scope: storeScopeEnum;
     cache: IndexCache;
+    constructor(scope: storeScopeEnum);
     init(): Promise<void>;
-    createIndex(index: any, { indexCacheOnly, propagate }?: {
-        indexCacheOnly?: boolean;
-        propagate?: boolean;
-    }): Promise<void>;
-    createCollection(index: any, collection: any, opts: any, { indexCacheOnly, propagate }?: {
-        indexCacheOnly?: boolean;
-        propagate?: boolean;
-    }): Promise<void>;
-    deleteIndex(index: any): Promise<void>;
-    deleteIndexes(indexes: any): Promise<any>;
-    deleteCollection(index: any, collection: any): Promise<void>;
+    createIndex(index: string, { indexCacheOnly, propagate }?: WriteScopeOptions): Promise<void>;
+    createCollection(index: string, collection: string, opts: JSONObject, { indexCacheOnly, propagate }?: WriteScopeOptions): Promise<void>;
+    deleteIndex(index: string): Promise<void>;
+    deleteIndexes(indexes: string[]): Promise<string[]>;
+    deleteCollection(index: string, collection: string): Promise<void>;
     /**
      * Populates the index cache with existing index/collection.
      * Also checks for duplicated index names.
@@ -44,9 +58,9 @@ declare class ClientAdapter {
      * @param {String} fixturesId
      * @returns {Promise}
      */
-    loadFixtures(fixtures?: {}, { refresh }?: {
+    loadFixtures(fixtures?: ImportPayload, { refresh }?: {
         refresh?: string;
-    }): Promise<any>;
+    }): Promise<void>;
     /**
      * Load database mappings into Kuzzle
      *
@@ -56,7 +70,11 @@ declare class ClientAdapter {
      * - indexCacheOnly (false): only update the cache, don't update the database
      * @returns {Promise}
      */
-    loadMappings(fixtures?: {}, options?: string): Promise<any>;
+    loadMappings(fixtures?: ImportPayload, options?: LoadMappingsOptions): Promise<void>;
+    /**
+     * Creates one index/collection pair from an import payload. Extracted from
+     * `loadMappings` verbatim.
+     */
+    private _loadCollectionMappings;
 }
-import { Elasticsearch } from "../../service/storage/Elasticsearch";
-import { IndexCache } from "./indexCache";
+export = ClientAdapter;

package/dist/lib/core/storage/clientAdapter.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,26 +19,54 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const { Elasticsearch } = require("../../service/storage/Elasticsearch");
-const { IndexCache } = require("./indexCache");
-const { isPlainObject } = require("../../util/safeObject");
-const kerror = require("../../kerror");
-const { Mutex } = require("../../util/mutex");
+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 Elasticsearch_1 = require("../../service/storage/Elasticsearch");
+const indexCache_1 = require("./indexCache");
+const safeObject_1 = require("../../util/safeObject");
+const kerror = __importStar(require("../../kerror"));
+const mutex_1 = require("../../util/mutex"); // NOSONAR: see loadMappings
+require("../../types/Global");
 const servicesError = kerror.wrap("services", "storage");
+/** Hoisted out of the signature: an object literal as a default parameter is
+ * re-allocated on every call, and this one is only ever read. */
+const DEFAULT_LOAD_MAPPINGS_OPTIONS = Object.freeze({
+    indexCacheOnly: false,
+    propagate: true,
+    rawMappings: false,
+    refresh: false,
+});
 /**
  * Storage client adapter to perform validation on index/collection existence
  * and to maintain the index/collection cache.
  */
 class ClientAdapter {
-    /**
-     * @param {storeScopeEnum} scope
-     */
     constructor(scope) {
-        this.es = new Elasticsearch(global.kuzzle.config.services.storageEngine, scope);
+        this.es = new Elasticsearch_1.Elasticsearch(global.kuzzle.config.services.storageEngine, scope);
         this.client = this.es.client;
         this.scope = scope;
-        this.cache = new IndexCache();
+        this.cache = new indexCache_1.IndexCache();
     }
     async init() {
         await this.es.init();
@@ -136,6 +165,8 @@ class ClientAdapter {
         if (global.kuzzle.config.services.storageEngine.generateMissingAliases) {
             await this.client.generateMissingAliases();
         }
+        // `client` is untyped (see the field's comment), so the schema shape is
+        // stated here: index name -> its collection names.
         const schema = await this.client.getSchema();
         for (const [index, collections] of Object.entries(schema)) {
             this.cache.addIndex(index);
@@ -682,14 +713,17 @@ class ClientAdapter {
      * @returns {Promise}
      */
     async loadFixtures(fixtures = {}, { refresh = "wait_for" } = {}) {
-        if (!isPlainObject(fixtures)) {
+        if (!(0, safeObject_1.isPlainObject)(fixtures)) {
             throw kerror.get("api", "assert", "invalid_argument", fixtures, "object");
         }
-        for (const index of Object.keys(fixtures)) {
-            if (!isPlainObject(fixtures[index])) {
-                throw kerror.get("api", "assert", "invalid_argument", fixtures[index], "object");
+        // `Object.entries`, not `keys` + three indexed reads: the value comes back
+        // with the key and there is nothing left for `noUncheckedIndexedAccess` to
+        // object to.
+        for (const [index, collections] of Object.entries(fixtures)) {
+            if (!(0, safeObject_1.isPlainObject)(collections)) {
+                throw kerror.get("api", "assert", "invalid_argument", collections, "object");
             }
-            for (const [collection, payload] of Object.entries(fixtures[index])) {
+            for (const [collection, payload] of Object.entries(collections)) {
                 this.cache.assertCollectionExists(index, collection);
                 const { errors } = await this.client.import(index, collection, payload, { refresh });
                 if (errors.length > 0) {
@@ -707,43 +741,22 @@ class ClientAdapter {
      * - indexCacheOnly (false): only update the cache, don't update the database
      * @returns {Promise}
      */
-    async loadMappings(fixtures = {}, options = {
-        indexCacheOnly: false,
-        propagate: true,
-        rawMappings: false,
-        refresh: false,
-    }) {
-        if (!isPlainObject(fixtures)) {
+    async loadMappings(fixtures = {}, options = DEFAULT_LOAD_MAPPINGS_OPTIONS) {
+        if (!(0, safeObject_1.isPlainObject)(fixtures)) {
             throw kerror.get("api", "assert", "invalid_argument", fixtures, "object");
         }
-        const mutex = new Mutex("loadMappings", { timeout: -1, ttl: 60000 });
+        // NOSONAR: `Mutex` is deprecated in favour of `withLock`, but the two use
+        // incompatible acquisition/TTL formats and must not contend on the same
+        // key — swapping it is a behaviour change, deferred to #2894.
+        const mutex = new mutex_1.Mutex("loadMappings", { timeout: -1, ttl: 60000 }); // NOSONAR
         await mutex.lock();
         try {
-            for (const index of Object.keys(fixtures)) {
-                if (!isPlainObject(fixtures[index])) {
-                    throw kerror.get("api", "assert", "invalid_argument", fixtures[index], "object");
+            for (const [index, collections] of Object.entries(fixtures)) {
+                if (!(0, safeObject_1.isPlainObject)(collections)) {
+                    throw kerror.get("api", "assert", "invalid_argument", collections, "object");
                 }
-                for (const [collection, mappings] of Object.entries(fixtures[index])) {
-                    try {
-                        await this.createIndex(index, {
-                            indexCacheOnly: options.indexCacheOnly,
-                            propagate: options.propagate,
-                        });
-                    }
-                    catch (error) {
-                        // @cluster: ignore if the index already exists to prevent race
-                        // conditions with index cache propagation
-                        if (error.id !== "services.storage.index_already_exists") {
-                            throw error;
-                        }
-                    }
-                    await this.createCollection(index, collection, options.rawMappings ? { mappings } : mappings, {
-                        indexCacheOnly: options.indexCacheOnly,
-                        propagate: options.propagate,
-                    });
-                    if (options.refresh && !options.indexCacheOnly) {
-                        await this.client.refreshCollection(index, collection);
-                    }
+                for (const [collection, mappings] of Object.entries(collections)) {
+                    await this._loadCollectionMappings(index, collection, mappings, options);
                 }
             }
         }
@@ -751,6 +764,33 @@ class ClientAdapter {
             await mutex.unlock();
         }
     }
+    /**
+     * Creates one index/collection pair from an import payload. Extracted from
+     * `loadMappings` verbatim.
+     */
+    async _loadCollectionMappings(index, collection, mappings, options) {
+        try {
+            await this.createIndex(index, {
+                indexCacheOnly: options.indexCacheOnly,
+                propagate: options.propagate,
+            });
+        }
+        catch (error) {
+            // @cluster: ignore if the index already exists to prevent race
+            // conditions with index cache propagation
+            if (error.id !==
+                "services.storage.index_already_exists") {
+                throw error;
+            }
+        }
+        await this.createCollection(index, collection, options.rawMappings ? { mappings } : mappings, {
+            indexCacheOnly: options.indexCacheOnly,
+            propagate: options.propagate,
+        });
+        if (options.refresh && !options.indexCacheOnly) {
+            await this.client.refreshCollection(index, collection);
+        }
+    }
 }
 module.exports = ClientAdapter;
 //# sourceMappingURL=clientAdapter.js.map

package/dist/lib/core/storage/indexCache.d.ts

@@ -48,6 +48,14 @@ export declare class IndexCache {
      * @throws If the index does not exist
      */
     assertIndexExists(index: string): void;
+    /**
+     * Answers an index's collections, or throws if the index is not cached.
+     *
+     * One lookup for both questions: `has()` followed by `get()` left every
+     * caller holding an invariant the Map had already been asked about, one line
+     * away from the answer.
+     */
+    private getCollections;
     /**
      * Assert that the provided index and collection exist
      */

package/dist/lib/core/storage/indexCache.js

@@ -73,8 +73,7 @@ class IndexCache {
      */
     addCollection(index, collection) {
         this.addIndex(index);
-        const collections = this.indexes.get(index);
-        collections.add(collection);
+        this.getCollections(index).add(collection);
     }
     /**
      * Check an index existence
@@ -104,8 +103,7 @@ class IndexCache {
      * @throws If the provided index does not exist
      */
     listCollections(index) {
-        this.assertIndexExists(index);
-        return Array.from(this.indexes.get(index));
+        return Array.from(this.getCollections(index));
     }
     /**
      * Remove an index from the cache
@@ -128,16 +126,27 @@ class IndexCache {
      * @throws If the index does not exist
      */
     assertIndexExists(index) {
-        if (!this.indexes.has(index)) {
+        this.getCollections(index);
+    }
+    /**
+     * Answers an index's collections, or throws if the index is not cached.
+     *
+     * One lookup for both questions: `has()` followed by `get()` left every
+     * caller holding an invariant the Map had already been asked about, one line
+     * away from the answer.
+     */
+    getCollections(index) {
+        const collections = this.indexes.get(index);
+        if (collections === undefined) {
             throw storageError.get("unknown_index", index);
         }
+        return collections;
     }
     /**
      * Assert that the provided index and collection exist
      */
     assertCollectionExists(index, collection) {
-        this.assertIndexExists(index);
-        if (!this.indexes.get(index).has(collection)) {
+        if (!this.getCollections(index).has(collection)) {
             throw storageError.get("unknown_collection", index, collection);
         }
     }

package/dist/lib/core/storage/storageEngine.d.ts

@@ -1,13 +1,14 @@
-export = StorageEngine;
+import ClientAdapter from "./clientAdapter";
+import type { Logger } from "../../kuzzle/Logger";
+import "../../types/Global";
 declare class StorageEngine {
     public: ClientAdapter;
     private: ClientAdapter;
-    logger: import("../../kuzzle/Logger").Logger;
+    logger: Logger;
+    constructor();
     /**
      * Initialize storage clients and perform integrity checks
-     *
-     * @returns {Promise}
      */
-    init(): Promise<any>;
+    init(): Promise<void>;
 }
-import ClientAdapter = require("./clientAdapter");
+export = StorageEngine;

package/dist/lib/core/storage/storageEngine.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,23 +19,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-"use strict";
-const kerror = require("../../kerror").wrap("services", "storage");
-const ClientAdapter = require("./clientAdapter");
-const { storeScopeEnum } = require("./storeScopeEnum");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const kerror_1 = require("../../kerror");
+const clientAdapter_1 = __importDefault(require("./clientAdapter"));
+const storeScopeEnum_1 = require("./storeScopeEnum");
+require("../../types/Global");
+const kerror = (0, kerror_1.wrap)("services", "storage");
 class StorageEngine {
     constructor() {
         // Storage client for public indexes only
-        this.public = new ClientAdapter(storeScopeEnum.PUBLIC);
+        this.public = new clientAdapter_1.default(storeScopeEnum_1.storeScopeEnum.PUBLIC);
         // Storage client for private indexes only
-        this.private = new ClientAdapter(storeScopeEnum.PRIVATE);
+        this.private = new clientAdapter_1.default(storeScopeEnum_1.storeScopeEnum.PRIVATE);
         this.logger = global.kuzzle.log.child("core:storage:storageEngine");
         this.logger.info(`[ℹ] Elasticsearch configuration is set to major version : ${global.kuzzle.config.services.storageEngine.majorVersion}`);
     }
     /**
      * Initialize storage clients and perform integrity checks
-     *
-     * @returns {Promise}
      */
     async init() {
         await Promise.all([this.public.init(), this.private.init()]);

package/dist/lib/core/validation/baseType.d.ts

@@ -1,35 +1,35 @@
-export = BaseType;
+import type { TypeOptions } from "./typeOptions";
 /**
- * @class BaseType
+ * Base class of every validation type, and the contract `Validation.addType`
+ * checks a plugin-provided type against.
+ *
+ * @typeParam TOptions - the `typeOptions` shape this type accepts, once
+ *   `validateFieldSpecification` has run
+ * @typeParam TSpecification - the `typeOptions` shape a user writes, which
+ *   `validateFieldSpecification` checks and normalises into `TOptions`; the
+ *   same shape unless the type converts something
  */
-declare class BaseType {
+declare class BaseType<TOptions extends TypeOptions = TypeOptions, TSpecification extends TypeOptions = TOptions> {
+    /** Name under which the type is registered */
+    typeName: string;
+    /** Whether fields of that type may declare children */
+    allowChildren: boolean;
+    /** `typeOptions` properties the type recognizes */
+    allowedTypeOptions: string[];
     /**
      * Validate a document against a registered field type validator
-     *
-     * @param {TypeOptions} typeOptions
-     * @param {*} fieldValue
-     * @param {string[]} errorMessages
-     * @returns {boolean}
      */
-    validate(): boolean;
+    validate(typeOptions?: TOptions, fieldValue?: unknown, errorMessages?: string[]): boolean;
     /**
      * Validate a field specification itself
      *
-     * @param {TypeOptions} typeOptions
-     * @returns {TypeOptions}
      * @throws {KuzzleError}
      */
-    validateFieldSpecification(opts: any): TypeOptions;
+    validateFieldSpecification(opts: TSpecification): TOptions;
     /**
-     * @param {*} object
-     * @param {string[]} allowedProperties
-     * @returns {boolean}
+     * Narrows `object` to a plain object holding none but the allowed properties.
      */
-    checkAllowedProperties(object: any, allowedProperties: string[]): boolean;
-    /**
-     * @param {StructuredFieldSpecification} fieldSpec
-     * @param {boolean} parentStrictness
-     * @returns {boolean}
-     */
-    getStrictness(fieldSpec: StructuredFieldSpecification, parentStrictness: boolean): boolean;
+    checkAllowedProperties(object: unknown, allowedProperties: string[]): object is Record<string, unknown>;
+    getStrictness(fieldSpec: TOptions, parentStrictness: boolean): boolean;
 }
+export = BaseType;