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

package/src/Seed_Client.res

@@ -43,11 +43,96 @@ 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)
 
+// ── What the bearer actually grants ─────────────────────────────────────────
+//
+// An account's listed groups are not necessarily the ones its token carries:
+// both platforms narrow a token to the single role the caller last chose to act
+// as. So a seed can log in as an account that looks eligible and be refused, and
+// the account list cannot explain it — only the token can.
+
+/** Claim names a narrowed token carries. These mirror the cross-provider
+    contract in `ReventlessCore.Auth_ActiveRole`; spelled out rather than
+    imported because this harness deliberately depends on no framework package. */
+let activeRoleClaim = "activeRole"
+let availableRolesClaim = "availableRoles"
+
+/** Group claim per provider, tried in order. */
+let groupClaimNames = ["cognito:groups", "groups"]
+
+let decodeSegment = (segment: string): option<dict<JSON.t>> =>
+  try {
+    segment
+    ->NodeBuffer.fromStringBase64Url
+    ->NodeBuffer.toStringUtf8
+    ->JSON.parseOrThrow
+    ->JSON.Decode.object
+  } catch {
+  | _ => None
+  }
+
+/** The bearer's payload, from whichever segment carries it — a Cognito JWT puts
+    it second and a local dev token first, so trying each in turn saves this from
+    having to know which platform signed the token. A segment that is not a JSON
+    object (a signature) simply does not decode. */
+let claims = (t: t): option<dict<JSON.t>> =>
+  t.token->Option.flatMap(token =>
+    token
+    ->String.split(".")
+    ->Array.reduce(None, (found, segment) =>
+      switch found {
+      | Some(_) => found
+      | None => decodeSegment(segment)
+      }
+    )
+  )
+
+// Arrays on the group claim, comma-joined on `availableRoles`.
+let asStrings = (value: JSON.t): option<array<string>> =>
+  switch value {
+  | Array(entries) => Some(entries->Array.filterMap(JSON.Decode.string))
+  | String(joined) =>
+    Some(joined->String.split(",")->Array.map(String.trim)->Array.filter(s => s != ""))
+  | _ => None
+  }
+
+let claimStrings = (t: t, name: string): option<array<string>> =>
+  t->claims->Option.flatMap(c => c->Dict.get(name))->Option.flatMap(asStrings)
+
+/** The groups the bearer actually presents — what every enforcement point reads.
+    `None` when the token is opaque to us, which is not an error: it just means
+    this cannot add anything. */
+let effectiveGroups = (t: t): option<array<string>> =>
+  groupClaimNames->Array.reduce(None, (found, name) =>
+    switch found {
+    | Some(_) => found
+    | None => t->claimStrings(name)
+    }
+  )
+
+/** One line naming the identity the bearer carries, and — when it was narrowed —
+    the membership it was narrowed from. The second half is the point: without it
+    a refusal looks like a misconfigured grant rather than a role switch. */
+let identitySummary = (t: t): option<string> =>
+  t
+  ->effectiveGroups
+  ->Option.map(groups => {
+    let held = groups->Array.length == 0 ? "no groups" : groups->Array.join(", ")
+    switch t->claimStrings(availableRolesClaim) {
+    | Some(available) if available->Array.length > 0 =>
+      `${held} — narrowed to this role from ${available->Array.join(", ")}`
+    | _ => held
+    }
+  })
+
 // ── JSON helpers ────────────────────────────────────────────────────────────
 
 let field = (json: JSON.t, key: string): option<JSON.t> =>
@@ -102,10 +187,72 @@ let login = async (t: t): unit => {
   t.token = json->field("token")->Option.flatMap(asString)
 }
 
