@reventlessdev/reventless-seed-aws 1.0.0-alpha.10

package/lib/bs/tests/EndpointResolutionTest.res

@@ -0,0 +1,83 @@
+// 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. 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.
+let clearOverrides = () =>
+  [
+    "REVENTLESS_GRAPHQL_ENDPOINT",
+    "AWS_REGION",
+    "COGNITO_CLIENT_ID",
+    "SEED_SKIP_UPLOADS",
+  ]->Array.forEach(k => NodeProcess.env->Dict.set(k, ""))
+
+let obj = entries => JSON.Encode.object(entries->Dict.fromArray)
+let str = JSON.Encode.string
+
+let config = (~extra: array<(string, JSON.t)>) =>
+  obj(
+    Array.concat(
+      [
+        ("apiEndpoint", str("https://api.example/graphql")),
+        ("region", str("eu-west-1")),
+        ("cognitoClientId", str("client-abc")),
+      ],
+      extra,
+    ),
+  )
+
+let outputs = (~extra: array<(string, JSON.t)>) =>
+  obj(
+    Array.concat(
+      [
+        ("domainApiEndpoint", str("https://domain.example/graphql")),
+        ("cognitoRegion", str("eu-west-1")),
+        ("cognitoUserPoolClientId", str("client-abc")),
+      ],
+      extra,
+    ),
+  )
+
+describe("endpointsFrom — host shell arm", () => {
+  beforeEach(clearOverrides)
+
+  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)
+
+  testSync("prefers the merged API endpoint over the per-plugin one", () => {
+    let eps = ReventlessSeedAws.endpointsFrom(
+      ~stack="pr-verify",
+      StackOutputs(outputs(~extra=[("domainMergedApiEndpoint", str("https://merged.example/"))])),
+    )
+    expect(eps.graphql)->toBe("https://merged.example/")
+  })
+
+  testSync("fails naming both keys when the stack exports neither API endpoint", () =>
+    switch ReventlessSeedAws.endpointsFrom(
+      ~stack="pr-verify",
+      StackOutputs(obj([("cognitoRegion", str("eu-west-1"))])),
+    ) {
+    | _ => fail("expected endpointsFrom to fail")
+    | exception Seed.Failed(msg) =>
+      expect(msg)->toContain("domainMergedApiEndpoint")
+      expect(msg)->toContain("domainApiEndpoint")
+    }
+  )
+})

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

@@ -0,0 +1,115 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as JestGlobals from "@reventlessdev/rescript-jest/src/JestGlobals.res.mjs";
+import * as ReventlessSeedAws from "../src/ReventlessSeedAws.res.mjs";
+import * as Seed$ReventlessSeed from "@reventlessdev/reventless-seed/src/Seed.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+function clearOverrides() {
+  [
+    "REVENTLESS_GRAPHQL_ENDPOINT",
+    "AWS_REGION",
+    "COGNITO_CLIENT_ID",
+    "SEED_SKIP_UPLOADS"
+  ].forEach(k => {
+    process.env[k] = "";
+  });
+}
+
+function obj(entries) {
+  return Object.fromEntries(entries);
+}
+
+function str(prim) {
+  return prim;
+}
+
+function config(extra) {
+  return Object.fromEntries([
+    [
+      "apiEndpoint",
+      "https://api.example/graphql"
+    ],
+    [
+      "region",
+      "eu-west-1"
+    ],
+    [
+      "cognitoClientId",
+      "client-abc"
+    ]
+  ].concat(extra));
+}
+
+function outputs(extra) {
+  return Object.fromEntries([
+    [
+      "domainApiEndpoint",
+      "https://domain.example/graphql"
+    ],
+    [
+      "cognitoRegion",
+      "eu-west-1"
+    ],
+    [
+      "cognitoUserPoolClientId",
+      "client-abc"
+    ]
+  ].concat(extra));
+}
+
+globalThis.describe("endpointsFrom — host shell arm", () => {
+  globalThis.beforeEach(clearOverrides);
+  globalThis.test("reads the GraphQL endpoint from the shell config", () => {
+    let eps = ReventlessSeedAws.endpointsFrom("alpha", {
+      TAG: "HostShellConfig",
+      _0: config([])
+    });
+    globalThis.expect(eps.graphql).toBe("https://api.example/graphql");
+  });
+});
+
+globalThis.describe("endpointsFrom — stack outputs arm", () => {
+  globalThis.beforeEach(clearOverrides);
+  globalThis.test("prefers the merged API endpoint over the per-plugin one", () => {
+    let eps = ReventlessSeedAws.endpointsFrom("pr-verify", {
+      TAG: "StackOutputs",
+      _0: outputs([[
+          "domainMergedApiEndpoint",
+          "https://merged.example/"
+        ]])
+    });
+    globalThis.expect(eps.graphql).toBe("https://merged.example/");
+  });
+  globalThis.test("fails naming both keys when the stack exports neither API endpoint", () => {
+    let val;
+    try {
+      val = ReventlessSeedAws.endpointsFrom("pr-verify", {
+        TAG: "StackOutputs",
+        _0: Object.fromEntries([[
+            "cognitoRegion",
+            "eu-west-1"
+          ]])
+      });
+    } catch (raw_msg) {
+      let msg = Primitive_exceptions.internalToException(raw_msg);
+      if (msg.RE_EXN_ID === Seed$ReventlessSeed.Failed) {
+        let msg$1 = msg._1;
+        globalThis.expect(msg$1).toContain("domainMergedApiEndpoint");
+        globalThis.expect(msg$1).toContain("domainApiEndpoint");
+        return;
+      }
+      throw msg;
+    }
+    JestGlobals.fail("expected endpointsFrom to fail");
+  });
+});
+
+export {
+  clearOverrides,
+  obj,
+  str,
+  config,
+  outputs,
+}
+/*  Not a pure module */

