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

package/lib/bs/tests/ObjectStoreResetTest.res

@@ -0,0 +1,170 @@
+// How the reset learns which uploaded objects belong to which plugin, and what
+// it refuses.
+//
+// A declared store's bucket is built by the PLATFORM deploy, so its tags say
+// which project built it, not whose data is in it. Ownership therefore comes
+// from the platform's `objectStores` stack output, and these pin the pure half
+// of that: parsing the output, and refusing any store set a prefix-scoped wipe
+// could not separate. The impure half is a `pulumi stack output` subprocess and
+// the S3 calls, and the decisions under test are in neither.
+
+open JestGlobals
+
+module Reset = ReventlessSeedAws_Reset
+
+let obj = entries => JSON.Encode.object(entries->Dict.fromArray)
+let str = JSON.Encode.string
+
+let storeEntry = (~bucket, ~prefix) =>
+  obj([("bucketName", str(bucket)), ("keyPrefix", str(prefix))])
+
+let output = entries => Some(obj(entries))
+
+let store = (~qualified, ~bucket, ~prefix): Reset.objectStore => {
+  let (plugin, name) = Reset.splitQualified(qualified)->Option.getOr(("", qualified))
+  {qualified, plugin, store: name, bucketName: bucket, keyPrefix: prefix}
+}
+
+describe("parseObjectStores", () => {
+  testSync("splits the qualified key into plugin and store", () =>
+    switch Reset.parseObjectStores(
+      output([("Catalog.productImages", storeEntry(~bucket="alpha-stores", ~prefix="productImages"))]),
+    ) {
+    | Ok([s]) =>
+      expect((s.plugin, s.store, s.bucketName, s.keyPrefix))->toEqual((
+        "Catalog",
+        "productImages",
+        "alpha-stores",
+        "productImages",
+      ))
+    | other => fail(`expected one parsed store, got ${other->JSON.stringifyAny->Option.getOr("?")}`)
+    }
+  )
+
+  // A store name may contain a dot; a registered plugin name may not — so the
+  // split is at the first one, matching how the key is composed.
+  testSync("splits at the first dot only", () =>
+    switch Reset.splitQualified("Catalog.product.images") {
+    | Some((plugin, name)) => expect((plugin, name))->toEqual(("Catalog", "product.images"))
+    | None => fail("expected a split")
+    }
+  )
+
+  // A platform that declares no stores is ordinary, not an error.
+  testSync("absent output yields no stores", () =>
+    switch Reset.parseObjectStores(None) {
+    | Ok(stores) => expect(stores->Array.length)->toBe(0)
+    | Error(message) => fail(message)
+    }
+  )
+
+  // A store the reset cannot read is a store it would silently leave behind, so
+  // a malformed entry fails the run rather than being skipped.
+  testSync("a malformed entry is an error, not a skip", () =>
+    switch Reset.parseObjectStores(output([("Catalog.productImages", obj([("keyPrefix", str("x"))]))])) {
+    | Ok(_) => fail("expected a malformed entry to be refused")
+    | Error(message) => expect(message->String.includes("Catalog.productImages"))->toBe(true)
+    }
+  )
+
+  testSync("an unqualified key is an error", () =>
+    switch Reset.parseObjectStores(
+      output([("productImages", storeEntry(~bucket="alpha-stores", ~prefix="productImages"))]),
+    ) {
+    | Ok(_) => fail("expected an unqualified key to be refused")
+    | Error(message) => expect(message->String.includes("productImages"))->toBe(true)
+    }
+  )
+})
+
+describe("validateStores", () => {
+  testSync("distinct prefixes in one bucket are fine", () =>
+    expect(
+      Reset.validateStores([
+        store(~qualified="Catalog.productImages", ~bucket="alpha-stores", ~prefix="productImages"),
+        store(~qualified="Ordering.labels", ~bucket="alpha-stores", ~prefix="labels"),
+      ]),
+    )->toEqual(Ok())
+  )
+
+  // The cross-plugin collision: one prefix, two owners, nothing to tell their
+  // objects apart.
+  testSync("two plugins on one prefix are refused", () =>
+    switch Reset.validateStores([
+      store(~qualified="Catalog.productImages", ~bucket="alpha-stores", ~prefix="productImages"),
+      store(~qualified="Ordering.productImages", ~bucket="alpha-stores", ~prefix="productImages"),
+    ]) {
+    | Ok() => fail("expected a collision to be refused")
+    | Error(message) =>
+      expect(
+        message->String.includes("Catalog.productImages") &&
+          message->String.includes("Ordering.productImages"),
+      )->toBe(true)
+    }
+  )
+
+  // The same shape one level up: `Catalog` encloses `Catalog/productImages`, so
+  // wiping the first would delete the second's objects.
+  testSync("an enclosing prefix is refused", () =>
+    switch Reset.validateStores([
+      store(~qualified="Legacy.catalog", ~bucket="alpha-stores", ~prefix="Catalog"),
+      store(~qualified="Catalog.productImages", ~bucket="alpha-stores", ~prefix="Catalog/productImages"),
+    ]) {
+    | Ok() => fail("expected an enclosing prefix to be refused")
+    | Error(message) => expect(message->String.includes("encloses"))->toBe(true)
+    }
+  )
+
+  // Different buckets cannot reach each other, so an equal prefix there is not a
+  // collision — which is what the per-store layout produces in production.
+  testSync("one prefix in two different buckets is fine", () =>
+    expect(
+      Reset.validateStores([
+        store(~qualified="Catalog.productImages", ~bucket="catalog-productImages", ~prefix="productImages"),
+        store(~qualified="Ordering.productImages", ~bucket="ordering-productImages", ~prefix="productImages"),
+      ]),
+    )->toEqual(Ok())
+  )
+
+  // A shared prefix that merely starts with another's characters is not nesting:
+  // the delete prefix carries a trailing slash, so `images` cannot reach
+  // `images-archive`.
+  testSync("a sibling prefix sharing a character run is fine", () =>
+    expect(
+      Reset.validateStores([
+        store(~qualified="Catalog.images", ~bucket="alpha-stores", ~prefix="images"),
+        store(~qualified="Catalog.imagesArchive", ~bucket="alpha-stores", ~prefix="images-archive"),
+      ]),
+    )->toEqual(Ok())
+  )
+
+  testSync("an empty or slash-bearing store name is refused", () => {
+    switch Reset.validateStores([
+      store(~qualified="Catalog.productImages", ~bucket="alpha-stores", ~prefix=""),
+    ]) {
+    | Ok() => fail("expected an empty prefix to be refused")
+    | Error(_) => ()
+    }
+    switch Reset.validateStores([
+      store(~qualified="Catalog.a/b", ~bucket="alpha-stores", ~prefix="a/b"),
+    ]) {
+    | Ok() => fail("expected a store name containing a slash to be refused")
+    | Error(_) => ()
+    }
+  })
+})
+
+describe("pluginOf", () => {
+  // The `objectStores` keys carry the REGISTERED plugin name; the menu carries
+  // the operator-facing label. Attribution uses the declared name so the reset
+  // never has to guess the relation between the two.
+  testSync("prefers the declared plugin name over the label", () =>
+    expect(
+      Reset.pluginOf({projectDir: "../catalog-aws", label: "catalog", group: Domain, plugin: "Catalog"}),
+    )->toBe("Catalog")
+  )
+
+  testSync("falls back to the label when no plugin name is declared", () =>
+    expect(Reset.pluginOf({projectDir: ".", label: "platform", group: Platform}))->toBe("platform")
+  )
+})

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

