@reventlessdev/reventless-seed 1.0.0-alpha.16 → 1.0.0-alpha.17

package/lib/bs/tests/Seed_UsersTest.res.mjs

@@ -0,0 +1,95 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Seed_Users$ReventlessSeed from "../src/Seed_Users.res.mjs";
+
+let document = `
+# Local dev users — a comment block like the real file carries.
+
+- username: admin
+  password: admin
+  groups: [Admin, Shopper]
+  userId: local-admin
+
+- username: shopper
+  password: Shopper-2026!
+  groups: [Shopper]
+
+- username: noGroups
+  password: pw
+`;
+
+globalThis.describe("Seed_Users.parseString:", () => {
+  globalThis.test("reads every account, in the order the file defines them", () => {
+    let users = Seed_Users$ReventlessSeed.parseString(document);
+    globalThis.expect(users.map(u => u.username)).toEqual([
+      "admin",
+      "shopper",
+      "noGroups"
+    ]);
+  });
+  globalThis.test("carries the password beside the username", () => {
+    let users = Seed_Users$ReventlessSeed.parseString(document);
+    globalThis.expect(users.map(u => u.password)).toEqual([
+      "admin",
+      "Shopper-2026!",
+      "pw"
+    ]);
+  });
+  globalThis.test("keeps the groups, and reads a missing groups key as none", () => {
+    let users = Seed_Users$ReventlessSeed.parseString(document);
+    globalThis.expect(users.map(u => u.groups)).toEqual([
+      [
+        "Admin",
+        "Shopper"
+      ],
+      ["Shopper"],
+      []
+    ]);
+  });
+  globalThis.test("skips an entry that names no password", () => {
+    let users = Seed_Users$ReventlessSeed.parseString(`
+- username: admin
+  password: admin
+- username: halfWritten
+  groups: [Shopper]
+`);
+    globalThis.expect(users.map(u => u.username)).toEqual(["admin"]);
+  });
+  globalThis.test("yields no accounts for a document that is not a list", () => {
+    globalThis.expect(Seed_Users$ReventlessSeed.parseString("users: {}").length).toBe(0);
+  });
+  globalThis.test("yields no accounts for malformed YAML instead of throwing", () => {
+    globalThis.expect(Seed_Users$ReventlessSeed.parseString("- username: [unclosed").length).toBe(0);
+  });
+});
+
+globalThis.describe("Seed_Users.load:", () => {
+  globalThis.test("is silent about a file that is not there", () => {
+    globalThis.expect(Seed_Users$ReventlessSeed.load("/nonexistent/.reventless/users.yaml")).toBe(undefined);
+  });
+});
+
+globalThis.describe("Seed_Users.label:", () => {
+  globalThis.test("names the groups an account carries", () => {
+    globalThis.expect(Seed_Users$ReventlessSeed.label({
+      username: "admin",
+      password: "x",
+      groups: [
+        "Admin",
+        "Shopper"
+      ]
+    })).toBe("admin  [Admin, Shopper]");
+  });
+  globalThis.test("is the bare username when the file records no groups", () => {
+    globalThis.expect(Seed_Users$ReventlessSeed.label({
+      username: "admin",
+      password: "x",
+      groups: []
+    })).toBe("admin");
+  });
+});
+
+export {
+  document,
+}
+/*  Not a pure module */

package/lib/ocaml/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1787013927827)
-#Done(1787013927856)
+#Start(1787252810629)
+#Done(1787252810671)

package/lib/ocaml/ReventlessSeed.mlmap

@@ -9,3 +9,5 @@ Seed_RandomTest
 Seed_Runner
 Seed_Types
 Seed_Upload
+Seed_Users
+Seed_UsersTest

package/lib/ocaml/Seed.res

@@ -10,6 +10,7 @@ module Client = Seed_Client
 module Runner = Seed_Runner
 module Upload = Seed_Upload
 module Prompt = Seed_Prompt
+module Users = Seed_Users
 module Connect = Seed_Connect
 
 exception Failed = Seed_Types.Failed

package/lib/ocaml/Seed_Prompt.res

@@ -121,11 +121,15 @@ let isAffirmative = (answer: string): bool =>
  * Auto-returns when there is a single option, so a lone data set or stack needs
  * no keypress. `env` (e.g. `SEED_SET`) preselects by matching label or 1-based
  * index, so CI runs without a TTY. Otherwise it prints a numbered menu.
