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

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 1.0.0-alpha.18 (2026-08-27)
+
+### Bug Fixes
+
+* **seed:** one endpoint-side fault throws away every command that landed ([6126dca](https://github.com/ReventlessDev/reventless-core/commit/6126dca7c62d193cf3a4efe379160af8207faa86))
+
+
+# 1.0.0-alpha.17 (2026-08-20)
+
+### Features
+
+* **seed:** choose the login from the platform's users.yaml ([74e61de](https://github.com/ReventlessDev/reventless-core/commit/74e61de8fba3ee4cc62b368ff12010f162d49db7))
+
+
 # 1.0.0-alpha.16 (2026-08-18)
 
 **Note:** Version bump only for package @reventlessdev/reventless-seed

package/lib/bs/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1787013927827)
-#Done(1787013927856)
+#Start(1787841681066)
+#Done(1787841681103)

package/lib/bs/ReventlessSeed.mlmap

@@ -1,6 +1,7 @@
 randjbuildsystem
 Seed
 Seed_Client
+Seed_ClientTest
 Seed_Connect
 Seed_Prompt
 Seed_PromptTest
@@ -9,3 +10,5 @@ Seed_RandomTest
 Seed_Runner
 Seed_Types
 Seed_Upload
+Seed_Users
+Seed_UsersTest

package/lib/bs/compiler-info.json

@@ -4,5 +4,5 @@
   "bsc_hash": "75e3a59c95cc953608fd3dd6ea6ed68141bba4414a20a52f114261b8a48385fa",
   "rescript_config_hash": "25cfff836d200084949fdfdfec2f6875901bfee1f04d84634eca252ef1ca1ef1",
   "runtime_path": "/home/runner/work/reventless-core/reventless-core/node_modules/@rescript/runtime",
-  "generated_at": "1787013927858"
+  "generated_at": "1787841681106"
 }

package/lib/bs/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/lib/bs/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/lib/bs/src/Seed_Client.res

@@ -106,10 +106,57 @@ let login = async (t: t): unit => {
   t.token = json->field("token")->Option.flatMap(asString)
 }
 
