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

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
@@ -53,7 +54,7 @@ function envValue(key) {
 }
 
 function requireTty() {
-  if (process.stdin.isTTY) {
+  if (Stdlib_Option.getOr(process.stdin.isTTY, false)) {
     return;
   }
   throw {
@@ -82,7 +83,19 @@ function askHidden(query) {
   });
 }
 
-async function select(title, options, env) {
+function isAffirmative(answer) {
+  let match = answer.trim().toLowerCase();
+  switch (match) {
+    case "1" :
+    case "y" :
+    case "yes" :
+      return true;
+    default:
+      return false;
+  }
+}
+
+async function select(title, options, env, defaultIndex) {
   if (options.length === 1) {
     return options[0][1];
   }
@@ -106,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) {
@@ -124,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: ");
@@ -144,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,
@@ -166,7 +228,10 @@ export {
   requireTty,
   ask,
   askHidden,
+  isAffirmative,
   select,
+  askCredentials,
+  fromUsersFile,
   credentials,
 }
 /* node:readline Not a pure module */

package/lib/bs/src/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) =>

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

@@ -83,6 +83,22 @@ 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 {
     await main();
@@ -139,13 +155,14 @@ 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];
       }
       let connection = await connect();
       Seed_Prompt$ReventlessSeed.close();
+      await assertStoreEmpty(connection.client, Stdlib_Option.getOr(chosen.probeViews, []));
       started = [
         chosen,
         connection
@@ -179,6 +196,7 @@ export {
   verifyViews,
   unfillableWarnings,
   warn,
+  assertStoreEmpty,
   run,
   abortStartup,
   seed,

package/lib/bs/src/Seed_Upload.res

@@ -1,27 +1,26 @@
-// Seed-time asset upload against the framework's presign-shaped upload contract.
+// Seed-time asset upload against the framework's upload contract (route B).
 //
-// One code path for both providers: the AWS `Upload_Presign_S3` Function URL and
-// the local dev upload route expose the SAME shape — POST `{fileName,contentType}`
-// → `{uploadUrl, storageRef}`, then PUT the bytes to `uploadUrl`. `uploadAsset`
-// resolves `Ok(storageRef)` — the same same-origin `/{prefix}/{key}` ref a command
-// stores and the UI renders.
+// Minting is a GraphQL mutation on the domain API — `Upload_Presign(store, fileName,
+// contentType)` — authenticated by the same bearer the seed already uses for commands
+// (no separate endpoint, no anonymous surface). `uploadAsset` issues it through the
+// shared `Seed_Client`, then PUTs the bytes to the returned `uploadUrl` and resolves
+// `Ok(storageRef)` — the same `/{prefix}/{key}` ref a command stores and the UI renders.
 //
-// The seed runs under Node, so the returned `uploadUrl` is resolved to an
-// absolute URL against the endpoint's origin: AWS returns an absolute presigned
-// S3 URL (unchanged), while the local route returns a same-origin relative
-// `/{prefix}/{key}` that Node's `fetch` cannot PUT to until it is made absolute.
+// The seed runs under Node, so a relative `uploadUrl` (the local dev server returns a
+// same-origin `/{prefix}/{key}`) is resolved to an absolute URL against the client's
+// endpoint origin before the PUT; AWS returns an absolute presigned S3 URL (used as-is).
+// The PUT itself is unauthenticated — presigned on AWS, open on the local route.
 
 type fetchInit = {method: string, headers: dict<string>, body: string}
 type response
 
 @val external fetch: (string, fetchInit) => promise<response> = "fetch"
-@send external responseJson: response => promise<JSON.t> = "json"
 @send external responseText: response => promise<string> = "text"
 @get external responseOk: response => bool = "ok"
 @get external responseStatus: response => int = "status"
 
-// Resolve a possibly-relative URL against a base (WHATWG URL semantics: an
-// absolute `input` ignores `base`, a relative one is resolved against it).
+// Resolve a possibly-relative URL against a base (WHATWG URL semantics: an absolute
+// `input` ignores `base`, a relative one is resolved against it).
 type url
 @new external makeUrl: (string, string) => url = "URL"
 @get external urlHref: url => string = "href"
@@ -38,51 +37,50 @@ let asString = (json: JSON.t): option<string> =>
   | _ => None
   }
 
-// A `fetch` that reports an unreachable endpoint as `Error` instead of throwing,
-// so the two-step upload can thread failures without exceptions.
+// Whether this run should skip uploads entirely. `SEED_SKIP_UPLOADS` seeds domain data
+// fast, or skips a broken/absent upload path without editing the data set.
+let uploadsSkipped = (): bool => Seed_Prompt.envValue("SEED_SKIP_UPLOADS")->Option.isSome
+
+// A `fetch` that reports an unreachable endpoint as `Error` instead of throwing.
 let tryFetch = async (url: string, init: fetchInit): result<response, string> =>
   try Ok(await fetch(url, init)) catch {
   | _ => Error(`cannot reach ${url}`)
   }
 
 /**
- * Uploads `bytes` under `fileName`/`contentType` through `uploadEndpoint` and
+ * Uploads `bytes` under `fileName`/`contentType` into `store` (the qualified
+ * `{plugin}.{store}` the asset's field declares, e.g. `"Catalog.productImages"`) and
  * resolves `Ok(storageRef)` (the stored `/{prefix}/{key}` ref), or `Error(msg)`
- * describing the step that failed. `authToken`, when supplied, is sent as a
- * Bearer on the presign request (the endpoint decides whether it is required;
- * the PUT itself is unauthenticated — presigned on AWS, open locally).
+ * describing the step that failed. Mints through the domain API's `Upload_Presign`
+ * mutation on `client`, then PUTs the bytes to the returned `uploadUrl`.
  */
 let uploadAsset = async (
-  ~uploadEndpoint: string,
+  ~client: Seed_Client.t,
+  ~store: string,
   ~bytes: string,
   ~fileName: string,
   ~contentType: string,
-  ~authToken: option<string>=?,
 ): result<string, string> => {
-  let presignHeaders = Dict.fromArray([("content-type", "application/json")])
-  authToken->Option.forEach(t => presignHeaders->Dict.set("authorization", `Bearer ${t}`))
-  let presignBody = JSON.stringify(
-    JSON.Encode.object(
-      Dict.fromArray([
-        ("fileName", JSON.Encode.string(fileName)),
-        ("contentType", JSON.Encode.string(contentType)),
-      ]),
-    ),
-  )
+  // GraphQL string literals: JSON-quote the argument values (JSON string escaping is a
+  // superset-safe subset of GraphQL's for these ASCII-ish inputs).
+  let q = s => JSON.stringify(JSON.Encode.string(s))
+  let query = `mutation { r: Upload_Presign(store: ${q(store)}, fileName: ${q(fileName)}, contentType: ${q(contentType)}) { uploadUrl storageRef } }`
+
+  let presign = try Ok(await Seed_Client.gql(client, ~query, ~label="Upload_Presign")) catch {
+  | Seed_Types.Failed(m) => Error(m)
+  | _ => Error("Upload_Presign: unexpected error")
+  }
 
-  switch await tryFetch(uploadEndpoint, {method: "POST", headers: presignHeaders, body: presignBody}) {
-  | Error(m) => Error(`presign: ${m} — is the platform running?`)
-  | Ok(presignRes) if !(presignRes->responseOk) =>
-    let detail = await presignRes->responseText
-    Error(`presign failed with HTTP ${(presignRes->responseStatus)->Int.toString}: ${detail}`)
-  | Ok(presignRes) =>
-    let json = await presignRes->responseJson
+  switch presign {
+  | Error(m) => Error(`presign: ${m}`)
+  | Ok(data) =>
+    let r = data->field("r")->Option.getOr(JSON.Encode.null)
     switch (
-      json->field("uploadUrl")->Option.flatMap(asString),
-      json->field("storageRef")->Option.flatMap(asString),
+      r->field("uploadUrl")->Option.flatMap(asString),
+      r->field("storageRef")->Option.flatMap(asString),
     ) {
     | (Some(uploadUrl), Some(storageRef)) =>
-      let putUrl = urlHref(makeUrl(uploadUrl, uploadEndpoint))
+      let putUrl = urlHref(makeUrl(uploadUrl, Seed_Client.endpoint(client)))
       switch await tryFetch(
         putUrl,
         {method: "PUT", headers: Dict.fromArray([("content-type", contentType)]), body: bytes},
@@ -93,7 +91,7 @@ let uploadAsset = async (
         let detail = await putRes->responseText
         Error(`upload PUT failed with HTTP ${(putRes->responseStatus)->Int.toString}: ${detail}`)
       }
-    | _ => Error("presign response missing uploadUrl/storageRef")
+    | _ => Error("Upload_Presign response missing uploadUrl/storageRef")
     }
   }
 }

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

@@ -1,6 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 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 field(json, key) {
   if (typeof json === "object" && json !== null && !Array.isArray(json)) {
@@ -14,6 +18,10 @@ function asString(json) {
   }
 }
 
+function uploadsSkipped() {
+  return Stdlib_Option.isSome(Seed_Prompt$ReventlessSeed.envValue("SEED_SKIP_UPLOADS"));
+}
+
 async function tryFetch(url, init) {
   try {
     return {
@@ -28,91 +36,79 @@ async function tryFetch(url, init) {
   }
 }
 
-async function uploadAsset(uploadEndpoint, bytes, fileName, contentType, authToken) {
-  let presignHeaders = Object.fromEntries([[
-      "content-type",
-      "application/json"
-    ]]);
-  Stdlib_Option.forEach(authToken, t => {
-    presignHeaders["authorization"] = `Bearer ` + t;
-  });
-  let presignBody = JSON.stringify(Object.fromEntries([
-    [
-      "fileName",
-      fileName
-    ],
-    [
-      "contentType",
-      contentType
-    ]
-  ]));
-  let m = await tryFetch(uploadEndpoint, {
-    method: "POST",
-    headers: presignHeaders,
-    body: presignBody
-  });
-  if (m.TAG !== "Ok") {
+async function uploadAsset(client, store, bytes, fileName, contentType) {
+  let query = `mutation { r: Upload_Presign(store: ` + JSON.stringify(store) + `, fileName: ` + JSON.stringify(fileName) + `, contentType: ` + JSON.stringify(contentType) + `) { uploadUrl storageRef } }`;
+  let presign;
+  try {
+    presign = {
+      TAG: "Ok",
+      _0: await Seed_Client$ReventlessSeed.gql(client, query, "Upload_Presign")
+    };
+  } catch (raw_m) {
+    let m = Primitive_exceptions.internalToException(raw_m);
+    presign = m.RE_EXN_ID === Seed_Types$ReventlessSeed.Failed ? ({
+        TAG: "Error",
+        _0: m._1
+      }) : ({
+        TAG: "Error",
+        _0: "Upload_Presign: unexpected error"
+      });
+  }
+  if (presign.TAG !== "Ok") {
     return {
       TAG: "Error",
-      _0: `presign: ` + m._0 + ` — is the platform running?`
+      _0: `presign: ` + presign._0
     };
   }
-  let presignRes = m._0;
-  if (presignRes.ok) {
-    let json = await presignRes.json();
-    let match = Stdlib_Option.flatMap(field(json, "uploadUrl"), asString);
-    let match$1 = Stdlib_Option.flatMap(field(json, "storageRef"), asString);
-    if (match === undefined) {
-      return {
-        TAG: "Error",
-        _0: "presign response missing uploadUrl/storageRef"
-      };
-    }
-    if (match$1 === undefined) {
-      return {
-        TAG: "Error",
-        _0: "presign response missing uploadUrl/storageRef"
-      };
-    }
-    let putUrl = new URL(match, uploadEndpoint).href;
-    let m$1 = await tryFetch(putUrl, {
-      method: "PUT",
-      headers: Object.fromEntries([[
-          "content-type",
-          contentType
-        ]]),
-      body: bytes
-    });
-    if (m$1.TAG !== "Ok") {
-      return {
-        TAG: "Error",
-        _0: `upload PUT: ` + m$1._0
-      };
-    }
-    let putRes = m$1._0;
-    if (putRes.ok) {
-      return {
-        TAG: "Ok",
-        _0: match$1
-      };
-    }
-    let detail = await putRes.text();
+  let r = Stdlib_Option.getOr(field(presign._0, "r"), null);
+  let match = Stdlib_Option.flatMap(field(r, "uploadUrl"), asString);
+  let match$1 = Stdlib_Option.flatMap(field(r, "storageRef"), asString);
+  if (match === undefined) {
     return {
       TAG: "Error",
-      _0: `upload PUT failed with HTTP ` + putRes.status.toString() + `: ` + detail
+      _0: "Upload_Presign response missing uploadUrl/storageRef"
+    };
+  }
+  if (match$1 === undefined) {
+    return {
+      TAG: "Error",
+      _0: "Upload_Presign response missing uploadUrl/storageRef"
+    };
+  }
+  let putUrl = new URL(match, Seed_Client$ReventlessSeed.endpoint(client)).href;
+  let m$1 = await tryFetch(putUrl, {
+    method: "PUT",
+    headers: Object.fromEntries([[
+        "content-type",
+        contentType
+      ]]),
+    body: bytes
+  });
+  if (m$1.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _0: `upload PUT: ` + m$1._0
+    };
+  }
+  let putRes = m$1._0;
+  if (putRes.ok) {
+    return {
+      TAG: "Ok",
+      _0: match$1
     };
   }
-  let detail$1 = await presignRes.text();
+  let detail = await putRes.text();
   return {
     TAG: "Error",
-    _0: `presign failed with HTTP ` + presignRes.status.toString() + `: ` + detail$1
+    _0: `upload PUT failed with HTTP ` + putRes.status.toString() + `: ` + detail
   };
 }
 
 export {
   field,
   asString,
+  uploadsSkipped,
   tryFetch,
   uploadAsset,
 }
-/* No side effect */
+/* Seed_Prompt-ReventlessSeed Not a pure module */