@reventlessdev/reventless-seed 1.0.0-alpha.1

package/src/Seed_Random.res.mjs

@@ -0,0 +1,86 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function make(seed) {
+  return {
+    state: seed
+  };
+}
+
+function float(r) {
+  r.state = r.state + 1831565813 | 0;
+  let a = r.state;
+  let b = Math.imul(a ^ (a >>> 15), a | 1);
+  let c = b ^ (b + Math.imul(b ^ (b >>> 7), b | 61) | 0);
+  let bits = c ^ (c >>> 14);
+  let unsigned = bits < 0 ? bits + 4294967296.0 : bits;
+  return unsigned / 4294967296.0;
+}
+
+function int(r, min, max) {
+  return min + (float(r) * ((max - min | 0) + 1 | 0) | 0) | 0;
+}
+
+function pick(r, xs) {
+  return xs[float(r) * xs.length | 0];
+}
+
+function pickOr(r, fallback, xs) {
+  return Stdlib_Option.getOr(pick(r, xs), fallback);
+}
+
+function sampleWeighted(r, entries, count) {
+  let pool = entries.slice();
+  let chosen = [];
+  let remaining = count < pool.length ? count : pool.length;
+  for (let _for = 1; _for <= remaining; ++_for) {
+    let total = Stdlib_Array.reduce(pool, 0.0, (sum, param) => sum + param[1]);
+    let cursor = {
+      contents: float(r) * total
+    };
+    let index = {
+      contents: pool.length - 1 | 0
+    };
+    let found = {
+      contents: false
+    };
+    pool.forEach((param, i) => {
+      if (!found.contents) {
+        cursor.contents = cursor.contents - param[1];
+        if (cursor.contents <= 0.0) {
+          index.contents = i;
+          found.contents = true;
+          return;
+        } else {
+          return;
+        }
+      }
+    });
+    let match = pool[index.contents];
+    if (match !== undefined) {
+      chosen.push(match[0]);
+      pool.splice(index.contents, 1);
+    }
+  }
+  return chosen;
+}
+
+function zipfWeights(items, exponent) {
+  return items.map((item, rank) => [
+    item,
+    1.0 / Math.pow(rank + 1 | 0, exponent)
+  ]);
+}
+
+export {
+  make,
+  float,
+  int,
+  pick,
+  pickOr,
+  sampleWeighted,
+  zipfWeights,
+}
+/* No side effect */

package/src/Seed_Runner.res

