@reventlessdev/reventless-aws 3.0.0-alpha.291 → 3.0.0-alpha.293

package/tests/Platform_ComponentDefinitions_Lambda_OpsTest.res

@@ -240,3 +240,113 @@ describe("bakeSelection", () => {
     expect(sel(`{"views": ["Orders"]}`)->Option.isNone)->toBe(true)
   )
 })
+
+// The bake reads a read model the deploy updates asynchronously, so "is this the
+// deployment I was asked to bake" is a question it has to be able to answer. The
+// answer is an equality check against the key each plugin stack just wrote.
+describe("pendingRegistrations", () => {
+  let row = (~name, ~key=?, ()) => {
+    let item = Dict.fromArray([("name", JSON.Encode.string(name))])
+    key->Option.forEach(k =>
+      item->Dict.set(
+        "structure",
+        JSON.parseOrThrow(`{"$offload": {"store": "pluginStructures", "key": "${k}"}}`),
+      )
+    )
+    item
+  }
+
+  let pending = (rows, expect) =>
+    Platform_ComponentDefinitions_Lambda_Ops.pendingRegistrations(
+      rows,
+      ~expect=Dict.fromArray(expect),
+    )
+
+  testSync("nothing is pending when every row carries the key the deploy wrote", () =>
+    expect(
+      pending(
+        [row(~name="Catalog", ~key="sha256/a", ()), row(~name="Ordering", ~key="sha256/b", ())],
+        [("Catalog", "sha256/a"), ("Ordering", "sha256/b")],
+      ),
+    )->toEqual([])
+  )
+
+  // The window this exists for: the stack wrote a new structure, the row still
+  // points at the one before it.
+  testSync("names a plugin still carrying the previous structure", () =>
+    expect(
+      pending(
+        [row(~name="Catalog", ~key="sha256/a", ()), row(~name="Ordering", ~key="sha256/old", ())],
+        [("Catalog", "sha256/a"), ("Ordering", "sha256/new")],
+      ),
+    )->toEqual(["Ordering"])
+  )
+
+  // A plugin that has never registered is behind, not absent — baking without it
+  // would ship a shop missing a section.
+  testSync("names a plugin with no row at all", () =>
+    expect(pending([], [("Ordering", "sha256/new")]))->toEqual(["Ordering"])
+  )
+
+  // Deployed before the stack exported its key, or invoked by hand: bake what is
+  // current rather than wait for an expectation nobody stated.
+  testSync("waits for nothing when the caller expects nothing", () =>
+    expect(pending([row(~name="Ordering", ~key="sha256/old", ())], []))->toEqual([])
+  )
+
+  testSync("reads the expectations off the invocation payload", () =>
+    expect(
+      Platform_ComponentDefinitions_Lambda_Ops.bakeExpectations(
+        JSON.parseOrThrow(`{"bake": true, "expect": {"Ordering": "sha256/b"}}`),
+      )->Dict.get("Ordering"),
+    )->toEqual(Some("sha256/b"))
+  )
+})
+
+describe("resolveStructure", () => {
+  let item = (structure: string) =>
+    Dict.fromArray([
+      ("name", JSON.Encode.string("Ordering")),
+      ("structure", JSON.parseOrThrow(structure)),
+    ])
+
+  let offloaded = `{"$offload": {"store": "pluginStructures", "key": "sha256/abc", "bytes": 4}}`
+
+  test("substitutes the fetched bytes for the reference", async () => {
+    let resolved = await Platform_ComponentDefinitions_Lambda_Ops.resolveStructure(
+      _ => Promise.resolve(`{"aggregates": []}`),
+      item(offloaded),
+    )
+    expect(resolved->Dict.get("structure")->Option.map(j => JSON.stringify(j)))->toEqual(
+      Some(`{"aggregates":[]}`),
+    )
+  })
+
+  // One offload bucket serves every plugin, so the S3 error names only the key —
+  // which plugin's row carries the unreadable reference is the part worth having.
+  // A missing object is the shape a deploy leaves behind while the read model
+  // still points at the previous structure.
+  test("names the plugin whose reference cannot be read", async () => {
+    let failed = await Platform_ComponentDefinitions_Lambda_Ops.resolveStructure(
+      _ => Promise.reject(JsExn.anyToExnInternal(JsError.make("AccessDenied"))),
+      item(offloaded),
+    )
+    ->Promise.thenResolve(_ => None)
+    ->Promise.catch(e =>
+      Promise.resolve(e->JsExn.fromException->Option.flatMap(JsExn.message))
+    )
+    expect(failed)->toEqual(
+      Some("offloaded structure for plugin Ordering is unreadable at sha256/abc: AccessDenied"),
+    )
+  })
+
+  test("passes an inline structure through untouched", async () => {
+    let resolved = await Platform_ComponentDefinitions_Lambda_Ops.resolveStructure(
+      _ => Promise.reject(JsExn.anyToExnInternal(JsError.make("must not fetch"))),
+      item(`{"aggregates": []}`),
+    )
+    expect(resolved->Dict.get("structure")->Option.map(j => JSON.stringify(j)))->toEqual(
+      Some(`{"aggregates":[]}`),
+    )
+  })
+})

