@reventlessdev/reventless-seed 1.0.0-alpha.1 → 1.0.0-alpha.3

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

@@ -0,0 +1,172 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+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";
+
+let rlRef = {
+  contents: undefined
+};
+
+let muted = {
+  contents: false
+};
+
+function iface() {
+  let rl = rlRef.contents;
+  if (rl !== undefined) {
+    return Primitive_option.valFromOption(rl);
+  }
+  let rl$1 = Nodereadline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  rl$1._writeToOutput = s => {
+    if (!muted.contents) {
+      process.stdout.write(s);
+      return;
+    }
+  };
+  rlRef.contents = Primitive_option.some(rl$1);
+  return rl$1;
+}
+
+function close() {
+  let rl = rlRef.contents;
+  if (rl !== undefined) {
+    Primitive_option.valFromOption(rl).close();
+    rlRef.contents = undefined;
+    process.stdin.pause();
+    process.stdin.unref();
+    return;
+  }
+}
+
+function envValue(key) {
+  let v = process.env[key];
+  if (v !== undefined && v.trim() !== "") {
+    return v.trim();
+  }
+}
+
+function requireTty() {
+  if (process.stdin.isTTY) {
+    return;
+  }
+  throw {
+    RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
+    _1: "no TTY for an interactive prompt — set the documented SEED_* / REVENTLESS_DEMO_* env vars to run non-interactively.",
+    Error: new Error()
+  };
+}
+
+function ask(query) {
+  return new Promise((resolve, param) => {
+    let rl = iface();
+    rl.question(query, answer => resolve(answer.trim()));
+  });
+}
+
+function askHidden(query) {
+  return new Promise((resolve, param) => {
+    let rl = iface();
+    rl.question(query, answer => {
+      muted.contents = false;
+      process.stdout.write("\n");
+      resolve(answer);
+    });
+    muted.contents = true;
+  });
+}
+
+async function select(title, options, env) {
+  if (options.length === 1) {
+    return options[0][1];
+  }
+  let fromEnv = Stdlib_Option.flatMap(Stdlib_Option.flatMap(env, envValue), v => {
+    let i = options.findIndex(param => param[0] === v);
+    if (i !== -1) {
+      return options[i];
+    }
+    let n = Stdlib_Int.fromString(v, undefined);
+    if (n !== undefined && n >= 1 && n <= options.length) {
+      return options[n - 1 | 0];
+    }
+  });
+  if (fromEnv !== undefined) {
+    return fromEnv[1];
+  }
+  requireTty();
+  console.log("");
+  console.log(title);
+  console.log("");
+  options.forEach((param, i) => {
+    console.log(`  ` + (i + 1 | 0).toString() + `) ` + param[0]);
+  });
+  let pick = async () => {
+    let answer = await ask(`\nSelect [1-` + options.length.toString() + `]: `);
+    let n = Stdlib_Int.fromString(answer, undefined);
+    if (n !== undefined) {
+      if (n >= 1 && n <= options.length) {
+        return options[n - 1 | 0][1];
+      } else {
+        console.log("  Not a valid choice.");
+        return await pick();
+      }
+    } else {
+      console.log("  Not a valid choice.");
+      return await pick();
+    }
+  };
+  return await pick();
+}
+
+async function credentials(localDefaultsOpt) {
+  let localDefaults = localDefaultsOpt !== undefined ? localDefaultsOpt : false;
+  let u = envValue("REVENTLESS_DEMO_USER");
+  let username;
+  if (u !== undefined) {
+    username = u;
+  } else {
+    requireTty();
+    let entered = await ask(localDefaults ? "Username [admin]: " : "Username: ");
+    username = entered === "" && localDefaults ? "admin" : entered;
+  }
+  let p = envValue("REVENTLESS_DEMO_PASSWORD");
+  let password;
+  if (p !== undefined) {
+    password = p;
+  } else {
+    requireTty();
+    let entered$1 = await askHidden(localDefaults ? "Password [admin]: " : "Password: ");
+    password = entered$1 === "" && localDefaults ? "admin" : entered$1;
+  }
+  if (username === "" || password === "") {
+    throw {
+      RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
+      _1: "username and password are required.",
+      Error: new Error()
+    };
+  }
+  return [
+    username,
+    password
+  ];
+}
+
+export {
+  rlRef,
+  muted,
+  iface,
+  close,
+  envValue,
+  requireTty,
+  ask,
+  askHidden,
+  select,
+  credentials,
+}
+/* node:readline Not a pure module */

package/lib/bs/src/Seed_Runner.res

@@ -90,12 +90,45 @@ 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.
  */
 let run = async (main: unit => promise<unit>): unit =>