+ *
+ * `defaultIndex` makes Enter a valid answer, selecting that 0-based option;
+ * without one every reply must name a choice.
  */
 let select = async (
   ~title: string,
   ~options: array<(string, 'a)>,
   ~env=?,
+  ~defaultIndex=?,
 ): 'a =>
   switch options {
   | [(_, only)] => only
@@ -153,29 +157,38 @@ let select = async (
       options->Array.forEachWithIndex(((label, _), i) =>
         Console.log(`  ${(i + 1)->Int.toString}) ${label}`)
       )
+      let fallback = defaultIndex->Option.flatMap(i => options->Array.get(i))
+      let hint = switch (defaultIndex, fallback) {
+      | (Some(i), Some(_)) => ` (default ${(i + 1)->Int.toString})`
+      | _ => ""
+      }
       let rec pick = async (): 'a => {
-        let answer = await ask(`\nSelect [1-${(options->Array.length)->Int.toString}]: `)
-        switch Int.fromString(answer) {
-        | Some(n) if n >= 1 && n <= options->Array.length =>
-          let (_, value) = options->Array.getUnsafe(n - 1)
-          value
+        let answer = await ask(
+          `\nSelect [1-${(options->Array.length)->Int.toString}]${hint}: `,
+        )
+        switch (answer, fallback) {
+        | ("", Some((_, value))) => value
         | _ =>
-          Console.log("  Not a valid choice.")
-          await pick()
+          switch Int.fromString(answer) {
+          | Some(n) if n >= 1 && n <= options->Array.length =>
+            let (_, value) = options->Array.getUnsafe(n - 1)
+            value
+          | _ =>
+            Console.log("  Not a valid choice.")
+            await pick()
+          }
         }
       }
       await pick()
     }
   }
 
-/**
- * Prompts for a username (visible) and password (echo muted).
- *
- * `REVENTLESS_DEMO_USER` / `REVENTLESS_DEMO_PASSWORD` skip the prompts. With
- * `localDefaults`, empty input falls back to `admin`/`admin` — the dev login.
- */
-let credentials = async (~localDefaults: bool=false): (string, string) => {
-  let username = switch envValue("REVENTLESS_DEMO_USER") {
+// Typing both halves is the fallback, not the first offer: it is what happens
+// when the platform keeps no accounts file. `envUser` is threaded in so a
+// `REVENTLESS_DEMO_USER` that named nobody in the file still skips the username
+// prompt rather than asking for a name that was already given.
+let askCredentials = async (~localDefaults: bool, ~envUser: option<string>): (string, string) => {
+  let username = switch envUser {
   | Some(u) => u
   | None =>
     requireTty()
@@ -189,6 +202,60 @@ let credentials = async (~localDefaults: bool=false): (string, string) => {
     let entered = await askHidden(localDefaults ? "Password [admin]: " : "Password: ")
     entered == "" && localDefaults ? "admin" : entered
   }
+  (username, password)
+}
+
+// The accounts file the platform already keeps (`.reventless/users.yaml`, or
+// `SEED_USERS_FILE`). It records the password beside the username, so choosing
+// an account is the whole credential step — nothing is typed.
+//
+// A named `REVENTLESS_DEMO_USER` picks its entry directly; otherwise the file's
+// accounts are offered in the order it defines them, first as the default.
+// `None` means the file has nothing to offer and the caller should ask.
+let fromUsersFile = async (~envUser: option<string>): option<(string, string)> =>
+  switch Seed_Users.load(~path=?envValue("SEED_USERS_FILE")) {
+  | None => None
+  | Some((path, users)) =>
+    let chosen = switch envUser {
+    | Some(name) => users->Array.find(u => u.username == name)
+    | None =>
+      Some(
+        await select(
+          ~title=`User (${path}):`,
+          ~options=users->Array.map(u => (Seed_Users.label(u), u)),
+          ~env="SEED_USER",
+          ~defaultIndex=0,
+        ),
+      )
+    }
+    // Logged for every arm, including the single-account file that selects
+    // itself without a keypress: which identity seeded the data is the thing an
+    // operator checks when owner-scoped rows turn up under the wrong account.
+    chosen->Option.map(u => {
+      Console.log(`Logging in as ${u.username} (from ${path})`)
+      (u.username, u.password)
+    })
+  }
+
+/**
+ * Resolves the credentials a seed run logs in with.
+ *
+ * `REVENTLESS_DEMO_USER` + `REVENTLESS_DEMO_PASSWORD` together are the
+ * non-interactive path and skip everything below. Otherwise the platform's
+ * `.reventless/users.yaml` supplies the accounts to choose from, and only a
+ * platform without one falls back to typing both halves — where, with
+ * `localDefaults`, empty input means `admin`/`admin`.
+ */
+let credentials = async (~localDefaults: bool=false): (string, string) => {
+  let envUser = envValue("REVENTLESS_DEMO_USER")
+  let (username, password) = switch (envUser, envValue("REVENTLESS_DEMO_PASSWORD")) {
+  | (Some(u), Some(p)) => (u, p)
+  | _ =>
+    switch await fromUsersFile(~envUser) {
+    | Some(pair) => pair
+    | None => await askCredentials(~localDefaults, ~envUser)
+    }
+  }
   if username == "" || password == "" {
     throw(Failed("username and password are required."))
   }

package/lib/ocaml/Seed_Users.res

@@ -0,0 +1,80 @@
+// The dev accounts a seed run can log in as, read from `.reventless/users.yaml`.
+//
+// Both platforms keep that file beside the package the seed runs from: locally
+// the in-memory auth adapter loads it at startup, and on AWS it is the record of
+// what was created in the Cognito pool. Either way it already holds the
+// credentials an operator would otherwise retype, so the credential prompt
+// offers its entries instead of asking for a password nobody remembers.
+//
+// Absence is normal and silent — the caller falls back to asking. Nothing here
+// throws: a missing, unreadable or malformed file yields no accounts.
+
+@module("yaml") external parseYaml: string => JSON.t = "parse"
+
+/** One account: what to log in as, and what to send with it. */
+type user = {username: string, password: string, groups: array<string>}
+
+let asString = (json: JSON.t): option<string> =>
+  switch json {
+  | String(s) => Some(s)
+  | _ => None
+  }
+
+let userOf = (json: JSON.t): option<user> =>
+  switch json {
+  | Object(obj) =>
+    switch (
+      obj->Dict.get("username")->Option.flatMap(asString),
+      obj->Dict.get("password")->Option.flatMap(asString),
+    ) {
+    | (Some(username), Some(password)) =>
+      let groups = switch obj->Dict.get("groups") {
+      | Some(JSON.Array(items)) => items->Array.filterMap(asString)
+      | _ => []
+      }
+      Some({username, password, groups})
+    | _ => None
+    }
+  | _ => None
+  }
+
+/**
+ * The accounts a users.yaml document defines, in the order it defines them —
+ * the order is what makes "the first one" a stable default.
+ *
+ * An entry without both a username and a password is skipped rather than
+ * rejected: the file is hand-maintained, and one incomplete entry should not
+ * cost the operator the rest of the list.
+ */
+let parseString = (yamlText: string): array<user> => {
+  let doc = try parseYaml(yamlText) catch {
+  | _ => JSON.Null
+  }
+  switch doc {
+  | Array(items) => items->Array.filterMap(userOf)
+  | _ => []
+  }
+}
+
+/** Where the file lives for the platform being seeded — the seed runs from that
+    package's directory, which is the same cwd the local auth adapter reads. */
+let defaultPath = (): string => NodePath.join([NodeProcess.cwd(), ".reventless", "users.yaml"])
+
+/**
+ * The accounts on disk, with the path they came from. `None` when there is no
+ * readable file with at least one usable account, which the caller reads as
+ * "ask for credentials instead".
+ */
+let load = (~path: option<string>=?): option<(string, array<user>)> => {
+  let file = path->Option.getOr(defaultPath())
+  let users = try {
+    NodeFs.existsSync(file) ? parseString(NodeFs.readFileSync(file)) : []
+  } catch {
+  | _ => []
+  }
+  users->Array.length == 0 ? None : Some((file, users))
+}
+
+/** Menu label: the username, plus whatever groups the file records for it. */
+let label = (u: user): string =>
+  u.groups->Array.length == 0 ? u.username : `${u.username}  [${u.groups->Array.join(", ")}]`

package/lib/ocaml/Seed_UsersTest.res

@@ -0,0 +1,92 @@
+open JestGlobals
+
+// `.reventless/users.yaml` is hand-maintained and shared with the auth adapter,
+// so the seed reads it defensively: it must survive the comment blocks both
+// copies carry, must not reorder the accounts (the first one is the prompt's
+// default, so order IS the contract), and must never throw — a broken file costs
+// the menu, not the run.
+
+let document = `
+# Local dev users — a comment block like the real file carries.
+
+- username: admin
+  password: admin
+  groups: [Admin, Shopper]
+  userId: local-admin
+
+- username: shopper
+  password: Shopper-2026!
+  groups: [Shopper]
+
+- username: noGroups
+  password: pw
+`
+
+describe("Seed_Users.parseString:", () => {
+  testSync("reads every account, in the order the file defines them", () => {
+    let users = Seed_Users.parseString(document)
+    expect(users->Array.map(u => u.Seed_Users.username))->Expect.toEqual([
+      "admin",
+      "shopper",
+      "noGroups",
+    ])
+  })
+
+  testSync("carries the password beside the username", () => {
+    let users = Seed_Users.parseString(document)
+    expect(users->Array.map(u => u.Seed_Users.password))->Expect.toEqual([
+      "admin",
+      "Shopper-2026!",
+      "pw",
+    ])
+  })
+
+  testSync("keeps the groups, and reads a missing groups key as none", () => {
+    let users = Seed_Users.parseString(document)
+    expect(users->Array.map(u => u.Seed_Users.groups))->Expect.toEqual([
+      ["Admin", "Shopper"],
+      ["Shopper"],
+      [],
+    ])
+  })
+
+  // An entry half-written by hand is the likely flaw in this file. Dropping it
+  // keeps the other accounts selectable; failing the parse would not.
+  testSync("skips an entry that names no password", () => {
+    let users = Seed_Users.parseString(`
+- username: admin
+  password: admin
+- username: halfWritten
+  groups: [Shopper]
+`)
+    expect(users->Array.map(u => u.Seed_Users.username))->Expect.toEqual(["admin"])
+  })
+
+  testSync("yields no accounts for a document that is not a list", () => {
+    expect(Seed_Users.parseString("users: {}")->Array.length)->Expect.toBe(0)
+  })
+
+  // The whole point of returning accounts rather than raising: the caller falls
+  // back to prompting, and it can only do that if nothing here escapes.
+  testSync("yields no accounts for malformed YAML instead of throwing", () => {
+    expect(Seed_Users.parseString("- username: [unclosed")->Array.length)->Expect.toBe(0)
+  })
+})
+
+describe("Seed_Users.load:", () => {
+  testSync("is silent about a file that is not there", () => {
+    expect(Seed_Users.load(~path="/nonexistent/.reventless/users.yaml"))->Expect.toBe(None)
+  })
+})
+
+describe("Seed_Users.label:", () => {
+  testSync("names the groups an account carries", () => {
+    expect(
+      Seed_Users.label({username: "admin", password: "x", groups: ["Admin", "Shopper"]}),
+    )->Expect.toBe("admin  [Admin, Shopper]")
+  })
+
+  testSync("is the bare username when the file records no groups", () => {
+    expect(Seed_Users.label({username: "admin", password: "x", groups: []}))->Expect.toBe("admin")
+  })
+})

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@reventlessdev/reventless-seed",
-  "version": "1.0.0-alpha.16",
+  "version": "1.0.0-alpha.17",
   "description": "Reusable harness for seeding a Reventless platform through its public GraphQL command API",
   "license": "Apache-2.0",
   "dependencies": {
+    "yaml": "^2.8.3",
     "@reventlessdev/rescript-node": "2.0.0-alpha.8"
   },
   "devDependencies": {

package/src/Seed.res

@@ -10,6 +10,7 @@ module Client = Seed_Client
 module Runner = Seed_Runner
 module Upload = Seed_Upload
 module Prompt = Seed_Prompt
+module Users = Seed_Users
 module Connect = Seed_Connect
 
 exception Failed = Seed_Types.Failed

package/src/Seed.res.mjs

@@ -12,6 +12,8 @@ let Upload;
 
 let Prompt;
 
+let Users;
+
 let Connect;
 
 let Failed = Seed_Types$ReventlessSeed.Failed;
@@ -30,6 +32,7 @@ export {
   Runner,
   Upload,
   Prompt,
+  Users,
   Connect,
   Failed,
   mutation,

package/src/Seed_Prompt.res

@@ -121,11 +121,15 @@ let isAffirmative = (answer: string): bool =>
  * Auto-returns when there is a single option, so a lone data set or stack needs
  * no keypress. `env` (e.g. `SEED_SET`) preselects by matching label or 1-based
  * index, so CI runs without a TTY. Otherwise it prints a numbered menu.
+ *
+ * `defaultIndex` makes Enter a valid answer, selecting that 0-based option;
+ * without one every reply must name a choice.
  */
 let select = async (
   ~title: string,
   ~options: array<(string, 'a)>,
   ~env=?,
+  ~defaultIndex=?,
 ): 'a =>
   switch options {
   | [(_, only)] => only
@@ -153,29 +157,38 @@ let select = async (
       options->Array.forEachWithIndex(((label, _), i) =>
         Console.log(`  ${(i + 1)->Int.toString}) ${label}`)
       )
+      let fallback = defaultIndex->Option.flatMap(i => options->Array.get(i))
+      let hint = switch (defaultIndex, fallback) {
+      | (Some(i), Some(_)) => ` (default ${(i + 1)->Int.toString})`
+      | _ => ""
+      }
       let rec pick = async (): 'a => {
-        let answer = await ask(`\nSelect [1-${(options->Array.length)->Int.toString}]: `)
-        switch Int.fromString(answer) {
-        | Some(n) if n >= 1 && n <= options->Array.length =>
-          let (_, value) = options->Array.getUnsafe(n - 1)
-          value
+        let answer = await ask(
+          `\nSelect [1-${(options->Array.length)->Int.toString}]${hint}: `,
+        )
+        switch (answer, fallback) {
+        | ("", Some((_, value))) => value
         | _ =>
-          Console.log("  Not a valid choice.")
-          await pick()
+          switch Int.fromString(answer) {
+          | Some(n) if n >= 1 && n <= options->Array.length =>
+            let (_, value) = options->Array.getUnsafe(n - 1)
+            value
+          | _ =>
+            Console.log("  Not a valid choice.")
+            await pick()
+          }
         }
       }
       await pick()
     }
   }
 
-/**
- * Prompts for a username (visible) and password (echo muted).
- *
- * `REVENTLESS_DEMO_USER` / `REVENTLESS_DEMO_PASSWORD` skip the prompts. With
- * `localDefaults`, empty input falls back to `admin`/`admin` — the dev login.
- */
-let credentials = async (~localDefaults: bool=false): (string, string) => {
-  let username = switch envValue("REVENTLESS_DEMO_USER") {
+// Typing both halves is the fallback, not the first offer: it is what happens
+// when the platform keeps no accounts file. `envUser` is threaded in so a
+// `REVENTLESS_DEMO_USER` that named nobody in the file still skips the username
+// prompt rather than asking for a name that was already given.
+let askCredentials = async (~localDefaults: bool, ~envUser: option<string>): (string, string) => {
+  let username = switch envUser {
   | Some(u) => u
   | None =>
     requireTty()
@@ -189,6 +202,60 @@ let credentials = async (~localDefaults: bool=false): (string, string) => {
     let entered = await askHidden(localDefaults ? "Password [admin]: " : "Password: ")
     entered == "" && localDefaults ? "admin" : entered
   }
+  (username, password)
+}
+
+// The accounts file the platform already keeps (`.reventless/users.yaml`, or
+// `SEED_USERS_FILE`). It records the password beside the username, so choosing
+// an account is the whole credential step — nothing is typed.
+//
+// A named `REVENTLESS_DEMO_USER` picks its entry directly; otherwise the file's
+// accounts are offered in the order it defines them, first as the default.
+// `None` means the file has nothing to offer and the caller should ask.
+let fromUsersFile = async (~envUser: option<string>): option<(string, string)> =>
+  switch Seed_Users.load(~path=?envValue("SEED_USERS_FILE")) {
+  | None => None
+  | Some((path, users)) =>
+    let chosen = switch envUser {
+    | Some(name) => users->Array.find(u => u.username == name)
+    | None =>
+      Some(
+        await select(
+          ~title=`User (${path}):`,
+          ~options=users->Array.map(u => (Seed_Users.label(u), u)),
+          ~env="SEED_USER",
+          ~defaultIndex=0,
+        ),
+      )
+    }
+    // Logged for every arm, including the single-account file that selects
+    // itself without a keypress: which identity seeded the data is the thing an
+    // operator checks when owner-scoped rows turn up under the wrong account.
+    chosen->Option.map(u => {
+      Console.log(`Logging in as ${u.username} (from ${path})`)
+      (u.username, u.password)
+    })
+  }
+
+/**
+ * Resolves the credentials a seed run logs in with.
+ *
+ * `REVENTLESS_DEMO_USER` + `REVENTLESS_DEMO_PASSWORD` together are the
+ * non-interactive path and skip everything below. Otherwise the platform's
+ * `.reventless/users.yaml` supplies the accounts to choose from, and only a
+ * platform without one falls back to typing both halves — where, with
+ * `localDefaults`, empty input means `admin`/`admin`.
+ */
+let credentials = async (~localDefaults: bool=false): (string, string) => {
+  let envUser = envValue("REVENTLESS_DEMO_USER")
+  let (username, password) = switch (envUser, envValue("REVENTLESS_DEMO_PASSWORD")) {
+  | (Some(u), Some(p)) => (u, p)
+  | _ =>
+    switch await fromUsersFile(~envUser) {
+    | Some(pair) => pair
+    | None => await askCredentials(~localDefaults, ~envUser)
+    }
+  }
   if username == "" || password == "" {
     throw(Failed("username and password are required."))
   }