kuzzle 2.19.2 → 2.19.3

package/lib/types/config/storageEngine/StorageEngineElasticsearchConfiguration.d.ts

@@ -1,13 +1,13 @@
-import { ClientOptions } from '@elastic/elasticsearch';
+import { ClientOptions } from "@elastic/elasticsearch";
 export declare type StorageEngineElasticsearch = {
     /**
      * @default ['storageEngine']
-    */
+     */
     aliases: string[];
     /**
      * @default "elasticsearch"
-    */
-    backend: 'elasticsearch';
+     */
+    backend: "elasticsearch";
     /**
      * Elasticsearch constructor options. Use this field to specify your
      * Elasticsearch config options, this object is passed through to the
@@ -21,7 +21,7 @@ export declare type StorageEngineElasticsearch = {
      *    node: 'http://localhost:9200'
      * }
      *
-    */
+     */
     client: ClientOptions;
     /**
      * Default policy against new fields that are not referenced in the
@@ -38,8 +38,8 @@ export declare type StorageEngineElasticsearch = {
     commonMapping: {
         /**
          * @default "false"
-        */
-        dynamic: 'true' | 'false' | 'strict';
+         */
+        dynamic: "true" | "false" | "strict";
         properties: {
             _kuzzle_info: {
                 properties: {
@@ -68,26 +68,26 @@ export declare type StorageEngineElasticsearch = {
                         type: string;
                     };
                     /**
-                   * @default
-                   *
-                   * [
-                   *   {
-                   *     type: 'keyword',
-                   *   }
-                   * ]
-                   */
+                     * @default
+                     *
+                     * [
+                     *   {
+                     *     type: 'keyword',
+                     *   }
+                     * ]
+                     */
                     updater: {
                         type: string;
                     };
                     /**
-                   * @default
-                   *
-                   * [
-                   *   {
-                   *     type: 'date',
-                   *   }
-                   * ]
-                   */
+                     * @default
+                     *
+                     * [
+                     *   {
+                     *     type: 'date',
+                     *   }
+                     * ]
+                     */
                     updatedAt: {
                         type: string;
                     };
@@ -97,49 +97,73 @@ export declare type StorageEngineElasticsearch = {
     };
     internalIndex: {
         /**
-        * @default "kuzzle"
-        */
+         * @default "kuzzle"
+         */
         name: string;
         collections: {
             users: {
-                /**
-                * @default 'false'
-                */
-                dynamic: 'true' | 'false' | 'strict';
-                properties: {
+                settings: {
                     /**
-                      * @default
-                      *
-                      * [
-                      *   {
-                      *     type: 'keyword',
-                      *   }
-                      * ]
-                      */
-                    profileIds: {
-                        type: string;
+                     * @default 1
+                     */
+                    number_of_shards: number;
+                    /**
+                     * @default 1
+                     */
+                    number_of_replicas: number;
+                };
+                mappings: {
+                    /**
+                     * @default 'false'
+                     */
+                    dynamic: "true" | "false" | "strict";
+                    properties: {
+                        /**
+                         * @default
+                         *
+                         * [
+                         *   {
+                         *     type: 'keyword',
+                         *   }
+                         * ]
+                         */
+                        profileIds: {
+                            type: string;
+                        };
                     };
                 };
             };
             profiles: {
-                dynamic: 'false';
-                properties: {
-                    tags: {
-                        type: 'keyword';
-                    };
-                    policies: {
-                        properties: {
-                            roleId: {
-                                type: 'keyword';
-                            };
-                            restrictedTo: {
-                                type: 'nested';
-                                properties: {
-                                    index: {
-                                        type: 'keyword';
-                                    };
-                                    collections: {
-                                        type: 'keyword';
+                settings: {
+                    /**
+                     * @default 1
+                     */
+                    number_of_shards: number;
+                    /**
+                     * @default 1
+                     */
+                    number_of_replicas: number;
+                };
+                mappings: {
+                    dynamic: "false";
+                    properties: {
+                        tags: {
+                            type: "keyword";
+                        };
+                        policies: {
+                            properties: {
+                                roleId: {
+                                    type: "keyword";
+                                };
+                                restrictedTo: {
+                                    type: "nested";
+                                    properties: {
+                                        index: {
+                                            type: "keyword";
+                                        };
+                                        collections: {
+                                            type: "keyword";
+                                        };
                                     };
                                 };
                             };
@@ -148,77 +172,137 @@ export declare type StorageEngineElasticsearch = {
                 };
             };
             roles: {
-                dynamic: 'false';
-                properties: {
-                    tags: {
-                        type: 'keyword';
-                    };
-                    controllers: {
-                        dynamic: 'false';
-                        properties: Record<string, unknown>;
+                settings: {
+                    /**
+                     * @default 1
+                     */
+                    number_of_shards: number;
+                    /**
+                     * @default 1
+                     */
+                    number_of_replicas: number;
+                };
+                mappings: {
+                    dynamic: "false";
+                    properties: {
+                        tags: {
+                            type: "keyword";
+                        };
+                        controllers: {
+                            dynamic: "false";
+                            properties: Record<string, unknown>;
+                        };
                     };
                 };
             };
             validations: {
-                properties: {
-                    index: {
-                        type: 'keyword';
-                    };
-                    collection: {
-                        type: 'keyword';
-                    };
-                    validations: {
-                        dynamic: 'false';
-                        properties: Record<string, unknown>;
+                settings: {
+                    /**
+                     * @default 1
+                     */
+                    number_of_shards: number;
+                    /**
+                     * @default 1
+                     */
+                    number_of_replicas: number;
+                };
+                mappings: {
+                    properties: {
+                        index: {
+                            type: "keyword";
+                        };
+                        collection: {
+                            type: "keyword";
+                        };
+                        validations: {
+                            dynamic: "false";
+                            properties: Record<string, unknown>;
+                        };
                     };
                 };
             };
             config: {
-                dynamic: 'false';
-                properties: Record<string, unknown>;
+                settings: {
+                    /**
+                     * @default 1
+                     */
+                    number_of_shards: number;
+                    /**
+                     * @default 1
+                     */
+                    number_of_replicas: number;
+                };
+                mappings: {
+                    dynamic: "false";
+                    properties: Record<string, unknown>;
+                };
             };
-            'api-keys': {
-                dynamic: 'false';
-                properties: {
-                    userId: {
-                        type: 'keyword';
-                    };
-                    hash: {
-                        type: 'keyword';
-                    };
-                    description: {
-                        type: 'text';
-                    };
-                    expiresAt: {
-                        type: 'long';
-                    };
-                    ttl: {
-                        type: 'keyword';
-                    };
-                    token: {
-                        type: 'keyword';
+            "api-keys": {
+                settings: {
+                    /**
+                     * @default 1
+                     */
+                    number_of_shards: number;
+                    /**
+                     * @default 1
+                     */
+                    number_of_replicas: number;
+                };
+                mappings: {
+                    dynamic: "false";
+                    properties: {
+                        userId: {
+                            type: "keyword";
+                        };
+                        hash: {
+                            type: "keyword";
+                        };
+                        description: {
+                            type: "text";
+                        };
+                        expiresAt: {
+                            type: "long";
+                        };
+                        ttl: {
+                            type: "keyword";
+                        };
+                        token: {
+                            type: "keyword";
+                        };
                     };
                 };
             };
             installations: {
-                dynamic: 'strict';
-                properties: {
-                    description: {
-                        type: 'text';
-                    };
-                    handler: {
-                        type: 'text';
-                    };
-                    installedAt: {
-                        type: 'date';
+                settings: {
+                    /**
+                     * @default 1
+                     */
+                    number_of_shards: number;
+                    /**
+                     * @default 1
+                     */
+                    number_of_replicas: number;
+                };
+                mappings: {
+                    dynamic: "strict";
+                    properties: {
+                        description: {
+                            type: "text";
+                        };
+                        handler: {
+                            type: "text";
+                        };
+                        installedAt: {
+                            type: "date";
+                        };
                     };
                 };
             };
         };
     };
-    maxScrollDuration: '1m';
+    maxScrollDuration: "1m";
     defaults: {
         onUpdateConflictRetries: 0;
-        scrollTTL: '15s';
+        scrollTTL: "15s";
     };
 };

package/lib/types/errors/ErrorDefinition.d.ts

@@ -1,7 +1,7 @@
 /**
  * Available error class
  */
-export declare type ErrorClassNames = 'BadRequestError' | 'ExternalServiceError' | 'ForbiddenError' | 'GatewayTimeoutError' | 'InternalError' | 'KuzzleError' | 'MultipleErrorsError' | 'NotFoundError' | 'PartialError' | 'PluginImplementationError' | 'ServiceUnavailableError' | 'SizeLimitError' | 'UnauthorizedError' | 'PreconditionError' | 'TooManyRequestsError';
+export declare type ErrorClassNames = "BadRequestError" | "ExternalServiceError" | "ForbiddenError" | "GatewayTimeoutError" | "InternalError" | "KuzzleError" | "MultipleErrorsError" | "NotFoundError" | "PartialError" | "PluginImplementationError" | "ServiceUnavailableError" | "SizeLimitError" | "UnauthorizedError" | "PreconditionError" | "TooManyRequestsError";
 /**
  * Represents a standardized error definition
  */

package/lib/types/errors/ErrorDomains.d.ts

@@ -1,4 +1,4 @@
-import { ErrorDefinition } from './ErrorDefinition';
+import { ErrorDefinition } from "./ErrorDefinition";
 /**
  * Represents the domains, subDomains and error names with associated definitions
  */

package/lib/types/index.d.ts

@@ -1,38 +1,38 @@
-export * from './Plugin';
-export * from './Controller';
-export * from './ControllerDefinition';
-export * from './ControllerRights';
-export * from './ResponsePayload';
-export * from './Deprecation';
-export * from './EventHandler';
-export * from './Policy';
-export * from './PolicyRestrictions';
-export * from './User';
-export * from './Token';
-export * from './Target';
-export * from './Global';
-export * from './HttpStream';
-export * from './PasswordPolicy';
-export * from './config/KuzzleConfiguration';
-export * from './config/ServerConfiguration';
-export * from './config/ServicesConfiguration';
-export * from './config/SecurityConfiguration';
-export * from './config/HttpConfiguration';
-export * from './config/PluginsConfiguration';
-export * from './RoleDefinition';
-export * from './ProfileDefinition';
-export * from './Plugin';
-export * from './config/LimitsConfiguration';
-export * from './RoleDefinition';
-export * from './ProfileDefinition';
-export * from './realtime/RealtimeScope';
-export * from './realtime/RealtimeUsers';
-export * from './realtime/RoomList';
-export * from './KuzzleDocument';
-export * from './config/publicCache/PublicCacheRedisConfiguration';
-export * from './config/internalCache/InternalCacheRedisConfiguration';
-export * from './config/storageEngine/StorageEngineElasticsearchConfiguration';
-export * from './config/DumpConfiguration';
-export * from './OpenApiDefinition';
-export * from './errors/ErrorDefinition';
-export * from './errors/ErrorDomains';
+export * from "./Plugin";
+export * from "./Controller";
+export * from "./ControllerDefinition";
+export * from "./ControllerRights";
+export * from "./ResponsePayload";
+export * from "./Deprecation";
+export * from "./EventHandler";
+export * from "./Policy";
+export * from "./PolicyRestrictions";
+export * from "./User";
+export * from "./Token";
+export * from "./Target";
+export * from "./Global";
+export * from "./HttpStream";
+export * from "./PasswordPolicy";
+export * from "./config/KuzzleConfiguration";
+export * from "./config/ServerConfiguration";
+export * from "./config/ServicesConfiguration";
+export * from "./config/SecurityConfiguration";
+export * from "./config/HttpConfiguration";
+export * from "./config/PluginsConfiguration";
+export * from "./RoleDefinition";
+export * from "./ProfileDefinition";
+export * from "./Plugin";
+export * from "./config/LimitsConfiguration";
+export * from "./RoleDefinition";
+export * from "./ProfileDefinition";
+export * from "./realtime/RealtimeScope";
+export * from "./realtime/RealtimeUsers";
+export * from "./realtime/RoomList";
+export * from "./KuzzleDocument";
+export * from "./config/publicCache/PublicCacheRedisConfiguration";
+export * from "./config/internalCache/InternalCacheRedisConfiguration";
+export * from "./config/storageEngine/StorageEngineElasticsearchConfiguration";
+export * from "./config/DumpConfiguration";
+export * from "./OpenApiDefinition";
+export * from "./errors/ErrorDefinition";
+export * from "./errors/ErrorDomains";

package/lib/types/realtime/RealtimeScope.d.ts

@@ -1,4 +1,4 @@
 /**
  * Subscribe to notification of document entering, leaving the scope or both.
  */
-export declare type RealtimeScope = 'in' | 'out' | 'all';
+export declare type RealtimeScope = "in" | "out" | "all";

package/lib/types/realtime/RealtimeUsers.d.ts

@@ -1,4 +1,4 @@
 /**
  * Subscribe to users entering or leaving the room
  */
-export declare type RealtimeUsers = 'in' | 'out' | 'all' | 'none';
+export declare type RealtimeUsers = "in" | "out" | "all" | "none";

package/lib/util/assertType.js

@@ -19,9 +19,9 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const { BadRequestError } = require('../kerror/errors');
+const { BadRequestError } = require("../kerror/errors");
 
 /**
  * Throws if the provided data is not an object.
@@ -32,12 +32,12 @@ const { BadRequestError } = require('../kerror/errors');
  * @param {*} data
  * @return {object}
  */
-function assertObject (attr, data) {
+function assertObject(attr, data) {
   if (data === null || data === undefined) {
     return null;
   }
 
-  if (typeof data !== 'object' || Array.isArray(data)) {
+  if (typeof data !== "object" || Array.isArray(data)) {
     throw new BadRequestError(`Attribute ${attr} must be of type "object"`);
   }
 
@@ -54,12 +54,12 @@ function assertObject (attr, data) {
  * @param {*} data
  * @return {array}
  */
-function assertArray (attr, data, type) {
+function assertArray(attr, data, type) {
   if (data === null || data === undefined) {
     return [];
   }
 
-  if (! Array.isArray(data)) {
+  if (!Array.isArray(data)) {
     throw new BadRequestError(`Attribute ${attr} must be of type "array"`);
   }
 
@@ -68,7 +68,9 @@ function assertArray (attr, data, type) {
   for (const d of data) {
     if (d !== undefined && d !== null) {
       if (typeof d !== type) {
-        throw new BadRequestError(`Attribute ${attr} must contain only values of type "${type}"`);
+        throw new BadRequestError(
+          `Attribute ${attr} must contain only values of type "${type}"`
+        );
       }
 
       clone.push(d);
@@ -87,12 +89,12 @@ function assertArray (attr, data, type) {
  * @param {*} data
  * @return {null|string}
  */
-function assertString (attr, data) {
+function assertString(attr, data) {
   if (data === null || data === undefined) {
     return null;
   }
 
-  if (typeof data !== 'string') {
+  if (typeof data !== "string") {
     throw new BadRequestError(`Attribute ${attr} must be of type "string"`);
   }
 
@@ -108,8 +110,8 @@ function assertString (attr, data) {
  * @param {*} data
  * @return {number}
  */
-function assertInteger (attr, data) {
-  if (! Number.isInteger(data)) {
+function assertInteger(attr, data) {
+  if (!Number.isInteger(data)) {
     throw new BadRequestError(`Attribute ${attr} must be an integer`);
   }
 

package/lib/util/async.d.ts

@@ -0,0 +1 @@
+export declare function promiseAllN<T>(collection: Array<() => Promise<T>>, n?: number): Promise<T[]>;

package/lib/util/async.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseAllN = void 0;
+/*
+ * Resolve promises with a limited concurrency number
+ *
+ * Replacement of Bluebird.map taken from :
+ * https://gist.github.com/jcouyang/632709f30e12a7879a73e9e132c0d56b
+ */
+function promiseAllN(collection, n = 100) {
+    let i = 0;
+    let jobsLeft = collection.length;
+    const outcome = [];
+    let rejected = false;
+    // create a new promise and capture reference to resolve and reject to avoid nesting of code
+    let resolve, reject;
+    const pendingPromise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    // Guard clause
+    if (collection.length === 0) {
+        return resolve([]);
+    }
+    // execute the j'th thunk
+    function runJob(j) {
+        collection[j]()
+            .then((result) => {
+            if (rejected) {
+                return; // no op!
+            }
+            jobsLeft--;
+            outcome[j] = result;
+            if (jobsLeft <= 0) {
+                resolve(outcome);
+            }
+            else if (i < collection.length) {
+                runJob(i);
+                i++;
+            }
+            else {
+                return; // nothing to do here.
+            }
+        })
+            .catch((e) => {
+            if (rejected) {
+                return; // no op!
+            }
+            rejected = true;
+            reject(e);
+        });
+    }
+    // bootstrap, while handling cases where the length of the given array is smaller than maxConcurrent jobs
+    while (i < Math.min(collection.length, n)) {
+        runJob(i);
+        i++;
+    }
+    return pendingPromise;
+}
+exports.promiseAllN = promiseAllN;
+//# sourceMappingURL=async.js.map