WIP to get this cleaned up

Author: blackmad

.eslintignore

@@ -0,0 +1 @@
+node_modules

.eslintrc.json

@@ -0,0 +1,12 @@
+{
+  "env": {
+    "commonjs": true,
+    "es6": true
+  },
+  "extends": ["airbnb-base",     "plugin:import/typescript",    "plugin:@typescript-eslint/recommended", "plugin:jsdoc/recommended"],
+  "parser": "@typescript-eslint/parser",
+  "plugins": ["jsdoc"],
+  "rules": {
+    "import/extensions": 0
+  }
+}

lib/api.ts

@@ -1,10 +1,13 @@
 /* eslint-disable no-console */
-import * as _ from "lodash";
+import * as _ from 'lodash';
 import * as queryString from 'query-string';
-import { globalCommandLineOptions } from "./cli-utils";
-import { argvToApiEnv, getApiEnvCommandLineOptions, ApiEnv, fixApiEnvKey } from "./apiEnv";
-import { runQuery } from "./run-query";
-import config from "./config";
+import * as chalk from 'chalk';
+import { globalCommandLineOptions } from './cli-utils';
+import {
+  argvToApiEnv, getApiEnvCommandLineOptions, ApiEnv, fixApiEnvKey,
+} from './apiEnv';
+import runQuery from './run-query';
+import config from './config';
 
 const makeUsageString = (toolName: string) => `This tool has a lot of options, here are some examples:
 
@@ -19,10 +22,17 @@ ${toolName} --local /v1/endpoint param1=X param2=Y
 
 ${toolName} --local /v1/endpoint --env=staging param1=X param2=Y 
     would run against localhost, but look for STAGING_API_KEY
-`
-
-function parseArgv() {
-  let yargs = require("yargs");
+`;
+
+/**
+ * Return parsed commandline arguments
+ *
+ * @returns {any} the parsed commandline arguments
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parseArgv(): any {
+  // eslint-disable-next-line global-require, @typescript-eslint/no-var-requires
+  const yargs = require('yargs');
 
   yargs.usage(makeUsageString(process.argv[0]));
 
@@ -42,27 +52,13 @@ const argv = parseArgv();
 let endpoint = argv._[0];
 
 if (!endpoint) {
-  console.error("This tool requires an api endpoint to be specified");
+  console.error('This tool requires an api endpoint to be specified');
   process.exit(1);
 }
 
-function printResponse(response: any) {
-  console.log(response);
-
-  if (typeof response === "object") {
-    if (process.stdout.isTTY) {
-      console.dir(response, { depth: null, colors: true });
-    } else {
-      console.log(JSON.stringify(response, null, 4));
-    }
-  } else {
-    console.log(response);
-  }
-}
-
 let apiEnv: ApiEnv;
 
-let params: any = {};
+let params: Record<string, string> = {};
 
 if (argv._.length === 1 && argv._[0].startsWith('http')) {
   // The user just specified a radar url, they probably just want to run it with the
@@ -77,27 +73,29 @@ if (argv._.length === 1 && argv._[0].startsWith('http')) {
   if (!apiEnv.keyEnv) {
     _.forEach(config.hosts, (hostEntry) => {
       if (url.host === hostEntry.host) {
-        apiEnv.keyEnv = hostEntry.keyEnv
+        apiEnv.keyEnv = hostEntry.keyEnv;
       }
-    })
+    });
   }
 
   fixApiEnvKey(apiEnv);
 
   endpoint = url.pathname;
-  params = queryString.parse(url.search);
+  params = queryString.parse(url.search) as Record<string, string>;
 } else {
   apiEnv = argvToApiEnv(argv);
 
   argv._.slice(1).forEach((datum: string) => {
-    if (!datum.includes("=")) {
+    if (!datum.includes('=')) {
       console.error(`data argument ${datum} did not have =, exiting`);
       process.exit(1);
     }
-    const key = datum.split("=")[0];
-    const value = datum.split("=")[1];
+    const key = datum.split('=')[0];
+    const value = datum.split('=')[1];
     params[key] = value;
   });
 }
 
-runQuery(apiEnv, { params, method: argv.method, endpoint, verbose: true }).then(({ data }) => printResponse(data));
+runQuery(apiEnv, {
+  params, method: argv.method, endpoint, verbose: true,
+}).then(({ data }) => console.dir(data, { depth: null, colors: chalk.level > 0 }));

lib/apiEnv.ts

@@ -1,38 +1,44 @@
-import * as _ from "lodash";
-import logger from "./logger";
-import { ConfigHostEntry } from "./config";
-import config from "./config";
-import { failedExit } from "./cli-utils";
+import * as _ from 'lodash';
+import logger from './logger';
+import config, { ConfigHostEntry } from './config';
+
+import { failedExit } from './cli-utils';
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+require('dotenv').config();
 
 const apiEnvCommandLineOptions: Record<string, any> = {
   host: {
-    type: "string",
-    description: "Host/port - will override --env",
+    type: 'string',
+    description: 'Host/port - will override --env',
   },
   protocol: {
-    choices: ["http", "https"],
+    choices: ['http', 'https'],
     description:
-      "What protocol to use (if not specified in url), defaults to http for local, https otherwise",
+      'What protocol to use (if not specified in url), defaults to http for local, https otherwise',
   },
   key: {
-    type: "string",
-    description: `Authorization key, if not specified will try to find one in the env, in .env or, in local mode, directly in mongo`,
+    type: 'string',
+    description: 'Authorization key, if not specified will try to find one in the env, in .env or, in local mode, directly in mongo',
   },
 };
 
+/**
+ *
+ */
 export function getApiEnvCommandLineOptions(): Record<string, any> {
   if (config.keyTypes) {
     apiEnvCommandLineOptions.key_type = {
       choices: config.keyTypes,
       default: config.keyTypes[0],
-      description: "authorization key type to use",
+      description: 'authorization key type to use',
     };
   }
 
   if (config.hosts) {
     apiEnvCommandLineOptions.env = {
       choices: [..._.keys(config.hosts), ..._.flatMap(config.hosts, (v) => v.aliases || [])],
-      description: `api host to talk to`,
+      description: 'api host to talk to',
     };
 
     _.forEach(config.hosts, (hostEntry: ConfigHostEntry, key: string) => {
@@ -53,44 +59,55 @@ export interface ApiEnv {
   keyType?: string;
 }
 
-type KeyParams = Pick<ApiEnv, "keyEnv" | "keyType">;
+type KeyParams = Pick<ApiEnv, 'keyEnv' | 'keyType'>;
 
+/**
+ * @param root0
+ * @param root0.keyEnv
+ * @param root0.keyType
+ */
 function findKey({ keyEnv, keyType }: KeyParams): string {
-  require("dotenv").config();
-
-  const env_variable_name = [keyEnv, keyType, "API_KEY"]
+  const envVariableName = [keyEnv, keyType, 'API_KEY']
     .filter((s) => !_.isEmpty(s))
-    .join("_")
+    .join('_')
     .toUpperCase();
-  logger.info(`Looking for key in env ${env_variable_name}`);
-  const key = process.env[env_variable_name];
+  logger.info(`Looking for key in env ${envVariableName}`);
+  const key = process.env[envVariableName];
   if (!key) {
-    failedExit(`No key found for ${env_variable_name} in .env and --key not specified`);
+    failedExit(`No key found for ${envVariableName} in .env and --key not specified`);
   }
   return key;
 }
 
-export function fixApiEnvKey(apiEnv: Partial<ApiEnv>) {
-  apiEnv.key =
-    apiEnv.key ||
-    findKey({ keyEnv: apiEnv.keyEnv || "", keyType: apiEnv.keyType || config.keyTypes?.[0] });
+/**
+ * @param apiEnv
+ */
+export function fixApiEnvKey(apiEnv: Partial<ApiEnv>): void {
+  // eslint-disable-next-line no-param-reassign
+  apiEnv.key = apiEnv.key
+    || findKey({ keyEnv: apiEnv.keyEnv || '', keyType: apiEnv.keyType || config.keyTypes?.[0] });
 }
 
+/**
+ * @param argv
+ */
 export function argvToApiEnv(argv: any): ApiEnv {
   let apiEnv: Partial<ApiEnv> = _.clone(argv);
 
   let aliasedHostEntry: ConfigHostEntry;
   _.forEach(config.hosts, (hostEntry: ConfigHostEntry, key: string) => {
     if (argv[key]) {
       if (aliasedHostEntry) {
-        throw new Error(`Can only specify one of ${_.keys(config.hosts).join(",")}`);
+        throw new Error(`Can only specify one of ${_.keys(config.hosts).join(',')}`);
       }
 
       if (hostEntry.takesArg) {
         const toReplace = key.toUpperCase();
+        // eslint-disable-next-line no-param-reassign
         hostEntry.host = hostEntry.host.replace(toReplace, argv[key]);
       }
 
+      // eslint-disable-next-line no-param-reassign
       hostEntry.keyEnv = hostEntry.keyEnv || key;
 
       aliasedHostEntry = hostEntry;
@@ -104,10 +121,10 @@ export function argvToApiEnv(argv: any): ApiEnv {
     };
   }
 
-  if (apiEnv.host.startsWith("http")) {
+  if (apiEnv.host.startsWith('http')) {
     const url = new URL(apiEnv.host);
     apiEnv.host = url.host;
-    apiEnv.protocol = url.protocol.replace(":", "");
+    apiEnv.protocol = url.protocol.replace(':', '');
   }
 
   fixApiEnvKey(apiEnv);

lib/cli-utils.ts

@@ -1,16 +1,19 @@
+/**
+ * @param msg
+ */
 export function failedExit(msg: string) {
   console.error(msg);
   process.exit(1);
 }
 
 export const globalCommandLineOptions = {
   method: {
-    choices: ["GET", "POST", "PUT"],
-    default: "GET",
-    description: "what http method to use",
+    choices: ['GET', 'POST', 'PUT'],
+    default: 'GET',
+    description: 'what http method to use',
   },
   color: {
-    type: "boolean",
-    description: "turns on/off colorized output, defaults to true for stdin, false for redirected output"
+    type: 'boolean',
+    description: 'turns on/off colorized output, defaults to true for stdin, false for redirected output',
   },
-};
+};