kourou 0.24.2 → 0.25.0

package/lib/commands/app/doctor.d.ts

@@ -0,0 +1,24 @@
+import { flags } from "@oclif/command";
+import { Kommand } from "../../common";
+export default class AppDoctor extends Kommand {
+    static description: string;
+    static flags: {
+        host: flags.IOptionFlag<string>;
+        port: flags.IOptionFlag<string>;
+        ssl: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        username: flags.IOptionFlag<string>;
+        password: flags.IOptionFlag<string | undefined>;
+        protocol: flags.IOptionFlag<string>;
+        as: flags.IOptionFlag<string | undefined>;
+        "api-key": flags.IOptionFlag<string | undefined>;
+        help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
+        elasticsearch: flags.IOptionFlag<string>;
+    };
+    static args: never[];
+    static readStdin: boolean;
+    ELK_MAX_VERSION: number;
+    NODEJS_MAX_VERSION: number;
+    COMMANDS_PLATFORMS: Record<string, string>;
+    LIBRARIES_PLATFORMS: Record<string, string[]>;
+    runSafe(): Promise<void>;
+}

package/lib/commands/app/doctor.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const command_1 = require("@oclif/command");
+const common_1 = require("../../common");
+const kuzzle_1 = require("../../support/kuzzle");
+const elasticsearch_1 = require("@elastic/elasticsearch");
+const execute_1 = require("../../support/execute");
+const lodash_1 = (0, tslib_1.__importDefault)(require("lodash"));
+class AppDoctor extends common_1.Kommand {
+    constructor() {
+        super(...arguments);
+        this.ELK_MAX_VERSION = 7.17;
+        this.NODEJS_MAX_VERSION = 16;
+        // because ocliff we can't use 'as const' inference for object keys and values
+        this.COMMANDS_PLATFORMS = {
+            linux: "which",
+        };
+        this.LIBRARIES_PLATFORMS = {
+            linux: [
+                "curl",
+                "gdb",
+                "git",
+                "gnupg",
+                "make",
+                "python3",
+                "libfontconfig",
+                "libzmq3-dev",
+                "wget",
+                "procps",
+                "libunwind-dev",
+            ],
+        };
+    }
+    async runSafe() {
+        const suggestions = [];
+        const [nodeVersion, adminExists, anonymous] = await Promise.all([
+            this.sdk.query({ controller: "debug", action: "nodeVersion", }),
+            this.sdk.server.adminExists({}),
+            this.sdk.security.getRole("anonymous")
+        ]);
+        this.log(`----------------- DoKtor begin his job ! -----------------`);
+        this.log(`General checks`);
+        const anonymousNotRestricted = lodash_1.default.isEqual(anonymous.controllers, {
+            "*": { actions: { "*": true } },
+        });
+        if (adminExists) {
+            this.logOk(`An admin user exists`);
+        }
+        else {
+            this.logKo("No admin user exists");
+            suggestions.push(`Create an admin user ${anonymousNotRestricted ? "and restrict anonymous role " : ""}with
+           kourou security:createFirstAdmin '{
+              credentials: {
+                local: {
+                  username: "admin",
+                  password: "password"
+                }
+              }
+            }' ${anonymousNotRestricted ? "-a reset=true" : ""}`);
+        }
+        if (anonymousNotRestricted && adminExists) {
+            this.logKo(`Anonymous role does not restrict access to any controller`);
+            suggestions.push(`Restrict anonymous role controllers with
+           kourou security:updateRole '{
+            "controllers": {
+              "auth": {
+                "actions": {
+                  "checkToken": true,
+                  "getCurrentUser": true,
+                  "getMyRights": true,
+                  "login": true
+                }
+              },
+              "server": {
+                "actions": {
+                  "publicApi": true,
+                  "openapi": true
+                }
+              }
+            }
+          }' --id=anonymous
+          // or make your own restrictions (see: https://docs.kuzzle.io/core/2/guides/main-concepts/permissions/#roles)`);
+        }
+        const config = await this.sdk.server.getConfig({});
+        if (config) {
+            if (config.cluster.enabled) {
+                this.logOk(`Cluster is enabled`);
+            }
+            else {
+                this.logKo("Cluster is disabled");
+            }
+        }
+        else {
+            this.logInfo("No config found for the server");
+        }
+        // Redis
+        if ("PONG" === (await this.sdk.ms.ping())) {
+            this.logOk("Redis Memory Storage is running");
+        }
+        else {
+            this.logKo("=> Redis Memory Storage is not running");
+            suggestions.push("Check Redis instance dedicated to memory storage");
+        }
+        this.logOk(`Kuzzle Version: ${config.version}`);
+        this.logOk(`Kuzzle NodeJS version: ${nodeVersion.result}`);
+        if (nodeVersion.result > this.NODEJS_MAX_VERSION) {
+            this.logKo(`=> Kuzzle NodeJS version is not compatible with Kuzzle (max version is ${this.NODEJS_MAX_VERSION})`);
+        }
+        this.logOk(`NodeJS Building version: ${process.version}`);
+        if (nodeVersion.result !== process.version) {
+            this.logKo("=> Kuzzle node version is different from the build node version");
+            suggestions.push(`Match Kuzzle NodeJS version ${nodeVersion.result} with the build NodeJS version ${process.version}`);
+        }
+        let elkVersion;
+        try {
+            const serverInfo = await this.sdk.server.info({});
+            elkVersion = parseFloat(serverInfo.serverInfo.services.publicStorage.version);
+            if (elkVersion < this.ELK_MAX_VERSION) {
+                this.logOk(`ElasticSearch Version: ${elkVersion} which is compatible with Kuzzle (max version is ${this.ELK_MAX_VERSION})`);
+            }
+            else {
+                this.logKo(`=> ElasticSearch version ${elkVersion} is not compatible with Kuzzle (max version is ${this.ELK_MAX_VERSION})`);
+                suggestions.push(`Downgrade ElasticSearch to a compatible version (max: ${this.ELK_MAX_VERSION})`);
+            }
+            const client = new elasticsearch_1.Client({ node: this.flags.elasticsearch });
+            const info = await client.info();
+            this.log(`ElasticSearch checks`);
+            this.logOk(`Elasticsearch Cluster name: ${info.body.cluster_name}`);
+            this.logOk(`ElasticSearch Status: ${info.meta.connection.status}`);
+            const nodes = await client.cat.nodes({ format: "json" });
+            this.log(`ElasticSearch nodes`);
+            console.table(nodes.body.map((i) => ({ node_name: i.name, ip: i.ip })));
+            const indices = await client.cat.indices({ format: "json" });
+            this.log(`ElasticSearch indices`);
+            console.table(indices.body.map((i) => ({
+                indice_name: i.index,
+                health: i.health,
+                status: i.status,
+                count_docs: i["docs.count"],
+            })));
+        }
+        catch (e) {
+            this.logKo("=> Cannot show more information about ElasticSearch (cluster name, nodes, indices) because it's not accessible");
+        }
+        let librairies = [];
+        let command = "";
+        const platform = process.platform.toLowerCase();
+        if (platform in this.LIBRARIES_PLATFORMS &&
+            platform in this.COMMANDS_PLATFORMS) {
+            librairies = this.LIBRARIES_PLATFORMS[platform];
+            command = this.COMMANDS_PLATFORMS[platform];
+        }
+        this.log("Kuzzle related libraries installed");
+        const notInstalled = [];
+        for (const lib of librairies) {
+            try {
+                const result = await (0, execute_1.execute)(command, lib);
+                if (result.stdout) {
+                    this.logOk(` ${lib} is installed`);
+                }
+            }
+            catch (e) {
+                this.logKo(`  => ${lib} is not installed`);
+                notInstalled.push(lib);
+            }
+        }
+        if (notInstalled.length) {
+            suggestions.push(`Install missing libraries: sudo apt-get install ${notInstalled.join(" ")}`);
+        }
+        this.log("Docker checks");
+        try {
+            const docov = await (0, execute_1.execute)("docker-compose", "-v");
+            const matches = docov.stdout.match(/[^0-9.]*([0-9.]*).*/);
+            if (matches === null || matches.length === 0) {
+                this.logKo("Docker Version cannot be found");
+            }
+            else {
+                this.logOk(`Docker Compose Version: ${matches[1]}`);
+            }
+        }
+        catch (error) {
+            this.logKo("Docker Compose cannot be found");
+            suggestions.push("Install Docker Compose with 'npm run install:docker'");
+        }
+        this.log(`----------------- DoKtor finish his job ! -----------------`);
+        this.log(`He suggest you to check the following points:`);
+        for (const suggestion of suggestions) {
+            this.logInfo(" => " + suggestion);
+        }
+        this.log(`-------------------------------------------------------------`);
+    }
+}
+exports.default = AppDoctor;
+AppDoctor.description = "Analyze a Kuzzle application";
+AppDoctor.flags = Object.assign({ help: command_1.flags.help(), elasticsearch: command_1.flags.string({
+        description: "Elasticsearch server URL",
+        default: "http://localhost:9200",
+    }) }, kuzzle_1.kuzzleFlags);
+AppDoctor.args = [];
+AppDoctor.readStdin = true;