@@ -0,0 +1,114 @@
+// Run orchestration: progress output, view verification, and failure reporting.
+
+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)
+
+/** One line of progress per phase, so a slow run never looks hung. */
+let report = (line: string): unit => Console.log(`  ${line}`)
+
+let heading = (line: string): unit => {
+  Console.log("")
+  Console.log(line)
+}
+
+/**
+ * A view the seed is expected to fill, or one it demonstrably cannot.
+ *
+ * Splitting them matters: an unexpected empty view means the seed missed a
+ * component, which is exactly the "is it broken or is it empty?" ambiguity
+ * seeding exists to remove — so it fails the run. A view listed as unfillable
+ * reports its reason instead, so a zero is never mistaken for a gap.
+ */
+type view =
+  | Seeded(string)
+  | Unfillable(string, string)
+
+let viewName = (v: view): string =>
+  switch v {
+  | Seeded(name) => name
+  | Unfillable(name, _) => name
+  }
+
+/**
+ * Counts every view and fails if one that should have rows is empty.
+ * Returns the counts so callers can fold them into their own summary.
+ */
+let verifyViews = async (client: Seed_Client.t, ~views: array<view>): dict<int> => {
+  let counts = Dict.make()
+  for i in 0 to views->Array.length - 1 {
+    switch views->Array.get(i) {
+    | Some(v) =>
+      let name = v->viewName
+      counts->Dict.set(name, await Seed_Client.countNodes(client, ~field=name))
+    | None => ()
+    }
+  }
+
+  heading("View row counts:")
+  views->Array.forEach(v => {
+    let name = v->viewName
+    let count = counts->Dict.get(name)->Option.getOr(0)
+    let note = switch v {
+    | Unfillable(_, _) => "  (known empty — see warning below)"
+    | Seeded(_) => ""
+    }
+    Console.log(`  ${count->Int.toString->String.padStart(4, " ")}  ${name}${note}`)
+  })
+
+  let empty =
+    views
+    ->Array.filterMap(v =>
+      switch v {
+      | Seeded(name) if counts->Dict.get(name)->Option.getOr(0) == 0 => Some(name)
+      | _ => None
+      }
+    )
+  if empty->Array.length > 0 {
+    throw(Failed(`these views are still empty after seeding: ${empty->Array.join(", ")}`))
+  }
+  counts
+}
+
+/** Collects the reasons for any view that legitimately could not be filled. */
+let unfillableWarnings = (~views: array<view>, ~counts: dict<int>): array<string> =>
+  views->Array.filterMap(v =>
+    switch v {
+    | Unfillable(name, reason) if counts->Dict.get(name)->Option.getOr(0) == 0 =>
+      Some(`${name} is empty: ${reason}.`)
+    | _ => None
+    }
+  )
+
+let warn = (warnings: array<string>): unit =>
+  if warnings->Array.length > 0 {
+    heading("WARNING — the dataset is complete, but not everything could be filled:")
+    warnings->Array.forEach(w => Console.log(`  - ${w}`))
+  }
+
+/**
+ * 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 {
+  | Failed(message) =>
+    Console.error("")
+    Console.error("Seeding aborted — the store is now half-seeded; re-run against a")
+    Console.error("fresh store once the cause below is fixed.")
+    Console.error("")
+    Console.error(message)
+    exit(1)
+  | exn =>
+    Console.error("")
+    Console.error("Seeding aborted with an unexpected error:")
+    Console.error("")
+    Console.error(
+      exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown"),
+    )
+    exit(1)
+  }

package/src/Seed_Runner.res.mjs

@@ -0,0 +1,118 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+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";
+
+function envOr(key, fallback) {
+  return Stdlib_Option.getOr(process.env[key], fallback);
+}
+
+function report(line) {
+  console.log(`  ` + line);
+}
+
+function heading(line) {
+  console.log("");
+  console.log(line);
+}
+
+function viewName(v) {
+  return v._0;
+}
+
+async function verifyViews(client, views) {
+  let counts = {};
+  for (let i = 0, i_finish = views.length; i < i_finish; ++i) {
+    let v = views[i];
+    if (v !== undefined) {
+      let name = v._0;
+      counts[name] = await Seed_Client$ReventlessSeed.countNodes(client, name);
+    }
+  }
+  heading("View row counts:");
+  views.forEach(v => {
+    let name = v._0;
+    let count = Stdlib_Option.getOr(counts[name], 0);
+    let note;
+    note = v.TAG === "Seeded" ? "" : "  (known empty — see warning below)";
+    console.log(`  ` + count.toString().padStart(4, " ") + `  ` + name + note);
+  });
+  let empty = Stdlib_Array.filterMap(views, v => {
+    if (v.TAG !== "Seeded") {
+      return;
+    }
+    let name = v._0;
+    if (Stdlib_Option.getOr(counts[name], 0) === 0) {
+      return name;
+    }
+  });
+  if (empty.length !== 0) {
+    throw {
+      RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
+      _1: `these views are still empty after seeding: ` + empty.join(", "),
+      Error: new Error()
+    };
+  }
+  return counts;
+}
+
+function unfillableWarnings(views, counts) {
+  return Stdlib_Array.filterMap(views, v => {
+    if (v.TAG === "Seeded") {
+      return;
+    }
+    let name = v._0;
+    if (Stdlib_Option.getOr(counts[name], 0) === 0) {
+      return name + ` is empty: ` + v._1 + `.`;
+    }
+  });
+}
+
+function warn(warnings) {
+  if (warnings.length !== 0) {
+    heading("WARNING — the dataset is complete, but not everything could be filled:");
+    warnings.forEach(w => {
+      console.log(`  - ` + w);
+    });
+    return;
+  }
+}
+
+async function run(main) {
+  try {
+    return await main();
+  } catch (raw_message) {
+    let message = Primitive_exceptions.internalToException(raw_message);
+    if (message.RE_EXN_ID === Seed_Types$ReventlessSeed.Failed) {
+      console.error("");
+      console.error("Seeding aborted — the store is now half-seeded; re-run against a");
+      console.error("fresh store once the cause below is fixed.");
+      console.error("");
+      console.error(message._1);
+      process.exit(1);
+    } else {
+      console.error("");
+      console.error("Seeding aborted with an unexpected error:");
+      console.error("");
+      console.error(Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(message), Stdlib_JsExn.message), "unknown"));
+      process.exit(1);
+    }
+    return;
+  }
+}
+
+export {
+  envOr,
+  report,
+  heading,
+  viewName,
+  verifyViews,
+  unfillableWarnings,
+  warn,
+  run,
+}
+/* Stdlib_JsExn Not a pure module */