package/tests/Platform_ComponentDefinitions_Lambda_OpsTest.res.mjs

@@ -2,7 +2,10 @@
 
 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_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws from "../src/adapter/Api/Platform_ComponentDefinitions_Lambda_Ops.res.mjs";
 
 function entry(filter, structure) {
@@ -151,6 +154,90 @@ globalThis.describe("bakeSelection", () => {
   });
 });
 
+globalThis.describe("pendingRegistrations", () => {
+  let row = (name, key, param) => {
+    let item = Object.fromEntries([[
+        "name",
+        name
+      ]]);
+    Stdlib_Option.forEach(key, k => {
+      item["structure"] = JSON.parse(`{"$offload": {"store": "pluginStructures", "key": "` + k + `"}}`);
+    });
+    return item;
+  };
+  globalThis.test("nothing is pending when every row carries the key the deploy wrote", () => {
+    let rows = [
+      row("Catalog", "sha256/a", undefined),
+      row("Ordering", "sha256/b", undefined)
+    ];
+    globalThis.expect(Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.pendingRegistrations(rows, Object.fromEntries([
+      [
+        "Catalog",
+        "sha256/a"
+      ],
+      [
+        "Ordering",
+        "sha256/b"
+      ]
+    ]))).toEqual([]);
+  });
+  globalThis.test("names a plugin still carrying the previous structure", () => {
+    let rows = [
+      row("Catalog", "sha256/a", undefined),
+      row("Ordering", "sha256/old", undefined)
+    ];
+    globalThis.expect(Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.pendingRegistrations(rows, Object.fromEntries([
+      [
+        "Catalog",
+        "sha256/a"
+      ],
+      [
+        "Ordering",
+        "sha256/new"
+      ]
+    ]))).toEqual(["Ordering"]);
+  });
+  globalThis.test("names a plugin with no row at all", () => {
+    globalThis.expect(Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.pendingRegistrations([], Object.fromEntries([[
+        "Ordering",
+        "sha256/new"
+      ]]))).toEqual(["Ordering"]);
+  });
+  globalThis.test("waits for nothing when the caller expects nothing", () => {
+    let rows = [row("Ordering", "sha256/old", undefined)];
+    globalThis.expect(Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.pendingRegistrations(rows, Object.fromEntries([]))).toEqual([]);
+  });
+  globalThis.test("reads the expectations off the invocation payload", () => {
+    globalThis.expect(Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.bakeExpectations(JSON.parse(`{"bake": true, "expect": {"Ordering": "sha256/b"}}`))["Ordering"]).toEqual("sha256/b");
+  });
+});
+
+globalThis.describe("resolveStructure", () => {
+  let item = structure => Object.fromEntries([
+    [
+      "name",
+      "Ordering"
+    ],
+    [
+      "structure",
+      JSON.parse(structure)
+    ]
+  ]);
+  let offloaded = `{"$offload": {"store": "pluginStructures", "key": "sha256/abc", "bytes": 4}}`;
+  globalThis.test("substitutes the fetched bytes for the reference", async () => {
+    let resolved = await Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.resolveStructure(param => Promise.resolve(`{"aggregates": []}`), item(offloaded));
+    globalThis.expect(Stdlib_Option.map(resolved["structure"], j => JSON.stringify(j))).toEqual(`{"aggregates":[]}`);
+  });
+  globalThis.test("names the plugin whose reference cannot be read", async () => {
+    let failed = await Stdlib_Promise.$$catch(Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.resolveStructure(param => Promise.reject(Primitive_exceptions.internalToException(new Error("AccessDenied"))), item(offloaded)).then(param => {}), e => Promise.resolve(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(e), Stdlib_JsExn.message)));
+    globalThis.expect(failed).toEqual("offloaded structure for plugin Ordering is unreadable at sha256/abc: AccessDenied");
+  });
+  globalThis.test("passes an inline structure through untouched", async () => {
+    let resolved = await Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.resolveStructure(param => Promise.reject(Primitive_exceptions.internalToException(new Error("must not fetch"))), item(`{"aggregates": []}`));
+    globalThis.expect(Stdlib_Option.map(resolved["structure"], j => JSON.stringify(j))).toEqual(`{"aggregates":[]}`);
+  });
+});
+
 export {
   entry,
   members,