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

package/src/Seed_Connect.res.mjs

@@ -4,10 +4,14 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.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";
+import * as Seed_Upload$ReventlessSeed from "./Seed_Upload.res.mjs";
 
-async function make(label, endpoint, uploadEndpoint, login, localDefaultsOpt) {
+async function make(label, endpoint, uploadEndpoint, uploadEndpointsOpt, login, localDefaultsOpt) {
+  let uploadEndpoints = uploadEndpointsOpt !== undefined ? uploadEndpointsOpt : ({});
   let localDefaults = localDefaultsOpt !== undefined ? localDefaultsOpt : false;
-  let uploadEndpoint$1 = Stdlib_Option.isSome(Seed_Prompt$ReventlessSeed.envValue("SEED_SKIP_UPLOADS")) ? "" : uploadEndpoint;
+  let skip = Stdlib_Option.isSome(Seed_Prompt$ReventlessSeed.envValue("SEED_SKIP_UPLOADS"));
+  let uploadEndpoint$1 = skip ? "" : uploadEndpoint;
+  let uploadEndpoints$1 = skip ? ({}) : uploadEndpoints;
   let match = await Seed_Prompt$ReventlessSeed.credentials(localDefaults);
   let token = await login(match[0], match[1]);
   let client = Seed_Client$ReventlessSeed.make({
@@ -17,10 +21,26 @@ async function make(label, endpoint, uploadEndpoint, login, localDefaultsOpt) {
   return {
     client: client,
     uploadEndpoint: uploadEndpoint$1,
+    uploadEndpoints: uploadEndpoints$1,
     label: label
   };
 }
 
+function uploadEndpointFor(c, store) {
+  let endpoint = Seed_Upload$ReventlessSeed.endpointFor(store, c.uploadEndpoint, c.uploadEndpoints);
+  if (endpoint !== undefined) {
+    return {
+      TAG: "Ok",
+      _0: endpoint
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: Seed_Upload$ReventlessSeed.unresolvedReason(store, c.uploadEndpoints)
+    };
+  }
+}
+
 function viaLoginEndpoint(loginEndpoint) {
   return async (username, password) => {
     let client = Seed_Client$ReventlessSeed.make({
@@ -50,11 +70,12 @@ function local(graphql, upload, login, param) {
   let endpoint = Stdlib_Option.getOr(graphql, Stdlib_Option.getOr(Seed_Prompt$ReventlessSeed.envValue("REVENTLESS_GRAPHQL_ENDPOINT"), "http://localhost:4000/graphql"));
   let uploadEndpoint = Stdlib_Option.getOr(upload, Stdlib_Option.getOr(Seed_Prompt$ReventlessSeed.envValue("REVENTLESS_UPLOAD_ENDPOINT"), "http://localhost:4000/__inmemory/upload"));
   let loginEndpoint = Stdlib_Option.getOr(login, Stdlib_Option.getOr(Seed_Prompt$ReventlessSeed.envValue("REVENTLESS_LOGIN_ENDPOINT"), "http://localhost:4000/__inmemory/login"));
-  return () => make("local", endpoint, uploadEndpoint, viaLoginEndpoint(loginEndpoint), true);
+  return () => make("local", endpoint, uploadEndpoint, undefined, viaLoginEndpoint(loginEndpoint), true);
 }
 
 export {
   make,
+  uploadEndpointFor,
   viaLoginEndpoint,
   envOr,
   local,

package/src/Seed_Upload.res

@@ -10,6 +10,11 @@
 // 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.
 
 type fetchInit = {method: string, headers: dict<string>, body: string}
 type response
@@ -38,6 +43,60 @@ 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`
+  }
+}
+
 // 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> =>

package/src/Seed_Upload.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+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 +15,31 @@ 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";
+  }
+}
+
 async function tryFetch(url, init) {
   try {
     return {
@@ -112,7 +138,9 @@ async function uploadAsset(uploadEndpoint, bytes, fileName, contentType, authTok
 export {
   field,
   asString,
+  endpointFor,
+  unresolvedReason,
   tryFetch,
   uploadAsset,
 }
-/* No side effect */
+/* Seed_Prompt-ReventlessSeed Not a pure module */

package/tests/UploadEndpointResolutionTest.res

@@ -0,0 +1,101 @@
+// Which endpoint an asset uploads through once a deployment publishes one per
+// declared store, and what a data set is told when none resolves.
+//
+// The four rows are the same ones the AutoUI renderer resolves an upload field
+// by. They are pinned here because the two middle ones are what keep a
+// deployment predating per-store endpoints — and the local dev server, which
+// serves a single upload route — working unchanged, and because the row that
+// falls back to the legacy service must never fall back to *another store*: that
+// uploads into a different plugin's bucket with a 2xx and a plausible ref.
+
+open JestGlobals
+
+@val @scope("process") external processEnv: dict<string> = "env"
+
+// `unresolvedReason` reads the knob, so the ambient environment has to be quiet.
+let clearSkip = () => processEnv->Dict.set("SEED_SKIP_UPLOADS", "")
+
+let perStore = Dict.fromArray([
+  ("Catalog.productImages", "https://catalog.example/"),
+  ("Ordering.invoices", "https://ordering.example/"),
+])
+
+describe("Seed.Upload.endpointFor", () => {
+  testSync("a declared store with a matching endpoint uses that store's endpoint", () =>
+    expect(
+      Seed.Upload.endpointFor(
+        ~store="Catalog.productImages",
+        ~uploadEndpoint="https://legacy.example/",
+        ~uploadEndpoints=perStore,
+      ),
+    )->toEqual(Some("https://catalog.example/"))
+  )
+
+  // Not "https://ordering.example/" — a wrong guess here is a silent
+  // wrong-bucket write.
+  testSync("a declared store with no matching endpoint falls back to the legacy service", () =>
+    expect(
+      Seed.Upload.endpointFor(
+        ~store="Catalog.brochures",
+        ~uploadEndpoint="https://legacy.example/",
+        ~uploadEndpoints=perStore,
+      ),
+    )->toEqual(Some("https://legacy.example/"))
+  )
+
+  testSync("naming no store uses the legacy service", () =>
+    expect(
+      Seed.Upload.endpointFor(~uploadEndpoint="https://legacy.example/", ~uploadEndpoints=perStore),
+    )->toEqual(Some("https://legacy.example/"))
+  )
+
+  testSync("neither available resolves nothing", () =>
+    expect(
+      Seed.Upload.endpointFor(
+        ~store="Catalog.brochures",
+        ~uploadEndpoint="",
+        ~uploadEndpoints=Dict.make(),
+      ),
+    )->toEqual(None)
+  )
+
+  // The local dev server's shape: one upload route, no per-store map, and a data
+  // set that names its store all the same.
+  testSync("a single-route deployment serves a store-naming data set", () =>
+    expect(
+      Seed.Upload.endpointFor(
+        ~store="Catalog.productImages",
+        ~uploadEndpoint="http://localhost:4000/__inmemory/upload",
+        ~uploadEndpoints=Dict.make(),
+      ),
+    )->toEqual(Some("http://localhost:4000/__inmemory/upload"))
+  )
+})
+
+// "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.
+describe("Seed.Upload.unresolvedReason", () => {
+  beforeEach(clearSkip)
+
+  testSync("no endpoints at all reads as a fact about the deployment", () =>
+    expect(
+      Seed.Upload.unresolvedReason(~store="Catalog.productImages", ~uploadEndpoints=Dict.make()),
+    )->toBe("this deployment publishes no upload endpoint")
+  )
+
+  testSync("an unmatched store names the store and the keys that were available", () => {
+    let msg = Seed.Upload.unresolvedReason(~store="Catalog.brochures", ~uploadEndpoints=perStore)
+    expect(msg)->toContain("Catalog.brochures")
+    expect(msg)->toContain("Catalog.productImages")
+    expect(msg)->toContain("Ordering.invoices")
+  })
+
+  testSync("the knob outranks both, so a skipped run is never read as a broken one", () => {
+    processEnv->Dict.set("SEED_SKIP_UPLOADS", "1")
+    expect(
+      Seed.Upload.unresolvedReason(~store="Catalog.productImages", ~uploadEndpoints=perStore),
+    )->toBe("SEED_SKIP_UPLOADS is set")
+  })
+})

package/tests/UploadEndpointResolutionTest.res.mjs

@@ -0,0 +1,59 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Seed_Upload$ReventlessSeed from "../src/Seed_Upload.res.mjs";
+
+function clearSkip() {
+  process.env["SEED_SKIP_UPLOADS"] = "";
+}
+
+let perStore = Object.fromEntries([
+  [
+    "Catalog.productImages",
+    "https://catalog.example/"
+  ],
+  [
+    "Ordering.invoices",
+    "https://ordering.example/"
+  ]
+]);
+
+globalThis.describe("Seed.Upload.endpointFor", () => {
+  globalThis.test("a declared store with a matching endpoint uses that store's endpoint", () => {
+    globalThis.expect(Seed_Upload$ReventlessSeed.endpointFor("Catalog.productImages", "https://legacy.example/", perStore)).toEqual("https://catalog.example/");
+  });
+  globalThis.test("a declared store with no matching endpoint falls back to the legacy service", () => {
+    globalThis.expect(Seed_Upload$ReventlessSeed.endpointFor("Catalog.brochures", "https://legacy.example/", perStore)).toEqual("https://legacy.example/");
+  });
+  globalThis.test("naming no store uses the legacy service", () => {
+    globalThis.expect(Seed_Upload$ReventlessSeed.endpointFor(undefined, "https://legacy.example/", perStore)).toEqual("https://legacy.example/");
+  });
+  globalThis.test("neither available resolves nothing", () => {
+    globalThis.expect(Seed_Upload$ReventlessSeed.endpointFor("Catalog.brochures", "", {})).toEqual(undefined);
+  });
+  globalThis.test("a single-route deployment serves a store-naming data set", () => {
+    globalThis.expect(Seed_Upload$ReventlessSeed.endpointFor("Catalog.productImages", "http://localhost:4000/__inmemory/upload", {})).toEqual("http://localhost:4000/__inmemory/upload");
+  });
+});
+
+globalThis.describe("Seed.Upload.unresolvedReason", () => {
+  globalThis.beforeEach(clearSkip);
+  globalThis.test("no endpoints at all reads as a fact about the deployment", () => {
+    globalThis.expect(Seed_Upload$ReventlessSeed.unresolvedReason("Catalog.productImages", {})).toBe("this deployment publishes no upload endpoint");
+  });
+  globalThis.test("an unmatched store names the store and the keys that were available", () => {
+    let msg = Seed_Upload$ReventlessSeed.unresolvedReason("Catalog.brochures", perStore);
+    globalThis.expect(msg).toContain("Catalog.brochures");
+    globalThis.expect(msg).toContain("Catalog.productImages");
+    globalThis.expect(msg).toContain("Ordering.invoices");
+  });
+  globalThis.test("the knob outranks both, so a skipped run is never read as a broken one", () => {
+    process.env["SEED_SKIP_UPLOADS"] = "1";
+    globalThis.expect(Seed_Upload$ReventlessSeed.unresolvedReason("Catalog.productImages", perStore)).toBe("SEED_SKIP_UPLOADS is set");
+  });
+});
+
+export {
+  clearSkip,
+  perStore,
+}
+/* perStore Not a pure module */