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

package/lib/ocaml/Seed_Prompt.res

@@ -0,0 +1,188 @@
+// 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
+// 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
+// instead of opening a second one just to suppress the echo.
+//
+// Node bindings are declared here as typed externals; this package is
+// stdlib-only, so no `%raw`.
+
+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}
+@module("node:readline") external createInterface: rlOptions => rl = "createInterface"
+@send external question: (rl, string, string => unit) => unit = "question"
+@send external closeRl: rl => unit = "close"
+@set external setWriteToOutput: (rl, string => unit) => unit = "_writeToOutput"
+
+// ── Shared interface ──────────────────────────────────────────────────────────
+
+// Created on first use, closed once via `close`. `muted` gates the echo so the
+// same interface serves both visible and hidden prompts.
+let rlRef: ref<option<rl>> = ref(None)
+let muted = ref(false)
+
+let iface = (): rl =>
+  switch rlRef.contents {
+  | Some(rl) => rl
+  | None =>
+    let rl = createInterface({input: stdin, output: stdout, terminal: true})
+    rl->setWriteToOutput(s =>
+      if !muted.contents {
+        stdout->writeStream(s)
+      }
+    )
+    rlRef := Some(rl)
+    rl
+  }
+
+let close = (): unit =>
+  switch rlRef.contents {
+  | Some(rl) =>
+    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
+    // never exits after seeding. Release it explicitly.
+    stdin->pauseStream
+    stdin->unrefStream
+  | None => ()
+  }
+
+// ── Env + TTY ─────────────────────────────────────────────────────────────────
+
+let envValue = (key: string): option<string> =>
+  switch processEnv->Dict.get(key) {
+  | Some(v) if v->String.trim != "" => Some(v->String.trim)
+  | _ => None
+  }
+
+let requireTty = (): unit =>
+  if !(stdin->isTTY) {
+    throw(
+      Failed(
+        "no TTY for an interactive prompt — set the documented SEED_* / REVENTLESS_DEMO_* " ++
+        "env vars to run non-interactively.",
+      ),
+    )
+  }
+
+// ── Prompts ───────────────────────────────────────────────────────────────────
+
+let ask = (query: string): promise<string> =>
+  Promise.make((resolve, _) => {
+    let rl = iface()
+    rl->question(query, answer => resolve(answer->String.trim))
+  })
+
+// Same interface, echo suppressed for the keystrokes. `question` writes the
+// prompt synchronously first (while unmuted), then muting is switched on so only
+// the typed characters are hidden — the canonical readline recipe, which keeps
+// the line editor's cursor state consistent (a manual write + empty `question`
+// left some terminals unable to read the next line).
+let askHidden = (query: string): promise<string> =>
+  Promise.make((resolve, _) => {
+    let rl = iface()
+    rl->question(query, answer => {
+      muted := false
+      stdout->writeStream("\n")
+      resolve(answer)
+    })
+    muted := true
+  })
+
+/**
+ * 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.
+ */
+let select = async (
+  ~title: string,
+  ~options: array<(string, 'a)>,
+  ~env=?,
+): 'a =>
+  switch options {
+  | [(_, only)] => only
+  | _ =>
+    let fromEnv =
+      env
+      ->Option.flatMap(envValue)
+      ->Option.flatMap(v =>
+        switch options->Array.findIndex(((label, _)) => label == v) {
+        | -1 =>
+          switch Int.fromString(v) {
+          | Some(n) if n >= 1 && n <= options->Array.length => options->Array.get(n - 1)
+          | _ => None
+          }
+        | i => options->Array.get(i)
+        }
+      )
+    switch fromEnv {
+    | Some((_, value)) => value
+    | None =>
+      requireTty()
+      Console.log("")
+      Console.log(title)
+      Console.log("")
+      options->Array.forEachWithIndex(((label, _), i) =>
+        Console.log(`  ${(i + 1)->Int.toString}) ${label}`)
+      )
+      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
+        | _ =>
+          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") {
+  | Some(u) => u
+  | None =>
+    requireTty()
+    let entered = await ask(localDefaults ? "Username [admin]: " : "Username: ")
+    entered == "" && localDefaults ? "admin" : entered
+  }
+  let password = switch envValue("REVENTLESS_DEMO_PASSWORD") {
+  | Some(p) => p
+  | None =>
+    requireTty()
+    let entered = await askHidden(localDefaults ? "Password [admin]: " : "Password: ")
+    entered == "" && localDefaults ? "admin" : entered
+  }
+  if username == "" || password == "" {
+    throw(Failed("username and password are required."))
+  }
+  (username, password)
+}

package/lib/ocaml/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-seed",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0-alpha.3",
   "description": "Reusable harness for seeding a Reventless platform through its public GraphQL command API",
   "license": "Apache-2.0",
   "devDependencies": {

package/src/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/src/Seed.res.mjs

@@ -10,6 +10,10 @@ let Runner;
 
 let Upload;
 
+let Prompt;
+
+let Connect;
+
 let Failed = Seed_Types$ReventlessSeed.Failed;
 
 let mutation = Seed_Types$ReventlessSeed.mutation;
@@ -25,6 +29,8 @@ export {
   Client,
   Runner,
   Upload,
+  Prompt,
+  Connect,
   Failed,
   mutation,
   ids,

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

@@ -21,6 +21,10 @@ function currentToken(t) {
   return t.token;
 }
 
+function useToken(t, token) {
+  t.token = token;
+}
+
 function field(json, key) {
   if (typeof json === "object" && json !== null && !Array.isArray(json)) {
     return json[key];
@@ -38,19 +42,32 @@ function nodeString(node, key) {
 }
 
 async function login(t) {
+  let e = t.config.loginEndpoint;
+  let loginEndpoint;
+  if (e !== undefined) {
+    loginEndpoint = e;
+  } else {
+    throw {
+      RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
+      _1: "login: no loginEndpoint configured — supply one or call useToken",
+      Error: new Error()
+    };
+  }
+  let username = Stdlib_Option.getOr(t.config.username, "");
+  let password = Stdlib_Option.getOr(t.config.password, "");
   let body = JSON.stringify(Object.fromEntries([
     [
       "username",
-      t.config.username
+      username
     ],
     [
       "password",
-      t.config.password
+      password
     ]
   ]));
   let res;
   try {
-    res = await fetch(t.config.loginEndpoint, {
+    res = await fetch(loginEndpoint, {
       method: "POST",
       headers: Object.fromEntries([[
           "content-type",
@@ -61,7 +78,7 @@ async function login(t) {
   } catch (exn) {
     throw {
       RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
-      _1: `login: cannot reach ` + t.config.loginEndpoint + ` — is the platform running?`,
+      _1: `login: cannot reach ` + loginEndpoint + ` — is the platform running?`,
       Error: new Error()
     };
   }
@@ -69,7 +86,7 @@ async function login(t) {
     let detail = await res.text();
     throw {
       RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
-      _1: `login as "` + t.config.username + `" failed with HTTP ` + res.status.toString() + `: ` + detail,
+      _1: `login as "` + username + `" failed with HTTP ` + res.status.toString() + `: ` + detail,
       Error: new Error()
     };
   }
@@ -227,6 +244,7 @@ export {
   sleep,
   make,
   currentToken,
+  useToken,
   field,
   asString,
   nodeString,

package/src/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,
+    )
+}

package/src/Seed_Connect.res.mjs

@@ -0,0 +1,62 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.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";
+
+async function make(label, endpoint, uploadEndpoint, login, localDefaultsOpt) {
+  let localDefaults = localDefaultsOpt !== undefined ? localDefaultsOpt : false;
+  let uploadEndpoint$1 = Stdlib_Option.isSome(Seed_Prompt$ReventlessSeed.envValue("SEED_SKIP_UPLOADS")) ? "" : uploadEndpoint;
+  let match = await Seed_Prompt$ReventlessSeed.credentials(localDefaults);
+  let token = await login(match[0], match[1]);
+  let client = Seed_Client$ReventlessSeed.make({
+    endpoint: endpoint
+  });
+  Seed_Client$ReventlessSeed.useToken(client, token);
+  return {
+    client: client,
+    uploadEndpoint: uploadEndpoint$1,
+    label: label
+  };
+}
+
+function viaLoginEndpoint(loginEndpoint) {
+  return async (username, password) => {
+    let client = Seed_Client$ReventlessSeed.make({
+      endpoint: loginEndpoint,
+      loginEndpoint: loginEndpoint,
+      username: username,
+      password: password
+    });
+    await Seed_Client$ReventlessSeed.login(client);
+    let token = Seed_Client$ReventlessSeed.currentToken(client);
+    if (token !== undefined) {
+      return token;
+    }
+    throw {
+      RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
+      _1: `login at ` + loginEndpoint + ` returned no token`,
+      Error: new Error()
+    };
+  };
+}
+
+function envOr(key, fallback) {
+  return Stdlib_Option.getOr(Seed_Prompt$ReventlessSeed.envValue(key), fallback);
+}
+
+function local(graphql, upload, login, param) {
+  let endpoint = Stdlib_Option.getOr(graphql, Stdlib_Option.getOr(Seed_Prompt$ReventlessSeed.envValue("REVENTLESS_GRAPHQL_ENDPOINT"), "http://localhost:4000/graphql"));
+  let uploadEndpoint = Stdlib_Option.getOr(upload, Stdlib_Option.getOr(Seed_Prompt$ReventlessSeed.envValue("REVENTLESS_UPLOAD_ENDPOINT"), "http://localhost:4000/__inmemory/upload"));
+  let loginEndpoint = Stdlib_Option.getOr(login, Stdlib_Option.getOr(Seed_Prompt$ReventlessSeed.envValue("REVENTLESS_LOGIN_ENDPOINT"), "http://localhost:4000/__inmemory/login"));
+  return () => make("local", endpoint, uploadEndpoint, viaLoginEndpoint(loginEndpoint), true);
+}
+
+export {
+  make,
+  viaLoginEndpoint,
+  envOr,
+  local,
+}
+/* Seed_Prompt-ReventlessSeed Not a pure module */