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

package/lib/ocaml/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,23 +48,23 @@ 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
   }
 
 let requireTty = (): unit =>
-  if !(stdin->isTTY) {
+  if !(NodeProcess.stdin->NodeProcess.isTTY->Option.getOr(false)) {
     throw(
       Failed(
         "no TTY for an interactive prompt — set the documented SEED_* / REVENTLESS_DEMO_* " ++
@@ -101,23 +91,45 @@ 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=?,
+  ~defaultIndex=?,
 ): 'a =>
   switch options {
   | [(_, only)] => only
@@ -145,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()
@@ -181,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_PromptTest.res

@@ -0,0 +1,59 @@
+open JestGlobals
+
+// `isAffirmative` is the one vocabulary for "yes", shared by a typed `[y/N]`
+// reply and by the env var that stands in for it on a run with no terminal.
+//
+// It exists because those two drifted: the prompt took `y`, the env var took
+// only the literals `1` and `yes`, and every other value — `y` included, and an
+// explicit `no` with it — fell through to the interactive branch, which throws
+// when there is no TTY. So the variable that exists to make the tool
+// non-interactive had two spellings that worked and a crash for the rest.
+//
+// The suite is written around the shape of that bug rather than around the
+// function: what must confirm, what must decline, and — the case that actually
+// broke CI — that declining is a normal answer and not a fall-through.
+
+describe("Seed_Prompt.isAffirmative:", () => {
+  testSync("takes the three spellings of yes", () => {
+    ["y", "yes", "1"]->Array.forEach(v =>
+      expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(true)
+    )
+  })
+
+  // A prompt that prints `[y/N]` invites a capital as readily as a lowercase
+  // one, and an env var set by hand is written however the hand felt.
+  testSync("ignores case, so Y and YES answer as y does", () => {
+    ["Y", "Yes", "YES"]->Array.forEach(v =>
+      expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(true)
+    )
+  })
+
+  testSync("ignores surrounding space", () => {
+    [" y", "y ", "  yes  "]->Array.forEach(v =>
+      expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(true)
+    )
+  })
+
+  // The half that matters most: every one of these is an ANSWER, and the caller
+  // reads it as "no". None may be mistaken for "nothing was said", which is what
+  // sent the old code to a prompt it could not open.
+  testSync("declines every spelling of no, capital N included", () => {
+    ["n", "N", "no", "No", "NO"]->Array.forEach(v =>
+      expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(false)
+    )
+  })
+
+  testSync("declines anything it does not recognise", () => {
+    ["", "  ", "0", "true", "yep", "y.", "yesplease", "affirmative"]->Array.forEach(v =>
+      expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(false)
+    )
+  })
+
+  // `true` is deliberately absent from the vocabulary above. Named here so that
+  // adding it is a decision someone takes against a failing test rather than a
+  // kindness someone slips in: the prompt this stands in for asks `[y/N]`, and a
+  // reply nobody would type at that prompt should not work around it either.
+  testSync("does not quietly grow a fourth spelling", () => {
+    expect(Seed_Prompt.isAffirmative("true"))->Expect.toBe(false)
+  })
+})

package/lib/ocaml/Seed_RandomTest.res

@@ -0,0 +1,160 @@
+open JestGlobals
+
+// `Seed_Random` exists so that two seed runs against a fresh store produce the
+// same data — that is what makes a seeded store usable as a screenshot baseline
+// or a comparison target. Its correctness is therefore not "looks random" but
+// "repeats exactly, and stays inside the bounds it advertises".
+//
+// The suite is written around that: every case below fails for a generator that
+// is subtly non-reproducible or that walks out of its range, and none of them
+// would notice a change of algorithm that kept both properties.
+
+describe("Seed_Random:", () => {
+  let take = (~seed, ~n) => {
+    let r = Seed_Random.make(~seed)
+    Array.make(~length=n, 0.0)->Array.map(_ => Seed_Random.float(r))
+  }
+
+  describe("reproducibility — the reason this module exists:", () => {
+    testSync("the same seed replays the same sequence", () =>
+      expect(take(~seed=42, ~n=25))->toEqual(take(~seed=42, ~n=25))
+    )
+
+    // Without this, a generator that returned a constant would satisfy the
+    // case above and nothing else in the suite would catch it.
+    testSync("different seeds diverge", () =>
+      expect(take(~seed=42, ~n=25) == take(~seed=43, ~n=25))->toBe(false)
+    )
+
+    testSync("a fresh generator does not continue the previous one", () => {
+      let r = Seed_Random.make(~seed=7)
+      let first = Seed_Random.float(r)
+      let _ = Seed_Random.float(r)
+      expect(Seed_Random.float(Seed_Random.make(~seed=7)))->toEqual(first)
+    })
+  })
+
+  describe("float stays a unit interval:", () => {
+    // mulberry32's last step is a signed 32-bit value folded back to unsigned.
+    // Get that fold wrong and roughly half the draws come out negative, which
+    // every consumer below (int, pick, sampleWeighted) silently mis-scales.
+    testSync("every draw is in [0, 1)", () =>
+      expect(take(~seed=99, ~n=500)->Array.every(f => f >= 0.0 && f < 1.0))->toBe(true)
+    )
+
+    testSync("and the draws are not all the same value", () => {
+      let draws = take(~seed=99, ~n=100)
+      expect(draws->Array.some(f => f != draws->Array.getUnsafe(0)))->toBe(true)
+    })
+  })
+
+  describe("int is inclusive on both ends, as documented:", () => {
+    let draws = (~min, ~max, ~n) => {
+      let r = Seed_Random.make(~seed=5)
+      Array.make(~length=n, 0)->Array.map(_ => Seed_Random.int(r, ~min, ~max))
+    }
+
+    testSync("never escapes the range", () =>
+      expect(draws(~min=3, ~max=7, ~n=500)->Array.every(i => i >= 3 && i <= 7))->toBe(true)
+    )
+
+    // The documented contract is "inclusive on both ends"; an off-by-one in the
+    // `max - min + 1` scaling shows up as a bound that is never drawn.
+    testSync("reaches both bounds", () => {
+      let d = draws(~min=3, ~max=7, ~n=500)
+      expect((d->Array.includes(3), d->Array.includes(7)))->toEqual((true, true))
+    })
+
+    testSync("a single-value range is that value", () =>
+      expect(draws(~min=4, ~max=4, ~n=10)->Array.every(i => i == 4))->toBe(true)
+    )
+  })
+
+  describe("pick:", () => {
+    testSync("returns None for an empty array", () =>
+      expect(Seed_Random.make(~seed=1)->Seed_Random.pick([]))->toEqual(None)
+    )
+
+    testSync("always lands on a member", () => {
+      let r = Seed_Random.make(~seed=2)
+      let xs = ["a", "b", "c", "d"]
+      let hits = Array.make(~length=200, "")->Array.map(_ =>
+        r->Seed_Random.pickOr(~fallback="MISS", xs)
+      )
+      expect(hits->Array.every(h => xs->Array.includes(h)))->toBe(true)
+    })
+
+    testSync("pickOr falls back only when there is nothing to pick", () =>
+      expect(Seed_Random.make(~seed=3)->Seed_Random.pickOr(~fallback="fallback", []))->toBe(
+        "fallback",
+      )
+    )
+  })
+
+  describe("sampleWeighted is without replacement:", () => {
+    let equal = xs => xs->Array.map(x => (x, 1.0))
+
+    // The documented shuffle use: equal weights, count = length. If sampling
+    // ever replaced instead of removing, duplicates would appear here.
+    testSync("count = length yields a permutation, not a multiset", () => {
+      let xs = ["a", "b", "c", "d", "e"]
+      let out = Seed_Random.make(~seed=11)->Seed_Random.sampleWeighted(equal(xs), ~count=5)
+      let sorted = out->Array.toSorted(String.compare)
+      expect((out->Array.length, sorted))->toEqual((5, ["a", "b", "c", "d", "e"]))
+    })
+
+    testSync("count < length returns exactly count distinct items", () => {
+      let xs = ["a", "b", "c", "d", "e"]
+      let out = Seed_Random.make(~seed=12)->Seed_Random.sampleWeighted(equal(xs), ~count=3)
+      let distinct = Set.fromArray(out)->Set.size
+      expect((out->Array.length, distinct))->toEqual((3, 3))
+    })
+
+    testSync("count > length clamps to the pool", () =>
+      expect(
+        Seed_Random.make(~seed=13)
+        ->Seed_Random.sampleWeighted(equal(["a", "b"]), ~count=99)
+        ->Array.length,
+      )->toBe(2)
+    )
+
+    testSync("a zero-weight entry is never chosen while others remain", () => {
+      let out =
+        Seed_Random.make(~seed=14)->Seed_Random.sampleWeighted(
+          [("never", 0.0), ("a", 1.0), ("b", 1.0)],
+          ~count=2,
+        )
+      expect(out->Array.includes("never"))->toBe(false)
+    })
+
+    testSync("is reproducible for a given seed", () => {
+      let run = () =>
+        Seed_Random.make(~seed=15)->Seed_Random.sampleWeighted(
+          equal(["a", "b", "c", "d", "e", "f"]),
+          ~count=4,
+        )
+      expect(run())->toEqual(run())
+    })
+  })
+
+  describe("zipfWeights skews toward the head:", () => {
+    let weights = Seed_Random.zipfWeights(["a", "b", "c", "d", "e"], ~exponent=1.1)
+
+    testSync("keeps every item, in order", () =>
+      expect(weights->Array.map(((item, _)) => item))->toEqual(["a", "b", "c", "d", "e"])
+    )
+
+    testSync("weight decreases monotonically with rank", () => {
+      let ws = weights->Array.map(((_, w)) => w)
+      let decreasing =
+        ws->Array.everyWithIndex((w, i) => i == 0 || w < ws->Array.getUnsafe(i - 1))
+      expect(decreasing)->toBe(true)
+    })
+
+    testSync("the leader is clear — first outweighs last several times over", () => {
+      let first = weights->Array.get(0)->Option.mapOr(0.0, ((_, w)) => w)
+      let last = weights->Array.get(4)->Option.mapOr(0.0, ((_, w)) => w)
+      expect(first > last *. 3.0)->toBe(true)
+    })
+  })
+})

package/lib/ocaml/Seed_Runner.res

@@ -2,11 +2,9 @@
 
 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}`)
@@ -90,6 +88,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 +125,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,7 +133,7 @@ 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:")
@@ -116,7 +141,7 @@ let run = async (main: unit => promise<unit>): unit =>
     Console.error(
       exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown"),
     )
-    exit(1)
+    NodeProcess.exit(1)
   }
 
 /**
@@ -128,6 +153,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 +170,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 +207,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) =>