package/lib/bs/tests/ObjectStoreReconcileTest.res

@@ -0,0 +1,84 @@
+// The half of reconciliation that decides whether an object is referenced.
+//
+// Everything else in the report is counting; `collectRefs` is the judgement, and
+// it is judgement in one direction only. A ref it misses turns a live object
+// into an "unreferenced, tagged pending" row — which is the row an operator
+// reads as permission to enable an expiry rule. A ref it collects too eagerly
+// only ever leaves an object alive.
+//
+// So these tests are about reach: nesting, arrays, records, and the prefix
+// boundary that separates one store from another.
+
+open JestGlobals
+
+module Reconcile = ReventlessSeedAws_Reconcile
+
+let prefix = "Catalog/productImages"
+let refIn = "/Catalog/productImages/user-1/uuid/photo.png"
+let refOther = "/Ordering/receipts/user-1/uuid/r.pdf"
+
+let collect = (json: JSON.t): array<string> => {
+  let out = Set.make()
+  Reconcile.collectRefs(~prefix, json, out)
+  out->Set.toArray
+}
+
+let obj = (fields: array<(string, JSON.t)>) => fields->Dict.fromArray->JSON.Encode.object
+
+describe("ReventlessSeedAws_Reconcile.collectRefs", () => {
+  testSync("finds a ref on a top-level field", () =>
+    expect(collect(obj([("imageUrl", JSON.Encode.string(refIn))])))->toEqual([refIn])
+  )
+
+  // Deliberately not declaration-driven: the claim component reads `@storageRef`
+  // annotations, so a report reading the same list would inherit the same blind
+  // spot and agree precisely where both are wrong. An unannotated field holding a
+  // ref has to show up here, as the thing to fix before expiry goes on.
+  testSync("finds a ref on a field no annotation would have named", () =>
+    expect(collect(obj([("someUndeclaredField", JSON.Encode.string(refIn))])))->toEqual([refIn])
+  )
+
+  testSync("finds refs inside an array", () =>
+    expect(collect(obj([("images", JSON.Encode.array([JSON.Encode.string(refIn)]))])))->toEqual([
+      refIn,
+    ])
+  )
+
+  testSync("finds a ref nested inside a record", () =>
+    expect(collect(obj([("variant", obj([("photo", JSON.Encode.string(refIn))]))])))->toEqual([refIn])
+  )
+
+  // Store isolation: one bucket holds several stores under distinct prefixes, so
+  // a reconciliation scoped to one store must not count another's refs — that
+  // would mark a genuinely abandoned object as referenced and hide it forever.
+  testSync("ignores a ref belonging to another store", () =>
+    expect(collect(obj([("receipt", JSON.Encode.string(refOther))])))->toEqual([])
+  )
+
+  // The prefix boundary is a path segment, not a string prefix.
+  testSync("ignores a store whose name merely starts the same way", () =>
+    expect(
+      collect(obj([("x", JSON.Encode.string("/Catalog/productImagesArchive/u/i/p.png"))])),
+    )->toEqual([])
+  )
+
+  testSync("ignores strings that are not refs at all", () =>
+    expect(
+      collect(
+        obj([
+          ("name", JSON.Encode.string("A product")),
+          ("external", JSON.Encode.string("https://example.com/Catalog/productImages/p.png")),
+          ("count", JSON.Encode.int(3)),
+        ]),
+      ),
+    )->toEqual([])
+  )
+
+  testSync("collects each distinct ref once", () => {
+    let json = obj([
+      ("a", JSON.Encode.string(refIn)),
+      ("b", JSON.Encode.string(refIn)),
+    ])
+    expect(collect(json)->Array.length)->toBe(1)
+  })
+})

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

