@reventlessdev/reventless-seed-aws 1.0.0-alpha.6 → 1.0.0-alpha.7

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 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.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-aws

package/lib/bs/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1785535392961)
-#Done(1785535392990)
+#Start(1785603404469)
+#Done(1785603404495)

package/lib/bs/compiler-info.json

@@ -4,5 +4,5 @@
   "bsc_hash": "75e3a59c95cc953608fd3dd6ea6ed68141bba4414a20a52f114261b8a48385fa",
   "rescript_config_hash": "c18a0067c363fd1290f6e7f6fe6212d2e16e201c1702fac667962047f88ed468",
   "runtime_path": "/home/runner/work/reventless-core/reventless-core/node_modules/@rescript/runtime",
-  "generated_at": "1785535392996"
+  "generated_at": "1785603404501"
 }

package/lib/bs/src/ReventlessSeedAws.res

@@ -36,18 +36,6 @@ let asString = (json: JSON.t): option<string> =>
   | _ => None
   }
 
-// Non-string members are dropped rather than failing the whole map: one
-// malformed entry should not cost a run every endpoint it could have used.
-let asStringDict = (json: JSON.t): dict<string> =>
-  switch json {
-  | Object(obj) =>
-    obj
-    ->Dict.toArray
-    ->Array.filterMap(((k, v)) => v->asString->Option.map(s => (k, s)))
-    ->Dict.fromArray
-  | _ => Dict.make()
-  }
-
 // ── Stack discovery ───────────────────────────────────────────────────────────
 
 // Which Pulumi backend the `pulumi` subprocess reads from. When `backend` is
@@ -158,16 +146,6 @@ let resolveField = (~envKey: string, ~fromSource: option<string>, ~human: string
     }
   }
 
-// Same precedence, for a value whose absence is a legitimate answer rather than
-// a broken deployment: a stack that declares no store publishes no upload
-// endpoint, and that must stay a no-op at the data set instead of failing the
-// run before a single command is sent.
-let optionalField = (~envKey: string, ~fromSource: option<string>): string =>
-  switch Seed.Prompt.envValue(envKey) {
-  | Some(v) => v
-  | None => fromSource->Option.getOr("")
-  }
-
 // Which document publishes the deployment's endpoints. A stack that serves a
 // host shell publishes them in the shell's `config.json` under the client's key
 // names; one that does not publishes them as stack outputs under Pulumi's. The
@@ -177,11 +155,6 @@ type source = HostShellConfig(JSON.t) | StackOutputs(JSON.t)
 
 type endpoints = {
   graphql: string,
-  // The legacy single presign service; "" when the deployment publishes none.
-  uploadEndpoint: string,
-  // Qualified `{plugin}.{store}` → that store's presign endpoint. Empty when the
-  // deployment declares no store.
-  uploadEndpoints: dict<string>,
   cognitoRegion: string,
   cognitoClientId: string,
 }
@@ -190,15 +163,9 @@ type endpoints = {
  * The endpoints a source document publishes — pure, so the branch selection and
  * every key it reads can be exercised with synthetic documents.
  *
- * `uploadEndpoints` is read on **both** arms. It was read on neither: the
- * host-shell arm looked only at the singular `uploadEndpoint`, and the
- * stack-output arm had no upload lookup at all, so a platform that publishes its
- * stores and no host shell resolved "" and reported itself as serving no
- * uploads.
- *
- * `REVENTLESS_UPLOAD_ENDPOINT` still overrides the singular endpoint and does
- * not touch the map: one string cannot express a map, so it could only ever
- * override one store and would need a naming convention to say which.
+ * Upload endpoints are no longer resolved here: under route B the seed mints through
+ * the domain API's `Upload_Presign` mutation on `graphql`, passing the store per asset,
+ * so there is no per-store URL to discover.
  */
 let endpointsFrom = (~stack: string, source: source): endpoints =>
   switch source {
@@ -210,11 +177,6 @@ let endpointsFrom = (~stack: string, source: source): endpoints =>
         ~fromSource=fromCfg("apiEndpoint"),
         ~human="apiEndpoint",
       ),
-      uploadEndpoint: optionalField(
-        ~envKey="REVENTLESS_UPLOAD_ENDPOINT",
-        ~fromSource=fromCfg("uploadEndpoint"),
-      ),
-      uploadEndpoints: cfg->field("uploadEndpoints")->Option.mapOr(Dict.make(), asStringDict),
       cognitoRegion: resolveField(
         ~envKey="AWS_REGION",
         ~fromSource=fromCfg("region"),
@@ -242,10 +204,6 @@ let endpointsFrom = (~stack: string, source: source): endpoints =>
           ),
         )
       },
