kuzzle 2.16.8 → 2.17.0

package/lib/types/ControllerRights.d.ts

@@ -0,0 +1,22 @@
+/** @internal */
+export declare type ControllerRight = {
+    actions: {
+        [action: string]: boolean;
+    };
+};
+/**
+ * @internal
+ * A Controller Rights definition
+ *
+ * @example
+ * {
+ *   "document": {
+ *     actions: {
+ *       "create": true,
+ *     }
+ *   }
+ * }
+ */
+export declare type ControllerRights = {
+    [controller: string]: ControllerRight;
+};

package/lib/types/ControllerRights.js

@@ -0,0 +1,23 @@
+"use strict";
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2022 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ControllerRights.js.map

package/lib/types/HttpStream.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+export declare type HttpStreamProperties = {
+    totalBytes?: number;
+};
+/**
+ * A simple class used to wrap a Readable stream
+ * and provide additional informations about the given data
+ */
+export declare class HttpStream {
+    readonly stream: Readable;
+    readonly totalBytes: number;
+    private _destroyed;
+    constructor(readableStream: Readable, { totalBytes }?: HttpStreamProperties);
+    /**
+     * Returns if the stream is errored
+     */
+    get errored(): boolean;
+    /**
+     * Get the error
+     */
+    get error(): Error;
+    /**
+     * Returns if the stream has been destroyed
+     */
+    get destroyed(): boolean;
+    /**
+     * Destroy the stream
+     * true if the stream has been destroyed
+     */
+    destroy(): boolean;
+}

package/lib/types/HttpStream.js

@@ -0,0 +1,70 @@
+"use strict";
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2022 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpStream = void 0;
+/**
+ * A simple class used to wrap a Readable stream
+ * and provide additional informations about the given data
+ */
+class HttpStream {
+    constructor(readableStream, { totalBytes = -1 } = {}) {
+        this._destroyed = false;
+        this.stream = readableStream;
+        this.totalBytes = totalBytes;
+        this._destroyed = readableStream.destroyed;
+    }
+    /**
+     * Returns if the stream is errored
+     */
+    get errored() {
+        // @ts-ignore
+        return this.stream._readableState.errored !== null // @ts-ignore
+            && this.stream._readableState.errored !== undefined;
+    }
+    /**
+     * Get the error
+     */
+    get error() {
+        // @ts-ignore
+        return this.stream._readableState.errored;
+    }
+    /**
+     * Returns if the stream has been destroyed
+     */
+    get destroyed() {
+        return this._destroyed;
+    }
+    /**
+     * Destroy the stream
+     * true if the stream has been destroyed
+     */
+    destroy() {
+        if (this._destroyed) {
+            return false;
+        }
+        this.stream.destroy();
+        this._destroyed = true;
+        return true;
+    }
+}
+exports.HttpStream = HttpStream;
+//# sourceMappingURL=HttpStream.js.map

package/lib/types/OpenApiDefinition.d.ts

@@ -0,0 +1,43 @@
+import { JSONObject } from 'kuzzle-sdk';
+export declare type OpenApiDefinition = {
+    swagger?: string;
+    openapi?: string;
+    info: {
+        title: string;
+        description: string;
+        contact: {
+            name: string;
+            url: string;
+            email: string;
+            discord: string;
+        };
+        license: {
+            name: string;
+            url: string;
+        };
+        version: string;
+    };
+    externalDocs: {
+        description: string;
+        url: string;
+    };
+    servers: Array<{
+        url: string;
+        description: string;
+        variables: {
+            baseUrl: {
+                default: string;
+            };
+            port: {
+                default: number;
+            };
+        };
+    }>;
+    tags: Array<{
+        description: string;
+        name: string;
+    }>;
+    schemes: string[];
+    paths: JSONObject;
+    components: JSONObject;
+};

package/lib/types/{config/StorageService/StorageServiceElasticsearchConfiguration.js → OpenApiDefinition.js}

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

package/lib/types/Policy.d.ts

@@ -0,0 +1,25 @@
+import { PolicyRestrictions, OptimizedPolicyRestrictions } from './PolicyRestrictions';
+/**
+ * Policy definition for a role
+ * and its restrictions
+ *
+ * @example
+ * {
+ *   "roleId": "admin",
+ *   "restrictedTo": [
+ *     {
+ *       "index": "index-yellow-taxi",
+ *       "collections": ["foo", "bar"]
+ *     }
+ *   ]
+ * }
+ */
+export declare type Policy = {
+    roleId: string;
+    restrictedTo?: PolicyRestrictions[];
+};
+/** @internal */
+export declare type OptimizedPolicy = {
+    roleId: string;
+    restrictedTo?: OptimizedPolicyRestrictions;
+};