+/** Error types the endpoint returns for a fault on its own side rather than a
+    problem with the document. They say nothing about the request, so the same
+    request sent again can succeed — and across the few hundred commands a seed
+    issues, one of these is ordinary rather than exceptional.
+
+    Everything else — a validation error, an unknown field, a refused token — is
+    an answer, and the same answer comes back however many times it is asked. */
+let transientErrorTypes = [
+  "InternalFailure",
+  "ServiceUnavailable",
+  "ServiceUnavailableError",
+  "Throttling",
+  "ThrottlingException",
+  "TooManyRequestsException",
+  "RequestTimeout",
+]
+
+/** Every entry must be transient for the document to be worth resending: one
+    real error alongside a transient one still means the request was wrong. An
+    empty `errors` array is not a reason to retry either. */
+let isTransient = (errors: JSON.t): bool =>
+  switch errors->JSON.Decode.array {
+  | None | Some([]) => false
+  | Some(entries) =>
+    entries->Array.every(e =>
+      switch e->nodeString("errorType") {
+      | Some(errorType) => transientErrorTypes->Array.includes(errorType)
+      | None => false
+      }
+    )
+  }
+
+let attempts = 4
+
 /**
  * Sends one GraphQL document and returns its `data`. A GraphQL-level error
  * aborts the run: a half-seeded store is worse than an empty one, because it
  * looks like a working dataset.
+ *
+ * Which is exactly why a fault on the endpoint's own side must not abort it. A
+ * seed issues hundreds of commands, many of them concurrently and all of them
+ * against runtimes that a preceding reset left cold, so a single
+ * `InternalFailure` somewhere in the batch is a normal event. Treating it as
+ * fatal threw away every command that had already landed and demanded a full
+ * wipe and re-run — for a request that would have succeeded on being asked
+ * again. So resend those, backing off between tries, and keep failing fast on
+ * everything that is an answer rather than a fault.
+ *
+ * The backoff is jittered because the commands go out in concurrent batches: a
+ * fixed delay would have the whole batch retry in lockstep and rebuild the same
+ * burst that provoked the fault.
  */
 let gql = async (t: t, ~query: string, ~label: string): JSON.t => {
   let headers = Dict.fromArray([("content-type", "application/json")])
@@ -120,18 +167,27 @@ let gql = async (t: t, ~query: string, ~label: string): JSON.t => {
   let body = JSON.stringify(
     JSON.Encode.object(Dict.fromArray([("query", JSON.Encode.string(query))])),
   )
-  let res = try await fetch(t.config.endpoint, {method: "POST", headers, body}) catch {
-  | _ =>
-    throw(Failed(`${label}: cannot reach ${t.config.endpoint} — is the platform running?`))
-  }
-  let json = await res->responseJson
-  switch json->field("errors") {
-  | Some(errors) =>
-    throw(
-      Failed(`${label} failed\n  query: ${query}\n  response: ${JSON.stringify(errors)}`),
-    )
-  | None => json->field("data")->Option.getOr(JSON.Encode.null)
+  let rec attempt = async (n: int): JSON.t => {
+    let res = try await fetch(t.config.endpoint, {method: "POST", headers, body}) catch {
+    | _ =>
+      throw(Failed(`${label}: cannot reach ${t.config.endpoint} — is the platform running?`))
+    }
+    let json = await res->responseJson
+    switch json->field("errors") {
+    | Some(errors) =>
+      if errors->isTransient && n < attempts {
+        await sleep(250 * Int.shiftLeft(1, n - 1) + Int.fromFloat(Math.random() *. 250.))
+        await attempt(n + 1)
+      } else {
+        let tried = n > 1 ? `\n  gave up after ${n->Int.toString} attempts` : ""
+        throw(
+          Failed(`${label} failed\n  query: ${query}\n  response: ${JSON.stringify(errors)}${tried}`),
+        )
+      }
+    | None => json->field("data")->Option.getOr(JSON.Encode.null)
+    }
   }
+  await attempt(1)
 }
 
 // ── Commands ────────────────────────────────────────────────────────────────

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

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Seed_Types$ReventlessSeed from "./Seed_Types.res.mjs";
@@ -98,6 +99,32 @@ async function login(t) {
   t.token = Stdlib_Option.flatMap(field(json, "token"), asString);
 }
 
+let transientErrorTypes = [
+  "InternalFailure",
+  "ServiceUnavailable",
+  "ServiceUnavailableError",
+  "Throttling",
+  "ThrottlingException",
+  "TooManyRequestsException",
+  "RequestTimeout"
+];
+
+function isTransient(errors) {
+  let entries = Stdlib_JSON.Decode.array(errors);
+  if (entries !== undefined && entries.length !== 0) {
+    return entries.every(e => {
+      let errorType = nodeString(e, "errorType");
+      if (errorType !== undefined) {
+        return transientErrorTypes.includes(errorType);
+      } else {
+        return false;
+      }
+    });
+  } else {
+    return false;
+  }
+}
+
 async function gql(t, query, label) {
   let headers = Object.fromEntries([[
       "content-type",
@@ -111,30 +138,38 @@ async function gql(t, query, label) {
       "query",
       query
     ]]));
-  let res;
-  try {
-    res = await fetch(t.config.endpoint, {
-      method: "POST",
-      headers: headers,
-      body: body
-    });
-  } catch (exn) {
-    throw {
-      RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
-      _1: label + `: cannot reach ` + t.config.endpoint + ` — is the platform running?`,
-      Error: new Error()
-    };
-  }
-  let json = await res.json();
-  let errors = field(json, "errors");
-  if (errors !== undefined) {
+  let attempt = async n => {
+    let res;
+    try {
+      res = await fetch(t.config.endpoint, {
+        method: "POST",
+        headers: headers,
+        body: body
+      });
+    } catch (exn) {
+      throw {
+        RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
+        _1: label + `: cannot reach ` + t.config.endpoint + ` — is the platform running?`,
+        Error: new Error()
+      };
+    }
+    let json = await res.json();
+    let errors = field(json, "errors");
+    if (errors === undefined) {
+      return Stdlib_Option.getOr(field(json, "data"), null);
+    }
+    if (isTransient(errors) && n < 4) {
+      await sleep((250 * (1 << (n - 1 | 0)) | 0) + (Math.random() * 250 | 0) | 0);
+      return await attempt(n + 1 | 0);
+    }
+    let tried = n > 1 ? `\n  gave up after ` + n.toString() + ` attempts` : "";
     throw {
       RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
-      _1: label + ` failed\n  query: ` + query + `\n  response: ` + JSON.stringify(errors),
+      _1: label + ` failed\n  query: ` + query + `\n  response: ` + JSON.stringify(errors) + tried,
       Error: new Error()
     };
-  }
-  return Stdlib_Option.getOr(field(json, "data"), null);
+  };
+  return await attempt(1);
 }
 
 let commandResultSelection = `__typename
@@ -269,6 +304,8 @@ async function waitForIds(t, fieldName, ids, timeoutMsOpt) {
   return Stdlib_Option.getOr(result, 0);
 }
 
+let attempts = 4;
+
 export {
   sleep,
   make,
@@ -279,6 +316,9 @@ export {
   asString,
   nodeString,
   login,
+  transientErrorTypes,
+  isTransient,
+  attempts,
   gql,
   commandResultSelection,
   send,

package/lib/bs/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."))
   }

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
@@ -94,7 +95,7 @@ function isAffirmative(answer) {
   }
 }
 
-async function select(title, options, env) {
+async function select(title, options, env, defaultIndex) {
   if (options.length === 1) {
     return options[0][1];
   }
@@ -118,8 +119,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) {
@@ -136,12 +142,10 @@ 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");
+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: ");
@@ -156,6 +160,52 @@ async function credentials(localDefaultsOpt) {
     let entered$1 = await askHidden(localDefaults ? "Password [admin]: " : "Password: ");
     password = entered$1 === "" && localDefaults ? "admin" : entered$1;
   }
+  return [
+    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 [
+      u.username,
+      u.password
+    ];
+  });
+}
+
+async function credentials(localDefaultsOpt) {
+  let localDefaults = localDefaultsOpt !== undefined ? localDefaultsOpt : false;
+  let envUser = envValue("REVENTLESS_DEMO_USER");
+  let match = envValue("REVENTLESS_DEMO_PASSWORD");
+  let match$1;
+  let exit = 0;
+  if (envUser !== undefined && match !== undefined) {
+    match$1 = [
+      envUser,
+      match
+    ];
+  } else {
+    exit = 1;
+  }
+  if (exit === 1) {
+    let pair = await fromUsersFile(envUser);
+    match$1 = pair !== undefined ? pair : await askCredentials(localDefaults, envUser);
+  }
+  let password = match$1[1];
+  let username = match$1[0];
   if (username === "" || password === "") {
     throw {
       RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
@@ -180,6 +230,8 @@ export {
   askHidden,
   isAffirmative,
   select,
+  askCredentials,
+  fromUsersFile,
   credentials,
 }
 /* node:readline Not a pure module */

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

@@ -155,7 +155,7 @@ 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];