-  try await main() catch {
+  try {
+    await main()
+    // 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)
+  } catch {
   | Failed(message) =>
     Console.error("")
     Console.error("Seeding aborted — the store is now half-seeded; re-run against a")
@@ -112,3 +145,88 @@ let run = async (main: unit => promise<unit>): unit =>
     )
     exit(1)
   }
+
+/**
+ * A named, seedable data set. `seed` owns everything domain-specific — the
+ * phases, `verifyViews`, the summary board — so the generic runner never sees
+ * domain detail. `label` is what the selection menu shows.
+ */
+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>,
+}
+
+/**
+ * A failure before any command is sent — bad data-set selection, an
+ * unreachable/undeployed target, a login failure. Nothing was written, so this
+ * says so plainly rather than warning about a half-seeded store (which would
+ * send the user resetting a store the run never touched).
+ */
+let abortStartup = (message: string): unit => {
+  Seed_Prompt.close()
+  Console.error("")
+  Console.error("Seeding did not start — nothing was written. Fix the cause below and re-run.")
+  Console.error("")
+  Console.error(message)
+  exit(1)
+}
+
+/**
+ * Top-level seed entry: choose a data set (auto when there is one, `SEED_SET`
+ * or a menu otherwise), connect, then hand the connection to the chosen set.
+ * Prompts are closed before seeding so the shared readline never lingers.
+ *
+ * Selection and connect run before any command is sent, so a failure there is
+ * reported as "did not start"; only failures inside the data set's own `seed`
+ * carry the half-seeded warning (via `run`).
+ */
+let seed = (~sets: array<dataSet>, ~connect: unit => promise<Seed_Connect.connection>): unit => {
+  let go = async () => {
+    let started = try {
+      let chosen = switch sets {
+      | [only] => only
+      | _ =>
+        switch Seed_Prompt.envValue("SEED_SET") {
+        | Some(wanted) =>
+          switch sets->Array.find(s => s.name == wanted) {
+          | Some(s) => s
+          | None =>
+            throw(
+              Failed(
+                `SEED_SET="${wanted}" matches no data set (have: ${sets
+                  ->Array.map(s => s.name)
+                  ->Array.join(", ")})`,
+              ),
+            )
+          }
+        | None =>
+          await Seed_Prompt.select(~title="Data set:", ~options=sets->Array.map(s => (s.label, s)))
+        }
+      }
+      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) =>
+      abortStartup(message)
+      None
+    | exn =>
+      abortStartup(exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown"))
+      None
+    }
+    switch started {
+    | None => () // unreachable: abortStartup has already exited
+    | Some((chosen, connection)) =>
+      heading(`Seeding "${chosen.label}" into ${connection.label}`)
+      await run(() => chosen.seed(connection))
+    }
+  }
+  go()->ignore
+}

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

@@ -6,6 +6,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Seed_Types$ReventlessSeed from "./Seed_Types.res.mjs";
 import * as Seed_Client$ReventlessSeed from "./Seed_Client.res.mjs";
