kourou 0.21.0 → 0.21.1

package/README.md

@@ -26,7 +26,7 @@ $ npm install -g kourou
 $ kourou COMMAND
 running command...
 $ kourou (-v|--version|version)
-kourou/0.21.0 linux-x64 node-v16.13.2
+kourou/0.21.1 linux-x64 node-v16.13.2
 $ kourou --help [COMMAND]
 USAGE
   $ kourou COMMAND

package/lib/commands/api-key/check.d.ts

@@ -0,0 +1,24 @@
+import { flags } from '@oclif/command';
+import { Kommand } from '../../common';
+declare class ApiKeyCheck 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>;
+    };
+    static args: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    static examples: string[];
+    runSafe(): Promise<void>;
+}
+export default ApiKeyCheck;

package/lib/commands/api-key/check.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const common_1 = require("../../common");
+const kuzzle_1 = require("../../support/kuzzle");
+class ApiKeyCheck extends common_1.Kommand {
+    async runSafe() {
+        const { valid } = await this.sdk.auth.checkToken(this.args.token);
+        if (valid) {
+            this.logOk('API key is still valid');
+        }
+        else {
+            this.logKo('API key is not valid');
+        }
+    }
+}
+ApiKeyCheck.description = 'Checks an API key validity';
+ApiKeyCheck.flags = Object.assign({ help: command_1.flags.help() }, kuzzle_1.kuzzleFlags);
+ApiKeyCheck.args = [
+    { name: 'token', description: 'API key token', required: true },
+];
+ApiKeyCheck.examples = [
+    'kourou api-key:check eyJhbG...QxfQrc'
+];
+exports.default = ApiKeyCheck;

package/lib/commands/api-key/create.d.ts

@@ -0,0 +1,26 @@
+import { flags } from '@oclif/command';
+import { Kommand } from '../../common';
+declare class ApiKeyCreate 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>;
+        description: flags.IOptionFlag<string>;
+        id: flags.IOptionFlag<string | undefined>;
+        expire: flags.IOptionFlag<string>;
+    };
+    static args: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    runSafe(): Promise<void>;
+}
+export default ApiKeyCreate;

package/lib/commands/api-key/create.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const common_1 = require("../../common");
+const kuzzle_1 = require("../../support/kuzzle");
+class ApiKeyCreate extends common_1.Kommand {
+    async runSafe() {
+        const apiKey = await this.sdk.security.createApiKey(this.args.user, this.flags.description, {
+            _id: this.flags.id,
+            expiresIn: this.flags.expire
+        });
+        this.logOk(`Successfully created API Key "${apiKey._id}" for user "${this.args.user}"`);
+        this.log(apiKey._source.token);
+    }
+}
+ApiKeyCreate.description = 'Creates a new API Key for a user';
+ApiKeyCreate.flags = Object.assign({ help: command_1.flags.help(), description: command_1.flags.string({
+        char: 'd',
+        description: 'API Key description',
+        required: true,
+    }), id: command_1.flags.string({
+        description: 'API Key unique ID',
+    }), expire: command_1.flags.string({
+        description: 'API Key validity',
+        default: '-1',
+    }) }, kuzzle_1.kuzzleFlags);
+ApiKeyCreate.args = [
+    { name: 'user', description: 'User kuid', required: true },
+];
+exports.default = ApiKeyCreate;

package/lib/commands/api-key/delete.d.ts

@@ -0,0 +1,24 @@
+import { flags } from '@oclif/command';
+import { Kommand } from '../../common';
+declare class ApiKeyDelete 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>;
+    };
+    static args: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    static examples: string[];
+    runSafe(): Promise<void>;
+}
+export default ApiKeyDelete;