package/lib/commands/app/scaffold.d.ts

@@ -1,5 +1,5 @@
-import { flags } from '@oclif/command';
-import { Kommand } from '../../common';
+import { flags } from "@oclif/command";
+import { Kommand } from "../../common";
 export default class AppScaffold extends Kommand {
     static initSdk: boolean;
     static description: string;

package/lib/commands/app/scaffold.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const command_1 = require("@oclif/command");
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const listr_1 = tslib_1.__importDefault(require("listr"));
+const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+const listr_1 = (0, tslib_1.__importDefault)(require("listr"));
 const common_1 = require("../../common");
 const execute_1 = require("../../support/execute");
 class AppScaffold extends common_1.Kommand {
@@ -12,32 +12,37 @@ class AppScaffold extends common_1.Kommand {
         const flavor = this.flags.flavor;
         const tasks = new listr_1.default([
             {
-                title: 'Creating and rendering application files',
-                task: async () => this.cloneTemplate(flavor, destination)
+                title: "Creating and rendering application files",
+                task: async () => this.cloneTemplate(flavor, destination),
             },
         ]);
         await tasks.run();
-        this.log('');
+        this.log("");
         this.logOk(`Scaffolding complete! Use ${chalk_1.default.grey(`cd ${destination} && npm run docker npm install`)} install dependencies and then ${chalk_1.default.grey(`npm run docker:dev`)} to run your application!`);
     }
     async cloneTemplate(flavor, destination) {
-        const templatesDir = '/tmp/project-templates';
-        await (0, execute_1.execute)('rm', '-rf', templatesDir);
-        await (0, execute_1.execute)('git', 'clone', '--depth=1', 'https://github.com/kuzzleio/project-templates', '--branch', flavor, '--single-branch', templatesDir);
-        await (0, execute_1.execute)('cp', '-r', `${templatesDir}/${flavor}`, `${destination}/`);
-        await (0, execute_1.execute)('rm', '-rf', templatesDir);
+        const templatesDir = "/tmp/project-templates";
+        await (0, execute_1.execute)("rm", "-rf", templatesDir);
+        await (0, execute_1.execute)("git", "clone", "--depth=1", "https://github.com/kuzzleio/project-templates", "--branch", flavor, "--single-branch", templatesDir);
+        await (0, execute_1.execute)("cp", "-r", `${templatesDir}/${flavor}`, `${destination}/`);
+        await (0, execute_1.execute)("rm", "-rf", templatesDir);
     }
 }
 exports.default = AppScaffold;
 AppScaffold.initSdk = false;
-AppScaffold.description = 'Scaffolds a new Kuzzle application';
+AppScaffold.description = "Scaffolds a new Kuzzle application";
 AppScaffold.flags = {
     help: command_1.flags.help(),
     flavor: command_1.flags.string({
-        default: 'generic',
-        description: 'Template flavor ("generic", "iot-platform")'
-    })
+        default: "generic",
+        description: `Template flavor ("generic", "iot-platform", "iot-console", "iot-platform").
+    Those can be found here: https://github.com/kuzzleio/project-templates`,
+    }),
 };
 AppScaffold.args = [
-    { name: 'destination', description: 'Directory to scaffold the app', required: true },
+    {
+        name: "destination",
+        description: "Directory to scaffold the app",
+        required: true,
+    },
 ];