+/** Error types the endpoint returns for a fault on its own side rather than a
+    problem with the document. They say nothing about the request, so the same
+    request sent again can succeed — and across the few hundred commands a seed
+    issues, one of these is ordinary rather than exceptional.
+
+    Everything else — a validation error, an unknown field, a refused token — is
+    an answer, and the same answer comes back however many times it is asked. */
+let transientErrorTypes = [
+  "InternalFailure",
+  "ServiceUnavailable",
+  "ServiceUnavailableError",
+  "Throttling",
+  "ThrottlingException",
+  "TooManyRequestsException",
+  "RequestTimeout",
+]
+
+/** Every entry must be transient for the document to be worth resending: one
+    real error alongside a transient one still means the request was wrong. An
+    empty `errors` array is not a reason to retry either. */
+let isTransient = (errors: JSON.t): bool =>
+  switch errors->JSON.Decode.array {
+  | None | Some([]) => false
+  | Some(entries) =>
+    entries->Array.every(e =>
+      switch e->nodeString("errorType") {
+      | Some(errorType) => transientErrorTypes->Array.includes(errorType)
+      | None => false
+      }
+    )
+  }
+
+/** An authorization refusal, in either platform's vocabulary — AppSync answers
+    `errorType: "Unauthorized"`, the local server carries it in the message. */
+let isDenied = (errors: JSON.t): bool =>
+  switch errors->JSON.Decode.array {
+  | None => false
+  | Some(entries) =>
+    entries->Array.some(e =>
+      switch (e->nodeString("errorType"), e->nodeString("message")) {
+      | (Some(errorType), _) if errorType->String.includes("Unauthorized") => true
+      | (_, Some(message)) => message->String.includes("Not Authorized")
+      | _ => false
+      }
+    )
+  }
+
+let attempts = 4
+
 /**
  * Sends one GraphQL document and returns its `data`. A GraphQL-level error
  * aborts the run: a half-seeded store is worse than an empty one, because it
  * looks like a working dataset.
+ *
+ * Which is exactly why a fault on the endpoint's own side must not abort it. A
+ * seed issues hundreds of commands, many of them concurrently and all of them
+ * against runtimes that a preceding reset left cold, so a single
+ * `InternalFailure` somewhere in the batch is a normal event. Treating it as
+ * fatal threw away every command that had already landed and demanded a full
+ * wipe and re-run — for a request that would have succeeded on being asked
+ * again. So resend those, backing off between tries, and keep failing fast on
+ * everything that is an answer rather than a fault.
+ *
+ * The backoff is jittered because the commands go out in concurrent batches: a
+ * fixed delay would have the whole batch retry in lockstep and rebuild the same
+ * burst that provoked the fault.
  */
 let gql = async (t: t, ~query: string, ~label: string): JSON.t => {
   let headers = Dict.fromArray([("content-type", "application/json")])
@@ -116,18 +263,38 @@ let gql = async (t: t, ~query: string, ~label: string): JSON.t => {
   let body = JSON.stringify(
     JSON.Encode.object(Dict.fromArray([("query", JSON.Encode.string(query))])),
   )
-  let res = try await fetch(t.config.endpoint, {method: "POST", headers, body}) catch {
-  | _ =>
-    throw(Failed(`${label}: cannot reach ${t.config.endpoint} — is the platform running?`))
-  }
-  let json = await res->responseJson
-  switch json->field("errors") {
-  | Some(errors) =>
-    throw(
-      Failed(`${label} failed\n  query: ${query}\n  response: ${JSON.stringify(errors)}`),
-    )
-  | None => json->field("data")->Option.getOr(JSON.Encode.null)
+  let rec attempt = async (n: int): JSON.t => {
+    let res = try await fetch(t.config.endpoint, {method: "POST", headers, body}) catch {
+    | _ =>
+      throw(Failed(`${label}: cannot reach ${t.config.endpoint} — is the platform running?`))
+    }
+    let json = await res->responseJson
+    switch json->field("errors") {
+    | Some(errors) =>
+      if errors->isTransient && n < attempts {
+        await sleep(250 * Int.shiftLeft(1, n - 1) + Int.fromFloat(Math.random() *. 250.))
+        await attempt(n + 1)
+      } else {
+        let tried = n > 1 ? `\n  gave up after ${n->Int.toString} attempts` : ""
+        // A refusal is the one failure the response cannot explain on its own:
+        // it names the field, never the caller. The account list can't either —
+        // it holds membership, and a narrowed token carries less.
+        let identity = switch isDenied(errors) ? t->identitySummary : None {
+        | Some(summary) => `\n  identity: ${summary}`
+        | None => ""
+        }
+        throw(
+          Failed(
+            `${label} failed\n  query: ${query}\n  response: ${JSON.stringify(
+                errors,
+              )}${identity}${tried}`,
+          ),
+        )
+      }
+    | None => json->field("data")->Option.getOr(JSON.Encode.null)
+    }
   }
+  await attempt(1)
 }
 
 // ── Commands ────────────────────────────────────────────────────────────────
@@ -175,18 +342,27 @@ let sendAll = async (t: t, mutations: array<mutation>): unit =>
  * Walks a Relay-style connection to the end. Connections page at 50 by default,
  * so any count taken from a single request silently truncates.
  */
-let queryAllNodes = async (t: t, ~field as fieldName: string, ~selection: string): array<
-  JSON.t,
-> => {
+// `~args` is spliced into the connection's argument list — `"includeRetired: true"`
+// is the case it exists for, and the only way to read rows the resolvers withhold
+// by default. Literal GraphQL rather than a typed argument list because a seed
+// writes the query it means; the alternative is a builder that has to grow a case
+// per argument the platform adds.
+let queryAllNodes = async (
+  t: t,
+  ~field as fieldName: string,
+  ~selection: string,
+  ~args: string="",
+): array<JSON.t> => {
   let nodes = []
   let after = ref(None)
   let more = ref(true)
+  let extra = args == "" ? "" : `, ${args}`
   while more.contents {
     let cursor = switch after.contents {
     | Some(c) => `, after: ${quote(c)}`
     | None => ""
     }
-    let query = `{ ${fieldName}(first: 100${cursor}) { edges { node { ${selection} } } pageInfo { hasNextPage endCursor } } }`
+    let query = `{ ${fieldName}(first: 100${extra}${cursor}) { edges { node { ${selection} } } pageInfo { hasNextPage endCursor } } }`
     let data = await gql(t, ~query, ~label=fieldName)
     let connection = data->field(fieldName)->Option.getOr(JSON.Encode.null)
     switch connection->field("edges") {
@@ -216,6 +392,43 @@ 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,
+  ~args: 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, ~args)
+    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/src/Seed_Client.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Seed_Types$ReventlessSeed from "./Seed_Types.res.mjs";
@@ -21,10 +22,77 @@ function currentToken(t) {
   return t.token;
 }
 
+function endpoint(t) {
+  return t.config.endpoint;
+}
+
 function useToken(t, token) {
   t.token = token;
 }
 
+let availableRolesClaim = "availableRoles";
+
+let groupClaimNames = [
+  "cognito:groups",
+  "groups"
+];
+
+function decodeSegment(segment) {
+  try {
+    return Stdlib_JSON.Decode.object(JSON.parse(Buffer.from(segment, "base64url").toString("utf8")));
+  } catch (exn) {
+    return;
+  }
+}
+
+function claims(t) {
+  return Stdlib_Option.flatMap(t.token, token => Stdlib_Array.reduce(token.split("."), undefined, (found, segment) => {
+    if (found !== undefined) {
+      return found;
+    } else {
+      return decodeSegment(segment);
+    }
+  }));
+}
+
+function asStrings(value) {
+  if (Array.isArray(value)) {
+    return Stdlib_Array.filterMap(value, Stdlib_JSON.Decode.string);
+  }
+  switch (typeof value) {
+    case "string" :
+      return value.split(",").map(prim => prim.trim()).filter(s => s !== "");
+    default:
+      return;
+  }
+}
+
+function claimStrings(t, name) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(claims(t), c => c[name]), asStrings);
+}
+
+function effectiveGroups(t) {
+  return Stdlib_Array.reduce(groupClaimNames, undefined, (found, name) => {
+    if (found !== undefined) {
+      return found;
+    } else {
+      return claimStrings(t, name);
+    }
+  });
+}
+
+function identitySummary(t) {
+  return Stdlib_Option.map(effectiveGroups(t), groups => {
+    let held = groups.length === 0 ? "no groups" : groups.join(", ");
+    let available = claimStrings(t, availableRolesClaim);
+    if (available !== undefined && available.length !== 0) {
+      return held + ` — narrowed to this role from ` + available.join(", ");
+    } else {
+      return held;
+    }
+  });
+}
+
 function field(json, key) {
   if (typeof json === "object" && json !== null && !Array.isArray(json)) {
     return json[key];
@@ -94,6 +162,57 @@ async function login(t) {
   t.token = Stdlib_Option.flatMap(field(json, "token"), asString);
 }
 
+let transientErrorTypes = [
+  "InternalFailure",
+  "ServiceUnavailable",
+  "ServiceUnavailableError",
+  "Throttling",
+  "ThrottlingException",
+  "TooManyRequestsException",
+  "RequestTimeout"
+];
+
+function isTransient(errors) {
+  let entries = Stdlib_JSON.Decode.array(errors);
+  if (entries !== undefined && entries.length !== 0) {
+    return entries.every(e => {
+      let errorType = nodeString(e, "errorType");
+      if (errorType !== undefined) {
+        return transientErrorTypes.includes(errorType);
+      } else {
+        return false;
+      }
+    });
+  } else {
+    return false;
+  }
+}
+
+function isDenied(errors) {
+  let entries = Stdlib_JSON.Decode.array(errors);
+  if (entries !== undefined) {
+    return entries.some(e => {
+      let match = nodeString(e, "errorType");
+      let match$1 = nodeString(e, "message");
+      if (match !== undefined) {
+        if (match.includes("Unauthorized")) {
+          return true;
+        } else if (match$1 !== undefined) {
+          return match$1.includes("Not Authorized");
+        } else {
+          return false;
+        }
+      } else if (match$1 !== undefined) {
+        return match$1.includes("Not Authorized");
+      } else {
+        return false;
+      }
+    });
+  } else {
+    return false;
+  }
+}
+
 async function gql(t, query, label) {
   let headers = Object.fromEntries([[
       "content-type",
@@ -107,30 +226,40 @@ async function gql(t, query, label) {
       "query",
       query
     ]]));
-  let res;
-  try {
-    res = await fetch(t.config.endpoint, {
-      method: "POST",
-      headers: headers,
-      body: body
-    });
-  } catch (exn) {
-    throw {
-      RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
-      _1: label + `: cannot reach ` + t.config.endpoint + ` — is the platform running?`,
-      Error: new Error()
-    };
-  }
-  let json = await res.json();
-  let errors = field(json, "errors");
-  if (errors !== undefined) {
+  let attempt = async n => {
+    let res;
+    try {
+      res = await fetch(t.config.endpoint, {
+        method: "POST",
+        headers: headers,
+        body: body
+      });
+    } catch (exn) {
+      throw {
+        RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
+        _1: label + `: cannot reach ` + t.config.endpoint + ` — is the platform running?`,
+        Error: new Error()
+      };
+    }
+    let json = await res.json();
+    let errors = field(json, "errors");
+    if (errors === undefined) {
+      return Stdlib_Option.getOr(field(json, "data"), null);
+    }
+    if (isTransient(errors) && n < 4) {
+      await sleep((250 * (1 << (n - 1 | 0)) | 0) + (Math.random() * 250 | 0) | 0);
+      return await attempt(n + 1 | 0);
+    }
+    let tried = n > 1 ? `\n  gave up after ` + n.toString() + ` attempts` : "";
+    let summary = isDenied(errors) ? identitySummary(t) : undefined;
+    let identity = summary !== undefined ? `\n  identity: ` + summary : "";
     throw {
       RE_EXN_ID: Seed_Types$ReventlessSeed.Failed,
-      _1: label + ` failed\n  query: ` + query + `\n  response: ` + JSON.stringify(errors),
+      _1: label + ` failed\n  query: ` + query + `\n  response: ` + JSON.stringify(errors) + identity + tried,
       Error: new Error()
     };
-  }
-  return Stdlib_Option.getOr(field(json, "data"), null);
+  };
+  return await attempt(1);
 }
 
 let commandResultSelection = `__typename
@@ -171,14 +300,16 @@ async function sendAll(t, mutations) {
   }
 }
 
-async function queryAllNodes(t, fieldName, selection) {
+async function queryAllNodes(t, fieldName, selection, argsOpt) {
+  let args = argsOpt !== undefined ? argsOpt : "";
   let nodes = [];
   let after;
   let more = true;
+  let extra = args === "" ? "" : `, ` + args;
   while (more) {
     let c = after;
     let cursor = c !== undefined ? `, after: ` + Seed_Types$ReventlessSeed.quote(c) : "";
-    let query = `{ ` + fieldName + `(first: 100` + cursor + `) { edges { node { ` + selection + ` } } pageInfo { hasNextPage endCursor } } }`;
+    let query = `{ ` + fieldName + `(first: 100` + extra + cursor + `) { edges { node { ` + selection + ` } } pageInfo { hasNextPage endCursor } } }`;
     let data = await gql(t, query, fieldName);
     let connection = Stdlib_Option.getOr(field(data, fieldName), null);
     let match = field(connection, "edges");
@@ -205,7 +336,30 @@ async function queryAllNodes(t, fieldName, selection) {
 }
 
 async function countNodes(t, field) {
-  return (await queryAllNodes(t, field, "id")).length;
+  return (await queryAllNodes(t, field, "id", undefined)).length;
+}
+
+async function queryAllNodesUntil(t, field, selection, argsOpt, satisfied, onTimeout, timeoutMsOpt) {
+  let args = argsOpt !== undefined ? argsOpt : "";
+  let timeoutMs = timeoutMsOpt !== undefined ? timeoutMsOpt : 60000;
+  let deadline = Date.now() + timeoutMs;
+  let result;
+  while (result === undefined) {
+    let nodes = await queryAllNodes(t, field, selection, args);
+    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) {
@@ -240,21 +394,40 @@ async function waitForIds(t, fieldName, ids, timeoutMsOpt) {
   return Stdlib_Option.getOr(result, 0);
 }
 
+let activeRoleClaim = "activeRole";
+
+let attempts = 4;
+
 export {
   sleep,
   make,
   currentToken,
+  endpoint,
   useToken,
+  activeRoleClaim,
+  availableRolesClaim,
+  groupClaimNames,
+  decodeSegment,
+  claims,
+  asStrings,
+  claimStrings,
+  effectiveGroups,
+  identitySummary,
   field,
   asString,
   nodeString,
   login,
+  transientErrorTypes,
+  isTransient,
+  isDenied,
+  attempts,
   gql,
   commandResultSelection,
   send,
   sendAll,
   queryAllNodes,
   countNodes,
+  queryAllNodesUntil,
   waitForIds,
 }
 /* No side effect */

package/src/Seed_Connect.res

@@ -1,15 +1,23 @@
 // 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
+// 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
 
-type connection = {client: Seed_Client.t, uploadEndpoint: string, label: string}
+// 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
@@ -19,22 +27,25 @@ type connection = {client: Seed_Client.t, uploadEndpoint: string, label: string}
 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
+  // `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, uploadEndpoint, label}
+  // What the bearer grants, which is not always what the account list showed: a
+  // token narrowed to one role presents that role alone. Said at login so the
+  // run starts from the identity it will actually be refused or served under.
+  switch Seed_Client.identitySummary(client) {
+  | Some(summary) => Console.log(`Acting as: ${summary}`)
+  | None => ()
+  }
+  {client, uploadsSkipped, label}
 }
 
 /**
@@ -63,21 +74,19 @@ let envOr = (key: string, fallback: string): string =>
  * 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=?, ~upload=?, ~login=?, ()): (unit => promise<connection>) => {
+let local = (~graphql=?, ~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,
     )