kourou 0.24.2 → 0.25.0

package/lib/commands/user/import.js

@@ -2,24 +2,22 @@
 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 fs_1 = (0, tslib_1.__importDefault)(require("fs"));
 const common_1 = require("../../common");
 const kuzzle_1 = require("../../support/kuzzle");
 const restore_securities_1 = require("../../support/restore-securities");
 class UserImport extends common_1.Kommand {
     async runSafe() {
         this.logInfo(`Importing users from ${this.args.path} ...`);
-        const dump = JSON.parse(fs_1.default.readFileSync(this.args.path, 'utf-8'));
+        const dump = JSON.parse(fs_1.default.readFileSync(this.args.path, "utf-8"));
         const count = await (0, restore_securities_1.restoreUsers)(this, dump);
         this.logOk(`${count} users restored`);
     }
 }
 exports.default = UserImport;
-UserImport.description = 'Imports users';
+UserImport.description = "Imports users";
 UserImport.flags = Object.assign(Object.assign({ help: command_1.flags.help({}) }, kuzzle_1.kuzzleFlags), { protocol: command_1.flags.string({
-        description: 'Kuzzle protocol (http or websocket)',
-        default: 'ws',
+        description: "Kuzzle protocol (http or websocket)",
+        default: "ws",
     }) });
-UserImport.args = [
-    { name: 'path', description: 'Dump file', required: true },
-];
+UserImport.args = [{ name: "path", description: "Dump file", required: true }];

package/lib/commands/vault/add.d.ts

