@reventlessdev/reventless-aws 3.0.0-alpha.336 → 3.0.0-alpha.338

package/tests/Util_ShellConfigTest.res

@@ -81,6 +81,48 @@ describe("Util_ShellConfig.fields — bakedManifest", () => {
   })
 })
 
+// The seam's two halves meet here. The deploy writes the module as an object and
+// names it with this key, and the shell imports nothing when the key is absent —
+// so a deploy that wrote the file without naming it would ship a module nothing
+// fetches, and the surface would draw its own regions exactly as it does when no
+// slots were declared. There is no symptom to notice, which is why it is pinned.
+describe("Util_ShellConfig.fields — uiSlotsFile", () => {
+  testSync("unset ⇒ no uiSlotsUrl, and the shell imports nothing", () => {
+    let out = Util_ShellConfig.fields(~computed)
+    expect(out->Dict.get("uiSlotsUrl")->Option.isNone)->toBe(true)
+  })
+
+  testSync("declared ⇒ the URL the deploy writes the module to", () => {
+    let out = Util_ShellConfig.fields(~computed, ~uiSlotsFile="/src/storefront-slots.js")
+    expect(out->get("uiSlotsUrl"))->toEqual(JSON.Encode.string("/ui-slots.js"))
+  })
+
+  // The declared path is where the file is *authored*; the URL is where it is
+  // *served*. Publishing the author's path would name a file no browser can
+  // reach, and on a laptop it would name someone's home directory.
+  testSync("names where the file is served, never where it was authored", () => {
+    let out = Util_ShellConfig.fields(~computed, ~uiSlotsFile="/home/me/prj/slots.js")
+    expect(out->get("uiSlotsUrl"))->toEqual(JSON.Encode.string("/ui-slots.js"))
+  })
+
+  testSync("a shellConfig uiSlotsUrl fails the deploy rather than redirecting it", () => {
+    let failure = try {
+      let _ = Util_ShellConfig.fields(
+        ~computed,
+        ~uiSlotsFile="/src/storefront-slots.js",
+        ~shellConfig=Dict.fromArray([("uiSlotsUrl", JSON.Encode.string("/elsewhere.js"))]),
+      )
+      None
+    } catch {
+    | Failure(message) => Some(message)
+    }
+    switch failure {
+    | Some(message) => expect(message->String.includes("uiSlotsUrl"))->toBe(true)
+    | None => fail("a shellConfig key redirecting the computed slots module must fail the deploy")
+    }
+  })
+})
+
 // ── Journeys ──────────────────────────────────────────────────────────────
 //
 // One curated surface per audience, beside the default one. The property under

package/tests/Util_ShellConfigTest.res.mjs