package/lib/types/Policy.js

@@ -0,0 +1,23 @@
+"use strict";
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2022 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Policy.js.map

package/lib/types/PolicyRestrictions.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Policy Restiction definition of
+ * a index and its collections
+ *
+ * @example
+ * {
+ *   "index": "index-yellow-taxi",
+ *   "collections": ["foo", "bar"]
+ * }
+ */
+export declare type PolicyRestrictions = {
+    index: string;
+    collections: string[];
+};
+/**
+ * @internal
+ * A policy definition
+ * the key {string} represent the index name
+ * the value {string[]} represent the collection names
+ */
+export declare type OptimizedPolicyRestrictions = Map<string, string[]>;

package/lib/types/PolicyRestrictions.js

@@ -0,0 +1,23 @@
+"use strict";
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2022 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=PolicyRestrictions.js.map

package/lib/types/Target.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Target definition
+ *
+ * Target are used to specify multiple index and collection
+ * inside of a single query
+ * @example
+ * {
+ *   "index": "yellow-taxi",
+ *   "collections": ["foo", "bar"]
+ * }
+ */
+export declare type Target = {
+    index?: string;
+    collections?: string[];
+};

package/lib/types/Target.js

@@ -0,0 +1,23 @@
+"use strict";
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2022 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Target.js.map

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

