@reventlessdev/reventless-seed 1.0.0-alpha.2 → 1.0.0-alpha.21

package/lib/bs/src/Seed_Prompt.res

@@ -1,7 +1,7 @@
 // One shared readline interface for every interactive prompt in a seed run.
 //
 // The reason this module exists: creating and closing a fresh `readline`
-// interface per prompt leaves stdin paused after the first `close`, so the
+// interface per prompt leaves NodeProcess.stdin paused after the first `close`, so the
 // second prompt (password after username) never fires and the run hangs. A
 // single interface, created lazily and closed exactly once, avoids that — and a
 // `muted` gate on its output lets password entry reuse the same interface
@@ -14,18 +14,8 @@ open Seed_Types
 
 // ── Node bindings ─────────────────────────────────────────────────────────────
 
-type stream
-@val @scope("process") external stdin: stream = "stdin"
-@val @scope("process") external stdout: stream = "stdout"
-@send external writeStream: (stream, string) => unit = "write"
-@get external isTTY: stream => bool = "isTTY"
-@send external pauseStream: stream => unit = "pause"
-@send external unrefStream: stream => unit = "unref"
-
-@scope("process") @val external processEnv: dict<string> = "env"
-
 type rl
-type rlOptions = {input: stream, output: stream, terminal?: bool}
+type rlOptions = {input: NodeProcess.stream, output: NodeProcess.stream, terminal?: bool}
 @module("node:readline") external createInterface: rlOptions => rl = "createInterface"
 @send external question: (rl, string, string => unit) => unit = "question"
 @send external closeRl: rl => unit = "close"
@@ -42,10 +32,10 @@ let iface = (): rl =>
   switch rlRef.contents {
   | Some(rl) => rl
   | None =>
-    let rl = createInterface({input: stdin, output: stdout, terminal: true})
+    let rl = createInterface({input: NodeProcess.stdin, output: NodeProcess.stdout, terminal: true})
     rl->setWriteToOutput(s =>
       if !muted.contents {
-        stdout->writeStream(s)
+        NodeProcess.stdout->NodeProcess.write(s)
       }
     )
     rlRef := Some(rl)
@@ -58,27 +48,31 @@ let close = (): unit =>
     rl->closeRl
     rlRef := None
     // Closing the interface is not enough: a terminal-mode readline leaves
-    // stdin resumed and reffed, which keeps the event loop alive so the CLI
+    // NodeProcess.stdin resumed and reffed, which keeps the event loop alive so the CLI
     // never exits after seeding. Release it explicitly.
-    stdin->pauseStream
-    stdin->unrefStream
+    NodeProcess.stdin->NodeProcess.pause
+    NodeProcess.stdin->NodeProcess.unref
   | None => ()
   }
 
 // ── Env + TTY ─────────────────────────────────────────────────────────────────
 
 let envValue = (key: string): option<string> =>
-  switch processEnv->Dict.get(key) {
+  switch NodeProcess.env->Dict.get(key) {
   | Some(v) if v->String.trim != "" => Some(v->String.trim)
   | _ => None
   }
 
+/** Whether an interactive prompt is possible at all. Callers that can carry on
+    without an answer ask this first; a prompt nobody can answer is worse than a
+    default, because it turns a workable run into a hang or a throw. */
+let hasTty = (): bool => NodeProcess.stdin->NodeProcess.isTTY->Option.getOr(false)
+
 let requireTty = (): unit =>
-  if !(stdin->isTTY) {
+  if !hasTty() {
     throw(
       Failed(
-        "no TTY for an interactive prompt — set the documented SEED_* / REVENTLESS_DEMO_* " ++
-        "env vars to run non-interactively.",
+        "no TTY for an interactive prompt — set the documented SEED_* / REVENTLESS_DEMO_* " ++ "env vars to run non-interactively.",
       ),
     )
   }
@@ -101,24 +95,41 @@ let askHidden = (query: string): promise<string> =>
     let rl = iface()
     rl->question(query, answer => {
       muted := false
-      stdout->writeStream("\n")
+      NodeProcess.stdout->NodeProcess.write("\n")
       resolve(answer)
     })
     muted := true
   })
 
