secrez 1.1.1 → 1.1.2

package/src/Command.js

@@ -1,115 +1,136 @@
-const {chalk} = require('./utils/Logger')
-const Logger = require('./utils/Logger')
-const cliConfig = require('./cliConfig')
-const PreCommand = require('./PreCommand')
+const { chalk } = require("./utils/Logger");
+const Logger = require("./utils/Logger");
+const cliConfig = require("./cliConfig");
+const PreCommand = require("./PreCommand");
 
 class Command extends PreCommand {
-
   constructor(prompt) {
-    super()
-    this.prompt = prompt
-    this.secrez = prompt.secrez
-    this.optionDefinitions = []
-    this.cliConfig = cliConfig
-    this.internalFs = prompt.internalFs
-    this.externalFs = prompt.externalFs
-    this.Logger = Logger
-    this.chalk = chalk
+    super();
+    this.prompt = prompt;
+    this.secrez = prompt.secrez;
+    this.optionDefinitions = [];
+    this.cliConfig = cliConfig;
+    this.internalFs = prompt.internalFs;
+    this.externalFs = prompt.externalFs;
+    this.Logger = Logger;
+    this.chalk = chalk;
   }
 
-  help() {
-  }
+  help() {}
 
   showHelp() {
-    let command = this.constructor.name.toLowerCase()
-    this.prompt.commands.help.exec({command})
+    let command = this.constructor.name.toLowerCase();
+    this.prompt.commands.help.exec({ command });
   }
 
-  setHelpAndCompletion() {
-  }
+  setHelpAndCompletion() {}
 
   getCompletionType(option) {
     if (!this.completionTypes) {
-      this.completionTypes = {}
+      this.completionTypes = {};
       for (let item of this.optionDefinitions) {
-        this.completionTypes[item.name] = item.completionType
+        this.completionTypes[item.name] = item.completionType;
       }
     }
-    return this.completionTypes[option]
+    return this.completionTypes[option];
   }
 
   selfCompletion(self, extraOptions = {}) {
     return async (options, originalLine, currentOption) => {
-      options = Object.assign(options, extraOptions)
-      options.forAutoComplete = true
-      let completionType = this.getCompletionType(currentOption)
+      options = Object.assign(options, extraOptions);
+      options.forAutoComplete = true;
+      let completionType = this.getCompletionType(currentOption);
       /* istanbul ignore if  */
       if (this.customCompletion) {
-        let extra = await this.customCompletion(options, originalLine, currentOption)
+        let extra = await this.customCompletion(
+          options,
+          originalLine,
+          currentOption
+        );
         if (extra) {
-          return extra
+          return extra;
         }
       }
-      if (completionType === 'dataset') {
-        let datasetsInfo = await this.internalFs.getDatasetsInfo()
-        options.forAutoComplete = true
+      if (completionType === "dataset") {
+        let datasetsInfo = await this.internalFs.getDatasetsInfo();
+        options.forAutoComplete = true;
         if (options.dataset) {
-          return datasetsInfo.map(e => e.name).filter(e => RegExp('^' + options.dataset).test(e))
+          return datasetsInfo
+            .map((e) => e.name)
+            .filter((e) => RegExp("^" + options.dataset).test(e));
         } else {
-          return datasetsInfo.map(e => e.name)
+          return datasetsInfo.map((e) => e.name);
         }
       }
-      if ((process.env.NODE_ENV === 'test' && currentOption === 'path')
-          || completionType === 'file') {
+      if (
+        (process.env.NODE_ENV === "test" && currentOption === "path") ||
+        completionType === "file"
+      ) {
         if (options[currentOption] === null) {
-          delete options[currentOption]
+          delete options[currentOption];
         }
-        if (currentOption !== 'path') {
-          options.path = options[currentOption]
+        if (currentOption !== "path") {
+          options.path = options[currentOption];
         }
-        if (self.prompt.cache && self.prompt.cache.findResult && /^(#|£)\d+$/.test(options.path)) {
-          return [options.path + self.prompt.cache.findResult[options.path.replace(/^(#|£)/, '')][1] || undefined]
+        if (
+          self.prompt.cache &&
+          self.prompt.cache.findResult &&
+          /^(#|£)\d+$/.test(options.path)
+        ) {
+          return [
+            options.path +
+              self.prompt.cache.findResult[
+                options.path.replace(/^(#|£)/, "")
+              ][1] || undefined,
+          ];
         }
-        return await self.prompt[extraOptions.external ? 'externalFs' : 'internalFs'].getFileList(options, true)
+        return await self.prompt[
+          extraOptions.external ? "externalFs" : "internalFs"
+        ].getFileList(options, true);
       } else {
-        return []
+        return [];
       }
-    }
+    };
   }
 
   threeRedDots(large) {
-    return chalk.cyan(large ? '•••' : '···')
+    return chalk.cyan(large ? "•••" : "···");
   }
 
   checkPath(options) {
-    if (typeof options.path !== 'string' || !options.path) {
-      throw new Error('A valid path is required')
+    if (typeof options.path !== "string" || !options.path) {
+      throw new Error("A valid path is required");
     }
   }
 
   validate(options, mandatoryOptions) {
     if (options._unknown) {
-      throw new Error(`Unknown option: ${options._unknown} ` + chalk.grey(`(run "${this.constructor.name.toLowerCase()} -h" for help)`))
+      throw new Error(
+        `Unknown option: ${options._unknown} ` +
+          chalk.grey(
+            `(run "${this.constructor.name.toLowerCase()} -h" for help)`
+          )
+      );
     }
-    if (options.path && (/^(#|£)\d+\//.test(options.path) || /^(#|£)\d+\w+:\//.test(options.path))) {
-      options.path = options.path.replace(/^(#|£)\d+/, '')
+    if (
+      options.path &&
+      (/^(#|£)\d+\//.test(options.path) || /^(#|£)\d+\w+:\//.test(options.path))
+    ) {
+      options.path = options.path.replace(/^(#|£)\d+/, "");
     }
     if (mandatoryOptions) {
-      let err = ''
-      let prefix = 'Missing options: '
+      let err = "";
+      let prefix = "Missing options: ";
       for (let o in mandatoryOptions) {
         if (!options[o]) {
-          err += (err ? ', ' : '') + o
+          err += (err ? ", " : "") + o;
         }
       }
       if (err) {
-        throw new Error(prefix + err)
+        throw new Error(prefix + err);
       }
     }
   }
-
 }
 
-module.exports = Command
-
-
+module.exports = Command;

package/src/PreCommand.js

@@ -1,116 +1,120 @@
-const {chalk} = require('./utils/Logger')
-const Crypto = require('@secrez/crypto')
-const {utils: hubUtils} = require('@secrez/hub')
-const superagent = require('superagent')
+const { chalk } = require("./utils/Logger");
+const Crypto = require("@secrez/crypto");
+const { utils: hubUtils } = require("@secrez/hub");
+const superagent = require("superagent");
 
 class PreCommand {
-
   async useEditor(options) {
-    let message = 'your OS default editor.'
+    let message = "your OS default editor.";
     if (options.internal) {
-      message = 'the minimalistic internal editor.'
+      message = "the minimalistic internal editor.";
     } else if (options.editor) {
-      message = `${options.editor}.`
+      message = `${options.editor}.`;
     }
-    let extraMessage = chalk.dim('Press <enter> to launch ')
-        + message
-        + chalk.reset(
-            options.internal ? chalk.green('\n  Ctrl-d to save the changes. Ctrl-c to abort.') : ''
-        )
-    let {result} = await this.prompt.inquirer.prompt([{
-      type: 'multiEditor',
-      name: 'result',
-      message: 'Editing...',
-      default: options.content,
-      tempDir: this.cliConfig.tmpPath,
-      validate: function (text) {
-        return true
+    let extraMessage =
+      chalk.dim("Press <enter> to launch ") +
+      message +
+      chalk.reset(
+        options.internal
+          ? chalk.green("\n  Ctrl-d to save the changes. Ctrl-c to abort.")
+          : ""
+      );
+    let { result } = await this.prompt.inquirer.prompt([
+      {
+        type: "multiEditor",
+        name: "result",
+        message: "Editing...",
+        default: options.content,
+        tempDir: this.cliConfig.tmpPath,
+        validate: function (text) {
+          return true;
+        },
+        extraMessage,
       },
-      extraMessage
-    }])
-    return result
-
+    ]);
+    return result;
   }
 
-
   async useSelect(options) {
-    let cancel = '(cancel)'
+    let cancel = "(cancel)";
     if (!options.dontCancel) {
-      options.choices = options.choices.concat([cancel])
+      options.choices = options.choices.concat([cancel]);
     }
-    let {result} = await this.prompt.inquirer.prompt([
+    let { result } = await this.prompt.inquirer.prompt([
       {
-        type: 'list',
-        name: 'result',
+        type: "list",
+        name: "result",
         message: options.message,
-        choices: options.choices
-      }
-    ])
+        choices: options.choices,
+      },
+    ]);
     if (result === cancel) {
-      return
+      return;
     } else {
-      return result
+      return result;
     }
-
   }
 
   async useConfirm(options) {
-    let {result} = await this.prompt.inquirer.prompt([
+    let { result } = await this.prompt.inquirer.prompt([
       {
-        type: 'confirm',
-        name: 'result',
+        type: "confirm",
+        name: "result",
         message: options.message,
-        default: options.default
-      }
-    ])
-    return result
-
+        default: options.default,
+      },
+    ]);
+    return result;
   }
 
   async useInput(options) {
-
-    let prompt = this.prompt
-    let exitCode = Crypto.getRandomBase58String(2)
-    let {result} = await prompt.inquirer.prompt([
+    let prompt = this.prompt;
+    let exitCode = Crypto.getRandomBase58String(2);
+    let { result } = await prompt.inquirer.prompt([
       {
-        type: options.type || 'input',
-        name: 'result',
+        type: options.type || "input",
+        name: "result",
         message: options.message,
         default: options.content,
-        validate: val => {
+        validate: (val) => {
           if (val) {
             if (val === exitCode) {
-              return true
+              return true;
             } else if (options.validate) {
-              return options.validate(val, exitCode)
+              return options.validate(val, exitCode);
             } else if (val.length) {
-              return true
+              return true;
             }
           }
-          return chalk.grey(`Please, type the ${options.name}, or cancel typing ${chalk.bold(exitCode)}`)
-        }
-      }
-    ])
+          return chalk.grey(
+            `Please, type the ${options.name}, or cancel typing ${chalk.bold(
+              exitCode
+            )}`
+          );
+        },
+      },
+    ]);
     if (result !== exitCode) {
-      return result
+      return result;
     }
   }
 
   async callCourier(_payload, port, caCrt, pathname) {
-    const {payload, signature} = hubUtils.setPayloadAndSignIt(this.secrez, _payload)
+    const { payload, signature } = hubUtils.setPayloadAndSignIt(
+      this.secrez,
+      _payload
+    );
     try {
       const res = await superagent
-          .get(`https://localhost:${port}${pathname || ''}`)
-          .set('Accept', 'application/json')
-          .query({payload, signature})[caCrt ? 'ca' : 'trustLocalhost'](caCrt)
-      return res.body
+        .get(`https://localhost:${port}${pathname || ""}`)
+        .set("Accept", "application/json")
+        .query({ payload, signature })
+        [caCrt ? "ca" : "trustLocalhost"](caCrt);
+      return res.body;
     } catch (e) {
-      return {error: e.message}
+      return { error: e.message };
     }
   }
-
 }
 
-module.exports = PreCommand
-
-
+module.exports = PreCommand;