@reventlessdev/reventless-aws 3.0.0-alpha.355 → 3.0.0-alpha.356

package/scripts/ProvisionIdentity.res.mjs

@@ -2,6 +2,7 @@
 
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as CliArgs$Reventless from "@reventlessdev/reventless-spec/src/CliArgs.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as ClientDynamodb from "@aws-sdk/client-dynamodb";
 import * as DynamoDb_DynamoDb$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/DynamoDb_DynamoDb.res.mjs";
@@ -15,123 +16,41 @@ import * as Auth_ActiveRoleStore_Schema$ReventlessAws from "../src/adapter/Auth/
 let defaultPoolName = "ReventlessIdentity";
 
 function parseArgs(argv) {
-  let acc = {
-    TAG: "Ok",
-    _0: {
-      poolName: defaultPoolName,
-      providerId: undefined,
-      loginIdentifier: Auth_LoginIdentifier$ReventlessAws.default,
-      signUpMode: Auth_SignUpMode$ReventlessAws.default,
-      help: false
-    }
-  };
-  let i = 0;
-  let count = argv.length;
-  while (i < count) {
-    let flag = argv[i];
-    let value = argv[i + 1 | 0];
-    let match = acc;
-    let exit = 0;
-    if (match.TAG === "Ok") {
-      let a = match._0;
-      let exit$1 = 0;
-      switch (flag) {
-        case "--login-identifier" :
-          if (value !== undefined) {
-            acc = Stdlib_Result.map(Auth_LoginIdentifier$ReventlessAws.parse(value), loginIdentifier => ({
-              poolName: a.poolName,
-              providerId: a.providerId,
-              loginIdentifier: loginIdentifier,
-              signUpMode: a.signUpMode,
-              help: a.help
-            }));
-            i = i + 2 | 0;
-          } else {
-            exit = 1;
-          }
-          break;
-        case "--name" :
-          if (value !== undefined) {
-            acc = {
-              TAG: "Ok",
-              _0: {
-                poolName: value,
-                providerId: a.providerId,
-                loginIdentifier: a.loginIdentifier,
-                signUpMode: a.signUpMode,
-                help: a.help
-              }
-            };
-            i = i + 2 | 0;
-          } else {
-            exit = 1;
-          }
-          break;
-        case "--provider-id" :
-          if (value !== undefined) {
-            acc = {
-              TAG: "Ok",
-              _0: {
-                poolName: a.poolName,
-                providerId: value,
-                loginIdentifier: a.loginIdentifier,
-                signUpMode: a.signUpMode,
-                help: a.help
-              }
-            };
-            i = i + 2 | 0;
-          } else {
-            exit = 1;
-          }
-          break;
-        case "--sign-up-mode" :
-          if (value !== undefined) {
-            acc = Stdlib_Result.map(Auth_SignUpMode$ReventlessAws.parse(value), signUpMode => ({
-              poolName: a.poolName,
-              providerId: a.providerId,
-              loginIdentifier: a.loginIdentifier,
-              signUpMode: signUpMode,
-              help: a.help
-            }));
-            i = i + 2 | 0;
-          } else {
-            exit = 1;
-          }
-          break;
-        case "--help" :
-        case "-h" :
-          exit$1 = 2;
-          break;
-        default:
-          acc = {
-            TAG: "Error",
-            _0: `unknown argument "` + flag + `"`
-          };
-      }
-      if (exit$1 === 2) {
-        acc = {
+  return Stdlib_Result.flatMap(Stdlib_Result.flatMap(CliArgs$Reventless.parse([
+    "name",
+    "provider-id",
+    "login-identifier",
+    "sign-up-mode"
+  ], undefined, undefined, undefined, argv), CliArgs$Reventless.noPositionals), a => {
+    let v = CliArgs$Reventless.string(a, "login-identifier");
+    let loginIdentifier = v !== undefined ? Auth_LoginIdentifier$ReventlessAws.parse(v) : ({
+        TAG: "Ok",
+        _0: Auth_LoginIdentifier$ReventlessAws.default
+      });
+    let v$1 = CliArgs$Reventless.string(a, "sign-up-mode");
+    let signUpMode = v$1 !== undefined ? Auth_SignUpMode$ReventlessAws.parse(v$1) : ({
+        TAG: "Ok",
+        _0: Auth_SignUpMode$ReventlessAws.default
+      });
+    if (loginIdentifier.TAG === "Ok") {
+      if (signUpMode.TAG === "Ok") {
+        return {
           TAG: "Ok",
           _0: {
-            poolName: a.poolName,
-            providerId: a.providerId,
-            loginIdentifier: a.loginIdentifier,
-            signUpMode: a.signUpMode,
-            help: true
+            poolName: Stdlib_Option.getOr(CliArgs$Reventless.string(a, "name"), defaultPoolName),
+            providerId: CliArgs$Reventless.string(a, "provider-id"),
+            loginIdentifier: loginIdentifier._0,
+            signUpMode: signUpMode._0,
+            help: CliArgs$Reventless.help(a)
           }
         };
-        i = i + 1 | 0;
+      } else {
+        return signUpMode;
       }
     } else {
-      i = count;
-    }
-    if (exit === 1) {
-      acc = {
-        TAG: "Error",
-        _0: flag + ` needs a value`
-      };
+      return loginIdentifier;
     }
-  };
-  return acc;
+  });
 }
 
 let _loginIdentifiers = Auth_LoginIdentifier$ReventlessAws.all.map(Auth_LoginIdentifier$ReventlessAws.toString).join(" | ");
@@ -143,6 +62,8 @@ let _signUpModes = Auth_SignUpMode$ReventlessAws.all.map(Auth_SignUpMode$Reventl
 let _defaultSignUpMode = Auth_SignUpMode$ReventlessAws.toString(Auth_SignUpMode$ReventlessAws.default);
 
 let usage = `
+Usage: provision-identity [--name <name>] [--provider-id <id>] [--login-identifier <a>] [--sign-up-mode <m>]
+
 Provision a Reventless identity provider and its active-role store.
 
   --name <name>          Pool name to create or adopt (default: ` + defaultPoolName + `)
@@ -369,29 +290,17 @@ is needed on a pool created here and on one a stack created for itself alike. Se
 [ProvisionAdmin].`;
 }
 
-async function run() {
-  let e = parseArgs(process.argv.slice(2, process.argv.length));
+async function run(args) {
+  let e = await resolvePool(args);
   if (e.TAG !== "Ok") {
     return e;
   }
-  let args = e._0;
-  if (args.help) {
-    console.log(usage);
-    return {
-      TAG: "Ok",
-      _0: undefined
-    };
-  }
-  let e$1 = await resolvePool(args);
+  let providerId = e._0;
+  let tableName = Auth_ActiveRoleStore_Schema$ReventlessAws.derivedStoreName(providerId);
+  let e$1 = await provisionStore(tableName);
   if (e$1.TAG !== "Ok") {
     return e$1;
   }
-  let providerId = e$1._0;
-  let tableName = Auth_ActiveRoleStore_Schema$ReventlessAws.derivedStoreName(providerId);
-  let e$2 = await provisionStore(tableName);
-  if (e$2.TAG !== "Ok") {
-    return e$2;
-  }
   console.log(nextSteps(providerId));
   return {
     TAG: "Ok",
@@ -399,21 +308,29 @@ async function run() {
   };
 }
 
-async function main() {
-  let message;
-  try {
-    message = await run();
-  } catch (raw_exn) {
-    let exn = Primitive_exceptions.internalToException(raw_exn);
-    console.error(`provision-identity: ` + Util_AwsError$ReventlessAws.describe(exn));
+let cli = {
+  bin: "provision-identity",
+  usage: usage,
+  parse: parseArgs
+};
+
+function main() {
+  return CliArgs$Reventless.run(cli, undefined, undefined, async args => {
+    let message;
+    try {
+      message = await run(args);
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      console.error(`provision-identity: ` + Util_AwsError$ReventlessAws.describe(exn));
+      process.exit(1);
+      return;
+    }
+    if (message.TAG === "Ok") {
+      return;
+    }
+    console.error(`provision-identity: ` + message._0);
     process.exit(1);
-    return;
-  }
-  if (message.TAG === "Ok") {
-    return;
-  }
-  console.error(`provision-identity: ` + message._0);
-  process.exit(1);
+  });
 }
 
 let Schema;
@@ -436,6 +353,7 @@ export {
   provisionStore,
   nextSteps,
   run,
+  cli,
   main,
 }
 /* _loginIdentifiers Not a pure module */

package/tests/CommandLineTest.res

@@ -0,0 +1,94 @@
+open JestGlobals
+
+// How this package's five bins behave on the command line, as a person or a
+// script meets them: help anywhere answers with the usage and exit 0, a usage
+// mistake names itself and shows the usage on stderr with exit 2. Exit 1 is
+// left to a run that failed, so a caller can tell the two apart.
+
+module CliArgs = Reventless.CliArgs
+
+let answersLikeEveryTool = (cli: CliArgs.cli<'args>, ~mistake, ~message) =>
+  test(`${cli.bin}: --help and a usage mistake`, async () => {
+    let usage = cli.usage->String.trim
+    expect(usage->String.startsWith(`Usage: ${cli.bin} `))->toBe(true)
+    let help = {CliArgs.stdout: [usage], stderr: [], exitCode: Some(0), reachedMain: false}
+    expect(await CliArgs.observe(cli, ["-h"]))->toEqual(help)
+    // Help wins: whoever asks what a tool takes is least sure of their arguments.
+    expect(await CliArgs.observe(cli, mistake->Array.concat(["--help"])))->toEqual(help)
+    expect(await CliArgs.observe(cli, mistake))->toEqual({
+      CliArgs.stdout: [],
+      stderr: [`${cli.bin}: ${message}\n\n${usage}`],
+      exitCode: Some(2),
+      reachedMain: false,
+    })
+  })
+
+describe("every bin", () => {
+  answersLikeEveryTool(
+    DeployApp.cli,
+    ~mistake=["up", "--stak", "x"],
+    ~message=`unknown argument "--stak"`,
+  )
+  answersLikeEveryTool(
+    BakeManifest.cli,
+    ~mistake=["--stak", "x"],
+    ~message=`unknown argument "--stak"`,
+  )
+  answersLikeEveryTool(
+    ProvisionAccounts.cli,
+    ~mistake=["--pool", "x"],
+    ~message=`unknown argument "--pool"`,
+  )
+  answersLikeEveryTool(
+    ProvisionAdmin.cli,
+    ~mistake=["--email", "me@example.com", "stray"],
+    ~message=`unknown argument "stray"`,
+  )
+  answersLikeEveryTool(
+    ProvisionIdentity.cli,
+    ~mistake=["--provider_id", "x"],
+    ~message=`unknown argument "--provider_id"`,
+  )
+})
+
+describe("a string flag's value", () => {
+  // Read literally, `--manifest --stack try` deploys with the manifest
+  // "--stack". Nobody who typed it meant that.
+  testSync("is never the next flag", () =>
+    expect(DeployApp.parseArgs(["up", "--manifest", "--stack", "try"]))->toEqual(
+      Error("--manifest needs a value"),
+    )
+  )
+
+  testSync("may be given inline", () =>
+    expect(DeployApp.parseArgs(["down", "--manifest=../m.yaml", "--stack=try"]))->toEqual(
+      Ok({DeployApp.command: Some(Down), manifest: Some("../m.yaml"), stack: "try", help: false}),
+    )
+  )
+
+  testSync("--since may be empty inline, as CI can pass it", () =>
+    expect(BakeManifest.parseArgs(["--since="])->Result.map(a => a.since))->toEqual(Ok(None))
+  )
+})
+
+describe("a bare invocation", () => {
+  test("deploy-app has to be told up or down", async () => {
+    let observed = await CliArgs.observe(DeployApp.cli, [])
+    expect((
+      observed.exitCode,
+      observed.stderr->Array.get(0)->Option.map(e => e->String.split("\n")->Array.getUnsafe(0)),
+    ))->toEqual((Some(2), Some("deploy-app: say `up` or `down`")))
+  })
+
+  test("provision-admin has to be told whom to make", async () => {
+    let observed = await CliArgs.observe(ProvisionAdmin.cli, [])
+    expect(observed.exitCode)->toEqual(Some(2))
+    expect(observed.stderr->Array.join("")->String.includes("--email is required"))->toBe(true)
+  })
+
+  test("the tools that need nothing run", async () => {
+    expect((await CliArgs.observe(BakeManifest.cli, [])).reachedMain)->toBe(true)
+    expect((await CliArgs.observe(ProvisionAccounts.cli, [])).reachedMain)->toBe(true)
+    expect((await CliArgs.observe(ProvisionIdentity.cli, [])).reachedMain)->toBe(true)
+  })
+})

package/tests/CommandLineTest.res.mjs

@@ -0,0 +1,125 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as CliArgs$Reventless from "@reventlessdev/reventless-spec/src/CliArgs.res.mjs";
+import * as DeployApp$ReventlessAws from "../scripts/DeployApp.res.mjs";
+import * as BakeManifest$ReventlessAws from "../scripts/BakeManifest.res.mjs";
+import * as ProvisionAdmin$ReventlessAws from "../scripts/ProvisionAdmin.res.mjs";
+import * as ProvisionAccounts$ReventlessAws from "../scripts/ProvisionAccounts.res.mjs";
+import * as ProvisionIdentity$ReventlessAws from "../scripts/ProvisionIdentity.res.mjs";
+
+function answersLikeEveryTool(cli, mistake, message) {
+  globalThis.test(cli.bin + `: --help and a usage mistake`, async () => {
+    let usage = cli.usage.trim();
+    globalThis.expect(usage.startsWith(`Usage: ` + cli.bin + ` `)).toBe(true);
+    let help_stdout = [usage];
+    let help_stderr = [];
+    let help_exitCode = 0;
+    let help = {
+      stdout: help_stdout,
+      stderr: help_stderr,
+      exitCode: help_exitCode,
+      reachedMain: false
+    };
+    globalThis.expect(await CliArgs$Reventless.observe(cli, ["-h"])).toEqual(help);
+    globalThis.expect(await CliArgs$Reventless.observe(cli, mistake.concat(["--help"]))).toEqual(help);
+    globalThis.expect(await CliArgs$Reventless.observe(cli, mistake)).toEqual({
+      stdout: [],
+      stderr: [cli.bin + `: ` + message + `\n\n` + usage],
+      exitCode: 2,
+      reachedMain: false
+    });
+  });
+}
+
+globalThis.describe("every bin", () => {
+  answersLikeEveryTool(DeployApp$ReventlessAws.cli, [
+    "up",
+    "--stak",
+    "x"
+  ], `unknown argument "--stak"`);
+  answersLikeEveryTool(BakeManifest$ReventlessAws.cli, [
+    "--stak",
+    "x"
+  ], `unknown argument "--stak"`);
+  answersLikeEveryTool(ProvisionAccounts$ReventlessAws.cli, [
+    "--pool",
+    "x"
+  ], `unknown argument "--pool"`);
+  answersLikeEveryTool(ProvisionAdmin$ReventlessAws.cli, [
+    "--email",
+    "me@example.com",
+    "stray"
+  ], `unknown argument "stray"`);
+  answersLikeEveryTool(ProvisionIdentity$ReventlessAws.cli, [
+    "--provider_id",
+    "x"
+  ], `unknown argument "--provider_id"`);
+});
+
+globalThis.describe("a string flag's value", () => {
+  globalThis.test("is never the next flag", () => {
+    globalThis.expect(DeployApp$ReventlessAws.parseArgs([
+      "up",
+      "--manifest",
+      "--stack",
+      "try"
+    ])).toEqual({
+      TAG: "Error",
+      _0: "--manifest needs a value"
+    });
+  });
+  globalThis.test("may be given inline", () => {
+    globalThis.expect(DeployApp$ReventlessAws.parseArgs([
+      "down",
+      "--manifest=../m.yaml",
+      "--stack=try"
+    ])).toEqual({
+      TAG: "Ok",
+      _0: {
+        command: "Down",
+        manifest: "../m.yaml",
+        stack: "try",
+        help: false
+      }
+    });
+  });
+  globalThis.test("--since may be empty inline, as CI can pass it", () => {
+    globalThis.expect(Stdlib_Result.map(BakeManifest$ReventlessAws.parseArgs(["--since="]), a => a.since)).toEqual({
+      TAG: "Ok",
+      _0: undefined
+    });
+  });
+});
+
+globalThis.describe("a bare invocation", () => {
+  globalThis.test("deploy-app has to be told up or down", async () => {
+    let observed = await CliArgs$Reventless.observe(DeployApp$ReventlessAws.cli, []);
+    globalThis.expect([
+      observed.exitCode,
+      Stdlib_Option.map(observed.stderr[0], e => e.split("\n")[0])
+    ]).toEqual([
+      2,
+      "deploy-app: say `up` or `down`"
+    ]);
+  });
+  globalThis.test("provision-admin has to be told whom to make", async () => {
+    let observed = await CliArgs$Reventless.observe(ProvisionAdmin$ReventlessAws.cli, []);
+    globalThis.expect(observed.exitCode).toEqual(2);
+    globalThis.expect(observed.stderr.join("").includes("--email is required")).toBe(true);
+  });
+  globalThis.test("the tools that need nothing run", async () => {
+    globalThis.expect((await CliArgs$Reventless.observe(BakeManifest$ReventlessAws.cli, [])).reachedMain).toBe(true);
+    globalThis.expect((await CliArgs$Reventless.observe(ProvisionAccounts$ReventlessAws.cli, [])).reachedMain).toBe(true);
+    globalThis.expect((await CliArgs$Reventless.observe(ProvisionIdentity$ReventlessAws.cli, [])).reachedMain).toBe(true);
+  });
+});
+
+let CliArgs;
+
+export {
+  CliArgs,
+  answersLikeEveryTool,
+}
+/*  Not a pure module */