Improve credential handling

src/cli.mjs

@@ -3,15 +3,14 @@
 import chalk from "chalk";
 import yargs from "yargs";
 
-import keyCommand from "./commands/key.mjs";
+import databaseCommand from "./commands/database/database.mjs";
 import evalCommand from "./commands/eval.mjs";
-import shellCommand from "./commands/shell.mjs";
+import keyCommand from "./commands/key.mjs";
 import loginCommand from "./commands/login.mjs";
 import schemaCommand from "./commands/schema/schema.mjs";
-import databaseCommand from "./commands/database/database.mjs";
-
-import { authNZMiddleware } from "./lib/auth/authNZ.mjs";
+import shellCommand from "./commands/shell.mjs";
 import { checkForUpdates, fixPaths, logArgv } from "./lib/middleware.mjs";
+import { cleanupSecretsFile } from "./lib/auth/authNZ.mjs";
 
 /** @typedef {import('awilix').AwilixContainer<import('./config/setup-container.mjs').modifiedInjectables>} cliContainer */
 
@@ -36,8 +35,10 @@ export async function run(argvInput, _container) {
     builtYargs = buildYargs(argvInput);
     await parseYargs(builtYargs);
   } catch (e) {
-    let subMessage = chalk.reset("Use 'fauna <command> --help' for more information about a command.");
-
+    let subMessage = chalk.reset(
+      "Use 'fauna <command> --help' for more information about a command.",
+    );
+
     if (argvInput.length > 0) {
       subMessage = chalk.red(e.message);
     }
@@ -97,7 +98,7 @@ function buildYargs(argvInput) {
   return yargsInstance
     .scriptName("fauna")
     .middleware([checkForUpdates, logArgv], true)
-    .middleware([fixPaths, authNZMiddleware], false)
+    .middleware([fixPaths, cleanupSecretsFile], false)
     .command("eval", "evaluate a query", evalCommand)
     .command("shell", "start an interactive shell", shellCommand)
     .command("login", "login via website", loginCommand)

src/commands/database.mjs

@@ -0,0 +1,90 @@
+//@ts-check
+
+import { container } from "../cli.mjs";
+import { performQuery } from "./eval.mjs";
+
+async function listDatabases(profile) {
+  const logger = container.resolve("logger");
+  const AccountClient = container.resolve("AccountClient");
+  logger.stdout("Listing Databases...");
+  const databases = await new AccountClient(profile).listDatabases();
+  logger.stdout(databases);
+}
+
+async function createDatabase(argv) {
+  const client = await container.resolve("getSimpleClient")(argv);
+  const logger = container.resolve("logger");
+  // performQuery only gives us an error code if we ask for the json-tagged format.
+  //  so gotta go deeper to keep it agnostic of the format.
+  // And it can't be only on initial client init, because repl needs to
+  //  refresh on the fly w/out kicking out.
+  const result = await performQuery(client, "1 + 1", undefined, {
+    ...argv,
+    format: "json-tagged",
+  });
+  const result2 = await performQuery(client, "2 + 2", undefined, {
+    ...argv,
+    format: "json-tagged",
+  });
+  logger.stdout(result, result2);
+}
+
+function buildDatabaseCommand(yargs) {
+  return yargs
+    .positional("method", {
+      type: "string",
+      choices: ["create", "list", "delete"],
+      describe: "choose a method to interact with your databases",
+    })
+    .options({
+      profile: {
+        type: "string",
+        description: "a user profile",
+        default: "default",
+      },
+      authRequired: {
+        default: true,
+      },
+      url: {
+        type: "string",
+        description: "the Fauna URL to query",
+        default: "https://db.fauna.com:443",
+      },
+      secret: {
+        type: "string",
+        description: "the secret to use",
+        // default: "somesecret",
+      },
+    })
+    .help("help", "show help")
+    .example([["$0 db list"]]);
+}
+
+async function databaseHandler(argv) {
+  const logger = container.resolve("logger");
+  const method = argv.method;
+  let result;
+  switch (method) {
+    case "create":
+      logger.stdout("Creating database...");
+      result = await createDatabase(argv);
+      break;
+    case "delete":
+      logger.stdout("Deleting database...");
+      break;
+    case "list":
+      result = await listDatabases(argv.profile);
+      break;
+    default:
+      break;
+  }
+  return result;
+}
+
+export default {
+  command: "database <method>",
+  aliases: ["db"],
+  description: "Interact with your databases:",
+  builder: buildDatabaseCommand,
+  handler: databaseHandler,
+};

src/commands/eval.mjs

@@ -169,7 +169,6 @@ export async function performV4Query(client, fqlQuery, outputFile, flags) {
 export async function performQuery(client, fqlQuery, outputFile, argv) {
   const performV4Query = container.resolve("performV4Query");
   const performV10Query = container.resolve("performV10Query");
-
   if (argv.version === "4") {
     return performV4Query(client, fqlQuery, outputFile, argv);
   } else {

src/commands/key.mjs

@@ -7,7 +7,7 @@ import { getAccountKey, getDBKey } from "../lib/auth/authNZ.mjs";
 //  consider an optional flag that will save this secret to the creds file, overwriting
 //  the existing secret if it exists at key/path/role
 async function createKey(argv) {
-  const { database, profile, role, url } = argv;
+  const { database, profile, role } = argv;
   const logger = container.resolve("logger");
   const accountKey = await getAccountKey(profile);
   // TODO: after logging in, should we list the top level databases and create db keys for them?
@@ -23,7 +23,6 @@ async function createKey(argv) {
     accountKey,
     path: database,
     role,
-    url,
   });
   logger.stdout("got account key", accountKey);
   logger.stdout("got db secret", dbSecret);

src/commands/login.mjs

@@ -5,22 +5,22 @@ import { container } from "../cli.mjs";
 async function doLogin(argv) {
   const logger = container.resolve("logger");
   const open = container.resolve("open");
-  const accountClient = container.resolve("accountClient");
+  const AccountClient = new (container.resolve("AccountClient"))(argv.profile);
   const oAuth = container.resolve("oauthClient");
   const accountCreds = container.resolve("accountCreds");
   oAuth.server.on("ready", async () => {
     const authCodeParams = oAuth.getOAuthParams();
     const dashboardOAuthURL =
-      await accountClient.startOAuthRequest(authCodeParams);
+      await AccountClient.startOAuthRequest(authCodeParams);
     open(dashboardOAuthURL);
     logger.stdout(`To login, open your browser to:\n ${dashboardOAuthURL}`);
   });
   oAuth.server.on("auth_code_received", async () => {
     try {
       const tokenParams = oAuth.getTokenParams();
-      const accessToken = await accountClient.getToken(tokenParams);
+      const accessToken = await AccountClient.getToken(tokenParams);
       const { accountKey, refreshToken } =
-        await accountClient.getSession(accessToken);
+        await AccountClient.getSession(accessToken);
       accountCreds.save({
         creds: { accountKey, refreshToken },
         key: argv.profile,

src/config/setup-container.mjs

@@ -75,9 +75,7 @@ export const injectables = {
   performV4Query: awilix.asValue(performV4Query),
   performV10Query: awilix.asValue(performV10Query),
   getSimpleClient: awilix.asValue(getSimpleClient),
-  accountClient: awilix.asClass(FaunaAccountClient, {
-    lifetime: Lifetime.SCOPED,
-  }),
+  AccountClient: awilix.asValue(FaunaAccountClient),
   oauthClient: awilix.asClass(OAuthClient, { lifetime: Lifetime.SCOPED }),
   makeAccountRequest: awilix.asValue(makeAccountRequest),
   makeFaunaRequest: awilix.asValue(makeFaunaRequest),

src/config/setup-test-container.mjs

@@ -61,7 +61,7 @@ export function setupTestContainer() {
     getSimpleClient: awilix.asValue(
       stub().returns({ close: () => Promise.resolve() }),
     ),
-    accountClient: awilix.asFunction(stub()),
+    AccountClient: awilix.asValue(stub()),
     oauthClient: awilix.asFunction(stub()),
     accountCreds: awilix.asClass(AccountKey).scoped(),
     secretCreds: awilix.asClass(SecretKey).scoped(),

src/lib/account.mjs

@@ -79,6 +79,7 @@ async function parseResponse(response, shouldThrow) {
     }
     switch (response.status) {
       case 401:
+        // TODO: try and refresh creds and then redo the call, if not then throw.
         throw new InvalidCredsError(message);
       case 403:
         throw new UnauthorizedError(message);