@@ -72,6 +72,10 @@ export interface IKuzzleConfiguration {
         statsInterval: number;
     };
     cluster: {
+        /**
+         * @default true
+         */
+        enabled: boolean;
         /**
          * @default 50
          */

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

@@ -1,4 +1,4 @@
-import { PublicCacheRedisConfiguration, InternalCacheConfiguration, StorageServiceElasticsearch } from '../index';
+import { PublicCacheRedisConfiguration, InternalCacheConfiguration, StorageEngineElasticsearch } from '../index';
 export declare type ServicesConfiguration = {
     common: {
         /**
@@ -37,5 +37,5 @@ export declare type ServicesConfiguration = {
      * The default storage layer is Elasticsearch and it is
      * currently the only storage layer we support.
      */
-    storageEngine: StorageServiceElasticsearch;
+    storageEngine: StorageEngineElasticsearch;
 };

package/lib/types/config/{StorageService/StorageServiceElasticsearchConfiguration.d.ts → storageEngine/StorageEngineElasticsearchConfiguration.d.ts}

@@ -1,5 +1,5 @@
-import { JSONObject } from '../../../../index';
-export declare type StorageServiceElasticsearch = {
+import { ClientOptions } from '@elastic/elasticsearch';
+export declare type StorageEngineElasticsearch = {
     /**
      * @default ['storageEngine']
     */
@@ -12,10 +12,17 @@ export declare type StorageServiceElasticsearch = {
      * 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
      *
+     * @default
+     *
+     * {
+     *    node: 'http://localhost:9200'
+     * }
+     *
     */
-    client: JSONObject;
+    client: ClientOptions;
     /**
      * Default policy against new fields that are not referenced in the
      * collection mapping.

package/lib/types/config/storageEngine/StorageEngineElasticsearchConfiguration.js

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

package/lib/types/index.d.ts

@@ -1,13 +1,18 @@
 export * from './Plugin';
 export * from './Controller';
 export * from './ControllerDefinition';
+export * from './ControllerRights';
 export * from './RequestPayload';
 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';
@@ -27,5 +32,6 @@ 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/storageEngine/StorageEngineElasticsearchConfiguration';
 export * from './config/DumpConfiguration';
+export * from './OpenApiDefinition';

package/lib/types/index.js

@@ -33,13 +33,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Plugin"), exports);
 __exportStar(require("./Controller"), exports);
 __exportStar(require("./ControllerDefinition"), exports);
+__exportStar(require("./ControllerRights"), exports);
 __exportStar(require("./RequestPayload"), exports);
 __exportStar(require("./ResponsePayload"), exports);
 __exportStar(require("./Deprecation"), exports);
 __exportStar(require("./EventHandler"), exports);
+__exportStar(require("./Policy"), exports);
+__exportStar(require("./PolicyRestrictions"), exports);
 __exportStar(require("./User"), exports);
 __exportStar(require("./Token"), exports);
+__exportStar(require("./Target"), exports);
 __exportStar(require("./Global"), exports);
+__exportStar(require("./HttpStream"), exports);
 __exportStar(require("./PasswordPolicy"), exports);
 __exportStar(require("./config/KuzzleConfiguration"), exports);
 __exportStar(require("./config/ServerConfiguration"), exports);
@@ -59,6 +64,7 @@ __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/storageEngine/StorageEngineElasticsearchConfiguration"), exports);
 __exportStar(require("./config/DumpConfiguration"), exports);
+__exportStar(require("./OpenApiDefinition"), exports);
 //# sourceMappingURL=index.js.map

package/lib/util/array.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Binary Search
+ *
+ * @param array Sorted Array
+ * @param predicate A function that return -1, 0, or 1
+ * - [-1] The value is greater than what you search
+ * - [1] The value is lesser than what you search
+ * - [0] Both value are equals
+ * @returns {number} The index of the value, or -1 if not found
+ */
+export declare function binarySearch(array: any[], predicate: (value: any) => number): number;

package/lib/util/array.js

@@ -0,0 +1,57 @@
+"use strict";
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2020 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.binarySearch = void 0;
+/**
+ * Binary Search
+ *
+ * @param array Sorted Array
+ * @param predicate A function that return -1, 0, or 1
+ * - [-1] The value is greater than what you search
+ * - [1] The value is lesser than what you search
+ * - [0] Both value are equals
+ * @returns {number} The index of the value, or -1 if not found
+ */
+function binarySearch(array, predicate) {
+    let lowerBound = 0;
+    let upperBound = array.length - 1;
+    if (array.length === 1) {
+        return predicate(array[0]) === 0 ? 0 : -1;
+    }
+    while (lowerBound <= upperBound) {
+        // 5x faster than Math.floor((lowerBound + upperBound) / 2)
+        const index = (lowerBound + upperBound) >> 1;
+        const comparison = predicate(array[index]);
+        if (comparison < 0) {
+            upperBound = index - 1;
+        }
+        else if (comparison > 0) {
+            lowerBound = index + 1;
+        }
+        else {
+            return index;
+        }
+    }
+    return -1;
+}
+exports.binarySearch = binarySearch;
+//# sourceMappingURL=array.js.map

package/lib/util/assertType.js

@@ -32,7 +32,7 @@ const { BadRequestError } = require('../kerror/errors');
  * @param {*} data
  * @return {object}
  */
-function assertObject(attr, data) {
+function assertObject (attr, data) {
   if (data === null || data === undefined) {
     return null;
   }
@@ -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"`);
   }
 
@@ -87,7 +87,7 @@ 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;
   }
@@ -108,8 +108,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/bufferedPassThrough.d.ts

@@ -0,0 +1,76 @@
+/// <reference types="node" />
+import stream from 'stream';
+declare type Encoding = BufferEncoding | 'buffer';
+declare type ChunkData = Buffer | string;
+declare type Chunk = {
+    chunk: ChunkData;
+    encoding: Encoding;
+};
+declare type Callback = (error?: Error) => void;
+/**
+ * This streams accumulate chunks data into a buffer until the amount of data is equal or exceed  the buffer size.
+ * Then, it emits a single chunk with the accumulated data.
+ *
+ * This stream is useful when you want to reduce the amount of chunk produced by a stream.
+ * This can helps reducing the number of syscall made by the stream consumer.
+ */
+export declare class BufferedPassThrough extends stream.Duplex {
+    private bufferSize;
+    private buffer;
+    private offset;
+    constructor(options?: stream.DuplexOptions);
+    /**
+     * Writes a string or buffer to the internal buffer starting at the internal buffer offset.
+     * Data will be copied from the given start to the end position.
+     *
+     * @param data
+     * @param start Where to start copying/writing data from
+     * @param end Where to end copying/writing data from
+     * @param encoding Type of encoding to use
+     * @returns How many bytes have been copied / written to the internal buffer.
+     */
+    private writeToBuffer;
+    private writeChunks;
+    /**
+     * Writes a chunk of data to the internal buffer.
+     * If the internal buffer is full, it will be pushed to the stream.
+     * @param chunk
+     * @param encoding
+     */
+    private writeChunkData;
+    /**
+     * @override from stream.Duplex
+     * Internal method called when data needs to be written.
+     * @param chunkData
+     * @param encoding
+     * @param callback
+     */
+    _write(chunkData: ChunkData, encoding: Encoding, callback: Callback): void;
+    /**
+     * @override from stream.Duplex
+     * Internal method called when multiple chunks were stored and needs to be written.
+     * @param chunks
+     * @param callback
+     */
+    _writev(chunks: Chunk[], callback: Callback): void;
+    /**
+     * @override from stream.Duplex
+     * Internal method called when the stream is drained, to resume pushing data.
+     * @param size
+     */
+    _read(): void;
+    /**
+     * @override from stream.Duplex
+     * Internal method called when the stream is ended.
+     * @param callback
+     */
+    _final(callback: Callback): void;
+    /**
+     * @override from stream.Duplex
+     * Internal method called when stream is destroyed.
+     * @param err
+     * @param callback
+     */
+    _destroy(err: Error, callback: Callback): void;
+}
+export {};