@reventlessdev/reventless-seed 1.0.0-alpha.5 → 1.0.0-alpha.7

package/src/Seed_Upload.res

@@ -1,32 +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.
-//
-// `uploadAsset` is the transport and takes a resolved endpoint. *Which* endpoint
-// an asset uses — a deployment now publishes one per declared store — is
-// `endpointFor` below, kept separate so the decision is testable without a
-// running presign service.
+// 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"
@@ -43,105 +37,50 @@ let asString = (json: JSON.t): option<string> =>
   | _ => None
   }
 
-/**
- * Which endpoint an asset destined for `store` uploads through:
- *
- *   declares a store with a matching endpoint  → that store's endpoint
- *   declares a store with no matching endpoint → the legacy single service
- *   declares no store                          → the legacy single service
- *   neither available                          → `None`
- *
- * `store` is the qualified `{plugin}.{store}` the platform keys its per-store
- * presign endpoints by. The two middle rows are what keep a deployment predating
- * per-store endpoints — and the local dev server, which serves one upload route
- * — working unchanged.
- *
- * These are the same four rows the AutoUI renderer resolves an upload field by.
- * Resolving one declaration by two different rules is how an asset lands in
- * another plugin's bucket with a 2xx and a plausible-looking ref, so a missing
- * key falls back to the legacy service rather than to some other store.
- */
-let endpointFor = (
-  ~store: option<string>=?,
-  ~uploadEndpoint: string,
-  ~uploadEndpoints: dict<string>,
-): option<string> => {
-  let legacy = uploadEndpoint == "" ? None : Some(uploadEndpoint)
-  switch store {
-  | Some(s) => uploadEndpoints->Dict.get(s)->Option.orElse(legacy)
-  | None => legacy
-  }
-}
-
-/**
- * Why `endpointFor` resolved nothing — the message a data set reports when its
- * upload phase skips.
- *
- * "no upload endpoint" states a fact about the *deployment*; when the deployment
- * publishes endpoints the caller could not match, the fact is about the *client*
- * and that phrasing sends a reader to the bucket, the presign service and the
- * IAM policy, all of which are correct. So the three cases are distinguished and
- * the unmatched one names both the store it wanted and the keys it saw.
- */
-let unresolvedReason = (~store: option<string>=?, ~uploadEndpoints: dict<string>): string => {
-  let available = uploadEndpoints->Dict.keysToArray
-  switch (Seed_Prompt.envValue("SEED_SKIP_UPLOADS"), store, available) {
-  | (Some(_), _, _) => "SEED_SKIP_UPLOADS is set"
-  | (None, _, []) => "this deployment publishes no upload endpoint"
-  | (None, Some(s), keys) =>
-    `this deployment publishes upload endpoints for ${keys->Array.join(", ")}, none for "${s}"`
-  | (None, None, keys) =>
-    `this deployment publishes only per-store upload endpoints (${keys->Array.join(
-        ", ",
-      )}) and this upload names no store`
-  }
-}
+// 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,
-// so the two-step upload can thread failures without exceptions.
+// 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},
@@ -152,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/src/Seed_Upload.res.mjs

@@ -1,6 +1,9 @@
 // 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) {
@@ -15,29 +18,8 @@ function asString(json) {
   }
 }
 
-function endpointFor(store, uploadEndpoint, uploadEndpoints) {
-  let legacy = uploadEndpoint === "" ? undefined : uploadEndpoint;
-  if (store !== undefined) {
-    return Stdlib_Option.orElse(uploadEndpoints[store], legacy);
-  } else {
-    return legacy;
-  }
-}
-
-function unresolvedReason(store, uploadEndpoints) {
-  let available = Object.keys(uploadEndpoints);
-  let match = Seed_Prompt$ReventlessSeed.envValue("SEED_SKIP_UPLOADS");
-  if (match !== undefined) {
-    return "SEED_SKIP_UPLOADS is set";
-  } else if (available.length !== 0) {
-    if (store !== undefined) {
-      return `this deployment publishes upload endpoints for ` + available.join(", ") + `, none for "` + store + `"`;
-    } else {
-      return `this deployment publishes only per-store upload endpoints (` + available.join(", ") + `) and this upload names no store`;
-    }
-  } else {
-    return "this deployment publishes no upload endpoint";
-  }
+function uploadsSkipped() {
+  return Stdlib_Option.isSome(Seed_Prompt$ReventlessSeed.envValue("SEED_SKIP_UPLOADS"));
 }
 
 async function tryFetch(url, init) {
@@ -54,92 +36,78 @@ 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_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 failed with HTTP ` + putRes.status.toString() + `: ` + detail
+      _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,
-  endpointFor,
-  unresolvedReason,
+  uploadsSkipped,
   tryFetch,
   uploadAsset,
 }

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