kuzzle 2.18.1 → 2.19.2

package/lib/types/DebugModule.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import Inspector from 'inspector';
+export declare type DebugModuleOptions = {
+    methods?: string[];
+    events?: string[];
+};
+export declare abstract class DebugModule extends EventEmitter {
+    name: string;
+    methods: string[];
+    events: string[];
+    /**
+     * Called when the module is loaded, after the debugger has been enabled
+     */
+    abstract init(inspector: Inspector.Session): Promise<void>;
+    /**
+     * Called when the module should be cleaned up.
+     * - After the Debug Controller has been disabled
+     * - Before the debugger is disconnected
+     */
+    abstract cleanup(): Promise<void>;
+    constructor(name: string, options?: DebugModuleOptions);
+}

package/lib/types/DebugModule.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugModule = void 0;
+const events_1 = __importDefault(require("events"));
+class DebugModule extends events_1.default {
+    constructor(name, options = {}) {
+        super();
+        this.name = name;
+        this.methods = options.methods || [];
+        this.events = options.events || [];
+        if (!this.name || this.name.length === 0) {
+            throw new Error('DebugModule should have a name');
+        }
+        if (this.name.charAt(0) !== this.name.charAt(0).toUpperCase()) {
+            throw new Error(`Debug Module name "${name}" should start with an uppercase letter`);
+        }
+        for (const event of this.events) {
+            if (event.length === 0) {
+                throw new Error(`Event name should not be empty for "${name}"`);
+            }
+            if (event.charAt(0) !== event.charAt(0).toLowerCase()) {
+                throw new Error(`Event name "${event}" should start with a lowercase letter for module "${name}"`);
+            }
+        }
+        for (const method of this.methods) {
+            if (method.length === 0) {
+                throw new Error(`Method name should not be empty for Debug Module "${name}"`);
+            }
+            if (method.charAt(0) !== method.charAt(0).toLowerCase()) {
+                throw new Error(`Method name "${method}" should start with a lowercase letter for module "${name}"`);
+            }
+        }
+    }
+}
+exports.DebugModule = DebugModule;
+//# sourceMappingURL=DebugModule.js.map

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

@@ -2,6 +2,16 @@
 import { JSONObject } from '../../../index';
 import { RoleDefinition, ProfileDefinition } from '../index';
 export declare type SecurityConfiguration = {
+    /**
+     * Debugger configuration
+     */
+    debug: {
+        /**
+         * Allow to use the Chrome DevTools Protocol directly
+         * through `debug:post`
+         */
+        native_debug_protocol: boolean;
+    };
     /**
      * The profileIds applied to a user created with the API action
      * `security:createRestrictedUser`.

package/lib/util/crypto.d.ts

@@ -0,0 +1 @@
+export declare function sha256(string: string): string;

package/lib/util/crypto.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256 = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+function sha256(string) {
+    return crypto_1.default.createHash('sha256').update(string).digest('hex');
+}
+exports.sha256 = sha256;
+//# sourceMappingURL=crypto.js.map

package/lib/util/name-generator.d.ts

@@ -0,0 +1,79 @@
+export declare type GenerateRandomNameOpts = {
+    /**
+     * Optional prefix.
+     */
+    prefix?: string;
+    /**
+     * Optional separator. Defaults to `-`.
+     */
+    separator?: string;
+    /**
+     * Optional postfix random number range. Set to `false` to disable postfix. Defaults to `{ min: 0, max: 100000 }`
+     */
+    postfixRandRange?: {
+        /**
+         * Optional minimum postfix random number (inclusive). Defaults to `0`.
+         */
+        min?: number;
+        /**
+         * Maximum postfix random number (exclusive).
+         */
+        max: number;
+    } | false;
+};
+export declare class NameGenerator {
+    /**
+     * Returns a random name.
+     *
+     * # Usage:
+     *
+     * ```js
+     * const name = NameGenerator.getRandomName(); // 'verdi'
+     * ```
+     *
+     * @returns a random name
+     */
+    static getRandomName(): string;
+    /**
+     * Returns a random adjective.
+     *
+     * # Usage
+     *
+     * ```js
+     * const adj = NameGenerator.getRandomAdjective(); // 'absent'
+     * ```
+     *
+     * @returns a random adjective
+     */
+    static getRandomAdjective(): string;
+    /**
+     * Generates a random formatted name that consists of an optional prefix, a random adjective,
+     * a random name and an optional random number separated by separator (default: '-').
+     *
+     * Format: `[prefix<separator>]<adjective><separator><name>[<separator>random number]`
+     *
+     * Format example: `something-dashing-euler-1164`
+     *
+     * ## Usage
+     *
+     * ```js
+     * let name = NameGenerator.generateRandomName({
+     *   prefix: 'my',
+     *   separator: '_',
+     *   postfixRandRange: { min: 1, max: 10 }
+     * }); // 'my_abandoned_yogi_5'
+     *
+     * name = NameGenerator.generateRandomName({
+     *   separator: ' ',
+     *   postfixRandRange: false
+     * }); // 'amused vampire'
+     * ```
+     *
+     * @param {GenerateRandomNameOpts} opts Optional options
+     *
+     * @returns a random formatted name
+     */
+    static generateRandomName({ prefix, separator, postfixRandRange, }?: GenerateRandomNameOpts): string;
+}
+export declare function randomNumber(max: number): number;
+export declare function randomNumber(min: number, max: number): number;