@@ -0,0 +1,211 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as JestGlobals from "@reventlessdev/rescript-jest/src/JestGlobals.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as ReventlessSeedAws_Reset from "../src/ReventlessSeedAws_Reset.res.mjs";
+
+function obj(entries) {
+  return Object.fromEntries(entries);
+}
+
+function str(prim) {
+  return prim;
+}
+
+function storeEntry(bucket, prefix) {
+  return Object.fromEntries([
+    [
+      "bucketName",
+      bucket
+    ],
+    [
+      "keyPrefix",
+      prefix
+    ]
+  ]);
+}
+
+function output(entries) {
+  return Object.fromEntries(entries);
+}
+
+function store(qualified, bucket, prefix) {
+  let match = Stdlib_Option.getOr(ReventlessSeedAws_Reset.splitQualified(qualified), [
+    "",
+    qualified
+  ]);
+  return {
+    qualified: qualified,
+    plugin: match[0],
+    store: match[1],
+    bucketName: bucket,
+    keyPrefix: prefix
+  };
+}
+
+globalThis.describe("parseObjectStores", () => {
+  globalThis.test("splits the qualified key into plugin and store", () => {
+    let entries = [[
+        "Catalog.productImages",
+        storeEntry("alpha-stores", "productImages")
+      ]];
+    let other = ReventlessSeedAws_Reset.parseObjectStores(Object.fromEntries(entries));
+    if (other.TAG === "Ok") {
+      let match = other._0;
+      if (match.length === 1) {
+        let s = match[0];
+        globalThis.expect([
+          s.plugin,
+          s.store,
+          s.bucketName,
+          s.keyPrefix
+        ]).toEqual([
+          "Catalog",
+          "productImages",
+          "alpha-stores",
+          "productImages"
+        ]);
+        return;
+      }
+    }
+    JestGlobals.fail(`expected one parsed store, got ` + Stdlib_Option.getOr(JSON.stringify(other), "?"));
+  });
+  globalThis.test("splits at the first dot only", () => {
+    let match = ReventlessSeedAws_Reset.splitQualified("Catalog.product.images");
+    if (match !== undefined) {
+      globalThis.expect([
+        match[0],
+        match[1]
+      ]).toEqual([
+        "Catalog",
+        "product.images"
+      ]);
+      return;
+    } else {
+      return JestGlobals.fail("expected a split");
+    }
+  });
+  globalThis.test("absent output yields no stores", () => {
+    let stores = ReventlessSeedAws_Reset.parseObjectStores(undefined);
+    if (stores.TAG !== "Ok") {
+      return JestGlobals.fail(stores._0);
+    }
+    globalThis.expect(stores._0.length).toBe(0);
+  });
+  globalThis.test("a malformed entry is an error, not a skip", () => {
+    let entries = [[
+        "Catalog.productImages",
+        Object.fromEntries([[
+            "keyPrefix",
+            "x"
+          ]])
+      ]];
+    let message = ReventlessSeedAws_Reset.parseObjectStores(Object.fromEntries(entries));
+    if (message.TAG === "Ok") {
+      return JestGlobals.fail("expected a malformed entry to be refused");
+    }
+    globalThis.expect(message._0.includes("Catalog.productImages")).toBe(true);
+  });
+  globalThis.test("an unqualified key is an error", () => {
+    let entries = [[
+        "productImages",
+        storeEntry("alpha-stores", "productImages")
+      ]];
+    let message = ReventlessSeedAws_Reset.parseObjectStores(Object.fromEntries(entries));
+    if (message.TAG === "Ok") {
+      return JestGlobals.fail("expected an unqualified key to be refused");
+    }
+    globalThis.expect(message._0.includes("productImages")).toBe(true);
+  });
+});
+
+globalThis.describe("validateStores", () => {
+  globalThis.test("distinct prefixes in one bucket are fine", () => {
+    globalThis.expect(ReventlessSeedAws_Reset.validateStores([
+      store("Catalog.productImages", "alpha-stores", "productImages"),
+      store("Ordering.labels", "alpha-stores", "labels")
+    ])).toEqual({
+      TAG: "Ok",
+      _0: undefined
+    });
+  });
+  globalThis.test("two plugins on one prefix are refused", () => {
+    let message = ReventlessSeedAws_Reset.validateStores([
+      store("Catalog.productImages", "alpha-stores", "productImages"),
+      store("Ordering.productImages", "alpha-stores", "productImages")
+    ]);
+    if (message.TAG === "Ok") {
+      return JestGlobals.fail("expected a collision to be refused");
+    }
+    let message$1 = message._0;
+    globalThis.expect(message$1.includes("Catalog.productImages") && message$1.includes("Ordering.productImages")).toBe(true);
+  });
+  globalThis.test("an enclosing prefix is refused", () => {
+    let message = ReventlessSeedAws_Reset.validateStores([
+      store("Legacy.catalog", "alpha-stores", "Catalog"),
+      store("Catalog.productImages", "alpha-stores", "Catalog/productImages")
+    ]);
+    if (message.TAG === "Ok") {
+      return JestGlobals.fail("expected an enclosing prefix to be refused");
+    }
+    globalThis.expect(message._0.includes("encloses")).toBe(true);
+  });
+  globalThis.test("one prefix in two different buckets is fine", () => {
+    globalThis.expect(ReventlessSeedAws_Reset.validateStores([
+      store("Catalog.productImages", "catalog-productImages", "productImages"),
+      store("Ordering.productImages", "ordering-productImages", "productImages")
+    ])).toEqual({
+      TAG: "Ok",
+      _0: undefined
+    });
+  });
+  globalThis.test("a sibling prefix sharing a character run is fine", () => {
+    globalThis.expect(ReventlessSeedAws_Reset.validateStores([
+      store("Catalog.images", "alpha-stores", "images"),
+      store("Catalog.imagesArchive", "alpha-stores", "images-archive")
+    ])).toEqual({
+      TAG: "Ok",
+      _0: undefined
+    });
+  });
+  globalThis.test("an empty or slash-bearing store name is refused", () => {
+    let match = ReventlessSeedAws_Reset.validateStores([store("Catalog.productImages", "alpha-stores", "")]);
+    if (match.TAG === "Ok") {
+      JestGlobals.fail("expected an empty prefix to be refused");
+    }
+    let match$1 = ReventlessSeedAws_Reset.validateStores([store("Catalog.a/b", "alpha-stores", "a/b")]);
+    if (match$1.TAG === "Ok") {
+      return JestGlobals.fail("expected a store name containing a slash to be refused");
+    }
+  });
+});
+
+globalThis.describe("pluginOf", () => {
+  globalThis.test("prefers the declared plugin name over the label", () => {
+    globalThis.expect(ReventlessSeedAws_Reset.pluginOf({
+      projectDir: "../catalog-aws",
+      label: "catalog",
+      group: "Domain",
+      plugin: "Catalog"
+    })).toBe("Catalog");
+  });
+  globalThis.test("falls back to the label when no plugin name is declared", () => {
+    globalThis.expect(ReventlessSeedAws_Reset.pluginOf({
+      projectDir: ".",
+      label: "platform",
+      group: "Platform"
+    })).toBe("platform");
+  });
+});
+
+let Reset;
+
+export {
+  Reset,
+  obj,
+  str,
+  storeEntry,
+  output,
+  store,
+}
+/*  Not a pure module */

package/lib/ocaml/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1785535392961)
-#Done(1785535392990)
+#Start(1785624003215)
+#Done(1785624003246)

package/lib/ocaml/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"])
-  })
-})