package/lib/commands/app/start-services.d.ts

@@ -1,4 +1,4 @@
-import { Kommand } from '../../common';
+import { Kommand } from "../../common";
 export default class AppStartServices extends Kommand {
     static initSdk: boolean;
     static description: string;

package/lib/commands/app/start-services.js

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const fs_1 = require("fs");
-const path_1 = tslib_1.__importDefault(require("path"));
+const path_1 = (0, tslib_1.__importDefault)(require("path"));
 const command_1 = require("@oclif/command");
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const listr_1 = tslib_1.__importDefault(require("listr"));
-const node_emoji_1 = tslib_1.__importDefault(require("node-emoji"));
+const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+const listr_1 = (0, tslib_1.__importDefault)(require("listr"));
+const node_emoji_1 = (0, tslib_1.__importDefault)(require("node-emoji"));
 const common_1 = require("../../common");
 const execute_1 = require("../../support/execute");
-const MIN_DOCO_VERSION = '1.12.0';
+const MIN_DOCO_VERSION = "1.12.0";
 const kuzzleServicesFile = `
 version: '3'
 
@@ -29,49 +29,49 @@ services:
 class AppStartServices extends common_1.Kommand {
     async runSafe() {
         this.createKourouDir();
-        const docoFilename = path_1.default.join(this.kourouDir, 'kuzzle-services.yml');
-        const successfullCheck = this.flags.check ?
-            await this.checkPrerequisites() :
-            true;
+        const docoFilename = path_1.default.join(this.kourouDir, "kuzzle-services.yml");
+        const successfullCheck = this.flags.check
+            ? await this.checkPrerequisites()
+            : true;
         if (this.flags.check && successfullCheck) {
-            this.log(`\n${node_emoji_1.default.get('ok_hand')} Prerequisites are ${chalk_1.default.green.bold('OK')}!`);
+            this.log(`\n${node_emoji_1.default.get("ok_hand")} Prerequisites are ${chalk_1.default.green.bold("OK")}!`);
         }
         else if (this.flags.check && !successfullCheck) {
-            throw new Error(`${node_emoji_1.default.get('shrug')} Your system doesn't satisfy all the prerequisites. Cannot run Kuzzle services.`);
+            throw new Error(`${node_emoji_1.default.get("shrug")} Your system doesn't satisfy all the prerequisites. Cannot run Kuzzle services.`);
         }
         this.log(chalk_1.default.grey(`\nWriting docker-compose file to ${docoFilename}...\n`));
         (0, fs_1.writeFileSync)(docoFilename, kuzzleServicesFile);
         // clean up
