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

package/CHANGELOG.md

@@ -3,6 +3,81 @@
 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.11 (2026-08-11)
+
+**Note:** Version bump only for package @reventlessdev/reventless-seed
+
+
+
+
+
+# 1.0.0-alpha.10 (2026-08-09)
+
+**Note:** Version bump only for package @reventlessdev/reventless-seed
+
+
+
+
+
+# 1.0.0-alpha.9 (2026-08-05)
+
+**Note:** Version bump only for package @reventlessdev/reventless-seed
+
+
+
+
+
+# 1.0.0-alpha.8 (2026-08-02)
+
+**Note:** Version bump only for package @reventlessdev/reventless-seed
+
+
+
+
+
+# 1.0.0-alpha.7 (2026-08-01)
+
+### Features
+
+* **upload:** add the release half of the upload contract via the domain API ([448f887](https://github.com/ReventlessDev/reventless-core/commit/448f88714a5875be420f794a08d482fcf4ba8404))
+
+
+# 1.0.0-alpha.6 (2026-07-31)
+
+**Note:** Version bump only for package @reventlessdev/reventless-seed
+
+
+
+
+
+# 1.0.0-alpha.5 (2026-07-31)
+
+### Bug Fixes
+
+* **seed:** address a deployment's per-store upload endpoints ([45b226e](https://github.com/ReventlessDev/reventless-core/commit/45b226e00604af9fd28b6fb0b75ba7d3414791f2))
+
+
+# 1.0.0-alpha.4 (2026-07-27)
+
+### Features
+
+* **seed:** guarded AWS store reset (seed:reset) with per-project scope selection ([8446172](https://github.com/ReventlessDev/reventless-core/commit/8446172cbb53776a58f53220d19e96d96ce94508))
+
+
+# 1.0.0-alpha.3 (2026-07-27)
+
+### Features
+
+* **seed:** refuse to seed onto a non-empty store (fresh-store guard) ([987613f](https://github.com/ReventlessDev/reventless-core/commit/987613f0767fc4391297dfeed3a6b19cd76d8157))
+
+
+# 1.0.0-alpha.2 (2026-07-26)
+
+### Features
+
+* **seed:** per-provider seed scripts, shared machinery, exportable data sets ([ba43e9e](https://github.com/ReventlessDev/reventless-core/commit/ba43e9efab84dd2955b6dafd1e187fd4aad699ad))
+
+
 # 1.0.0-alpha.1 (2026-07-26)
 
 ### Bug Fixes

package/lib/bs/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1785055307106)
-#Done(1785055311634)
+#Start(1786453304385)
+#Done(1786453304425)

package/lib/bs/.sourcedirs.json

@@ -0,0 +1 @@
+{"cmt_scan":[{"also_scan_build_root":true,"build_root":"lib/bs","scan_dirs":["src","tests"]}],"dirs":["src","tests"],"generated":[],"pkgs":[["@reventlessdev/rescript-jest","/home/runner/work/reventless-core/reventless-core/rescript/jest"],["@reventlessdev/rescript-node","/home/runner/work/reventless-core/reventless-core/rescript/node"]],"version":2}

package/lib/bs/ReventlessSeed.mlmap

@@ -1,7 +1,10 @@
 randjbuildsystem
 Seed
 Seed_Client
+Seed_Connect
+Seed_Prompt
 Seed_Random
+Seed_RandomTest
 Seed_Runner
 Seed_Types
 Seed_Upload

package/lib/bs/compiler-info.json

@@ -2,7 +2,7 @@
   "version": "12.3.0",
   "bsc_path": "/home/runner/work/reventless-core/reventless-core/node_modules/@rescript/linux-x64/bin/bsc.exe",
   "bsc_hash": "75e3a59c95cc953608fd3dd6ea6ed68141bba4414a20a52f114261b8a48385fa",
-  "rescript_config_hash": "ad3a9d479584c1d6e4fe10cd993d9e290f74732e9b0cb3dd5d7429e88b4bba38",
+  "rescript_config_hash": "25cfff836d200084949fdfdfec2f6875901bfee1f04d84634eca252ef1ca1ef1",
   "runtime_path": "/home/runner/work/reventless-core/reventless-core/node_modules/@rescript/runtime",
-  "generated_at": "1785055311640"
+  "generated_at": "1786453304428"
 }

package/lib/bs/src/Seed.res

@@ -9,9 +9,28 @@ 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, whether uploads
+// are skipped this run, and a label. Uploads mint through the domain API's
+// `Upload_Presign` mutation on the client (route B), so no upload endpoint is carried.
+type connection = Seed_Connect.connection = {
+  client: Seed_Client.t,
+  uploadsSkipped: bool,
+  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/bs/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/lib/bs/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,15 @@ 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
 
+/** The GraphQL endpoint this client targets — so `Seed.Upload` can resolve a
+    relative presigned `uploadUrl` against the same origin. */
+let endpoint = (t: t): string => t.config.endpoint
+
+/** 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 +73,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}`,
       ),
     )
@@ -205,6 +220,42 @@ let queryAllNodes = async (t: t, ~field as fieldName: string, ~selection: string
 let countNodes = async (t: t, ~field: string): int =>
   (await queryAllNodes(t, ~field, ~selection="id"))->Array.length
 
+/**
+ * Polls a connection field until the collected nodes satisfy `satisfied`, or the
+ * timeout elapses. Read models are eventually consistent: a view queried the
+ * instant after the writes that feed it can still read empty or partial (a
+ * DynamoDB connection scan is eventually consistent by default, and the write and
+ * read-back can land on different replicas), so a cross-check that asserts on a
+ * single immediate read races the projection. Same rationale as `waitForIds`,
+ * for the "observe the whole connection" case rather than a fixed id set.
+ *
+ * On timeout, throws `Failed(onTimeout(finalNodes))` so the caller can report
+ * what the view actually settled on — distinguishing a still-empty view from a
+ * genuine count mismatch — instead of a bare assertion.
+ */
+let queryAllNodesUntil = async (
+  t: t,
+  ~field: string,
+  ~selection: string,
+  ~satisfied: array<JSON.t> => bool,
+  ~onTimeout: array<JSON.t> => string,
+  ~timeoutMs: int=60000,
+): array<JSON.t> => {
+  let deadline = nowMs() +. Int.toFloat(timeoutMs)
+  let result = ref(None)
+  while result.contents == None {
+    let nodes = await queryAllNodes(t, ~field, ~selection)
+    if satisfied(nodes) {
+      result := Some(nodes)
+    } else if nowMs() > deadline {
+      throw(Failed(onTimeout(nodes)))
+    } else {
+      await sleep(500)
+    }
+  }
+  result.contents->Option.getOr([])
+}
+
 /**
  * Polls a `<View>ByIds` field until every id is present.
  *

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

@@ -21,6 +21,14 @@ function currentToken(t) {
   return t.token;
 }
 
+function endpoint(t) {
+  return t.config.endpoint;
+}
+
+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 +46,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 +82,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 +90,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()
     };
   }
@@ -191,6 +212,28 @@ async function countNodes(t, field) {
   return (await queryAllNodes(t, field, "id")).length;
 }
 
+async function queryAllNodesUntil(t, field, selection, satisfied, onTimeout, timeoutMsOpt) {
+  let timeoutMs = timeoutMsOpt !== undefined ? timeoutMsOpt : 60000;
+  let deadline = Date.now() + timeoutMs;
+  let result;
+  while (result === undefined) {
+    let nodes = await queryAllNodes(t, field, selection);
+    if (satisfied(nodes)) {
+      result = nodes;
+    } else {
+      if (Date.now() > deadline) {
+        throw {
+          RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
+          _1: onTimeout(nodes),
+          Error: new Error()
+        };
+      }
+      await sleep(500);
+    }
+  };
+  return Stdlib_Option.getOr(result, []);
+}
+
 async function waitForIds(t, fieldName, ids, timeoutMsOpt) {
   let timeoutMs = timeoutMsOpt !== undefined ? timeoutMsOpt : 60000;
   let deadline = Date.now() + timeoutMs;
@@ -227,6 +270,8 @@ export {
   sleep,
   make,
   currentToken,
+  endpoint,
+  useToken,
   field,
   asString,
   nodeString,
@@ -237,6 +282,7 @@ export {
   sendAll,
   queryAllNodes,
   countNodes,
+  queryAllNodesUntil,
   waitForIds,
 }
 /* No side effect */

package/lib/bs/src/Seed_Connect.res

@@ -0,0 +1,86 @@
+// Turns endpoints plus a login function into a ready `connection`.
+//
+// A connection is what a data set seeds against: an authenticated GraphQL
+// client, the deployment's upload endpoints (empty when it 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
+
+// Under route B the client mints uploads through the domain API's `Upload_Presign`
+// mutation (authenticated by the same bearer as commands), so a connection needs no
+// upload endpoint — just the authenticated client and whether uploads are skipped this
+// run (`SEED_SKIP_UPLOADS`). Which store an asset uploads into is the caller's `~store`.
+type connection = {
+  client: Seed_Client.t,
+  uploadsSkipped: bool,
+  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,
+  ~login: (~username: string, ~password: string) => promise<string>,
+  ~localDefaults: bool=false,
+): connection => {
+  // `SEED_SKIP_UPLOADS` forces the upload phase to no-op — seed domain data fast, or
+  // skip a broken/absent upload path without editing the data set. The data set reads
+  // `connection.uploadsSkipped` and reports the skip.
+  let uploadsSkipped = Seed_Upload.uploadsSkipped()
+  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, uploadsSkipped, 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`.
+ *
+ * No upload endpoint: uploads mint through the domain API's `Upload_Presign` mutation
+ * on the same `graphql` endpoint, with the store passed per asset.
+ */
+let local = (~graphql=?, ~login=?, ()): (unit => promise<connection>) => {
+  let endpoint =
+    graphql->Option.getOr(envOr("REVENTLESS_GRAPHQL_ENDPOINT", "http://localhost:4000/graphql"))
+  let loginEndpoint =
+    login->Option.getOr(envOr("REVENTLESS_LOGIN_ENDPOINT", "http://localhost:4000/__inmemory/login"))
+  () =>
+    make(
+      ~label="local",
+      ~endpoint,
+      ~login=viaLoginEndpoint(~loginEndpoint),
+      ~localDefaults=true,
+    )
+}

package/lib/bs/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";
+import * as Seed_Upload$ReventlessSeed from "./Seed_Upload.res.mjs";
+
+async function make(label, endpoint, login, localDefaultsOpt) {
+  let localDefaults = localDefaultsOpt !== undefined ? localDefaultsOpt : false;
+  let uploadsSkipped = Seed_Upload$ReventlessSeed.uploadsSkipped();
+  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,
+    uploadsSkipped: uploadsSkipped,
+    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, login, param) {
+  let endpoint = Stdlib_Option.getOr(graphql, Stdlib_Option.getOr(Seed_Prompt$ReventlessSeed.envValue("REVENTLESS_GRAPHQL_ENDPOINT"), "http://localhost:4000/graphql"));
+  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, viaLoginEndpoint(loginEndpoint), true);
+}
+
+export {
+  make,
+  viaLoginEndpoint,
+  envOr,
+  local,
+}
+/* Seed_Prompt-ReventlessSeed Not a pure module */