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

package/scripts/ProvisionAdmin.res

@@ -52,36 +52,19 @@ type args = {
   `--email` that parsed as "absent" would be caught by the required-argument check
   below, but a typo'd `--provider-id` would fall through to the environment and
   create the administrator in a *different pool* than the operator named. */
-let parseArgs = (argv: array<string>): result<args, string> => {
-  let acc = ref(Ok({providerId: None, stack: None, email: None, help: false}))
-  let i = ref(0)
-  let count = argv->Array.length
-  while i.contents < count {
-    let flag = argv->Array.getUnsafe(i.contents)
-    let value = argv->Array.get(i.contents + 1)
-    switch (acc.contents, flag, value) {
-    | (Error(_), _, _) => i := count
-    | (Ok(a), "--provider-id", Some(v)) =>
-      acc := Ok({...a, providerId: Some(v)})
-      i := i.contents + 2
-    | (Ok(a), "--stack", Some(v)) =>
-      acc := Ok({...a, stack: Some(v)})
-      i := i.contents + 2
-    | (Ok(a), "--email", Some(v)) =>
-      acc := Ok({...a, email: Some(v)})
-      i := i.contents + 2
-    | (Ok(a), "--help", _) | (Ok(a), "-h", _) =>
-      acc := Ok({...a, help: true})
-      i := i.contents + 1
-    | (Ok(_), "--provider-id", None) | (Ok(_), "--email", None) | (Ok(_), "--stack", None) =>
-      acc := Error(`${flag} needs a value`)
-    | (Ok(_), unknown, _) => acc := Error(`unknown argument "${unknown}"`)
-    }
-  }
-  acc.contents
-}
+let parseArgs = (argv: array<string>): result<args, string> =>
+  Reventless.CliArgs.parse(~strings=["provider-id", "stack", "email"], argv)
+  ->Result.flatMap(Reventless.CliArgs.noPositionals)
+  ->Result.map(a => {
+    providerId: a->Reventless.CliArgs.string("provider-id"),
+    stack: a->Reventless.CliArgs.string("stack"),
+    email: a->Reventless.CliArgs.string("email"),
+    help: a->Reventless.CliArgs.help,
+  })
 
 let usage = `
+Usage: provision-admin --email <address> [--provider-id <id>] [--stack <name>]
+
 Make the first administrator of a Reventless deployment.
 
   --provider-id <id>   The identity provider to create the account in. Usually
@@ -217,57 +200,59 @@ made through a signed-in session because there is no signed-in session yet. The
 rest of the cast is a list rather than a command: declare it in
 .reventless/users.yaml and run \`pnpm exec provision-accounts\`.`
 
-let run = async (): result<unit, string> =>
-  // argv[0] is node, argv[1] this script.
-  switch parseArgs(NodeProcess.argv->Array.slice(~start=2, ~end=NodeProcess.argv->Array.length)) {
-  | Error(_) as e => e
-  | Ok(args) if args.help =>
-    Console.log(usage)
-    Ok()
-  | Ok(args) =>
-    // The address is checked before the provider is resolved: it costs nothing,
-    // while resolving may shell out to Pulumi, and a run missing both arguments
-    // should say the cheap thing rather than fail on a stack lookup it never
-    // needed.
-    switch args.email {
+type request = {email: string, providerId: option<string>, stack: option<string>}
+
+/** The address is required before anything else is looked at: it costs nothing,
+    while resolving the provider may shell out to Pulumi, and a run missing both
+    arguments should say the cheap thing rather than fail on a stack lookup it
+    never needed. */
+let parseRequest = (argv: array<string>): result<request, string> =>
+  parseArgs(argv)->Result.flatMap(({email, providerId, stack}) =>
+    switch email {
     | None => Error("--email is required — it is the address the administrator signs in with")
-    | Some(email) =>
-      switch ProvisionProvider.resolve(~given=args.providerId, ~stack=args.stack) {
-      | Error(_) as e => e
-      | Ok((providerId, source)) =>
-        Console.log(`provider ${providerId} (from ${source->ProvisionProvider.describe})`)
-        switch await checkPoolAcceptsEmail(~providerId) {
-        | Error(_) as e => e
-        | Ok() =>
-          let group = Reventless.AdminGroup.name
-          let password = Reventless.Util_Password.generate()
-          await ensureGroup(~providerId, ~group)
-          await ensureUser(~providerId, ~email)
-          await setPassword(~providerId, ~email, ~password)
-          await addToGroup(~providerId, ~email, ~group)
-          Console.log(signInDetails(~providerId, ~email, ~password, ~group))
-          Ok()
-        }
-      }
+    | Some(email) => Ok({email, providerId, stack})
+    }
+  )
+
+let run = async ({email, providerId, stack}: request): result<unit, string> =>
+  switch ProvisionProvider.resolve(~given=providerId, ~stack) {
+  | Error(_) as e => e
+  | Ok((providerId, source)) =>
+    Console.log(`provider ${providerId} (from ${source->ProvisionProvider.describe})`)
+    switch await checkPoolAcceptsEmail(~providerId) {
+    | Error(_) as e => e
+    | Ok() =>
+      let group = Reventless.AdminGroup.name
+      let password = Reventless.Util_Password.generate()
+      await ensureGroup(~providerId, ~group)
+      await ensureUser(~providerId, ~email)
+      await setPassword(~providerId, ~email, ~password)
+      await addToGroup(~providerId, ~email, ~group)
+      Console.log(signInDetails(~providerId, ~email, ~password, ~group))
+      Ok()
     }
   }
 
+let cli: Reventless.CliArgs.cli<request> = {bin: "provision-admin", usage, parse: parseRequest}
+
 /**
 🚨 **Catches thrown exceptions, not only `Error` results** — the reason
 [ProvisionIdentity.main] gives. Without it an SDK failure escapes an async
 function nothing awaits and Node reports `UnhandledPromiseRejection ...
 "#<Object>"`, naming neither the call that failed nor why.
 */
-let main = async () =>
-  switch await run() {
-  | Ok() => ()
-  | Error(message) =>
-    Console.error(`provision-admin: ${message}`)
-    NodeProcess.exit(1)
-  | exception exn =>
-    Console.error(`provision-admin: ${Util_AwsError.describe(exn)}`)
-    NodeProcess.exit(1)
-  }
+let main = () =>
+  Reventless.CliArgs.run(cli, async request =>
+    switch await run(request) {
+    | Ok() => ()
+    | Error(message) =>
+      Console.error(`provision-admin: ${message}`)
+      NodeProcess.exit(1)
+    | exception exn =>
+      Console.error(`provision-admin: ${Util_AwsError.describe(exn)}`)
+      NodeProcess.exit(1)
+    }
+  )
 
 // 🚨 **No top-level call.** `../run-provision-admin.mjs` invokes [main]; this
 // module only defines it. A module that ran itself on import could not be

package/scripts/ProvisionAdmin.res.mjs

@@ -1,5 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+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 AdminGroup$Reventless from "@reventlessdev/reventless-spec/src/types/AdminGroup.res.mjs";
 import * as Util_Password$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Password.res.mjs";
@@ -8,110 +10,21 @@ import * as ProvisionCognito$ReventlessAws from "./ProvisionCognito.res.mjs";
 import * as ProvisionProvider$ReventlessAws from "./ProvisionProvider.res.mjs";
 
 function parseArgs(argv) {
-  let acc = {
-    TAG: "Ok",
-    _0: {
-      providerId: undefined,
-      stack: undefined,
-      email: undefined,
-      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 "--email" :
-          if (value !== undefined) {
-            acc = {
-              TAG: "Ok",
-              _0: {
-                providerId: a.providerId,
-                stack: a.stack,
-                email: value,
-                help: a.help
-              }
-            };
-            i = i + 2 | 0;
-          } else {
-            exit = 1;
-          }
-          break;
-        case "--provider-id" :
-          if (value !== undefined) {
-            acc = {
-              TAG: "Ok",
-              _0: {
-                providerId: value,
-                stack: a.stack,
-                email: a.email,
-                help: a.help
-              }
-            };
-            i = i + 2 | 0;
-          } else {
-            exit = 1;
-          }
-          break;
-        case "--stack" :
-          if (value !== undefined) {
-            acc = {
-              TAG: "Ok",
-              _0: {
-                providerId: a.providerId,
-                stack: value,
-                email: a.email,
-                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 = {
-          TAG: "Ok",
-          _0: {
-            providerId: a.providerId,
-            stack: a.stack,
-            email: a.email,
-            help: true
-          }
-        };
-        i = i + 1 | 0;
-      }
-    } else {
-      i = count;
-    }
-    if (exit === 1) {
-      acc = {
-        TAG: "Error",
-        _0: flag + ` needs a value`
-      };
-    }
-  };
-  return acc;
+  return Stdlib_Result.map(Stdlib_Result.flatMap(CliArgs$Reventless.parse([
+    "provider-id",
+    "stack",
+    "email"
+  ], undefined, undefined, undefined, argv), CliArgs$Reventless.noPositionals), a => ({
+    providerId: CliArgs$Reventless.string(a, "provider-id"),
+    stack: CliArgs$Reventless.string(a, "stack"),
+    email: CliArgs$Reventless.string(a, "email"),
+    help: CliArgs$Reventless.help(a)
+  }));
 }
 
 let usage = `
+Usage: provision-admin --email <address> [--provider-id <id>] [--stack <name>]
+
 Make the first administrator of a Reventless deployment.
 
   --provider-id <id>   The identity provider to create the account in. Usually
@@ -209,36 +122,39 @@ rest of the cast is a list rather than a command: declare it in
 .reventless/users.yaml and run \`pnpm exec provision-accounts\`.`;
 }
 
-async function run() {
-  let e = parseArgs(process.argv.slice(2, process.argv.length));
+function parseRequest(argv) {
+  return Stdlib_Result.flatMap(parseArgs(argv), param => {
+    let email = param.email;
+    if (email !== undefined) {
+      return {
+        TAG: "Ok",
+        _0: {
+          email: email,
+          providerId: param.providerId,
+          stack: param.stack
+        }
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: "--email is required — it is the address the administrator signs in with"
+      };
+    }
+  });
+}
+
+async function run(param) {
+  let email = param.email;
+  let e = ProvisionProvider$ReventlessAws.resolve(param.providerId, param.stack);
   if (e.TAG !== "Ok") {
     return e;
   }
-  let args = e._0;
-  if (args.help) {
-    console.log(usage);
-    return {
-      TAG: "Ok",
-      _0: undefined
-    };
-  }
-  let email = args.email;
-  if (email === undefined) {
-    return {
-      TAG: "Error",
-      _0: "--email is required — it is the address the administrator signs in with"
-    };
-  }
-  let e$1 = ProvisionProvider$ReventlessAws.resolve(args.providerId, args.stack);
-  if (e$1.TAG !== "Ok") {
-    return e$1;
-  }
-  let match = e$1._0;
+  let match = e._0;
   let providerId = match[0];
   console.log(`provider ` + providerId + ` (from ` + ProvisionProvider$ReventlessAws.describe(match[1]) + `)`);
-  let e$2 = await checkPoolAcceptsEmail(providerId);
-  if (e$2.TAG !== "Ok") {
-    return e$2;
+  let e$1 = await checkPoolAcceptsEmail(providerId);
+  if (e$1.TAG !== "Ok") {
+    return e$1;
   }
   let password = Util_Password$Reventless.generate();
   await ensureGroup(providerId, AdminGroup$Reventless.name);
@@ -252,21 +168,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-admin: ` + Util_AwsError$ReventlessAws.describe(exn));
+let cli = {
+  bin: "provision-admin",
+  usage: usage,
+  parse: parseRequest
+};
+
+function main() {
+  return CliArgs$Reventless.run(cli, undefined, undefined, async request => {
+    let message;
+    try {
+      message = await run(request);
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      console.error(`provision-admin: ` + Util_AwsError$ReventlessAws.describe(exn));
+      process.exit(1);
+      return;
+    }
+    if (message.TAG === "Ok") {
+      return;
+    }
+    console.error(`provision-admin: ` + message._0);
     process.exit(1);
-    return;
-  }
-  if (message.TAG === "Ok") {
-    return;
-  }
-  console.error(`provision-admin: ` + message._0);
-  process.exit(1);
+  });
 }
 
 let Cognito;
@@ -283,7 +207,9 @@ export {
   addToGroup,
   passwordNote,
   signInDetails,
+  parseRequest,
   run,
+  cli,
   main,
 }
-/* Util_Password-Reventless Not a pure module */
+/* CliArgs-Reventless Not a pure module */

package/scripts/ProvisionIdentity.res

@@ -48,52 +48,34 @@ let defaultPoolName = "ReventlessIdentity"
 /** Parsed rather than positional, and unknown flags are an error: a typo'd
   `--provider-id` that parsed as "absent" would create a *second* pool beside the
   one the operator meant to extend. */
-let parseArgs = (argv: array<string>): result<args, string> => {
-  let acc = ref(
-    Ok({
-      poolName: defaultPoolName,
-      providerId: None,
-      loginIdentifier: Auth_LoginIdentifier.default,
-      signUpMode: Auth_SignUpMode.default,
-      help: false,
-    }),
+let parseArgs = (argv: array<string>): result<args, string> =>
+  Reventless.CliArgs.parse(
+    ~strings=["name", "provider-id", "login-identifier", "sign-up-mode"],
+    argv,
   )
-  let i = ref(0)
-  let count = argv->Array.length
-  while i.contents < count {
-    let flag = argv->Array.getUnsafe(i.contents)
-    let value = argv->Array.get(i.contents + 1)
-    switch (acc.contents, flag, value) {
-    | (Error(_), _, _) => i := count
-    | (Ok(a), "--name", Some(v)) =>
-      acc := Ok({...a, poolName: v})
-      i := i.contents + 2
-    | (Ok(a), "--provider-id", Some(v)) =>
-      acc := Ok({...a, providerId: Some(v)})
-      i := i.contents + 2
-    | (Ok(a), "--login-identifier", Some(v)) =>
-      acc :=
-        Auth_LoginIdentifier.parse(Some(v))->Result.map(loginIdentifier => {
-          ...a,
-          loginIdentifier,
-        })
-      i := i.contents + 2
-    | (Ok(a), "--sign-up-mode", Some(v)) =>
-      acc := Auth_SignUpMode.parse(Some(v))->Result.map(signUpMode => {...a, signUpMode})
-      i := i.contents + 2
-    | (Ok(a), "--help", _) | (Ok(a), "-h", _) =>
-      acc := Ok({...a, help: true})
-      i := i.contents + 1
-    | (Ok(_), "--name", None)
-    | (Ok(_), "--provider-id", None)
-    | (Ok(_), "--login-identifier", None)
-    | (Ok(_), "--sign-up-mode", None) =>
-      acc := Error(`${flag} needs a value`)
-    | (Ok(_), unknown, _) => acc := Error(`unknown argument "${unknown}"`)
+  ->Result.flatMap(Reventless.CliArgs.noPositionals)
+  ->Result.flatMap(a => {
+    let given = name => a->Reventless.CliArgs.string(name)
+    let loginIdentifier = switch given("login-identifier") {
+    | None => Ok(Auth_LoginIdentifier.default)
+    | Some(_) as v => Auth_LoginIdentifier.parse(v)
     }
-  }
-  acc.contents
-}
+    let signUpMode = switch given("sign-up-mode") {
+    | None => Ok(Auth_SignUpMode.default)
+    | Some(_) as v => Auth_SignUpMode.parse(v)
+    }
+    switch (loginIdentifier, signUpMode) {
+    | (Error(_) as e, _) | (_, Error(_) as e) => e
+    | (Ok(loginIdentifier), Ok(signUpMode)) =>
+      Ok({
+        poolName: given("name")->Option.getOr(defaultPoolName),
+        providerId: given("provider-id"),
+        loginIdentifier,
+        signUpMode,
+        help: a->Reventless.CliArgs.help,
+      })
+    }
+  })
 
 let _loginIdentifiers =
   Auth_LoginIdentifier.all->Array.map(Auth_LoginIdentifier.toString)->Array.join(" | ")
@@ -105,6 +87,8 @@ let _signUpModes = Auth_SignUpMode.all->Array.map(Auth_SignUpMode.toString)->Arr
 let _defaultSignUpMode = Auth_SignUpMode.toString(Auth_SignUpMode.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})
@@ -327,27 +311,21 @@ That is a separate bin because it provisions nothing a stack owns, and because i
 is needed on a pool created here and on one a stack created for itself alike. See
 [ProvisionAdmin].`
 
-let run = async (): result<unit, string> =>
-  // argv[0] is node, argv[1] this script.
-  switch parseArgs(NodeProcess.argv->Array.slice(~start=2, ~end=NodeProcess.argv->Array.length)) {
+let run = async (args: args): result<unit, string> =>
+  switch await resolvePool(~args) {
   | Error(_) as e => e
-  | Ok(args) if args.help =>
-    Console.log(usage)
-    Ok()
-  | Ok(args) =>
-    switch await resolvePool(~args) {
+  | Ok(providerId) =>
+    let tableName = Schema.derivedStoreName(~identityProviderId=providerId)
+    switch await provisionStore(~tableName) {
     | Error(_) as e => e
-    | Ok(providerId) =>
-      let tableName = Schema.derivedStoreName(~identityProviderId=providerId)
-      switch await provisionStore(~tableName) {
-      | Error(_) as e => e
-      | Ok() =>
-        Console.log(nextSteps(~providerId))
-        Ok()
-      }
+    | Ok() =>
+      Console.log(nextSteps(~providerId))
+      Ok()
     }
   }
 
+let cli: Reventless.CliArgs.cli<args> = {bin: "provision-identity", usage, parse: parseArgs}
+
 /**
 🚨 **Catches thrown exceptions, not only `Error` results.**
 
@@ -356,16 +334,18 @@ reports `UnhandledPromiseRejection ... "#<Object>"` — which names neither the
 that failed nor why. Every AWS call in this script can throw, so the top level has
 to turn any of them into something an operator can read.
 */
-let main = async () =>
-  switch await run() {
-  | Ok() => ()
-  | Error(message) =>
-    Console.error(`provision-identity: ${message}`)
-    NodeProcess.exit(1)
-  | exception exn =>
-    Console.error(`provision-identity: ${Util_AwsError.describe(exn)}`)
-    NodeProcess.exit(1)
-  }
+let main = () =>
+  Reventless.CliArgs.run(cli, async args =>
+    switch await run(args) {
+    | Ok() => ()
+    | Error(message) =>
+      Console.error(`provision-identity: ${message}`)
+      NodeProcess.exit(1)
+    | exception exn =>
+      Console.error(`provision-identity: ${Util_AwsError.describe(exn)}`)
+      NodeProcess.exit(1)
+    }
+  )
 
 // 🚨 **No top-level call.** `../run-provision-identity.mjs` invokes [main]; this
 // module only defines it. A module that ran itself on import could not be