kuzzle 2.16.4 → 2.16.8

package/lib/types/config/ServicesConfiguration.d.ts

@@ -0,0 +1,41 @@
+import { PublicCacheRedisConfiguration, InternalCacheConfiguration, StorageServiceElasticsearch } from '../index';
+export declare type ServicesConfiguration = {
+    common: {
+        /**
+         * Time in ms after which a service is considered failing if
+         * it has not init.
+         *
+         * @default 120000
+         */
+        defaultInitTimeout: number;
+        /**
+         * Default interval in ms between Kuzzle tries to init
+         * the service again on first failure.
+         *
+         * @default 1000
+         */
+        retryInterval: number;
+    };
+    /**
+     * The database engine used for Kuzzle internal index
+     */
+    internalCache: InternalCacheConfiguration;
+    memoryStorage: PublicCacheRedisConfiguration;
+    /**
+     * The database engine used for Kuzzle internal index
+    */
+    internalIndex: {
+        /**
+         * Maximum amount of time (in milliseconds)
+         * to wait for a concurrent database bootstrap
+         *
+         * @default 60000
+         */
+        bootstrapLockTimeout: number;
+    };
+    /**
+     * The default storage layer is Elasticsearch and it is
+     * currently the only storage layer we support.
+     */
+    storageEngine: StorageServiceElasticsearch;
+};

package/lib/types/config/ServicesConfiguration.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ServicesConfiguration.js.map

package/lib/types/config/StorageService/StorageServiceElasticsearchConfiguration.d.ts