+/**
+ * Whether an answer means yes — the one vocabulary, for the typed reply and the
+ * env var that stands in for it alike.
+ *
+ * It exists because those two drifted: a `[y/N]` prompt took `y`, and the env
+ * var beside it took only `1` or `yes`, so the obvious `SEED_RESET_CONFIRM=y`
+ * silently fell through to the interactive branch — which, on the CI runs the
+ * variable exists for, has no TTY and throws. Two spellings of one question are
+ * one spelling too many; callers ask this instead of comparing strings.
+ *
+ * Trimmed and case-folded, so `Yes`/` y ` answer the same as `y`.
+ */
+let isAffirmative = (answer: string): bool =>
+  switch answer->String.trim->String.toLowerCase {
+  | "y" | "yes" | "1" => true
+  | _ => false
+  }
+
 /**
  * Chooses one of `options` (a label paired with the value it selects).
  *
  * 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=?,
-): 'a =>
+let select = async (~title: string, ~options: array<(string, 'a)>, ~env=?, ~defaultIndex=?): 'a =>
   switch options {
   | [(_, only)] => only
   | _ =>
@@ -145,15 +156,24 @@ 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()
@@ -161,13 +181,30 @@ let select = async (
   }
 
 /**
- * Prompts for a username (visible) and password (echo muted).
+ * The account a run authenticated as, alongside every account the platform's
+ * accounts file declares.
  *
- * `REVENTLESS_DEMO_USER` / `REVENTLESS_DEMO_PASSWORD` skip the prompts. With
- * `localDefaults`, empty input falls back to `admin`/`admin` — the dev login.
+ * `accounts` is `[]` whenever no file was read — the
+ * `REVENTLESS_DEMO_USER`/`REVENTLESS_DEMO_PASSWORD` path bypasses it entirely,
+ * and so does typing both halves — so a consumer must handle empty rather than
+ * assume the file was there. `caller` is always populated, but carries no
+ * `groups` and no `userId` on those paths: nothing read them off a file.
  */