@@ -27,7 +27,7 @@ function get(out, key) {
 
 globalThis.describe("Util_ShellConfig.fields — viewModes", () => {
   globalThis.test("unset ⇒ no viewModes key and the computed set is untouched", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined);
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, undefined);
     globalThis.expect(Object.keys(out)).toEqual([
       "apiEndpoint",
       "region"
@@ -38,7 +38,7 @@ globalThis.describe("Util_ShellConfig.fields — viewModes", () => {
     let out = Util_ShellConfig$ReventlessAws.fields(computed, [{
         TAG: "Map",
         _0: {}
-      }], undefined, undefined);
+      }], undefined, undefined, undefined);
     globalThis.expect(get(out, "viewModes")).toEqual(["map"]);
     globalThis.expect(Stdlib_Option.isNone(out["mapStyle"])).toBe(true);
   });
@@ -56,7 +56,7 @@ globalThis.describe("Util_ShellConfig.fields — viewModes", () => {
           layout: "dagre"
         }
       }
-    ], undefined, undefined);
+    ], undefined, undefined, undefined);
     globalThis.expect(get(out, "viewModes")).toEqual([
       "map",
       "graph"
@@ -76,21 +76,21 @@ globalThis.describe("Util_ShellConfig.fields — bakedManifest", () => {
     key: key
   });
   globalThis.test("unset ⇒ no manifestUrl, so every caller keeps the admin path", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined);
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, undefined);
     globalThis.expect(Stdlib_Option.isNone(out["manifestUrl"])).toBe(true);
   });
   globalThis.test("declared ⇒ the URL the deploy writes the file to", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, bake(undefined), undefined);
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, bake(undefined), undefined, undefined);
     globalThis.expect(get(out, "manifestUrl")).toEqual("/component-manifest.json");
   });
   globalThis.test("follows a renamed bake", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, bake("storefront.json"), undefined);
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, bake("storefront.json"), undefined, undefined);
     globalThis.expect(get(out, "manifestUrl")).toEqual("/storefront.json");
   });
   globalThis.test("a shellConfig manifestUrl fails the deploy rather than redirecting it", () => {
     let failure;
     try {
-      Util_ShellConfig$ReventlessAws.fields(computed, undefined, bake(undefined), Object.fromEntries([[
+      Util_ShellConfig$ReventlessAws.fields(computed, undefined, bake(undefined), undefined, Object.fromEntries([[
           "manifestUrl",
           "/elsewhere.json"
         ]]));
@@ -112,6 +112,44 @@ globalThis.describe("Util_ShellConfig.fields — bakedManifest", () => {
   });
 });
 
+globalThis.describe("Util_ShellConfig.fields — uiSlotsFile", () => {
+  globalThis.test("unset ⇒ no uiSlotsUrl, and the shell imports nothing", () => {
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, undefined);
+    globalThis.expect(Stdlib_Option.isNone(out["uiSlotsUrl"])).toBe(true);
+  });
+  globalThis.test("declared ⇒ the URL the deploy writes the module to", () => {
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, "/src/storefront-slots.js", undefined);
+    globalThis.expect(get(out, "uiSlotsUrl")).toEqual("/ui-slots.js");
+  });
+  globalThis.test("names where the file is served, never where it was authored", () => {
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, "/home/me/prj/slots.js", undefined);
+    globalThis.expect(get(out, "uiSlotsUrl")).toEqual("/ui-slots.js");
+  });
+  globalThis.test("a shellConfig uiSlotsUrl fails the deploy rather than redirecting it", () => {
+    let failure;
+    try {
+      Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, "/src/storefront-slots.js", Object.fromEntries([[
+          "uiSlotsUrl",
+          "/elsewhere.js"
+        ]]));
+      failure = undefined;
+    } catch (raw_message) {
+      let message = Primitive_exceptions.internalToException(raw_message);
+      if (message.RE_EXN_ID === "Failure") {
+        failure = message._1;
+      } else {
+        throw message;
+      }
+    }
+    if (failure !== undefined) {
+      globalThis.expect(failure.includes("uiSlotsUrl")).toBe(true);
+      return;
+    } else {
+      return JestGlobals.fail("a shellConfig key redirecting the computed slots module must fail the deploy");
+    }
+  });
+});
+
 globalThis.describe("Util_ShellConfig.fields — journeys", () => {
   let withJourneys = journeys => ({
     components: [{
@@ -148,22 +186,22 @@ globalThis.describe("Util_ShellConfig.fields — journeys", () => {
           views: ["Products"],
           commands: []
         }]
-    }, undefined);
+    }, undefined, undefined);
     globalThis.expect(Stdlib_Option.isNone(out["journeyManifestUrls"])).toBe(true);
   });
   globalThis.test("an empty journeys array is the same as none", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, withJourneys([]), undefined);
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, withJourneys([]), undefined, undefined);
     globalThis.expect(Stdlib_Option.isNone(out["journeyManifestUrls"])).toBe(true);
   });
   globalThis.test("keeps manifestUrl as the default journey", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, withJourneys([shopper]), undefined);
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, withJourneys([shopper]), undefined, undefined);
     globalThis.expect(get(out, "manifestUrl")).toEqual("/component-manifest.json");
   });
   globalThis.test("maps each declared group to its own file", () => {
     let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, withJourneys([
       shopper,
       fulfilment
-    ]), undefined);
+    ]), undefined, undefined);
     globalThis.expect(get(out, "journeyManifestUrls")).toEqual(Object.fromEntries([
       [
         "Shopper",
@@ -180,14 +218,14 @@ globalThis.describe("Util_ShellConfig.fields — journeys", () => {
       shopper,
       fulfilment
     ]);
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, bake, undefined);
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, bake, undefined, undefined);
     let published = Stdlib_Option.mapOr(Stdlib_JSON.Decode.string(get(out, "manifestUrl")), [], url => [url]).concat(Stdlib_Array.filterMap(Object.values(Stdlib_Option.getOr(Stdlib_JSON.Decode.object(get(out, "journeyManifestUrls")), {})), Stdlib_JSON.Decode.string));
     globalThis.expect(published).toEqual(Platform_BakedManifest$ReventlessCore.files(bake).map(param => "/" + param[0]));
   });
   globalThis.test("a shellConfig journey map fails the deploy rather than redirecting it", () => {
     let failure;
     try {
-      Util_ShellConfig$ReventlessAws.fields(computed, undefined, withJourneys([shopper]), Object.fromEntries([[
+      Util_ShellConfig$ReventlessAws.fields(computed, undefined, withJourneys([shopper]), undefined, Object.fromEntries([[
           "journeyManifestUrls",
           {}
         ]]));
@@ -211,7 +249,7 @@ globalThis.describe("Util_ShellConfig.fields — journeys", () => {
 
 globalThis.describe("Util_ShellConfig.fields — shellConfig passthrough", () => {
   globalThis.test("shell-owned keys land verbatim, under the computed ones", () => {
-    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, Object.fromEntries([
+    let out = Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, Object.fromEntries([
       [
         "platformName",
         "Online Shop"
@@ -232,7 +270,7 @@ globalThis.describe("Util_ShellConfig.fields — shellConfig passthrough", () =>
   globalThis.test("a key the deploy computes fails the deploy, naming it", () => {
     let failure;
     try {
-      Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, Object.fromEntries([[
+      Util_ShellConfig$ReventlessAws.fields(computed, undefined, undefined, undefined, Object.fromEntries([[
           "apiEndpoint",
           "https://wrong.example/graphql"
         ]]));

package/tests/util/Util_AlarmSpecTest.res

@@ -0,0 +1,109 @@
+open JestGlobals
+
+module M = ReventlessCore.Monitoring
+module A = Util_AlarmSpec
+
+describe("Util_AlarmSpec", () => {
+  testSync("every kind alarms on Errors by default", () => {
+    [M.CommandHandler, Projection, Reactor, EventCollector, Task, Other("Counter")]->Array.forEach(
+      kind => {
+        let specs = A.forKind(~kind)
+        expect(specs->Array.length)->toBe(1)
+        let spec = specs->Array.getUnsafe(0)
+        expect(spec.metricName)->toBe("Errors")
+        expect(spec.comparisonOperator)->toBe("GreaterThanOrEqualToThreshold")
+        // An idle stack publishes no datapoints, and "no traffic" must not read as
+        // a failure — an alarm permanently in ALARM teaches everyone to ignore it.
+        expect(spec.treatMissingData)->toBe("notBreaching")
+      },
+    )
+  })
+
+  // The handler fails on every delivery on purpose, so Errors says only that it is
+  // doing its job. That it ran at all is the incident.
+  testSync("a dead-letter sink alarms on Invocations, not Errors", () => {
+    let specs = A.forKind(~kind=DeadLetterSink)
+    expect(specs->Array.length)->toBe(1)
+    expect((specs->Array.getUnsafe(0)).metricName)->toBe("Invocations")
+  })
+
+  // The case that went unnoticed on a deployed estate: a heartbeat that stops
+  // emits no errors AND no invocations, so nothing an Errors alarm can see.
+  testSync("a scheduler also alarms on its own silence, and that alarm treats missing data as breaching", () => {
+    let specs = A.forKind(~kind=Scheduler, ~silenceWindowSeconds=1800)
+    expect(specs->Array.length)->toBe(2)
+
+    let silence = specs->Array.getUnsafe(1)
+    expect(silence.metricName)->toBe("Invocations")
+    expect(silence.comparisonOperator)->toBe("LessThanThreshold")
+    expect(silence.period)->toBe(1800)
+    expect(silence.treatMissingData)->toBe("breaching")
+    // Distinct suffix, or the two alarms would collide on one resource name.
+    expect(silence.suffix)->toBe("Silent")
+    expect(silence.meaning)->toBe("has not run for 30 minutes")
+  })
+
+  testSync("the silence window defaults to an hour — twelve missed heartbeats", () => {
+    let silence = A.forKind(~kind=Scheduler)->Array.getUnsafe(1)
+    expect(silence.period)->toBe(3600)
+  })
+
+  testSync("resource names separate a unit's alarms, and like-named components of different plugins", () => {
+    let specs = A.forKind(~kind=Scheduler)
+    let nameFor = (spec: A.t, ~plugin) =>
+      A.resourceName(~kind=Scheduler, ~name="Heartbeat", ~plugin, ~suffix=spec.suffix)
+
+    expect(nameFor(specs->Array.getUnsafe(0), ~plugin=Some("Catalog")))->toBe(
+      "alarm-scheduler-Catalog-Heartbeat",
+    )
+    expect(nameFor(specs->Array.getUnsafe(1), ~plugin=Some("Catalog")))->toBe(
+      "alarm-scheduler-Catalog-HeartbeatSilent",
+    )
+    // Two plugins can own like-named components; without the plugin these collide.
+    expect(nameFor(specs->Array.getUnsafe(0), ~plugin=Some("Ordering")))->toBe(
+      "alarm-scheduler-Ordering-Heartbeat",
+    )
+    // Platform substrate belongs to no plugin.
+    expect(
+      A.resourceName(~kind=DeadLetterSink, ~name="DeadLetterQueue", ~plugin=None, ~suffix=""),
+    )->toBe("alarm-deadlettersink-DeadLetterQueue")
+  })
+
+  // A state-change message carries the description and neither the tags nor the
+  // name, so everything a reader or a parser needs has to be in this one string.
+  testSync("the description names the unit for a person and carries a machine token", () => {
+    let spec = A.forKind(~kind=CommandHandler)->Array.getUnsafe(0)
+    let desc = A.description(
+      ~kind=CommandHandler,
+      ~name="AllAggregatesCmdHandler",
+      ~plugin=Some("Ordering"),
+      ~platform=Some("online-shop"),
+      ~spec,
+      ~logs=Some("/aws/lambda/online-shop-AllAggregatesCmdHandler"),
+    )
+    expect(desc->String.includes("'AllAggregatesCmdHandler' (plugin Ordering, platform online-shop)"))->toBe(true)
+    expect(desc->String.includes("Logs: /aws/lambda/online-shop-AllAggregatesCmdHandler."))->toBe(true)
+    expect(
+      desc->String.includes(
+        "[reventless plugin=Ordering platform=online-shop component=AllAggregatesCmdHandler kind=commandhandler]",
+      ),
+    )->toBe(true)
+  })
+
+  testSync("a unit owned by no plugin claims none, and one with no logs promises no address", () => {
+    let spec = A.forKind(~kind=DeadLetterSink)->Array.getUnsafe(0)
+    let desc = A.description(
+      ~kind=DeadLetterSink,
+      ~name="DeadLetterQueue",
+      ~plugin=None,
+      ~platform=None,
+      ~spec,
+      ~logs=None,
+    )
+    // A dead-letter queue is shared by every plugin in the estate — naming one
+    // would be a lie, and an empty parenthesis is noise.
+    expect(desc->String.includes("(plugin"))->toBe(false)
+    expect(desc->String.includes("Logs:"))->toBe(false)
+    expect(desc->String.includes("kind=deadlettersink"))->toBe(true)
+  })
+})

package/tests/util/Util_AlarmSpecTest.res.mjs

@@ -0,0 +1,78 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Util_AlarmSpec$ReventlessAws from "../../src/util/Util_AlarmSpec.res.mjs";
+
+globalThis.describe("Util_AlarmSpec", () => {
+  globalThis.test("every kind alarms on Errors by default", () => {
+    [
+      "CommandHandler",
+      "Projection",
+      "Reactor",
+      "EventCollector",
+      "Task",
+      {
+        TAG: "Other",
+        _0: "Counter"
+      }
+    ].forEach(kind => {
+      let specs = Util_AlarmSpec$ReventlessAws.forKind(kind, undefined);
+      globalThis.expect(specs.length).toBe(1);
+      let spec = specs[0];
+      globalThis.expect(spec.metricName).toBe("Errors");
+      globalThis.expect(spec.comparisonOperator).toBe("GreaterThanOrEqualToThreshold");
+      globalThis.expect(spec.treatMissingData).toBe("notBreaching");
+    });
+  });
+  globalThis.test("a dead-letter sink alarms on Invocations, not Errors", () => {
+    let specs = Util_AlarmSpec$ReventlessAws.forKind("DeadLetterSink", undefined);
+    globalThis.expect(specs.length).toBe(1);
+    globalThis.expect(specs[0].metricName).toBe("Invocations");
+  });
+  globalThis.test("a scheduler also alarms on its own silence, and that alarm treats missing data as breaching", () => {
+    let specs = Util_AlarmSpec$ReventlessAws.forKind("Scheduler", 1800);
+    globalThis.expect(specs.length).toBe(2);
+    let silence = specs[1];
+    globalThis.expect(silence.metricName).toBe("Invocations");
+    globalThis.expect(silence.comparisonOperator).toBe("LessThanThreshold");
+    globalThis.expect(silence.period).toBe(1800);
+    globalThis.expect(silence.treatMissingData).toBe("breaching");
+    globalThis.expect(silence.suffix).toBe("Silent");
+    globalThis.expect(silence.meaning).toBe("has not run for 30 minutes");
+  });
+  globalThis.test("the silence window defaults to an hour — twelve missed heartbeats", () => {
+    let silence = Util_AlarmSpec$ReventlessAws.forKind("Scheduler", undefined)[1];
+    globalThis.expect(silence.period).toBe(3600);
+  });
+  globalThis.test("resource names separate a unit's alarms, and like-named components of different plugins", () => {
+    let specs = Util_AlarmSpec$ReventlessAws.forKind("Scheduler", undefined);
+    let nameFor = (spec, plugin) => Util_AlarmSpec$ReventlessAws.resourceName("Scheduler", "Heartbeat", plugin, spec.suffix);
+    globalThis.expect(nameFor(specs[0], "Catalog")).toBe("alarm-scheduler-Catalog-Heartbeat");
+    globalThis.expect(nameFor(specs[1], "Catalog")).toBe("alarm-scheduler-Catalog-HeartbeatSilent");
+    globalThis.expect(nameFor(specs[0], "Ordering")).toBe("alarm-scheduler-Ordering-Heartbeat");
+    globalThis.expect(Util_AlarmSpec$ReventlessAws.resourceName("DeadLetterSink", "DeadLetterQueue", undefined, "")).toBe("alarm-deadlettersink-DeadLetterQueue");
+  });
+  globalThis.test("the description names the unit for a person and carries a machine token", () => {
+    let spec = Util_AlarmSpec$ReventlessAws.forKind("CommandHandler", undefined)[0];
+    let desc = Util_AlarmSpec$ReventlessAws.description("CommandHandler", "AllAggregatesCmdHandler", "Ordering", "online-shop", spec, "/aws/lambda/online-shop-AllAggregatesCmdHandler");
+    globalThis.expect(desc.includes("'AllAggregatesCmdHandler' (plugin Ordering, platform online-shop)")).toBe(true);
+    globalThis.expect(desc.includes("Logs: /aws/lambda/online-shop-AllAggregatesCmdHandler.")).toBe(true);
+    globalThis.expect(desc.includes("[reventless plugin=Ordering platform=online-shop component=AllAggregatesCmdHandler kind=commandhandler]")).toBe(true);
+  });
+  globalThis.test("a unit owned by no plugin claims none, and one with no logs promises no address", () => {
+    let spec = Util_AlarmSpec$ReventlessAws.forKind("DeadLetterSink", undefined)[0];
+    let desc = Util_AlarmSpec$ReventlessAws.description("DeadLetterSink", "DeadLetterQueue", undefined, undefined, spec, undefined);
+    globalThis.expect(desc.includes("(plugin")).toBe(false);
+    globalThis.expect(desc.includes("Logs:")).toBe(false);
+    globalThis.expect(desc.includes("kind=deadlettersink")).toBe(true);
+  });
+});
+
+let M;
+
+let A;
+
+export {
+  M,
+  A,
+}
+/*  Not a pure module */