package/lib/commands/api-key/delete.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const common_1 = require("../../common");
+const kuzzle_1 = require("../../support/kuzzle");
+class ApiKeyDelete extends common_1.Kommand {
+    async runSafe() {
+        await this.sdk.security.deleteApiKey(this.args.user, this.args.id);
+        this.logOk(`Successfully deleted API Key "${this.args.id}" of user "${this.args.user}"`);
+    }
+}
+ApiKeyDelete.description = 'Deletes an API key.';
+ApiKeyDelete.flags = Object.assign({ help: command_1.flags.help() }, kuzzle_1.kuzzleFlags);
+ApiKeyDelete.args = [
+    { name: 'user', description: 'User kuid', required: true },
+    { name: 'id', description: 'API Key unique ID', required: true },
+];
+ApiKeyDelete.examples = [
+    'kourou vault:delete sigfox-gateway 1k-BF3EBjsXdvA2PR8x'
+];
+exports.default = ApiKeyDelete;

package/lib/commands/api-key/search.d.ts

@@ -0,0 +1,24 @@
+import { flags } from '@oclif/command';
+import { Kommand } from '../../common';
+declare class ApiKeySearch 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>;
+        filter: flags.IOptionFlag<string | undefined>;
+    };
+    static args: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    runSafe(): Promise<void>;
+}
+export default ApiKeySearch;

package/lib/commands/api-key/search.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const common_1 = require("../../common");
+const kuzzle_1 = require("../../support/kuzzle");
+class ApiKeySearch extends common_1.Kommand {
+    async runSafe() {
+        let query = {};
+        if (this.flags.filter) {
+            query = {
+                match: {
+                    description: this.flags.filter,
+                },
+            };
+        }
+        const result = await this.sdk.security.searchApiKeys(this.args.user, query, {
+            from: 0,
+            size: 100
+        });
+        this.logOk(`${result.total} API Keys found for user ${this.args.user}`);
+        if (result.total !== 0) {
+            this.log('');
+            for (const { _id, _source } of result.hits) {
+                this.log(` - Key "${_id}"`);
+                this.log(`    Description: ${_source.description}`);
+                this.log(`    Fingerprint: ${_source.fingerprint}`);
+                this.log(`    Expires at: ${_source.expiresAt}`);
+            }
+        }
+    }
+}
+ApiKeySearch.description = 'Lists a user\'s API Keys.';
+ApiKeySearch.flags = Object.assign({ help: command_1.flags.help(), filter: command_1.flags.string({
+        description: 'Filter to match the API Key descriptions',
+    }) }, kuzzle_1.kuzzleFlags);
+ApiKeySearch.args = [
+    { name: 'user', description: 'User kuid', required: true },
+];
+exports.default = ApiKeySearch;

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

@@ -0,0 +1,17 @@
+import { flags } from '@oclif/command';
+import { Kommand } from '../../common';
+export default class AppScaffold extends Kommand {
+    static initSdk: boolean;
+    static description: string;
+    static flags: {
+        help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
+        flavor: flags.IOptionFlag<string>;
+    };
+    static args: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    runSafe(): Promise<void>;
+    cloneTemplate(flavor: string, destination: string): Promise<void>;
+}

package/lib/commands/app/scaffold.js

@@ -0,0 +1,41 @@
+"use strict";
+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 common_1 = require("../../common");
+const execute_1 = require("../../support/execute");
+class AppScaffold extends common_1.Kommand {
+    async runSafe() {
+        const destination = this.args.destination;
+        const flavor = this.flags.flavor;
+        const tasks = new listr_1.default([
+            {
+                title: 'Creating and rendering application files',
+                task: async () => this.cloneTemplate(flavor, destination)
+            },
+        ]);
+        await tasks.run();
+        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) {
+        await (0, execute_1.execute)('git', 'clone', '--depth=1', 'https://github.com/kuzzleio/project-templates', '--branch', flavor, '--single-branch');
+        await (0, execute_1.execute)('mv', `project-templates/${flavor}`, `${destination}/`);
+        await (0, execute_1.execute)('rm', '-rf', 'project-templates/');
+    }
+}
+exports.default = AppScaffold;
+AppScaffold.initSdk = false;
+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")'
+    })
+};
+AppScaffold.args = [
+    { name: 'destination', description: 'Directory to scaffold the app', required: true },
+];

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