+import * as Seed_Prompt$ReventlessSeed from "./Seed_Prompt.res.mjs";
 
 function envOr(key, fallback) {
   return Stdlib_Option.getOr(process.env[key], fallback);
@@ -82,9 +83,27 @@ 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 {
-    return await main();
+    await main();
+    process.exit(0);
+    return;
   } catch (raw_message) {
     let message = Primitive_exceptions.internalToException(raw_message);
     if (message.RE_EXN_ID === Seed_Types$ReventlessSeed.Failed) {
@@ -105,6 +124,70 @@ async function run(main) {
   }
 }
 
+function abortStartup(message) {
+  Seed_Prompt$ReventlessSeed.close();
+  console.error("");
+  console.error("Seeding did not start — nothing was written. Fix the cause below and re-run.");
+  console.error("");
+  console.error(message);
+  process.exit(1);
+}
+
+function seed(sets, connect) {
+  let go = async () => {
+    let started;
+    try {
+      let chosen;
+      if (sets.length !== 1) {
+        let wanted = Seed_Prompt$ReventlessSeed.envValue("SEED_SET");
+        if (wanted !== undefined) {
+          let s = sets.find(s => s.name === wanted);
+          if (s !== undefined) {
+            chosen = s;
+          } else {
+            throw {
+              RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
+              _1: `SEED_SET="` + wanted + `" matches no data set (have: ` + sets.map(s => s.name).join(", ") + `)`,
+              Error: new Error()
+            };
+          }
+        } else {
+          chosen = await Seed_Prompt$ReventlessSeed.select("Data set:", sets.map(s => [
+            s.label,
+            s
+          ]), 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
+      ];
+    } catch (raw_message) {
+      let message = Primitive_exceptions.internalToException(raw_message);
+      if (message.RE_EXN_ID === Seed_Types$ReventlessSeed.Failed) {
+        abortStartup(message._1);
+        started = undefined;
+      } else {
+        abortStartup(Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(message), Stdlib_JsExn.message), "unknown"));
+        started = undefined;
+      }
+    }
+    if (started === undefined) {
+      return;
+    }
+    let connection$1 = started[1];
+    let chosen$1 = started[0];
+    heading(`Seeding "` + chosen$1.label + `" into ` + connection$1.label);
+    return await run(() => chosen$1.seed(connection$1));
+  };
+  go();
+}
+
 export {
   envOr,
   report,
@@ -113,6 +196,9 @@ export {
   verifyViews,
   unfillableWarnings,
   warn,
+  assertStoreEmpty,
   run,
+  abortStartup,
+  seed,
 }
 /* Stdlib_JsExn Not a pure module */

package/lib/ocaml/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1785055307106)
-#Done(1785055311634)
+#Start(1785139469133)
+#Done(1785139473598)

package/lib/ocaml/ReventlessSeed.mlmap

@@ -1,6 +1,8 @@
 randjbuildsystem
 Seed
 Seed_Client
+Seed_Connect
+Seed_Prompt
 Seed_Random
 Seed_Runner
 Seed_Types

package/lib/ocaml/Seed.res

@@ -9,9 +9,27 @@ module Random = Seed_Random
 module Client = Seed_Client
 module Runner = Seed_Runner
 module Upload = Seed_Upload
+module Prompt = Seed_Prompt
+module Connect = Seed_Connect
 
 exception Failed = Seed_Types.Failed
 
+// A live target a data set seeds against: an authenticated client, the upload
+// endpoint (empty when the deployment serves no uploads), and a label.
+type connection = Seed_Connect.connection = {
+  client: Seed_Client.t,
+  uploadEndpoint: string,
+  label: string,
+}
+
+// A named, seedable data set. `seed` owns everything domain-specific.
+type dataSet = Seed_Runner.dataSet = {
+  name: string,
+  label: string,
+  seed: connection => promise<unit>,
+  probeViews?: array<string>,
+}
+
 type rec value = Seed_Types.value =
   | String(string)
   | Id(string)

package/lib/ocaml/Seed_Client.res

@@ -27,9 +27,12 @@ let sleep = (ms: int): promise<unit> => Promise.make((resolve, _) => setTimeout(
 
 type config = {
   endpoint: string,
-  loginEndpoint: string,
-  username: string,
-  password: string,
+  // Present only for the `login` flow (a platform that mints tokens over HTTP,
+  // e.g. the local dev `/__inmemory/login`). Omit when the bearer is supplied
+  // out-of-band via `useToken` (e.g. a Cognito id token minted by the caller).
+  loginEndpoint?: string,
+  username?: string,
+  password?: string,
 }
 
 type t = {config: config, mutable token: option<string>}
@@ -40,6 +43,11 @@ let make = (~config: config): t => {config, token: None}
     Seed.Upload) can authenticate side-channel requests with the same identity. */
 let currentToken = (t: t): option<string> => t.token
 
+/** Injects a bearer obtained out-of-band (e.g. a Cognito id token), instead of
+    minting one via `login`. Provider-agnostic: the harness only cares that the
+    token is a valid bearer for `endpoint`. */
+let useToken = (t: t, token: string): unit => t.token = Some(token)
+
 // ── JSON helpers ────────────────────────────────────────────────────────────
 
 let field = (json: JSON.t, key: string): option<JSON.t> =>
@@ -61,28 +69,31 @@ let nodeString = (node: JSON.t, key: string): option<string> =>
 // ── Requests ────────────────────────────────────────────────────────────────
 
 let login = async (t: t): unit => {
+  let loginEndpoint = switch t.config.loginEndpoint {
+  | Some(e) => e
+  | None => throw(Failed("login: no loginEndpoint configured — supply one or call useToken"))
+  }
+  let username = t.config.username->Option.getOr("")
+  let password = t.config.password->Option.getOr("")
   let body = JSON.stringify(
     JSON.Encode.object(
       Dict.fromArray([
-        ("username", JSON.Encode.string(t.config.username)),
-        ("password", JSON.Encode.string(t.config.password)),
+        ("username", JSON.Encode.string(username)),
+        ("password", JSON.Encode.string(password)),
       ]),
     ),
   )
   let res = try await fetch(
-    t.config.loginEndpoint,
+    loginEndpoint,
     {method: "POST", headers: Dict.fromArray([("content-type", "application/json")]), body},
   ) catch {
-  | _ =>
-    throw(
-      Failed(`login: cannot reach ${t.config.loginEndpoint} — is the platform running?`),
-    )
+  | _ => throw(Failed(`login: cannot reach ${loginEndpoint} — is the platform running?`))
   }
   if !(res->responseOk) {
     let detail = await res->responseText
     throw(
       Failed(
-        `login as "${t.config.username}" failed with HTTP ${(res->responseStatus)
+        `login as "${username}" failed with HTTP ${(res->responseStatus)
             ->Int.toString}: ${detail}`,
       ),
     )

package/lib/ocaml/Seed_Connect.res

@@ -0,0 +1,84 @@
+// Turns endpoints plus a login function into a ready `connection`.
+//
+// A connection is what a data set seeds against: an authenticated GraphQL
+// client, the upload endpoint (empty when the deployment serves no uploads), and
+// a human label for the target. `make` is provider-agnostic — it prompts for
+// credentials, calls the supplied `login` to obtain a bearer, and wires it onto
+// the client via `useToken`. Where the bearer comes from (a local `/login`
+// round-trip, a Cognito id token) is the caller's concern.
+
+open Seed_Types
+
+type connection = {client: Seed_Client.t, uploadEndpoint: string, label: string}
+
+/**
+ * Prompts for credentials, calls `login` to mint a bearer, and returns a
+ * connection with that bearer already applied. `login` returns the bearer so a
+ * single `useToken` path serves every provider.
+ */
+let make = async (
+  ~label: string,
+  ~endpoint: string,
+  ~uploadEndpoint: string,
+  ~login: (~username: string, ~password: string) => promise<string>,
+  ~localDefaults: bool=false,
+): connection => {
+  // `SEED_SKIP_UPLOADS` forces the connection to carry no upload endpoint, so a
+  // data set's upload phase no-ops the same way it does when a deployment serves
+  // none. Use it to seed domain data fast, or to skip a broken/absent upload path
+  // without editing the data set. It is the single knob: an empty
+  // `REVENTLESS_UPLOAD_ENDPOINT` env reads as "unset" (falls back to discovery),
+  // so this is the reliable way to disable uploads.
+  let uploadEndpoint = Seed_Prompt.envValue("SEED_SKIP_UPLOADS")->Option.isSome ? "" : uploadEndpoint
+  let (username, password) = await Seed_Prompt.credentials(~localDefaults)
+  let token = await login(~username, ~password)
+  let client = Seed_Client.make(~config={endpoint: endpoint})
+  client->Seed_Client.useToken(token)
+  {client, uploadEndpoint, label}
+}
+
+/**
+ * A login function backed by an HTTP login endpoint (the local dev
+ * `/__inmemory/login` shape: POST `{username, password}` → `{token}`). Reuses
+ * `Seed_Client.login` but hands the token back for `useToken`.
+ */
+let viaLoginEndpoint = (~loginEndpoint: string) => async (
+  ~username: string,
+  ~password: string,
+): string => {
+  let client = Seed_Client.make(
+    ~config={endpoint: loginEndpoint, loginEndpoint, username, password},
+  )
+  await Seed_Client.login(client)
+  switch Seed_Client.currentToken(client) {
+  | Some(token) => token
+  | None => throw(Failed(`login at ${loginEndpoint} returned no token`))
+  }
+}
+
+let envOr = (key: string, fallback: string): string =>
+  Seed_Prompt.envValue(key)->Option.getOr(fallback)
+
+/**
+ * A ready `connect` thunk for the local dev platform, with the localhost
+ * defaults baked in and overridable per endpoint (arg, then env var, then
+ * default). Empty input at the credential prompt falls back to `admin`/`admin`.
+ */
+let local = (~graphql=?, ~upload=?, ~login=?, ()): (unit => promise<connection>) => {
+  let endpoint =
+    graphql->Option.getOr(envOr("REVENTLESS_GRAPHQL_ENDPOINT", "http://localhost:4000/graphql"))
+  let uploadEndpoint =
+    upload->Option.getOr(
+      envOr("REVENTLESS_UPLOAD_ENDPOINT", "http://localhost:4000/__inmemory/upload"),
+    )
+  let loginEndpoint =
+    login->Option.getOr(envOr("REVENTLESS_LOGIN_ENDPOINT", "http://localhost:4000/__inmemory/login"))
+  () =>
+    make(
+      ~label="local",
+      ~endpoint,
+      ~uploadEndpoint,
+      ~login=viaLoginEndpoint(~loginEndpoint),
+      ~localDefaults=true,
+    )
+}