-        await (0, execute_1.execute)('docker-compose', '-f', docoFilename, 'down');
+        await (0, execute_1.execute)("docker-compose", "-f", docoFilename, "down");
         try {
-            await (0, execute_1.execute)('docker-compose', '-f', docoFilename, 'up', '-d');
-            this.logOk('Elasticsearch and Redis are booting in the background right now.');
-            this.log(chalk_1.default.grey('\nTo watch the logs, run'));
+            await (0, execute_1.execute)("docker-compose", "-f", docoFilename, "up", "-d");
+            this.logOk("Elasticsearch and Redis are booting in the background right now.");
+            this.log(chalk_1.default.grey("\nTo watch the logs, run"));
             this.log(chalk_1.default.grey(`  docker-compose -f ${docoFilename} logs -f\n`));
-            this.log('  Elasticsearch port: 9200');
-            this.log('  Redis port: 6379');
+            this.log("  Elasticsearch port: 9200");
+            this.log("  Redis port: 6379");
         }
         catch (error) {
             this.logKo(` Something went wrong: ${error.message}`);
-            this.log(chalk_1.default.grey('If you want to investigate the problem, try running'));
+            this.log(chalk_1.default.grey("If you want to investigate the problem, try running"));
             this.log(chalk_1.default.grey(`  docker-compose -f ${docoFilename} up\n`));
         }
     }
     async checkPrerequisites() {
-        this.log(chalk_1.default.grey('Checking prerequisites...'));
+        this.log(chalk_1.default.grey("Checking prerequisites..."));
         const checks = new listr_1.default([
             {
                 title: `docker-compose exists and the version is at least ${MIN_DOCO_VERSION}`,
                 task: async () => {
                     try {
-                        const docov = await (0, execute_1.execute)('docker-compose', '-v');
+                        const docov = await (0, execute_1.execute)("docker-compose", "-v");
                         const matches = docov.stdout.match(/[^0-9.]*([0-9.]*).*/);
                         if (matches === null) {
-                            throw new Error('Unable to read docker-compose verson. This is weird.');
+                            throw new Error("Unable to read docker-compose verson. This is weird.");
                         }
                         const docoVersion = matches.length > 0 ? matches[1] : null;
                         if (docoVersion === null) {
-                            throw new Error('Unable to read docker-compose version. This is weird.');
+                            throw new Error("Unable to read docker-compose version. This is weird.");
                         }
                         try {
                             if (docoVersion < MIN_DOCO_VERSION) {
@@ -83,10 +83,10 @@ class AppStartServices extends common_1.Kommand {
                         }
                     }
                     catch (error) {
-                        throw new Error('No docker-compose found. Are you sure docker-compose is installed?');
+                        throw new Error("No docker-compose found. Are you sure docker-compose is installed?");
                     }
                 },
-            }
+            },
         ]);
         try {
             await checks.run();
@@ -100,11 +100,11 @@ class AppStartServices extends common_1.Kommand {
 }
 exports.default = AppStartServices;
 AppStartServices.initSdk = false;
-AppStartServices.description = 'Starts Kuzzle services (Elasticsearch and Redis)';
+AppStartServices.description = "Starts Kuzzle services (Elasticsearch and Redis)";
 AppStartServices.flags = {
     help: command_1.flags.help(),
     check: command_1.flags.boolean({
-        description: 'Check prerequisite before running services',
+        description: "Check prerequisite before running services",
         default: false,
     }),
 };

package/lib/commands/collection/create.d.ts

@@ -1,5 +1,5 @@
-import { flags } from '@oclif/command';
-import { Kommand } from '../../common';
+import { flags } from "@oclif/command";
+import { Kommand } from "../../common";
 export default class CollectionCreate extends Kommand {
     static description: string;
     static flags: {
@@ -10,7 +10,7 @@ export default class CollectionCreate extends Kommand {
         password: flags.IOptionFlag<string | undefined>;
         protocol: flags.IOptionFlag<string>;
         as: flags.IOptionFlag<string | undefined>;
-        'api-key': flags.IOptionFlag<string | undefined>;
+        "api-key": flags.IOptionFlag<string | undefined>;
         help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
     };
     static args: ({

package/lib/commands/collection/create.js

@@ -5,8 +5,8 @@ const common_1 = require("../../common");
 const kuzzle_1 = require("../../support/kuzzle");
 class CollectionCreate extends common_1.Kommand {
     async runSafe() {
-        const body = this.stdin ? this.stdin : this.args.body || '{}';
-        if (!await this.sdk.index.exists(this.args.index)) {
+        const body = this.stdin ? this.stdin : this.args.body || "{}";
+        if (!(await this.sdk.index.exists(this.args.index))) {
             await this.sdk.index.create(this.args.index);
             this.logInfo(`Index "${this.args.index}" created`);
         }
@@ -15,11 +15,14 @@ class CollectionCreate extends common_1.Kommand {
     }
 }
 exports.default = CollectionCreate;
-CollectionCreate.description = 'Creates a collection';
+CollectionCreate.description = "Creates a collection";
 CollectionCreate.flags = Object.assign({ help: command_1.flags.help() }, kuzzle_1.kuzzleFlags);
 CollectionCreate.args = [
-    { name: 'index', description: 'Index name', required: true },
-    { name: 'collection', description: 'Collection name', required: true },
-    { name: 'body', description: 'Collection mappings and settings in JS or JSON format. Will be read from STDIN if available' },
+    { name: "index", description: "Index name", required: true },
+    { name: "collection", description: "Collection name", required: true },
+    {
+        name: "body",
+        description: "Collection mappings and settings in JS or JSON format. Will be read from STDIN if available",
+    },
 ];
 CollectionCreate.readStdin = true;

package/lib/commands/collection/export.d.ts

@@ -1,5 +1,5 @@
-import { flags } from '@oclif/command';
-import { Kommand } from '../../common';
+import { flags } from "@oclif/command";
+import { Kommand } from "../../common";
 export default class CollectionExport extends Kommand {
     static keepAuth: boolean;
     static description: string;
@@ -11,15 +11,15 @@ export default class CollectionExport extends Kommand {
         username: flags.IOptionFlag<string>;
         password: flags.IOptionFlag<string | undefined>;
         as: flags.IOptionFlag<string | undefined>;
-        'api-key': flags.IOptionFlag<string | undefined>;
+        "api-key": flags.IOptionFlag<string | undefined>;
         help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
         path: flags.IOptionFlag<string | undefined>;
-        'batch-size': flags.IOptionFlag<string>;
+        "batch-size": flags.IOptionFlag<string>;
         query: flags.IOptionFlag<string>;
         editor: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
         format: flags.IOptionFlag<string>;
         fields: flags.IOptionFlag<string | undefined>;
-        scrollTTL: flags.IOptionFlag<string | undefined>;
+        scrollTTL: flags.IOptionFlag<string>;
     };
     static args: {
         name: string;

package/lib/commands/collection/export.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const command_1 = require("@oclif/command");
-const fs_1 = tslib_1.__importDefault(require("fs"));
-const path_1 = tslib_1.__importDefault(require("path"));
+const fs_1 = (0, tslib_1.__importDefault)(require("fs"));
+const path_1 = (0, tslib_1.__importDefault)(require("path"));
 const common_1 = require("../../common");
 const kuzzle_1 = require("../../support/kuzzle");
 const dump_collection_1 = require("../../support/dump-collection");
@@ -12,11 +12,9 @@ class CollectionExport extends common_1.Kommand {
         const exportPath = this.flags.path
             ? path_1.default.join(this.flags.path, this.args.index)
             : this.args.index;
-        const fields = this.flags.fields
-            ? this.flags.fields.split(',')
-            : [];
-        if (this.flags.format === 'csv' && fields.length === 0) {
-            this.logInfo('It looks like you are exporting to CSV but you did not select any field. All exportable fields in the mapping will be exported.');
+        const fields = this.flags.fields ? this.flags.fields.split(",") : [];
+        if (this.flags.format === "csv" && fields.length === 0) {
+            this.logInfo("It looks like you are exporting to CSV but you did not select any field. All exportable fields in the mapping will be exported.");
         }
         let query = this.parseJs(this.flags.query);
         if (this.flags.editor) {
@@ -27,29 +25,29 @@ class CollectionExport extends common_1.Kommand {
         this.logInfo(`Dumping ${count} of ${countAll} documents from collection "${this.args.index}:${this.args.collection}" in ${exportPath} ...`);
         fs_1.default.mkdirSync(exportPath, { recursive: true });
         await (0, dump_collection_1.dumpCollectionMappings)(this.sdk, this.args.index, this.args.collection, exportPath, this.flags.format);
-        await (0, dump_collection_1.dumpCollectionData)(this.sdk, this.args.index, this.args.collection, Number(this.flags['batch-size']), exportPath, query, this.flags.format, fields, this.flags.scrollTTL);
+        await (0, dump_collection_1.dumpCollectionData)(this.sdk, this.args.index, this.args.collection, Number(this.flags["batch-size"]), exportPath, query, this.flags.format, fields, this.flags.scrollTTL);
         this.logOk(`Collection ${this.args.index}:${this.args.collection} dumped`);
     }
 }
 exports.default = CollectionExport;
 CollectionExport.keepAuth = true;
-CollectionExport.description = 'Exports a collection (JSONL format)';
+CollectionExport.description = "Exports a collection (JSONL format)";
 CollectionExport.flags = Object.assign(Object.assign({ help: command_1.flags.help({}), path: command_1.flags.string({
-        description: 'Dump root directory',
-    }), 'batch-size': command_1.flags.string({
-        description: 'Maximum batch size (see limits.documentsFetchCount config)',
-        default: '2000'
+        description: "Dump root directory",
+    }), "batch-size": command_1.flags.string({
+        description: "Maximum batch size (see limits.documentsFetchCount config)",
+        default: "2000",
     }), query: command_1.flags.string({
-        description: 'Only dump documents matching the query (JS or JSON format)',
-        default: '{}'
+        description: "Only dump documents matching the query (JS or JSON format)",
+        default: "{}",
     }), editor: command_1.flags.boolean({
-        description: 'Open an editor (EDITOR env variable) to edit the query before sending'
+        description: "Open an editor (EDITOR env variable) to edit the query before sending",
     }), format: command_1.flags.string({
         description: `"kuzzle" will export in Kuzzle format usable for internal fixtures,
 "jsonl" allows to import that data back with kourou,
 "csv" allows to import data into Excel (please, specify the fields to export using the --fields option).`,
-        options: ['jsonl', 'kuzzle', 'csv'],
-        default: 'jsonl'
+        options: ["jsonl", "kuzzle", "csv"],
+        default: "jsonl",
     }), fields: command_1.flags.string({
         description: `[CSV format only] The list of fields to be included in the CSV export in dot-path format.
 
@@ -57,19 +55,20 @@ Example:
 --fields oneField,anotherField,yetAnotherOne.nested.moarNested
 
 Note that the '_id' field is always included in the CSV export. Leaving this option empty implies that all
-exportable fields in the mapping will be exported.`
+exportable fields in the mapping will be exported.`,
     }), scrollTTL: command_1.flags.string({
         description: `The scroll TTL option to pass to the dump operation (which performs a document.search under the hood),
-expressed in ms format, e.g. '2s', '1m', '3h'.`
+expressed in ms format, e.g. '2s', '1m', '3h'.`,
+        default: "20s",
     }) }, kuzzle_1.kuzzleFlags), { protocol: command_1.flags.string({
-        description: 'Kuzzle protocol (http or websocket)',
-        default: 'ws',
+        description: "Kuzzle protocol (http or websocket)",
+        default: "ws",
     }) });
 CollectionExport.args = [
-    { name: 'index', description: 'Index name', required: true },
-    { name: 'collection', description: 'Collection name', required: true },
+    { name: "index", description: "Index name", required: true },
+    { name: "collection", description: "Collection name", required: true },
 ];
 CollectionExport.examples = [
-    'kourou collection:export nyc-open-data yellow-taxi',
-    'kourou collection:export nyc-open-data yellow-taxi --query \'{ term: { city: "Saigon" } }\'',
+    "kourou collection:export nyc-open-data yellow-taxi",
+    "kourou collection:export nyc-open-data yellow-taxi --query '{ term: { city: \"Saigon\" } }'",
 ];

package/lib/commands/collection/import.d.ts

@@ -1,5 +1,5 @@
-import { flags } from '@oclif/command';
-import { Kommand } from '../../common';
+import { flags } from "@oclif/command";
+import { Kommand } from "../../common";
 export default class CollectionImport extends Kommand {
     static keepAuth: boolean;
     static description: string;
@@ -11,12 +11,12 @@ export default class CollectionImport extends Kommand {
         username: flags.IOptionFlag<string>;
         password: flags.IOptionFlag<string | undefined>;
         as: flags.IOptionFlag<string | undefined>;
-        'api-key': flags.IOptionFlag<string | undefined>;
+        "api-key": flags.IOptionFlag<string | undefined>;
         help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
-        'batch-size': flags.IOptionFlag<string>;
+        "batch-size": flags.IOptionFlag<string>;
         index: flags.IOptionFlag<string | undefined>;
         collection: flags.IOptionFlag<string | undefined>;
-        'no-mappings': import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        "no-mappings": import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
     };
     static args: {
         name: string;