@@ -0,0 +1,102 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as ReventlessSeedAws_Reconcile from "../src/ReventlessSeedAws_Reconcile.res.mjs";
+
+let prefix = "Catalog/productImages";
+
+let refIn = "/Catalog/productImages/user-1/uuid/photo.png";
+
+let refOther = "/Ordering/receipts/user-1/uuid/r.pdf";
+
+function collect(json) {
+  let out = new Set();
+  ReventlessSeedAws_Reconcile.collectRefs(prefix, json, out);
+  return Array.from(out);
+}
+
+function obj(fields) {
+  return Object.fromEntries(fields);
+}
+
+globalThis.describe("ReventlessSeedAws_Reconcile.collectRefs", () => {
+  globalThis.test("finds a ref on a top-level field", () => {
+    globalThis.expect(collect(Object.fromEntries([[
+        "imageUrl",
+        refIn
+      ]]))).toEqual([refIn]);
+  });
+  globalThis.test("finds a ref on a field no annotation would have named", () => {
+    globalThis.expect(collect(Object.fromEntries([[
+        "someUndeclaredField",
+        refIn
+      ]]))).toEqual([refIn]);
+  });
+  globalThis.test("finds refs inside an array", () => {
+    globalThis.expect(collect(Object.fromEntries([[
+        "images",
+        [refIn]
+      ]]))).toEqual([refIn]);
+  });
+  globalThis.test("finds a ref nested inside a record", () => {
+    globalThis.expect(collect(Object.fromEntries([[
+        "variant",
+        Object.fromEntries([[
+            "photo",
+            refIn
+          ]])
+      ]]))).toEqual([refIn]);
+  });
+  globalThis.test("ignores a ref belonging to another store", () => {
+    globalThis.expect(collect(Object.fromEntries([[
+        "receipt",
+        refOther
+      ]]))).toEqual([]);
+  });
+  globalThis.test("ignores a store whose name merely starts the same way", () => {
+    globalThis.expect(collect(Object.fromEntries([[
+        "x",
+        "/Catalog/productImagesArchive/u/i/p.png"
+      ]]))).toEqual([]);
+  });
+  globalThis.test("ignores strings that are not refs at all", () => {
+    globalThis.expect(collect(Object.fromEntries([
+      [
+        "name",
+        "A product"
+      ],
+      [
+        "external",
+        "https://example.com/Catalog/productImages/p.png"
+      ],
+      [
+        "count",
+        3
+      ]
+    ]))).toEqual([]);
+  });
+  globalThis.test("collects each distinct ref once", () => {
+    let json = Object.fromEntries([
+      [
+        "a",
+        refIn
+      ],
+      [
+        "b",
+        refIn
+      ]
+    ]);
+    globalThis.expect(collect(json).length).toBe(1);
+  });
+});
+
+let Reconcile;
+
+export {
+  Reconcile,
+  prefix,
+  refIn,
+  refOther,
+  collect,
+  obj,
+}
+/*  Not a pure module */

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")
+  )
+})