-let credentials = async (~localDefaults: bool=false): (string, string) => {
-  let username = switch envValue("REVENTLESS_DEMO_USER") {
+type resolved = {caller: Seed_Users.user, accounts: array<Seed_Users.user>}
+
+let typedUser = (~username: string, ~password: string): Seed_Users.user => {
+  username,
+  password,
+  groups: [],
+  userId: None,
+}
+
+// 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>): Seed_Users.user => {
+  let username = switch envUser {
   | Some(u) => u
   | None =>
     requireTty()
@@ -181,8 +218,70 @@ let credentials = async (~localDefaults: bool=false): (string, string) => {
     let entered = await askHidden(localDefaults ? "Password [admin]: " : "Password: ")
     entered == "" && localDefaults ? "admin" : entered
   }
-  if username == "" || password == "" {
+  typedUser(~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.
+//
+// The whole list travels back with the chosen account, not just the credentials
+// it supplied: the file is also the only place a demo owner's id can be looked
+// up, and reading it once to pick a login and never again is what let a data set
+// seed rows under ids nobody on the platform holds.
+let fromUsersFile = async (~envUser: option<string>): option<resolved> =>
+  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})`)
+      {caller: u, accounts: users}
+    })
+  }
+
+/**
+ * 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`.
+ *
+ * Returns the resolved account rather than a pair, and the accounts file
+ * alongside it when there was one — see `resolved`.
+ */
+let credentials = async (~localDefaults: bool=false): resolved => {
+  let envUser = envValue("REVENTLESS_DEMO_USER")
+  let resolved = switch (envUser, envValue("REVENTLESS_DEMO_PASSWORD")) {
+  | (Some(username), Some(password)) => {caller: typedUser(~username, ~password), accounts: []}
+  | _ =>
+    switch await fromUsersFile(~envUser) {
+    | Some(resolved) => resolved
+    | None => {caller: await askCredentials(~localDefaults, ~envUser), accounts: []}
+    }
+  }
+  if resolved.caller.username == "" || resolved.caller.password == "" {
     throw(Failed("username and password are required."))
   }
-  (username, password)
+  resolved
 }

package/lib/bs/src/Seed_Prompt.res.mjs

@@ -5,6 +5,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Nodereadline from "node:readline";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Seed_Types$ReventlessSeed from "./Seed_Types.res.mjs";
+import * as Seed_Users$ReventlessSeed from "./Seed_Users.res.mjs";
 
 let rlRef = {
   contents: undefined
@@ -52,8 +53,12 @@ function envValue(key) {
   }
 }
 
+function hasTty() {
+  return Stdlib_Option.getOr(process.stdin.isTTY, false);
+}
+
 function requireTty() {
-  if (process.stdin.isTTY) {
+  if (Stdlib_Option.getOr(process.stdin.isTTY, false)) {
     return;
   }
   throw {
@@ -82,7 +87,19 @@ function askHidden(query) {
   });
 }
 
-async function select(title, options, env) {
+function isAffirmative(answer) {
+  let match = answer.trim().toLowerCase();
+  switch (match) {
+    case "1" :
+    case "y" :
+    case "yes" :
+      return true;
+    default:
+      return false;
+  }
+}
+
+async function select(title, options, env, defaultIndex) {
   if (options.length === 1) {
     return options[0][1];
   }
@@ -106,8 +123,13 @@ async function select(title, options, env) {
   options.forEach((param, i) => {
     console.log(`  ` + (i + 1 | 0).toString() + `) ` + param[0]);
   });
+  let fallback = Stdlib_Option.flatMap(defaultIndex, i => options[i]);
+  let hint = defaultIndex !== undefined && fallback !== undefined ? ` (default ` + (defaultIndex + 1 | 0).toString() + `)` : "";
   let pick = async () => {
-    let answer = await ask(`\nSelect [1-` + options.length.toString() + `]: `);
+    let answer = await ask(`\nSelect [1-` + options.length.toString() + `]` + hint + `: `);
+    if (answer === "" && fallback !== undefined) {
+      return fallback[1];
+    }
     let n = Stdlib_Int.fromString(answer, undefined);
     if (n !== undefined) {
       if (n >= 1 && n <= options.length) {
@@ -124,12 +146,19 @@ async function select(title, options, env) {
   return await pick();
 }
 
-async function credentials(localDefaultsOpt) {
-  let localDefaults = localDefaultsOpt !== undefined ? localDefaultsOpt : false;
-  let u = envValue("REVENTLESS_DEMO_USER");
+function typedUser(username, password) {
+  return {
+    username: username,
+    password: password,
+    groups: [],
+    userId: undefined
+  };
+}
+
+async function askCredentials(localDefaults, envUser) {
   let username;
-  if (u !== undefined) {
-    username = u;
+  if (envUser !== undefined) {
+    username = envUser;
   } else {
     requireTty();
     let entered = await ask(localDefaults ? "Username [admin]: " : "Username: ");
@@ -144,17 +173,58 @@ async function credentials(localDefaultsOpt) {
     let entered$1 = await askHidden(localDefaults ? "Password [admin]: " : "Password: ");
     password = entered$1 === "" && localDefaults ? "admin" : entered$1;
   }
-  if (username === "" || password === "") {
+  return typedUser(username, password);
+}
+
+async function fromUsersFile(envUser) {
+  let match = Seed_Users$ReventlessSeed.load(envValue("SEED_USERS_FILE"));
+  if (match === undefined) {
+    return;
+  }
+  let users = match[1];
+  let path = match[0];
+  let chosen = envUser !== undefined ? users.find(u => u.username === envUser) : await select(`User (` + path + `):`, users.map(u => [
+      Seed_Users$ReventlessSeed.label(u),
+      u
+    ]), "SEED_USER", 0);
+  return Stdlib_Option.map(chosen, u => {
+    console.log(`Logging in as ` + u.username + ` (from ` + path + `)`);
+    return {
+      caller: u,
+      accounts: users
+    };
+  });
+}
+
+async function credentials(localDefaultsOpt) {
+  let localDefaults = localDefaultsOpt !== undefined ? localDefaultsOpt : false;
+  let envUser = envValue("REVENTLESS_DEMO_USER");
+  let match = envValue("REVENTLESS_DEMO_PASSWORD");
+  let resolved;
+  let exit = 0;
+  if (envUser !== undefined && match !== undefined) {
+    resolved = {
+      caller: typedUser(envUser, match),
+      accounts: []
+    };
+  } else {
+    exit = 1;
+  }
+  if (exit === 1) {
+    let resolved$1 = await fromUsersFile(envUser);
+    resolved = resolved$1 !== undefined ? resolved$1 : ({
+        caller: await askCredentials(localDefaults, envUser),
+        accounts: []
+      });
+  }
+  if (resolved.caller.username === "" || resolved.caller.password === "") {
     throw {
       RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
       _1: "username and password are required.",
       Error: new Error()
     };
   }
-  return [
-    username,
-    password
-  ];
+  return resolved;
 }
 
 export {
@@ -163,10 +233,15 @@ export {
   iface,
   close,
   envValue,
+  hasTty,
   requireTty,
   ask,
   askHidden,
+  isAffirmative,
   select,
+  typedUser,
+  askCredentials,
+  fromUsersFile,
   credentials,
 }
 /* node:readline Not a pure module */

package/lib/bs/src/Seed_Random.res

@@ -10,13 +10,15 @@ type t = {mutable state: int}
 
 let make = (~seed: int): t => {state: seed}
 
-
 /** mulberry32 — small, fast, and stable across JS engines and Node versions. */
 let float = (r: t): float => {
   r.state = (r.state + 0x6d2b79f5)->Int.bitwiseOr(0)
   let a = r.state
   let b = imul(a->Int.bitwiseXor(a->Int.shiftRightUnsigned(15)), a->Int.bitwiseOr(1))
-  let c = b->Int.bitwiseXor(b + imul(b->Int.bitwiseXor(b->Int.shiftRightUnsigned(7)), b->Int.bitwiseOr(61)))
+  let c =
+    b->Int.bitwiseXor(
+      b + imul(b->Int.bitwiseXor(b->Int.shiftRightUnsigned(7)), b->Int.bitwiseOr(61)),
+    )
   let bits = c->Int.bitwiseXor(c->Int.shiftRightUnsigned(14))
   // `bits` is a signed 32-bit result; fold the sign bit back in to get the
   // unsigned value a `>>> 0` would produce.

package/lib/bs/src/Seed_Runner.res

@@ -2,11 +2,8 @@
 
 open Seed_Types
 
-@scope("process") @val external exit: int => unit = "exit"
-@scope("process") @val external env: dict<string> = "env"
-
 let envOr = (key: string, fallback: string): string =>
-  env->Dict.get(key)->Option.getOr(fallback)
+  NodeProcess.env->Dict.get(key)->Option.getOr(fallback)
 
 /** One line of progress per phase, so a slow run never looks hung. */
 let report = (line: string): unit => Console.log(`  ${line}`)
@@ -60,14 +57,12 @@ let verifyViews = async (client: Seed_Client.t, ~views: array<view>): dict<int>
     Console.log(`  ${count->Int.toString->String.padStart(4, " ")}  ${name}${note}`)
   })
 
-  let empty =
-    views
-    ->Array.filterMap(v =>
-      switch v {
-      | Seeded(name) if counts->Dict.get(name)->Option.getOr(0) == 0 => Some(name)
-      | _ => None
-      }
-    )
+  let empty = views->Array.filterMap(v =>
+    switch v {
+    | Seeded(name) if counts->Dict.get(name)->Option.getOr(0) == 0 => Some(name)
+    | _ => None
+    }
+  )
   if empty->Array.length > 0 {
     throw(Failed(`these views are still empty after seeding: ${empty->Array.join(", ")}`))
   }
@@ -90,6 +85,33 @@ let warn = (warnings: array<string>): unit =>
     warnings->Array.forEach(w => Console.log(`  - ${w}`))
   }
 
+/**
+ * Pre-flight: refuse to seed onto a store that already holds data.
+ *
+ * The harness is a one-shot against a fresh store — a re-run would hit the
+ * domain's own duplicate rejections (`CategoryAlreadyExists`, …) and abort
+ * mid-phase. Catching it here, before any command is sent, turns that into an
+ * honest "nothing was written" startup abort instead of a misleading
+ * half-seeded one. It is the inverse of `verifyViews`: seeding refuses to start
+ * unless the store reads empty. Stops at the first non-empty probe view, so a
+ * populated store aborts after a single query.
+ */
+let assertStoreEmpty = async (client: Seed_Client.t, ~probeViews: array<string>): unit =>
+  for i in 0 to probeViews->Array.length - 1 {
+    switch probeViews->Array.get(i) {
+    | Some(name) =>
+      let count = await Seed_Client.countNodes(client, ~field=name)
+      if count > 0 {
+        throw(
+          Failed(
+            `the target store is not empty — "${name}" already holds ${count->Int.toString} row(s). Seeding is a one-shot against a fresh store; reset the store before re-running.`,
+          ),
+        )
+      }
+    | None => ()
+    }
+  }
+
 /**
  * Wraps a seed run. On failure it prints the cause and exits non-zero, saying
  * plainly that the store is now half-seeded — recovery is a reset, not a re-run.
@@ -100,7 +122,7 @@ let run = async (main: unit => promise<unit>): unit =>
     // Exit cleanly: HTTP keep-alive sockets (and, on the interactive path, the
     // readline/stdin handle) can otherwise keep the event loop alive so the CLI
     // appears to hang after a successful run.
-    exit(0)
+    NodeProcess.exit(0)
   } catch {
   | Failed(message) =>
     Console.error("")
@@ -108,15 +130,13 @@ let run = async (main: unit => promise<unit>): unit =>
     Console.error("fresh store once the cause below is fixed.")
     Console.error("")
     Console.error(message)
-    exit(1)
+    NodeProcess.exit(1)
   | exn =>
     Console.error("")
     Console.error("Seeding aborted with an unexpected error:")
     Console.error("")
-    Console.error(
-      exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown"),
-    )
-    exit(1)
+    Console.error(exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown"))
+    NodeProcess.exit(1)
   }
 
 /**
@@ -128,6 +148,9 @@ type dataSet = {
   name: string,
   label: string,
   seed: Seed_Connect.connection => promise<unit>,
+  // View names probed by the fresh-store guard before any command is sent; a
+  // non-empty one aborts the run at startup. Omit to skip the guard.
+  probeViews?: array<string>,
 }
 
 /**
@@ -142,7 +165,7 @@ let abortStartup = (message: string): unit => {
   Console.error("Seeding did not start — nothing was written. Fix the cause below and re-run.")
   Console.error("")
   Console.error(message)
-  exit(1)
+  NodeProcess.exit(1)
 }
 
 /**
@@ -179,6 +202,9 @@ let seed = (~sets: array<dataSet>, ~connect: unit => promise<Seed_Connect.connec
       }
       let connection = await connect()
       Seed_Prompt.close()
+      // Runs inside this pre-seed `try`, so refusing a non-empty store (or a
+      // failed probe query) is reported as "did not start", not "half-seeded".
+      await assertStoreEmpty(connection.client, ~probeViews=chosen.probeViews->Option.getOr([]))
       Some((chosen, connection))
     } catch {
     | Failed(message) =>

package/lib/bs/src/Seed_Runner.res.mjs

@@ -83,6 +83,22 @@ function warn(warnings) {
   }
 }
 
+async function assertStoreEmpty(client, probeViews) {
+  for (let i = 0, i_finish = probeViews.length; i < i_finish; ++i) {
+    let name = probeViews[i];
+    if (name !== undefined) {
+      let count = await Seed_Client$ReventlessSeed.countNodes(client, name);
+      if (count > 0) {
+        throw {
+          RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
+          _1: `the target store is not empty — "` + name + `" already holds ` + count.toString() + ` row(s). Seeding is a one-shot against a fresh store; reset the store before re-running.`,
+          Error: new Error()
+        };
+      }
+    }
+  }
+}
+
 async function run(main) {
   try {
     await main();
@@ -139,13 +155,14 @@ function seed(sets, connect) {
           chosen = await Seed_Prompt$ReventlessSeed.select("Data set:", sets.map(s => [
             s.label,
             s
-          ]), undefined);
+          ]), undefined, undefined);
         }
       } else {
         chosen = sets[0];
       }
       let connection = await connect();
       Seed_Prompt$ReventlessSeed.close();
+      await assertStoreEmpty(connection.client, Stdlib_Option.getOr(chosen.probeViews, []));
       started = [
         chosen,
         connection
@@ -179,6 +196,7 @@ export {
   verifyViews,
   unfillableWarnings,
   warn,
+  assertStoreEmpty,
   run,
   abortStartup,
   seed,