package/src/Seed_Types.res

@@ -0,0 +1,49 @@
+// Argument values for a seeded mutation, and their GraphQL literal rendering.
+//
+// Seeding sends inline literals rather than declared variables, so any mutation
+// can be called without generating a per-command variable signature. That means
+// values have to know how to render themselves — in particular enums, which are
+// bare identifiers in GraphQL and would be rejected if quoted like strings.
+
+exception Failed(string)
+
+type rec value =
+  | String(string)
+  | Id(string)
+  | Int(int)
+  | Float(float)
+  | Bool(bool)
+  /** Rendered unquoted — GraphQL enum values are identifiers, not strings. */
+  | Enum(string)
+  | List(array<value>)
+  /** A nested GraphQL input object, e.g. a geo-point `{lat, lng}`. Keys are
+      rendered as bare identifiers, as GraphQL input-object fields require. */
+  | Object(array<(string, value)>)
+
+let quote = (s: string): string => JSON.stringify(JSON.Encode.string(s))
+
+let rec toLiteral = (v: value): string =>
+  switch v {
+  | String(s) | Id(s) => quote(s)
+  | Int(i) => i->Int.toString
+  | Float(f) => f->Float.toString
+  | Bool(b) => b ? "true" : "false"
+  | Enum(name) => name
+  | List(items) => `[${items->Array.map(toLiteral)->Array.join(", ")}]`
+  | Object(fields) =>
+    `{${fields->Array.map(((k, v)) => `${k}: ${toLiteral(v)}`)->Array.join(", ")}}`
+  }
+
+let ids = (xs: array<string>): value => List(xs->Array.map(x => Id(x)))
+let strings = (xs: array<string>): value => List(xs->Array.map(x => String(x)))
+
+/** One mutation call: the field name and its inline arguments. */
+type mutation = {field: string, args: array<(string, value)>}
+
+let mutation = (field: string, args: array<(string, value)>): mutation => {field, args}
+
+let renderArgs = (args: array<(string, value)>): string =>
+  args->Array.map(((k, v)) => `${k}: ${toLiteral(v)}`)->Array.join(", ")
+
+/** Human-readable form used in progress output and failure messages. */
+let describe = (m: mutation): string => `${m.field}(${renderArgs(m.args)})`

package/src/Seed_Types.res.mjs

