import api tool, make the whole thing configurable

Author: blackmad

.gitignore

@@ -104,3 +104,10 @@ dist
 
 # TernJS port file
 .tern-port
+
+
+*.txt
+*.log
+*.csv
+*.tsv
+config.hjson

api.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+./node_modules/.bin/ts-node lib/api.ts $@

compare.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+./node_modules/.bin/ts-node lib/compare.ts $@

config-example.hjson

@@ -0,0 +1,30 @@
+{
+  # "param" or "header"
+  authStyle: "header",
+
+  # only required if using authStyle="param"
+  # authParam: "api_key",
+
+  # first one is default
+  keyTypes: ['test', 'live'],
+
+  hosts: {
+    prod: {
+      host: 'prod.api.com',
+      aliases: ['production'],
+    }
+    staging: {
+      host: 'staging.api.com'
+    },
+    local: {
+      host: 'localhost:8000',
+      keyEnv: 'staging',
+      protocol: 'http',
+    },
+    user: {
+      takesArg: true,
+      host: 'USER-staging.api.com'
+      keyEnv: 'staging',
+    },
+  }
+}

lib/api.ts

@@ -0,0 +1,103 @@
+/* eslint-disable no-console */
+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";
+
+const makeUsageString = (toolName: string) => `This tool has a lot of options, here are some examples:
+
+${toolName} --prod /v1/endpoint param1=X param2=Y 
+    query /v1/endpoint in prod, with the params specified, and look for PROD_API_KEY in the environemnt or .env
+
+${toolName} --prod /v1/endpoint --key YYYY param1=X param2=Y 
+    same thing, but will use the key specified on the commandline
+
+${toolName} --local /v1/endpoint param1=X param2=Y 
+    would run against localhost, looking for LOCAL_API_KEY or reaching into mongo to try to find one
+
+${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");
+
+  yargs.usage(makeUsageString(process.argv[0]));
+
+  _.forEach(globalCommandLineOptions, (val, key) => {
+    yargs.option(key, val);
+  });
+
+  _.forEach(getApiEnvCommandLineOptions(), (val, key) => {
+    yargs.option(key, val);
+  });
+
+  return yargs.argv;
+}
+
+const argv = parseArgv();
+
+let endpoint = argv._[0];
+
+if (!endpoint) {
+  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 = {};
+
+if (argv._.length === 1 && argv._[0].startsWith('http')) {
+  // The user just specified a radar url, they probably just want to run it with the
+  // right api key. So infer all the params from the passed url
+  const url = new URL(argv._[0]);
+  apiEnv = {
+    ...apiEnv,
+    protocol: url.protocol.replace(':', ''),
+    host: url.host,
+  };
+
+  if (!apiEnv.keyEnv) {
+    _.forEach(config.hosts, (hostEntry) => {
+      if (url.host === hostEntry.host) {
+        apiEnv.keyEnv = hostEntry.keyEnv
+      }
+    })
+  }
+
+  fixApiEnvKey(apiEnv);
+
+  endpoint = url.pathname;
+  params = queryString.parse(url.search);
+} else {
+  apiEnv = argvToApiEnv(argv);
+
+  argv._.slice(1).forEach((datum: string) => {
+    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];
+    params[key] = value;
+  });
+}
+
+runQuery(apiEnv, { params, method: argv.method, endpoint, verbose: true }).then(({ data }) => printResponse(data));

lib/apiEnv.ts

@@ -0,0 +1,116 @@
+import * as _ from "lodash";
+import logger from "./logger";
+import { ConfigHostEntry } from "./config";
+import config from "./config";
+import { failedExit } from "./cli-utils";
+
+const apiEnvCommandLineOptions: Record<string, any> = {
+  host: {
+    type: "string",
+    description: "Host/port - will override --env",
+  },
+  protocol: {
+    choices: ["http", "https"],
+    description:
+      "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`,
+  },
+};
+
+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",
+    };
+  }
+
+  if (config.hosts) {
+    apiEnvCommandLineOptions.env = {
+      choices: [..._.keys(config.hosts), ..._.flatMap(config.hosts, (v) => v.aliases || [])],
+      description: `api host to talk to`,
+    };
+
+    _.forEach(config.hosts, (hostEntry: ConfigHostEntry, key: string) => {
+      apiEnvCommandLineOptions[key] = {
+        alias: hostEntry.aliases,
+        description: `set host to ${hostEntry.host}`,
+      };
+    });
+  }
+  return apiEnvCommandLineOptions;
+}
+
+export interface ApiEnv {
+  key: string;
+  protocol: string;
+  host: string;
+  keyEnv: string;
+  keyType?: string;
+}
+
+type KeyParams = Pick<ApiEnv, "keyEnv" | "keyType">;
+
+function findKey({ keyEnv, keyType }: KeyParams): string {
+  require("dotenv").config();
+
+  const env_variable_name = [keyEnv, keyType, "API_KEY"]
+    .filter((s) => !_.isEmpty(s))
+    .join("_")
+    .toUpperCase();
+  logger.info(`Looking for key in env ${env_variable_name}`);
+  const key = process.env[env_variable_name];
+  if (!key) {
+    failedExit(`No key found for ${env_variable_name} 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] });
+}
+
+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(",")}`);
+      }
+
+      if (hostEntry.takesArg) {
+        const toReplace = key.toUpperCase();
+        hostEntry.host = hostEntry.host.replace(toReplace, argv[key]);
+      }
+
+      hostEntry.keyEnv = hostEntry.keyEnv || key;
+
+      aliasedHostEntry = hostEntry;
+    }
+  });
+
+  if (aliasedHostEntry) {
+    apiEnv = {
+      ...aliasedHostEntry,
+      ...apiEnv,
+    };
+  }
+
+  if (apiEnv.host.startsWith("http")) {
+    const url = new URL(apiEnv.host);
+    apiEnv.host = url.host;
+    apiEnv.protocol = url.protocol.replace(":", "");
+  }
+
+  fixApiEnvKey(apiEnv);
+
+  return apiEnv as ApiEnv;
+}

lib/cli-utils.ts

@@ -0,0 +1,16 @@
+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",
+  },
+  color: {
+    type: "boolean",
+    description: "turns on/off colorized output, defaults to true for stdin, false for redirected output"
+  },
+};