-      // No stack output carries the legacy single service — it exists only in a
-      // host shell's config.json — so here the env override is its only source.
-      uploadEndpoint: optionalField(~envKey="REVENTLESS_UPLOAD_ENDPOINT", ~fromSource=None),
-      uploadEndpoints: outputs->field("uploadEndpoints")->Option.mapOr(Dict.make(), asStringDict),
       cognitoRegion: resolveField(
         ~envKey="AWS_REGION",
         ~fromSource=out("cognitoRegion"),
@@ -365,8 +323,6 @@ let connect = (~projectDir: string=".", ~stack=?, ~backend=?, ()): (
     await Seed.Connect.make(
       ~label=stackName,
       ~endpoint=eps.graphql,
-      ~uploadEndpoint=eps.uploadEndpoint,
-      ~uploadEndpoints=eps.uploadEndpoints,
       ~login=cognito(~region=eps.cognitoRegion, ~clientId=eps.cognitoClientId),
     )
   }

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

@@ -19,20 +19,6 @@ function asString(json) {
   }
 }
 
-function asStringDict(json) {
-  if (typeof json === "object" && json !== null && !Array.isArray(json)) {
-    return Object.fromEntries(Stdlib_Array.filterMap(Object.entries(json), param => {
-      let k = param[0];
-      return Stdlib_Option.map(asString(param[1]), s => [
-        k,
-        s
-      ]);
-    }));
-  } else {
-    return {};
-  }
-}
-
 function envForBackend(backend) {
   if (backend === undefined) {
     return;
@@ -166,23 +152,12 @@ function resolveField(envKey, fromSource, human) {
   };
 }
 
-function optionalField(envKey, fromSource) {
-  let v = Seed_Prompt$ReventlessSeed.envValue(envKey);
-  if (v !== undefined) {
-    return v;
-  } else {
-    return Stdlib_Option.getOr(fromSource, "");
-  }
-}
-
 function endpointsFrom(stack, source) {
   if (source.TAG === "HostShellConfig") {
     let cfg = source._0;
     let fromCfg = key => Stdlib_Option.flatMap(field(cfg, key), asString);
     return {
       graphql: resolveField("REVENTLESS_GRAPHQL_ENDPOINT", fromCfg("apiEndpoint"), "apiEndpoint"),
-      uploadEndpoint: optionalField("REVENTLESS_UPLOAD_ENDPOINT", fromCfg("uploadEndpoint")),
-      uploadEndpoints: Stdlib_Option.mapOr(field(cfg, "uploadEndpoints"), {}, asStringDict),
       cognitoRegion: resolveField("AWS_REGION", fromCfg("region"), "region"),
       cognitoClientId: resolveField("COGNITO_CLIENT_ID", fromCfg("cognitoClientId"), "cognitoClientId")
     };
@@ -208,8 +183,6 @@ function endpointsFrom(stack, source) {
   }
   return {
     graphql: tmp,
-    uploadEndpoint: optionalField("REVENTLESS_UPLOAD_ENDPOINT", undefined),
-    uploadEndpoints: Stdlib_Option.mapOr(field(outputs, "uploadEndpoints"), {}, asStringDict),
     cognitoRegion: resolveField("AWS_REGION", out("cognitoRegion"), "cognitoRegion"),
     cognitoClientId: resolveField("COGNITO_CLIENT_ID", out("cognitoUserPoolClientId"), "cognitoUserPoolClientId")
   };
@@ -313,14 +286,13 @@ function connect($staropt$star, stack, backend, param) {
     let backend$1 = url !== undefined ? url : backend;
     let stackName = await resolveStack(projectDir, backend$1, stack);
     let eps = await resolveEndpoints(projectDir, backend$1, stackName);
-    return await Seed_Connect$ReventlessSeed.make(stackName, eps.graphql, eps.uploadEndpoint, eps.uploadEndpoints, cognito(eps.cognitoRegion, eps.cognitoClientId), undefined);
+    return await Seed_Connect$ReventlessSeed.make(stackName, eps.graphql, cognito(eps.cognitoRegion, eps.cognitoClientId), undefined);
   };
 }
 
 export {
   field,
   asString,
-  asStringDict,
   envForBackend,
   pulumi,
   deployedStacks,
@@ -329,7 +301,6 @@ export {
   resolveStack,
   fetchConfig,
   resolveField,
-  optionalField,
   endpointsFrom,
   resolveEndpoints,
   cognito,

package/lib/bs/tests/EndpointResolutionTest.res

@@ -1,25 +1,22 @@
-// Which document `resolveEndpoints` reads, and what each arm takes from it.
+// Which document `resolveEndpoints` reads, and which GraphQL endpoint each arm takes
+// from it.
 //
 // `endpointsFrom` is the pure half of `resolveEndpoints`; the impure half is a
-// `pulumi stack output` subprocess and a `config.json` fetch, and the decision
-// these tests pin is in neither. The defect they lock out: **neither arm read
-// `uploadEndpoints`**, so a platform that publishes a presign endpoint per
-// declared store resolved "" and the seeder reported it as serving no uploads.
-// The stack-outputs arm is the one that matters — a platform deploying no host
-// shell publishes no `hostShellUrl` by construction, so it takes that arm, and
-// the per-store endpoint is its only way to reach the store.
+// `pulumi stack output` subprocess and a `config.json` fetch, and the decision these
+// tests pin is in neither. Upload endpoints are no longer resolved here — under route B
+// the seed mints through the domain API's `Upload_Presign` mutation on the GraphQL
+// endpoint below — so the only decision left is which GraphQL endpoint each source
+// publishes, and the merged-over-per-plugin precedence within the stack-outputs arm.
 
 open JestGlobals
 open ReventlessSeed
 
-
 // Every value read here has an env override, and an ambient one in the runner's
-// environment (AWS_REGION is routinely set) would silently stand in for the
-// document under test. An empty string reads as unset.
+// environment (AWS_REGION is routinely set) would silently stand in for the document
+// under test. An empty string reads as unset.
 let clearOverrides = () =>
   [
     "REVENTLESS_GRAPHQL_ENDPOINT",
-    "REVENTLESS_UPLOAD_ENDPOINT",
     "AWS_REGION",
     "COGNITO_CLIENT_ID",
     "SEED_SKIP_UPLOADS",
@@ -28,9 +25,6 @@ let clearOverrides = () =>
 let obj = entries => JSON.Encode.object(entries->Dict.fromArray)
 let str = JSON.Encode.string
 
-// A host shell's config.json and the stack outputs of a platform that serves no
-// shell — the two documents the two arms read, minus the upload keys each test
-// supplies.
 let config = (~extra: array<(string, JSON.t)>) =>
   obj(
     Array.concat(
@@ -55,84 +49,18 @@ let outputs = (~extra: array<(string, JSON.t)>) =>
     ),
   )
 
-let storeEndpoints = obj([("Catalog.productImages", str("https://presign.example/"))])
-
 describe("endpointsFrom — host shell arm", () => {
   beforeEach(clearOverrides)
 
-  testSync("reads the legacy single service and the per-store map together", () => {
-    let eps = ReventlessSeedAws.endpointsFrom(
-      ~stack="alpha",
-      HostShellConfig(
-        config(
-          ~extra=[
-            ("uploadEndpoint", str("https://legacy.example/")),
-            ("uploadEndpoints", storeEndpoints),
-          ],
-        ),
-      ),
-    )
-    expect(eps.uploadEndpoint)->toBe("https://legacy.example/")
-    expect(eps.uploadEndpoints)->toEqual(
-      Dict.fromArray([("Catalog.productImages", "https://presign.example/")]),
-    )
-  })
-
-  // A shell fronting only declared stores writes no singular key. That used to
-  // fail the whole run before a command was sent ("deployment is missing
-  // uploadEndpoint"), which is a harder failure than the one this plan fixes.
-  testSync("a shell publishing only per-store endpoints resolves an empty legacy service", () => {
-    let eps = ReventlessSeedAws.endpointsFrom(
-      ~stack="alpha",
-      HostShellConfig(config(~extra=[("uploadEndpoints", storeEndpoints)])),
-    )
-    expect(eps.uploadEndpoint)->toBe("")
-    expect(eps.uploadEndpoints->Dict.keysToArray)->toEqual(["Catalog.productImages"])
-  })
-
-  testSync("REVENTLESS_UPLOAD_ENDPOINT overrides the legacy service and leaves the map alone", () => {
-    NodeProcess.env->Dict.set("REVENTLESS_UPLOAD_ENDPOINT", "https://override.example/")
-    let eps = ReventlessSeedAws.endpointsFrom(
-      ~stack="alpha",
-      HostShellConfig(
-        config(
-          ~extra=[
-            ("uploadEndpoint", str("https://legacy.example/")),
-            ("uploadEndpoints", storeEndpoints),
-          ],
-        ),
-      ),
-    )
-    expect(eps.uploadEndpoint)->toBe("https://override.example/")
-    expect(eps.uploadEndpoints->Dict.get("Catalog.productImages"))->toEqual(
-      Some("https://presign.example/"),
-    )
+  testSync("reads the GraphQL endpoint from the shell config", () => {
+    let eps = ReventlessSeedAws.endpointsFrom(~stack="alpha", HostShellConfig(config(~extra=[])))
+    expect(eps.graphql)->toBe("https://api.example/graphql")
   })
 })
 
 describe("endpointsFrom — stack outputs arm", () => {
   beforeEach(clearOverrides)
 
-  // The lookup that was missing entirely: this arm had no upload source but the
-  // env var, so a `PlatformOwned` deployment resolved "" whatever it published.
-  testSync("reads the uploadEndpoints stack output", () => {
-    let eps = ReventlessSeedAws.endpointsFrom(
-      ~stack="pr-verify",
-      StackOutputs(outputs(~extra=[("uploadEndpoints", storeEndpoints)])),
-    )
-    expect(eps.uploadEndpoints)->toEqual(
-      Dict.fromArray([("Catalog.productImages", "https://presign.example/")]),
-    )
-  })
-
-  // Declaring no store is a legitimate deployment, not a broken one — it stays a
-  // no-op at the data set rather than failing the run.
-  testSync("a deployment declaring no store resolves an empty map without failing", () => {
-    let eps = ReventlessSeedAws.endpointsFrom(~stack="pr-verify", StackOutputs(outputs(~extra=[])))
-    expect(eps.uploadEndpoint)->toBe("")
-    expect(eps.uploadEndpoints->Dict.keysToArray)->toEqual([])
-  })
-
   testSync("prefers the merged API endpoint over the per-plugin one", () => {
     let eps = ReventlessSeedAws.endpointsFrom(
       ~stack="pr-verify",
@@ -153,28 +81,3 @@ describe("endpointsFrom — stack outputs arm", () => {
     }
   )
 })
-
-describe("endpointsFrom — malformed uploadEndpoints", () => {
-  beforeEach(clearOverrides)
-
-  // One bad member should not cost the run every endpoint it could have used.
-  testSync("drops a non-string member rather than the whole map", () => {
-    let eps = ReventlessSeedAws.endpointsFrom(
-      ~stack="pr-verify",
-      StackOutputs(
-        outputs(
-          ~extra=[
-            (
-              "uploadEndpoints",
-              obj([
-                ("Catalog.productImages", str("https://presign.example/")),
-                ("Catalog.broken", JSON.Encode.int(7)),
-              ]),
-            ),
-          ],
-        ),
-      ),
-    )
-    expect(eps.uploadEndpoints->Dict.keysToArray)->toEqual(["Catalog.productImages"])
-  })
-})

package/lib/bs/tests/EndpointResolutionTest.res.mjs

@@ -8,7 +8,6 @@ import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_excep
 function clearOverrides() {
   [
     "REVENTLESS_GRAPHQL_ENDPOINT",
-    "REVENTLESS_UPLOAD_ENDPOINT",
     "AWS_REGION",
     "COGNITO_CLIENT_ID",
     "SEED_SKIP_UPLOADS"
@@ -59,87 +58,19 @@ function outputs(extra) {
   ].concat(extra));
 }
 
-let storeEndpoints = Object.fromEntries([[
-    "Catalog.productImages",
-    "https://presign.example/"
-  ]]);
-
 globalThis.describe("endpointsFrom — host shell arm", () => {
   globalThis.beforeEach(clearOverrides);
-  globalThis.test("reads the legacy single service and the per-store map together", () => {
-    let eps = ReventlessSeedAws.endpointsFrom("alpha", {
-      TAG: "HostShellConfig",
-      _0: config([
-        [
-          "uploadEndpoint",
-          "https://legacy.example/"
-        ],
-        [
-          "uploadEndpoints",
-          storeEndpoints
-        ]
-      ])
-    });
-    globalThis.expect(eps.uploadEndpoint).toBe("https://legacy.example/");
-    globalThis.expect(eps.uploadEndpoints).toEqual(Object.fromEntries([[
-        "Catalog.productImages",
-        "https://presign.example/"
-      ]]));
-  });
-  globalThis.test("a shell publishing only per-store endpoints resolves an empty legacy service", () => {
+  globalThis.test("reads the GraphQL endpoint from the shell config", () => {
     let eps = ReventlessSeedAws.endpointsFrom("alpha", {
       TAG: "HostShellConfig",
-      _0: config([[
-          "uploadEndpoints",
-          storeEndpoints
-        ]])
+      _0: config([])
     });
-    globalThis.expect(eps.uploadEndpoint).toBe("");
-    globalThis.expect(Object.keys(eps.uploadEndpoints)).toEqual(["Catalog.productImages"]);
-  });
-  globalThis.test("REVENTLESS_UPLOAD_ENDPOINT overrides the legacy service and leaves the map alone", () => {
-    process.env["REVENTLESS_UPLOAD_ENDPOINT"] = "https://override.example/";
-    let eps = ReventlessSeedAws.endpointsFrom("alpha", {
-      TAG: "HostShellConfig",
-      _0: config([
-        [
-          "uploadEndpoint",
-          "https://legacy.example/"
-        ],
-        [
-          "uploadEndpoints",
-          storeEndpoints
-        ]
-      ])
-    });
-    globalThis.expect(eps.uploadEndpoint).toBe("https://override.example/");
-    globalThis.expect(eps.uploadEndpoints["Catalog.productImages"]).toEqual("https://presign.example/");
+    globalThis.expect(eps.graphql).toBe("https://api.example/graphql");
   });
 });
 
 globalThis.describe("endpointsFrom — stack outputs arm", () => {
   globalThis.beforeEach(clearOverrides);
-  globalThis.test("reads the uploadEndpoints stack output", () => {
-    let eps = ReventlessSeedAws.endpointsFrom("pr-verify", {
-      TAG: "StackOutputs",
-      _0: outputs([[
-          "uploadEndpoints",
-          storeEndpoints
-        ]])
-    });
-    globalThis.expect(eps.uploadEndpoints).toEqual(Object.fromEntries([[
-        "Catalog.productImages",
-        "https://presign.example/"
-      ]]));
-  });
-  globalThis.test("a deployment declaring no store resolves an empty map without failing", () => {
-    let eps = ReventlessSeedAws.endpointsFrom("pr-verify", {
-      TAG: "StackOutputs",
-      _0: outputs([])
-    });
-    globalThis.expect(eps.uploadEndpoint).toBe("");
-    globalThis.expect(Object.keys(eps.uploadEndpoints)).toEqual([]);
-  });
   globalThis.test("prefers the merged API endpoint over the per-plugin one", () => {
     let eps = ReventlessSeedAws.endpointsFrom("pr-verify", {
       TAG: "StackOutputs",
@@ -174,35 +105,11 @@ globalThis.describe("endpointsFrom — stack outputs arm", () => {
   });
 });
 
-globalThis.describe("endpointsFrom — malformed uploadEndpoints", () => {
-  globalThis.beforeEach(clearOverrides);
-  globalThis.test("drops a non-string member rather than the whole map", () => {
-    let eps = ReventlessSeedAws.endpointsFrom("pr-verify", {
-      TAG: "StackOutputs",
-      _0: outputs([[
-          "uploadEndpoints",
-          Object.fromEntries([
-            [
-              "Catalog.productImages",
-              "https://presign.example/"
-            ],
-            [
-              "Catalog.broken",
-              7
-            ]
-          ])
-        ]])
-    });
-    globalThis.expect(Object.keys(eps.uploadEndpoints)).toEqual(["Catalog.productImages"]);
-  });
-});
-
 export {
   clearOverrides,
   obj,
   str,
   config,
   outputs,
-  storeEndpoints,
 }
-/* storeEndpoints Not a pure module */
+/*  Not a pure module */

package/lib/ocaml/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1785535392961)
-#Done(1785535392990)
+#Start(1785603404469)
+#Done(1785603404495)