@@ -1,11 +1,11 @@
-import { flags } from '@oclif/command';
-import { Kommand } from '../../common';
+import { flags } from "@oclif/command";
+import { Kommand } from "../../common";
 export declare class VaultAdd extends Kommand {
     static initSdk: boolean;
     static description: string;
     static examples: string[];
     static flags: {
-        'vault-key': flags.IOptionFlag<string | undefined>;
+        "vault-key": flags.IOptionFlag<string | undefined>;
     };
     static args: {
         name: string;

package/lib/commands/vault/add.js

@@ -2,34 +2,34 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VaultAdd = void 0;
 const tslib_1 = require("tslib");
-const fs_1 = tslib_1.__importDefault(require("fs"));
+const fs_1 = (0, tslib_1.__importDefault)(require("fs"));
 const command_1 = require("@oclif/command");
-const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const lodash_1 = (0, tslib_1.__importDefault)(require("lodash"));
 const kuzzle_vault_1 = require("kuzzle-vault");
 const common_1 = require("../../common");
 class VaultAdd extends common_1.Kommand {
     async runSafe() {
-        if (lodash_1.default.isEmpty(this.flags['vault-key'])) {
-            throw new Error('A vault key must be provided');
+        if (lodash_1.default.isEmpty(this.flags["vault-key"])) {
+            throw new Error("A vault key must be provided");
         }
-        if (lodash_1.default.isEmpty(this.args['secrets-file'])) {
-            throw new Error('A secrets file must be provided');
+        if (lodash_1.default.isEmpty(this.args["secrets-file"])) {
+            throw new Error("A secrets file must be provided");
         }
-        const cryptonomicon = new kuzzle_vault_1.Cryptonomicon(this.flags['vault-key']);
-        const PARSER = kuzzle_vault_1.Vault.getParser(this.args['secrets-file']);
+        const cryptonomicon = new kuzzle_vault_1.Cryptonomicon(this.flags["vault-key"]);
+        const PARSER = kuzzle_vault_1.Vault.getParser(this.args["secrets-file"]);
         let encryptedSecrets = {};
-        if (fs_1.default.existsSync(this.args['secrets-file'])) {
-            encryptedSecrets = PARSER.parse(fs_1.default.readFileSync(this.args['secrets-file'], 'utf8'));
+        if (fs_1.default.existsSync(this.args["secrets-file"])) {
+            encryptedSecrets = PARSER.parse(fs_1.default.readFileSync(this.args["secrets-file"], "utf8"));
             try {
                 cryptonomicon.decryptObject(encryptedSecrets);
             }
             catch (error) {
-                throw new Error('Trying to add a secret encrypted with a different key');
+                throw new Error("Trying to add a secret encrypted with a different key");
             }
         }
         lodash_1.default.set(encryptedSecrets, this.args.key, cryptonomicon.encryptString(this.args.value));
-        fs_1.default.writeFileSync(this.args['secrets-file'], PARSER.stringify(encryptedSecrets, null, 2));
-        this.logOk(`Key "${this.args.key}" has been securely added "${this.args['secrets-file']}"`);
+        fs_1.default.writeFileSync(this.args["secrets-file"], PARSER.stringify(encryptedSecrets, null, 2));
+        this.logOk(`Key "${this.args.key}" has been securely added "${this.args["secrets-file"]}"`);
     }
 }
 exports.VaultAdd = VaultAdd;
@@ -44,16 +44,24 @@ Encrypted secrets are meant to be loaded inside an application with Kuzzle Vault
 See https://github.com/kuzzleio/kuzzle-vault/ for more information.
 `;
 VaultAdd.examples = [
-    'kourou vault:add config/secrets.enc.json aws.s3.keyId b61e267676660c314b006b06 --vault-key <vault-key>'
+    "kourou vault:add config/secrets.enc.json aws.s3.keyId b61e267676660c314b006b06 --vault-key <vault-key>",
 ];
 VaultAdd.flags = {
-    'vault-key': command_1.flags.string({
-        description: 'Kuzzle Vault Key (or KUZZLE_VAULT_KEY)',
+    "vault-key": command_1.flags.string({
+        description: "Kuzzle Vault Key (or KUZZLE_VAULT_KEY)",
         default: process.env.KUZZLE_VAULT_KEY,
     }),
 };
 VaultAdd.args = [
-    { name: 'secrets-file', description: 'Encrypted secrets file', required: true },
-    { name: 'key', description: 'Path to the key (lodash style)', required: true },
-    { name: 'value', description: 'Value to encrypt', required: true }
+    {
+        name: "secrets-file",
+        description: "Encrypted secrets file",
+        required: true,
+    },
+    {
+        name: "key",
+        description: "Path to the key (lodash style)",
+        required: true,
+    },
+    { name: "value", description: "Value to encrypt", required: true },
 ];

package/lib/commands/vault/decrypt.d.ts

@@ -1,13 +1,13 @@
-import { flags } from '@oclif/command';
-import { Kommand } from '../../common';
+import { flags } from "@oclif/command";
+import { Kommand } from "../../common";
 export declare class VaultDecrypt extends Kommand {
     static initSdk: boolean;
     static description: string;
     static examples: string[];
     static flags: {
         force: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-        'output-file': flags.IOptionFlag<string | undefined>;
-        'vault-key': flags.IOptionFlag<string | undefined>;
+        "output-file": flags.IOptionFlag<string | undefined>;
+        "vault-key": flags.IOptionFlag<string | undefined>;
     };
     static args: {
         name: string;

package/lib/commands/vault/decrypt.js

@@ -2,34 +2,34 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VaultDecrypt = void 0;
 const tslib_1 = require("tslib");
-const fs_1 = tslib_1.__importDefault(require("fs"));
-const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const fs_1 = (0, tslib_1.__importDefault)(require("fs"));
+const lodash_1 = (0, tslib_1.__importDefault)(require("lodash"));
 const command_1 = require("@oclif/command");
 const kuzzle_vault_1 = require("kuzzle-vault");
 const common_1 = require("../../common");
 class VaultDecrypt extends common_1.Kommand {
     async runSafe() {
-        if (lodash_1.default.isEmpty(this.flags['vault-key'])) {
-            throw new Error('A vault key must be provided');
+        if (lodash_1.default.isEmpty(this.flags["vault-key"])) {
+            throw new Error("A vault key must be provided");
         }
         if (lodash_1.default.isEmpty(this.args.file)) {
-            throw new Error('A secrets file must be provided');
+            throw new Error("A secrets file must be provided");
         }
-        let outputFile = `${this.args.file.replace('.enc', '')}`;
-        if (this.flags['output-file']) {
-            outputFile = this.flags['output-file'];
+        let outputFile = `${this.args.file.replace(".enc", "")}`;
+        if (this.flags["output-file"]) {
+            outputFile = this.flags["output-file"];
         }
         if (fs_1.default.existsSync(outputFile) && !this.flags.force) {
             throw new Error(`Output file "${outputFile}" already exists. Use -f flag to overwrite it.`);
         }
-        const cryptonomicon = new kuzzle_vault_1.Cryptonomicon(this.flags['vault-key']);
+        const cryptonomicon = new kuzzle_vault_1.Cryptonomicon(this.flags["vault-key"]);
         if (!fs_1.default.existsSync(this.args.file)) {
             throw new Error(`File "${this.args.file}" does not exists`);
         }
         const PARSER = kuzzle_vault_1.Vault.getParser(this.args.file);
         let encryptedSecrets = {};
         try {
-            encryptedSecrets = PARSER.parse(fs_1.default.readFileSync(this.args.file, 'utf8'));
+            encryptedSecrets = PARSER.parse(fs_1.default.readFileSync(this.args.file, "utf8"));
         }
         catch (error) {
             throw new Error(`Cannot read secrets from file "${this.args.file}": ${error.message}`);
@@ -49,23 +49,27 @@ Decrypted secrets file must NEVER be committed into the repository.
 See https://github.com/kuzzleio/kuzzle-vault/ for more information.
 `;
 VaultDecrypt.examples = [
-    'kourou vault:decrypt config/secrets.enc.json --vault-key <vault-key>',
-    'kourou vault:decrypt config/secrets.enc.json -o config/secrets.json --vault-key <vault-key>'
+    "kourou vault:decrypt config/secrets.enc.json --vault-key <vault-key>",
+    "kourou vault:decrypt config/secrets.enc.json -o config/secrets.json --vault-key <vault-key>",
 ];
 VaultDecrypt.flags = {
     force: command_1.flags.boolean({
-        char: 'f',
-        description: 'Overwrite the output file if it already exists'
+        char: "f",
+        description: "Overwrite the output file if it already exists",
     }),
-    'output-file': command_1.flags.string({
-        char: 'o',
-        description: 'Output file (default: remove ".enc")'
+    "output-file": command_1.flags.string({
+        char: "o",
+        description: 'Output file (default: remove ".enc")',
     }),
-    'vault-key': command_1.flags.string({
-        description: 'Kuzzle Vault Key (or KUZZLE_VAULT_KEY)',
+    "vault-key": command_1.flags.string({
+        description: "Kuzzle Vault Key (or KUZZLE_VAULT_KEY)",
         default: process.env.KUZZLE_VAULT_KEY,
     }),
 };
 VaultDecrypt.args = [
-    { name: 'file', description: 'File containing encrypted secrets', required: true }
+    {
+        name: "file",
+        description: "File containing encrypted secrets",
+        required: true,
+    },
 ];

package/lib/commands/vault/encrypt.d.ts

@@ -1,13 +1,13 @@
-import { flags } from '@oclif/command';
-import { Kommand } from '../../common';
+import { flags } from "@oclif/command";
+import { Kommand } from "../../common";
 export declare class VaultEncrypt extends Kommand {
     static initSdk: boolean;
     static description: string;
     static examples: string[];
     static flags: {
         force: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-        'output-file': flags.IOptionFlag<string | undefined>;
-        'vault-key': flags.IOptionFlag<string | undefined>;
+        "output-file": flags.IOptionFlag<string | undefined>;
+        "vault-key": flags.IOptionFlag<string | undefined>;
     };
     static args: {
         name: string;

package/lib/commands/vault/encrypt.js

@@ -2,36 +2,36 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VaultEncrypt = void 0;
 const tslib_1 = require("tslib");
-const fs_1 = tslib_1.__importDefault(require("fs"));
-const path_1 = tslib_1.__importDefault(require("path"));
-const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const fs_1 = (0, tslib_1.__importDefault)(require("fs"));
+const path_1 = (0, tslib_1.__importDefault)(require("path"));
+const lodash_1 = (0, tslib_1.__importDefault)(require("lodash"));
 const command_1 = require("@oclif/command");
 const kuzzle_vault_1 = require("kuzzle-vault");
 const common_1 = require("../../common");
 class VaultEncrypt extends common_1.Kommand {
     async runSafe() {
-        if (lodash_1.default.isEmpty(this.flags['vault-key'])) {
-            throw new Error('A vault key must be provided');
+        if (lodash_1.default.isEmpty(this.flags["vault-key"])) {
+            throw new Error("A vault key must be provided");
         }
         if (lodash_1.default.isEmpty(this.args.file)) {
-            throw new Error('A secrets file must be provided');
+            throw new Error("A secrets file must be provided");
         }
         const { name, ext } = path_1.default.parse(this.args.file);
         let outputFile = `${name}.enc${ext}`;
-        if (this.flags['output-file']) {
-            outputFile = this.flags['output-file'];
+        if (this.flags["output-file"]) {
+            outputFile = this.flags["output-file"];
         }
         if (fs_1.default.existsSync(outputFile) && !this.flags.force) {
             throw new Error(`Output file "${outputFile}" already exists. Use -f flag to overwrite it.`);
         }
-        const cryptonomicon = new kuzzle_vault_1.Cryptonomicon(this.flags['vault-key']);
+        const cryptonomicon = new kuzzle_vault_1.Cryptonomicon(this.flags["vault-key"]);
         if (!fs_1.default.existsSync(this.args.file)) {
             throw new Error(`File "${this.args.file}" does not exists`);
         }
         const PARSER = kuzzle_vault_1.Vault.getParser(this.args.file);
         let secrets = {};
         try {
-            secrets = PARSER.parse(fs_1.default.readFileSync(this.args.file, 'utf8'));
+            secrets = PARSER.parse(fs_1.default.readFileSync(this.args.file, "utf8"));
         }
         catch (error) {
             throw new Error(`Cannot read secrets from file "${this.args.file}": ${error.message}`);
@@ -62,23 +62,27 @@ Encrypted secrets are meant to be loaded inside an application with Kuzzle Vault
 See https://github.com/kuzzleio/kuzzle-vault/ for more information.
 `;
 VaultEncrypt.examples = [
-    'kourou vault:encrypt config/secrets.json --vault-key <vault-key>',
-    'kourou vault:encrypt config/secrets.json -o config/secrets_prod.enc.json --vault-key <vault-key>'
+    "kourou vault:encrypt config/secrets.json --vault-key <vault-key>",
+    "kourou vault:encrypt config/secrets.json -o config/secrets_prod.enc.json --vault-key <vault-key>",
 ];
 VaultEncrypt.flags = {
     force: command_1.flags.boolean({
-        char: 'f',
-        description: 'Overwrite the output file if it already exists'
+        char: "f",
+        description: "Overwrite the output file if it already exists",
     }),
-    'output-file': command_1.flags.string({
-        char: 'o',
-        description: 'Output file (default: <file>.enc.json)'
+    "output-file": command_1.flags.string({
+        char: "o",
+        description: "Output file (default: <file>.enc.json)",
     }),
-    'vault-key': command_1.flags.string({
-        description: 'Kuzzle Vault Key (or KUZZLE_VAULT_KEY)',
+    "vault-key": command_1.flags.string({
+        description: "Kuzzle Vault Key (or KUZZLE_VAULT_KEY)",
         default: process.env.KUZZLE_VAULT_KEY,
     }),
 };
 VaultEncrypt.args = [
-    { name: 'file', description: 'File containing unencrypted secrets', required: true }
+    {
+        name: "file",
+        description: "File containing unencrypted secrets",
+        required: true,
+    },
 ];

package/lib/commands/vault/show.d.ts

@@ -1,11 +1,11 @@
-import { flags } from '@oclif/command';
-import { Kommand } from '../../common';
+import { flags } from "@oclif/command";
+import { Kommand } from "../../common";
 export declare class VaultShow extends Kommand {
     static initSdk: boolean;
     static description: string;
     static examples: string[];
     static flags: {
-        'vault-key': flags.IOptionFlag<string | undefined>;
+        "vault-key": flags.IOptionFlag<string | undefined>;
     };
     static args: ({
         name: string;

package/lib/commands/vault/show.js

@@ -3,30 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VaultShow = void 0;
 const tslib_1 = require("tslib");
 const command_1 = require("@oclif/command");
-const lodash_1 = tslib_1.__importDefault(require("lodash"));
-const fs_1 = tslib_1.__importDefault(require("fs"));
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const lodash_1 = (0, tslib_1.__importDefault)(require("lodash"));
+const fs_1 = (0, tslib_1.__importDefault)(require("fs"));
+const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
 const kuzzle_vault_1 = require("kuzzle-vault");
 const common_1 = require("../../common");
 class VaultShow extends common_1.Kommand {
     async runSafe() {
-        if (lodash_1.default.isEmpty(this.flags['vault-key'])) {
-            throw new Error('A vault key must be provided');
+        if (lodash_1.default.isEmpty(this.flags["vault-key"])) {
+            throw new Error("A vault key must be provided");
         }
-        if (lodash_1.default.isEmpty(this.args['secrets-file'])) {
-            throw new Error('A secrets file must be provided');
+        if (lodash_1.default.isEmpty(this.args["secrets-file"])) {
+            throw new Error("A secrets file must be provided");
         }
-        const cryptonomicon = new kuzzle_vault_1.Cryptonomicon(this.flags['vault-key']);
-        if (!fs_1.default.existsSync(this.args['secrets-file'])) {
-            throw new Error(`File "${this.args['secrets-file']}" does not exists`);
+        const cryptonomicon = new kuzzle_vault_1.Cryptonomicon(this.flags["vault-key"]);
+        if (!fs_1.default.existsSync(this.args["secrets-file"])) {
+            throw new Error(`File "${this.args["secrets-file"]}" does not exists`);
         }
-        const PARSER = kuzzle_vault_1.Vault.getParser(this.args['secrets-file']);
+        const PARSER = kuzzle_vault_1.Vault.getParser(this.args["secrets-file"]);
         let encryptedSecrets = {};
         try {
-            encryptedSecrets = PARSER.parse(fs_1.default.readFileSync(this.args['secrets-file'], 'utf8'));
+            encryptedSecrets = PARSER.parse(fs_1.default.readFileSync(this.args["secrets-file"], "utf8"));
         }
         catch (error) {
-            throw new Error(`Cannot read secrets from file "${this.args['secrets-file']}": ${error.message}`);
+            throw new Error(`Cannot read secrets from file "${this.args["secrets-file"]}": ${error.message}`);
         }
         if (this.args.key) {
             const encryptedValue = lodash_1.default.get(encryptedSecrets, this.args.key);
@@ -39,7 +39,7 @@ class VaultShow extends common_1.Kommand {
         }
         else {
             const decryptedSecrets = cryptonomicon.decryptObject(encryptedSecrets);
-            this.logOk('Secrets file content:');
+            this.logOk("Secrets file content:");
             this.log(chalk_1.default.green(PARSER.stringify(decryptedSecrets, null, 2)));
         }
     }
@@ -56,16 +56,20 @@ This method can display either:
 See https://github.com/kuzzleio/kuzzle-vault/ for more information.
 `;
 VaultShow.examples = [
-    'kourou vault:show config/secrets.enc.json --vault-key <vault-key>',
-    'kourou vault:show config/secrets.enc.json aws.s3.secretKey --vault-key <vault-key>'
+    "kourou vault:show config/secrets.enc.json --vault-key <vault-key>",
+    "kourou vault:show config/secrets.enc.json aws.s3.secretKey --vault-key <vault-key>",
 ];
 VaultShow.flags = {
-    'vault-key': command_1.flags.string({
-        description: 'Kuzzle Vault Key (or KUZZLE_VAULT_KEY)',
+    "vault-key": command_1.flags.string({
+        description: "Kuzzle Vault Key (or KUZZLE_VAULT_KEY)",
         default: process.env.KUZZLE_VAULT_KEY,
     }),
 };
 VaultShow.args = [
-    { name: 'secrets-file', description: 'Encrypted secrets file', required: true },
-    { name: 'key', description: 'Path to a key (lodash style)' },
+    {
+        name: "secrets-file",
+        description: "Encrypted secrets file",
+        required: true,
+    },
+    { name: "key", description: "Path to a key (lodash style)" },
 ];

package/lib/commands/vault/test.d.ts

@@ -1,11 +1,11 @@
-import { flags } from '@oclif/command';
-import { Kommand } from '../../common';
+import { flags } from "@oclif/command";
+import { Kommand } from "../../common";
 export declare class VaultTest extends Kommand {
     static initSdk: boolean;
     static description: string;
     static examples: string[];
     static flags: {
-        'vault-key': flags.IOptionFlag<string | undefined>;
+        "vault-key": flags.IOptionFlag<string | undefined>;
     };
     static args: {
         name: string;

package/lib/commands/vault/test.js

@@ -3,21 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VaultTest = void 0;
 const tslib_1 = require("tslib");
 const command_1 = require("@oclif/command");
-const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const lodash_1 = (0, tslib_1.__importDefault)(require("lodash"));
 const kuzzle_vault_1 = require("kuzzle-vault");
 const common_1 = require("../../common");
 class VaultTest extends common_1.Kommand {
     async runSafe() {
-        if (lodash_1.default.isEmpty(this.flags['vault-key'])) {
-            throw new Error('A vault key must be provided');
+        if (lodash_1.default.isEmpty(this.flags["vault-key"])) {
+            throw new Error("A vault key must be provided");
         }
-        if (lodash_1.default.isEmpty(this.args['secrets-file'])) {
-            throw new Error('A secrets file must be provided');
+        if (lodash_1.default.isEmpty(this.args["secrets-file"])) {
+            throw new Error("A secrets file must be provided");
         }
-        const vault = new kuzzle_vault_1.Vault(this.flags['vault-key']);
+        const vault = new kuzzle_vault_1.Vault(this.flags["vault-key"]);
         try {
-            vault.decrypt(this.args['secrets-file']);
-            this.logOk('Secrets file can be decrypted');
+            vault.decrypt(this.args["secrets-file"]);
+            this.logOk("Secrets file can be decrypted");
         }
         catch (error) {
             this.logKo(`Secrets file cannot be decrypted: ${error.message}`);
@@ -32,14 +32,18 @@ Tests if an encrypted secrets file can be decrypted.
 See https://github.com/kuzzleio/kuzzle-vault/ for more information.
 `;
 VaultTest.examples = [
-    'kourou vault:test config/secrets.enc.json --vault-key <vault-key>'
+    "kourou vault:test config/secrets.enc.json --vault-key <vault-key>",
 ];
 VaultTest.flags = {
-    'vault-key': command_1.flags.string({
-        description: 'Kuzzle Vault Key (or KUZZLE_VAULT_KEY)',
+    "vault-key": command_1.flags.string({
+        description: "Kuzzle Vault Key (or KUZZLE_VAULT_KEY)",
         default: process.env.KUZZLE_VAULT_KEY,
     }),
 };
 VaultTest.args = [
-    { name: 'secrets-file', description: 'Encrypted secrets file', required: true }
+    {
+        name: "secrets-file",
+        description: "Encrypted secrets file",
+        required: true,
+    },
 ];

package/lib/common.d.ts

@@ -1,6 +1,6 @@
-import { Command } from '@oclif/command';
-import { KuzzleSDK } from './support/kuzzle';
-import { EditorParams } from './support/editor';
+import { Command } from "@oclif/command";
+import { KuzzleSDK } from "./support/kuzzle";
+import { EditorParams } from "./support/editor";
 export declare abstract class Kommand extends Command {
     protected sdk: KuzzleSDK;
     private exitCode;