@@ -0,0 +1,11 @@
+import { Kommand } from '../../common';
+export default class AppStartServices extends Kommand {
+    static initSdk: boolean;
+    static description: string;
+    static flags: {
+        help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
+        check: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+    };
+    runSafe(): Promise<void>;
+    checkPrerequisites(): Promise<boolean>;
+}

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

@@ -0,0 +1,110 @@
+"use strict";
+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 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 common_1 = require("../../common");
+const execute_1 = require("../../support/execute");
+const MIN_DOCO_VERSION = '1.12.0';
+const kuzzleServicesFile = `
+version: '3'
+
+services:
+  redis:
+    image: redis:5
+    ports:
+      - "6379:6379"
+
+  elasticsearch:
+    image: kuzzleio/elasticsearch:7
+    ports:
+      - "9200:9200"
+    ulimits:
+      nofile: 65536
+`;
+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;
+        if (this.flags.check && successfullCheck) {
+            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.`);
+        }
+        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');
+        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'));
+            this.log(chalk_1.default.grey(`  docker-compose -f ${docoFilename} logs -f\n`));
+            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(`  docker-compose -f ${docoFilename} up\n`));
+        }
+    }
+    async checkPrerequisites() {
+        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 matches = docov.stdout.match(/[^0-9.]*([0-9.]*).*/);
+                        if (matches === null) {
+                            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.');
+                        }
+                        try {
+                            if (docoVersion < MIN_DOCO_VERSION) {
+                                throw new Error(`The detected version of docker-compose (${docoVersion}) is not recent enough (${MIN_DOCO_VERSION})`);
+                            }
+                        }
+                        catch (error) {
+                            throw new Error(error);
+                        }
+                    }
+                    catch (error) {
+                        throw new Error('No docker-compose found. Are you sure docker-compose is installed?');
+                    }
+                },
+            }
+        ]);
+        try {
+            await checks.run();
+            return true;
+        }
+        catch (error) {
+            this.logKo(error.message);
+            return false;
+        }
+    }
+}
+exports.default = AppStartServices;
+AppStartServices.initSdk = false;
+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',
+        default: false,
+    }),
+};

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

@@ -0,0 +1,27 @@
+import { flags } from '@oclif/command';
+import { Kommand } from '../../common';
+export default class CollectionCreate 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>;
+    };
+    static args: ({
+        name: string;
+        description: string;
+        required: boolean;
+    } | {
+        name: string;
+        description: string;
+        required?: undefined;
+    })[];
+    static readStdin: boolean;
+    runSafe(): Promise<void>;
+}

package/lib/commands/collection/create.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+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)) {
+            await this.sdk.index.create(this.args.index);
+            this.logInfo(`Index "${this.args.index}" created`);
+        }
+        await this.sdk.collection.create(this.args.index, this.args.collection, this.parseJs(body));
+        this.logOk(`Collection "${this.args.index}":"${this.args.collection}" created`);
+    }
+}
+exports.default = CollectionCreate;
+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' },
+];
+CollectionCreate.readStdin = true;

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

@@ -0,0 +1,31 @@
+import { flags } from '@oclif/command';
+import { Kommand } from '../../common';
+export default class CollectionExport extends Kommand {
+    static keepAuth: boolean;
+    static description: string;
+    static flags: {
+        protocol: flags.IOptionFlag<string>;
+        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>;
+        as: 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>;
+        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>;
+    };
+    static args: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    static examples: string[];
+    runSafe(): Promise<void>;
+}

package/lib/commands/collection/export.js

@@ -0,0 +1,75 @@
+"use strict";
+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 common_1 = require("../../common");
+const kuzzle_1 = require("../../support/kuzzle");
+const dump_collection_1 = require("../../support/dump-collection");
+class CollectionExport extends common_1.Kommand {
+    async runSafe() {
+        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.');
+        }
+        let query = this.parseJs(this.flags.query);
+        if (this.flags.editor) {
+            query = this.fromEditor(query, { json: true });
+        }
+        const countAll = await this.sdk.document.count(this.args.index, this.args.collection);
+        const count = await this.sdk.document.count(this.args.index, this.args.collection, { query });
+        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);
+        this.logOk(`Collection ${this.args.index}:${this.args.collection} dumped`);
+    }
+}
+exports.default = CollectionExport;
+CollectionExport.keepAuth = true;
+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'
+    }), query: command_1.flags.string({
+        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'
+    }), 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'
+    }), fields: command_1.flags.string({
+        description: `[CSV format only] The list of fields to be included in the CSV export in dot-path format.
+
+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.`
+    }), 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'.`
+    }) }, kuzzle_1.kuzzleFlags), { protocol: command_1.flags.string({
+        description: 'Kuzzle protocol (http or websocket)',
+        default: 'ws',
+    }) });
+CollectionExport.args = [
+    { 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" } }\'',
+];

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

@@ -0,0 +1,27 @@
+import { flags } from '@oclif/command';
+import { Kommand } from '../../common';
+export default class CollectionImport extends Kommand {
+    static keepAuth: boolean;
+    static description: string;
+    static flags: {
+        protocol: flags.IOptionFlag<string>;
+        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>;
+        as: flags.IOptionFlag<string | undefined>;
+        'api-key': flags.IOptionFlag<string | undefined>;
+        help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
+        'batch-size': flags.IOptionFlag<string>;
+        index: flags.IOptionFlag<string | undefined>;
+        collection: flags.IOptionFlag<string | undefined>;
+        'no-mappings': import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+    };
+    static args: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    runSafe(): Promise<void>;
+}

package/lib/commands/collection/import.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const command_1 = require("@oclif/command");
+const common_1 = require("../../common");
+const kuzzle_1 = require("../../support/kuzzle");
+const restore_collection_1 = require("../../support/restore-collection");
+class CollectionImport extends common_1.Kommand {
+    async runSafe() {
+        this.logInfo(`Start importing dump from ${this.args.path}`);
+        if (!this.flags['no-mappings']) {
+            const mappingsPath = path_1.default.join(this.args.path, 'mappings.json');
+            const dump = JSON.parse(fs_1.default.readFileSync(mappingsPath, 'utf8'));
+            await (0, restore_collection_1.restoreCollectionMappings)(this.sdk, dump, this.flags.index, this.flags.collection);
+        }
+        const { index, collection, total } = await (0, restore_collection_1.restoreCollectionData)(this.sdk, this.log.bind(this), Number(this.flags['batch-size']), path_1.default.join(this.args.path, 'documents.jsonl'), this.flags.index, this.flags.collection);
+        this.logOk(`Successfully imported ${total} documents from "${this.args.path}" in "${index}:${collection}"`);
+    }
+}
+exports.default = CollectionImport;
+CollectionImport.keepAuth = true;
+CollectionImport.description = 'Imports a collection';
+CollectionImport.flags = Object.assign(Object.assign({ help: command_1.flags.help({}), 'batch-size': command_1.flags.string({
+        description: 'Maximum batch size (see limits.documentsWriteCount config)',
+        default: '200'
+    }), index: command_1.flags.string({
+        description: 'If set, override the index destination name',
+    }), collection: command_1.flags.string({
+        description: 'If set, override the collection destination name',
+    }), 'no-mappings': command_1.flags.boolean({
+        description: 'Skip collection mappings'
+    }) }, kuzzle_1.kuzzleFlags), { protocol: command_1.flags.string({
+        description: 'Kuzzle protocol (http or websocket)',
+        default: 'ws',
+    }) });
+CollectionImport.args = [
+    { name: 'path', description: 'Dump directory path', required: true },
+];