@@ -0,0 +1,79 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+let Failed = /* @__PURE__ */Primitive_exceptions.create("Seed_Types-ReventlessSeed.Failed");
+
+function quote(s) {
+  return JSON.stringify(s);
+}
+
+function toLiteral(v) {
+  switch (v.TAG) {
+    case "String" :
+    case "Id" :
+      return JSON.stringify(v._0);
+    case "Int" :
+    case "Float" :
+      return v._0.toString();
+    case "Bool" :
+      if (v._0) {
+        return "true";
+      } else {
+        return "false";
+      }
+    case "Enum" :
+      return v._0;
+    case "List" :
+      return `[` + v._0.map(toLiteral).join(", ") + `]`;
+    case "Object" :
+      return `{` + v._0.map(param => param[0] + `: ` + toLiteral(param[1])).join(", ") + `}`;
+  }
+}
+
+function ids(xs) {
+  return {
+    TAG: "List",
+    _0: xs.map(x => ({
+      TAG: "Id",
+      _0: x
+    }))
+  };
+}
+
+function strings(xs) {
+  return {
+    TAG: "List",
+    _0: xs.map(x => ({
+      TAG: "String",
+      _0: x
+    }))
+  };
+}
+
+function mutation(field, args) {
+  return {
+    field: field,
+    args: args
+  };
+}
+
+function renderArgs(args) {
+  return args.map(param => param[0] + `: ` + toLiteral(param[1])).join(", ");
+}
+
+function describe(m) {
+  return m.field + `(` + renderArgs(m.args) + `)`;
+}
+
+export {
+  Failed,
+  quote,
+  toLiteral,
+  ids,
+  strings,
+  mutation,
+  renderArgs,
+  describe,
+}
+/* No side effect */

package/src/Seed_Upload.res

@@ -0,0 +1,99 @@
+// Seed-time asset upload against the framework's presign-shaped upload contract.
+//
+// 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.
+//
+// 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.
+
+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).
+type url
+@new external makeUrl: (string, string) => url = "URL"
+@get external urlHref: url => string = "href"
+
+let field = (json: JSON.t, key: string): option<JSON.t> =>
+  switch json {
+  | Object(obj) => obj->Dict.get(key)
+  | _ => None
+  }
+
+let asString = (json: JSON.t): option<string> =>
+  switch json {
+  | String(s) => Some(s)
+  | _ => None
+  }
+
+// A `fetch` that reports an unreachable endpoint as `Error` instead of throwing,
+// so the two-step upload can thread failures without exceptions.
+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
+ * 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).
+ */
+let uploadAsset = async (
+  ~uploadEndpoint: 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)),
+      ]),
+    ),
+  )
+
+  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 (
+      json->field("uploadUrl")->Option.flatMap(asString),
+      json->field("storageRef")->Option.flatMap(asString),
+    ) {
+    | (Some(uploadUrl), Some(storageRef)) =>
+      let putUrl = urlHref(makeUrl(uploadUrl, uploadEndpoint))
+      switch await tryFetch(
+        putUrl,
+        {method: "PUT", headers: Dict.fromArray([("content-type", contentType)]), body: bytes},
+      ) {
+      | Error(m) => Error(`upload PUT: ${m}`)
+      | Ok(putRes) if putRes->responseOk => Ok(storageRef)
+      | Ok(putRes) =>
+        let detail = await putRes->responseText
+        Error(`upload PUT failed with HTTP ${(putRes->responseStatus)->Int.toString}: ${detail}`)
+      }
+    | _ => Error("presign response missing uploadUrl/storageRef")
+    }
+  }
+}

package/src/Seed_Upload.res.mjs

@@ -0,0 +1,118 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function field(json, key) {
+  if (typeof json === "object" && json !== null && !Array.isArray(json)) {
+    return json[key];
+  }
+}
+
+function asString(json) {
+  if (typeof json === "string") {
+    return json;
+  }
+}
+
+async function tryFetch(url, init) {
+  try {
+    return {
+      TAG: "Ok",
+      _0: await fetch(url, init)
+    };
+  } catch (exn) {
+    return {
+      TAG: "Error",
+      _0: `cannot reach ` + url
+    };
+  }
+}
+
+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") {
+    return {
+      TAG: "Error",
+      _0: `presign: ` + m._0 + ` — is the platform running?`
+    };
+  }
+  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();
+    return {
+      TAG: "Error",
+      _0: `upload PUT failed with HTTP ` + putRes.status.toString() + `: ` + detail
+    };
+  }
+  let detail$1 = await presignRes.text();
+  return {
+    TAG: "Error",
+    _0: `presign failed with HTTP ` + presignRes.status.toString() + `: ` + detail$1
+  };
+}
+
+export {
+  field,
+  asString,
+  tryFetch,
+  uploadAsset,
+}
+/* No side effect */