kuzzle 2.16.7 → 2.16.11

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

@@ -0,0 +1,195 @@
+import { JSONObject } from '../../../index';
+export declare type ServerConfiguration = {
+    /**
+     * The maximum size of an incoming request.
+     *
+     * Units can be expressed in bytes ("b" or none), kilobytes ("kb"),
+     * megabytes ("mb"), gigabytes ("gb") or terabytes ("tb").
+     *
+     * @default "1mb"
+     */
+    maxRequestSize: string;
+    /**
+    * The listening port for HTTP and WebSocket protocols.
+    *
+    * @default 7512
+    */
+    port: number;
+    /**
+    * Configuration section for Kuzzle access logs.
+    */
+    logs: {
+        /**
+        * An array of Winston transports configurations to output access
+        * logs.
+        *
+        * Possible transport types are: console, file, elasticsearch and syslog.
+        *
+        * Please refer to https://github.com/winstonjs/winston/blob/master/docs/transports.md
+        * for more information on transports configuration.
+        *
+        * @default
+        *
+        * [
+            {
+              transport: 'console',
+              level: 'info',
+              stderrLevels: [],
+              silent: true
+            }
+          ]
+        *
+        */
+        transports: JSONObject[];
+        /**
+        * Access log format.
+        *
+        * Currently supported are "combined" (=Apache combined logs format)
+        * and "logstash".
+        *
+        * "logstash" will output the whole request input to JSON, ready to
+        * be consumed by logstash agent.
+        *
+        * @default "combined"
+        */
+        accessLogFormat: 'combined' | 'logstash';
+        /**
+        * The offset to use as the client ip, from the FORWARDED-FOR chain,
+        * beginning from the right (0 = the ip address of the last
+        * client|proxy which connected to Kuzzle.
+        *
+        * @default 0
+        */
+        accessLogIpOffset: number;
+    };
+    /**
+    * protocols accepted by Kuzzle.
+    * protocols can be extended and configured in this section.
+    */
+    protocols: {
+        http: {
+            /**
+            * Enable support for compressed requests, using the Content-Encoding header
+            * Currently supported compression algorithms:  gzip, deflate, identity
+            * Note: "identity" is always an accepted value, even if compression support is disabled
+            *
+            * @default true
+            */
+            allowCompression: boolean;
+            /**
+             * Set to "false" to disable HTTP support
+             *
+             * @default true
+             */
+            enabled: boolean;
+            /**
+             * Maximum number of encoding layers that can be applied to an http message, using the Content-Encoding header.
+             * This parameter is meant to prevent abuses by setting an abnormally large number
+             * of encodings, forcing Kuzzle to  allocate as many decoders to handle the incoming request.
+             *
+             * @default 3
+             */
+            maxEncodingLayers: number;
+            /**
+             * Maximum size of requests sent via http forms
+             *
+             * @default "1MB"
+             */
+            maxFormFileSize: string;
+        };
+        mqtt: {
+            /**
+            * Set to true to enable MQTT support
+            *
+            * @default false
+            */
+            enabled: boolean;
+            /**
+            * Allow MQTT pub/sub capabilities or restrict to Kuzzle requests only
+            *
+            * @default false
+            */
+            allowPubSub: boolean;
+            /**
+             * Switches responseTopic back to a regular public topic
+             *
+             * @default false
+             */
+            developmentMode: boolean;
+            /**
+             * Delay in ms to apply between a disconnection notification is
+             * received and the connection is actually removed
+             *
+             * @default 250
+             */
+            disconnectDelay: number;
+            /**
+             * Name of the topic listened by the plugin for requests
+             *
+             * @default 'Kuzzle/request'
+             */
+            requestTopic: string;
+            /**
+             * Name of the topic clients should listen to get requests result
+             *
+             * @default 'Kuzzle/response'
+             */
+            responseTopic: string;
+            /**
+            * Constructor options passed to underlying MQTT server.
+            * See aedes documentation for further reference: https://github.com/moscajs/aedes
+            */
+            server: {
+                /**
+                 * @default 1883
+                 */
+                port: number;
+            };
+            /**
+             * Set to "true" to enable realtime notifications like "TokenExpired" notifications
+             *
+             * @default true
+             */
+            realtimeNotifications: boolean;
+        };
+        websocket: {
+            /**
+             * Set to true to enable WebSocket support
+             *
+             * @default true
+             */
+            enabled: boolean;
+            /**
+            * The maximum time (in milliseconds) without sending or receiving a message from a client.
+            * Once reached, the client's socket is forcibly closed.
+            * If a client socket is inactive for too long, the server will send a PING request before closing the socket.
+            * Minimum value: 1000 (but it's strongly advised to not set a value this low to forcibly close idle client sockets)
+            *
+            * @default 60000
+            */
+            idleTimeout: number;
+            /**
+             * Enable/Disable per message compression
+             *
+             * @default false
+             */
+            compression: boolean;
+            /**
+            * The maximum number of messages per second a single socket can
+            * submit to the server.
+            * @default 0
+            */
+            rateLimit: number;
+            /**
+             * Set to "true" to enable realtime notifications like "TokenExpired" notifications
+             *
+             * @default true
+             */
+            realtimeNotifications: boolean;
+        };
+    };
+    /**
+     * @default true
+     */
+    strictSdkVersion: boolean;
+};

package/lib/types/config/ServerConfiguration.js

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

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