@@ -0,0 +1,217 @@
+import { JSONObject } from '../../../../index';
+export declare type StorageServiceElasticsearch = {
+    /**
+     * @default ['storageEngine']
+    */
+    aliases: string[];
+    /**
+     * @default "elasticsearch"
+    */
+    backend: 'elasticsearch';
+    /**
+     * Elasticsearch constructor options. Use this field to specify your
+     * Elasticsearch config options, this object is passed through to the
+     * Elasticsearch constructor and can contain all options/keys outlined here:
+     * @see https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/client-configuration.html
+     *
+    */
+    client: JSONObject;
+    /**
+     * Default policy against new fields that are not referenced in the
+     * collection mapping.
+     * The value of this configuration will change Elasticsearch behavior
+     * on fields that are not declared in the collection mapping.
+     *   - "true": Stores document and update the collection mapping with
+     *     inferred type
+     *   - "false": Stores document and does not update the collection
+     *     mapping (field are not indexed)
+     *   - "strict": Rejects document
+     * @see https://www.elastic.co/guide/en/elasticsearch/reference/7.4/dynamic-mapping.html
+     */
+    commonMapping: {
+        /**
+         * @default "false"
+        */
+        dynamic: 'true' | 'false' | 'strict';
+        properties: {
+            _kuzzle_info: {
+                properties: {
+                    /**
+                     * @default
+                     *
+                     * [
+                     *   {
+                     *     type: 'keyword',
+                     *   }
+                     * ]
+                     */
+                    author: {
+                        type: string;
+                    };
+                    /**
+                     * @default
+                     *
+                     * [
+                     *   {
+                     *     type: 'date',
+                     *   }
+                     * ]
+                     */
+                    createdAt: {
+                        type: string;
+                    };
+                    /**
+                   * @default
+                   *
+                   * [
+                   *   {
+                   *     type: 'keyword',
+                   *   }
+                   * ]
+                   */
+                    updater: {
+                        type: string;
+                    };
+                    /**
+                   * @default
+                   *
+                   * [
+                   *   {
+                   *     type: 'date',
+                   *   }
+                   * ]
+                   */
+                    updatedAt: {
+                        type: string;
+                    };
+                };
+            };
+        };
+    };
+    internalIndex: {
+        /**
+        * @default "kuzzle"
+        */
+        name: string;
+        collections: {
+            users: {
+                /**
+                * @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';
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+            roles: {
+                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>;
+                    };
+                };
+            };
+            config: {
+                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';
+                    };
+                };
+            };
+            installations: {
+                dynamic: 'strict';
+                properties: {
+                    description: {
+                        type: 'text';
+                    };
+                    handler: {
+                        type: 'text';
+                    };
+                    installedAt: {
+                        type: 'date';
+                    };
+                };
+            };
+        };
+    };
+    maxScrollDuration: '1m';
+    defaults: {
+        onUpdateConflictRetries: 0;
+        scrollTTL: '15s';
+    };
+};

package/lib/types/config/StorageService/StorageServiceElasticsearchConfiguration.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=StorageServiceElasticsearchConfiguration.js.map

package/lib/types/config/internalCache/InternalCacheRedisConfiguration.d.ts

@@ -0,0 +1,111 @@
+export declare type InternalCacheConfiguration = {
+    /**
+     * The cache service relies on Redis sample settings for Redis service (see also https://github.com/luin/ioredis)
+     *
+     * 1. using a single Redis database:
+     *  * node:
+     *    * host:
+     *        The host on which Redis can be reached.
+     *        Can take an IP address, an URI or a hostname
+     *    * port:
+     *        The port on which Redis is running its database:
+     *          * (optional, deprecated) database:
+     *        ID of the redis database (default: 0)
+     *        NOTE: this option is deprecated and will be removed in Kuzzle v3.
+     *        Use 'options.db' instead. If both options are set, then
+     *        "options.db" will take precedence.
+     *  * (optional) options:
+     *    Redis specific options compatible with IORedis.
+     *    See Redis client constructor available options:
+     *    https://github.com/luin/ioredis/blob/master/API.md#new-redisport-host-options
+     *
+     * 2. using a master/slaves Redis instance with Redis sentinels
+     *   (cf. http://redis.io/topics/sentinel):
+     *  * node:
+     *    * sentinels:
+     *        array of sentinels instances:
+     *          * host:
+     *              Host name/address of the sentinel server
+     *              Can be an IP address, an URI or a hostname
+     *          * port:
+     *              Network port opened by Redis on the sentinel server
+     *    * name:
+     *        Group of Redis instances composed of a master and one
+     *        or more slaves
+     *    * (optional, deprecated) database:
+     *        ID of the redis database (default: 0)
+     *        NOTE: this option is deprecated and will be removed in Kuzzle v3.
+     *              Use 'options.db' instead. If both options are set, then
+     *              "options.db" will take precedence.
+     *  * (optional) options:
+     *      Redis specific options compatible with IORedis.
+     *      See Redis client constructor available options:
+     *      https://github.com/luin/ioredis/blob/master/API.md#redis--eventemitter
+     *
+     * 3. using a redis cluster (cf. http://redis.io/topics/cluster-spec):
+     *   * nodes: array of master nodes of the cluster
+     *     * host:
+     *         Host name/address of a redis cluster node
+     *         Can be an IP address, an URI or a hostname
+     *     * port:
+     *        Network port opened by the redis cluster node
+     *   * (optional, deprecated) database:
+     *       ID of the redis database (default: 0)
+     *       NOTE: this option is deprecated and will be removed in Kuzzle v3.
+     *             Use 'options.db' instead. If both options are set, then
+     *             "options.db" will take precedence.
+     *   * (optional) options:
+     *       Redis specific options compatible with IORedis.
+     *       See Redis client constructor available options:
+     *       https://github.com/luin/ioredis/blob/master/API.md#new-redisport-host-options
+     *   * (optional) clusterOptions:
+     *       Redis Cluster specific options compatible with IORedis.
+     *       See Redis Cluster client constructor available options:
+     *       https://github.com/luin/ioredis/blob/master/API.md#new-clusterstartupnodes-options
+     *   * (optional) overrideDnsLookup:
+     *       Only available when using a Redis Cluster config.
+     *       Use with caution: if set to true, it makes Kuzzle skip DNS validation for TLS certificates
+     *       This is the only way to connect to an AWS Elasticache Cluster with TLS encryption.
+     *       See: https://github.com/luin/ioredis#special-note-aws-elasticache-clusters-with-tls
+     */
+    /**
+     * @default 'redis'
+    */
+    backend: 'redis';
+    clusterOptions: {
+        /**
+         * @default true
+         */
+        enableReadyCheck: boolean;
+    };
+    /**
+     * @default 0
+    */
+    database: number;
+    node: {
+        /**
+         * @default "localhost"
+         */
+        host: string;
+        /**
+         * @default 6379
+         */
+        port: number;
+    };
+    /**
+     * * (optional) options:
+     *    Redis specific options compatible with IORedis.
+     *    See Redis client constructor available options:
+     *    https://github.com/luin/ioredis/blob/master/API.md#new-redisport-host-options
+     *
+    */
+    options?: Record<string, unknown>;
+    /**
+    * Only available when using a Redis Cluster config.
+    * Use with caution: if set to true, it makes Kuzzle skip DNS validation for TLS certificates
+    * This is the only way to connect to an AWS Elasticache Cluster with TLS encryption.
+    *  See: https://github.com/luin/ioredis#special-note-aws-elasticache-clusters-with-tls
+    * @default false
+    */
+    overrideDnsLookup: boolean;
+};

package/lib/types/config/internalCache/InternalCacheRedisConfiguration.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=InternalCacheRedisConfiguration.js.map

package/lib/types/config/publicCache/PublicCacheRedisConfiguration.d.ts

@@ -0,0 +1,31 @@
+export declare type PublicCacheRedisConfiguration = {
+    /**
+     * @default 'redis'
+     */
+    backend: 'redis';
+    clusterOptions: {
+        /**
+         * @default true
+         */
+        enableReadyCheck: boolean;
+    };
+    /**
+    * @default 5
+    */
+    database: number;
+    node: {
+        /**
+         * @default 'localhost'
+         */
+        host: string;
+        /**
+         * @default 6379
+         */
+        port: number;
+    };
+    options?: Record<string, unknown>;
+    /**
+     * @default false
+     */
+    overrideDnsLookup: boolean;
+};

package/lib/types/config/publicCache/PublicCacheRedisConfiguration.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=PublicCacheRedisConfiguration.js.map

package/lib/types/index.d.ts

@@ -8,7 +8,24 @@ export * from './EventHandler';
 export * from './User';
 export * from './Token';
 export * from './Global';
+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/StorageService/StorageServiceElasticsearchConfiguration';
+export * from './config/DumpConfiguration';

package/lib/types/index.js

@@ -40,8 +40,25 @@ __exportStar(require("./EventHandler"), exports);
 __exportStar(require("./User"), exports);
 __exportStar(require("./Token"), exports);
 __exportStar(require("./Global"), exports);
+__exportStar(require("./PasswordPolicy"), exports);
+__exportStar(require("./config/KuzzleConfiguration"), exports);
+__exportStar(require("./config/ServerConfiguration"), exports);
+__exportStar(require("./config/ServicesConfiguration"), exports);
+__exportStar(require("./config/SecurityConfiguration"), exports);
+__exportStar(require("./config/HttpConfiguration"), exports);
+__exportStar(require("./config/PluginsConfiguration"), exports);
+__exportStar(require("./RoleDefinition"), exports);
+__exportStar(require("./ProfileDefinition"), exports);
+__exportStar(require("./Plugin"), exports);
+__exportStar(require("./config/LimitsConfiguration"), exports);
+__exportStar(require("./RoleDefinition"), exports);
+__exportStar(require("./ProfileDefinition"), exports);
 __exportStar(require("./realtime/RealtimeScope"), exports);
 __exportStar(require("./realtime/RealtimeUsers"), exports);
 __exportStar(require("./realtime/RoomList"), exports);
 __exportStar(require("./KuzzleDocument"), exports);
+__exportStar(require("./config/publicCache/PublicCacheRedisConfiguration"), exports);
+__exportStar(require("./config/internalCache/InternalCacheRedisConfiguration"), exports);
+__exportStar(require("./config/StorageService/StorageServiceElasticsearchConfiguration"), exports);
+__exportStar(require("./config/DumpConfiguration"), exports);
 //# sourceMappingURL=index.js.map

package/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "kuzzle",
-  "version": "2.16.4",
+  "version": "2.16.8",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kuzzle",
   "author": "The Kuzzle Team <support@kuzzle.io>",
-  "version": "2.16.4",
+  "version": "2.16.8",
   "description": "Kuzzle is an open-source solution that handles all the data management through a secured API, with a large choice of protocols.",
   "bin": {
     "kuzzle": "bin/start-kuzzle-server"