@reventlessdev/reventless-aws 3.0.0-alpha.304 → 3.0.0-alpha.306

package/tests/Util_LambdaEnvBudgetTest.res

@@ -0,0 +1,78 @@
+// Guards the deploy-time check on a Lambda's 4KB environment.
+//
+// The check exists because the limit is enforced by AWS mid-`pulumi up`, on a
+// call that names a byte count and not the field that grew. The two cases worth
+// pinning are the ones that decide whether a deploy proceeds: an exact total
+// already over the limit must stop it, and an over-limit total that only appears
+// once the unresolved queue-URL vars are estimated must not — a wrong estimate
+// blocking a good deploy would be worse than the failure it prevents.
+
+open JestGlobals
+
+let budget = Util_LambdaEnvBudget.limit
+
+let throws = (f: unit => 'a): option<string> =>
+  try {
+    let _ = f()
+    None
+  } catch {
+  | exn => exn->JsExn.fromException->Option.flatMap(JsExn.message)
+  }
+
+describe("Util_LambdaEnvBudget.check", () => {
+  testSync("passes a small environment", () => {
+    let msg = throws(() =>
+      Util_LambdaEnvBudget.check(~lambdaName="Small", ~handlerConfigJson=`{"queueUrl":"q"}`)
+    )
+    expect(msg)->toEqual(None)
+  })
+
+  testSync("throws when HANDLER_CONFIG alone exceeds the limit", () => {
+    let big = `{"x":"` ++ String.repeat("a", budget) ++ `"}`
+    let msg = throws(() => Util_LambdaEnvBudget.check(~lambdaName="TooBig", ~handlerConfigJson=big))
+    expect(msg->Option.isSome)->toBe(true)
+    // Names the Lambda and points at the fix, not just the byte count.
+    expect(msg->Option.mapOr(false, m => m->String.includes("TooBig")))->toBe(true)
+    expect(msg->Option.mapOr(false, m => m->String.includes("extraStringAssets")))->toBe(true)
+  })
+
+  testSync("counts the queue-URL var names toward the exact total", () => {
+    // Sized so HANDLER_CONFIG alone fits and the var NAMES alone push it over —
+    // the names are known at check time, so this must throw rather than warn.
+    let keys = Array.make(~length=40, "")->Array.mapWithIndex((_, i) =>
+      `PTA_AVeryLongAggregateNameNumber${i->Int.toString}_QUEUE_URL`
+    )
+    let keyBytes = keys->Array.reduce(0, (acc, k) => acc + String.length(k))
+    let fixed = Util_LambdaEnvBudget.frameworkVarsBytes + String.length("HANDLER_CONFIG")
+    // Just past the limit on the exact total alone — the names are enough.
+    let json = String.repeat("a", budget - fixed - keyBytes + 1)
+    let msg = throws(() =>
+      Util_LambdaEnvBudget.check(
+        ~lambdaName="ManyTargets",
+        ~handlerConfigJson=json,
+        ~outputValuedKeys=keys,
+      )
+    )
+    expect(msg->Option.isSome)->toBe(true)
+  })
+
+  testSync("only estimating over the limit warns rather than throwing", () => {
+    // Exact total sits under the limit; it is the per-URL allowance that crosses
+    // it. The deploy must be allowed to proceed and find out.
+    let keys = Array.make(~length=20, "")->Array.mapWithIndex((_, i) => `PTA_A${i->Int.toString}_URL`)
+    let exact =
+      Util_LambdaEnvBudget.frameworkVarsBytes +
+      String.length("HANDLER_CONFIG") +
+      keys->Array.reduce(0, (acc, k) => acc + String.length(k))
+    let room = budget - exact - 100
+    let json = String.repeat("a", room)
+    let msg = throws(() =>
+      Util_LambdaEnvBudget.check(
+        ~lambdaName="Estimated",
+        ~handlerConfigJson=json,
+        ~outputValuedKeys=keys,
+      )
+    )
+    expect(msg)->toEqual(None)
+  })
+})

package/tests/Util_LambdaEnvBudgetTest.res.mjs

@@ -0,0 +1,55 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Util_LambdaEnvBudget$ReventlessAws from "../src/util/Util_LambdaEnvBudget.res.mjs";
+
+function throws(f) {
+  try {
+    f();
+    return;
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    return Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message);
+  }
+}
+
+globalThis.describe("Util_LambdaEnvBudget.check", () => {
+  globalThis.test("passes a small environment", () => {
+    let msg = throws(() => Util_LambdaEnvBudget$ReventlessAws.check("Small", `{"queueUrl":"q"}`, undefined));
+    globalThis.expect(msg).toEqual(undefined);
+  });
+  globalThis.test("throws when HANDLER_CONFIG alone exceeds the limit", () => {
+    let big = `{"x":"` + "a".repeat(Util_LambdaEnvBudget$ReventlessAws.limit) + `"}`;
+    let msg = throws(() => Util_LambdaEnvBudget$ReventlessAws.check("TooBig", big, undefined));
+    globalThis.expect(Stdlib_Option.isSome(msg)).toBe(true);
+    globalThis.expect(Stdlib_Option.mapOr(msg, false, m => m.includes("TooBig"))).toBe(true);
+    globalThis.expect(Stdlib_Option.mapOr(msg, false, m => m.includes("extraStringAssets"))).toBe(true);
+  });
+  globalThis.test("counts the queue-URL var names toward the exact total", () => {
+    let keys = Stdlib_Array.make(40, "").map((param, i) => `PTA_AVeryLongAggregateNameNumber` + i.toString() + `_QUEUE_URL`);
+    let keyBytes = Stdlib_Array.reduce(keys, 0, (acc, k) => acc + k.length | 0);
+    let fixed = Util_LambdaEnvBudget$ReventlessAws.frameworkVarsBytes + "HANDLER_CONFIG".length | 0;
+    let json = "a".repeat(((Util_LambdaEnvBudget$ReventlessAws.limit - fixed | 0) - keyBytes | 0) + 1 | 0);
+    let msg = throws(() => Util_LambdaEnvBudget$ReventlessAws.check("ManyTargets", json, keys));
+    globalThis.expect(Stdlib_Option.isSome(msg)).toBe(true);
+  });
+  globalThis.test("only estimating over the limit warns rather than throwing", () => {
+    let keys = Stdlib_Array.make(20, "").map((param, i) => `PTA_A` + i.toString() + `_URL`);
+    let exact = (Util_LambdaEnvBudget$ReventlessAws.frameworkVarsBytes + "HANDLER_CONFIG".length | 0) + Stdlib_Array.reduce(keys, 0, (acc, k) => acc + k.length | 0) | 0;
+    let room = (Util_LambdaEnvBudget$ReventlessAws.limit - exact | 0) - 100 | 0;
+    let json = "a".repeat(room);
+    let msg = throws(() => Util_LambdaEnvBudget$ReventlessAws.check("Estimated", json, keys));
+    globalThis.expect(msg).toEqual(undefined);
+  });
+});
+
+let budget = Util_LambdaEnvBudget$ReventlessAws.limit;
+
+export {
+  budget,
+  throws,
+}
+/*  Not a pure module */

package/tests/integration/AggregateEntryPoint_IntegrationTest.res

@@ -11,7 +11,7 @@
 // CommandAccepted -> Lambda:Unhandled.
 //
 // This is also the harness that unblocks moving the Aggregate functor wiring
-// behind a typed core (docs/plans/minimize-lambda-entrypoint-mjs-shell.md,
+// behind a typed core (docs/plans/done/minimize-lambda-entrypoint-mjs-shell.md,
 // Tier 2.5): with it green, that refactor is verifiable end-to-end rather than
 // only at compile time. Boots via the same Docker-gated
 // `pnpm run test:integration` suite as the storage-runtime tests.

package/tests/integration/DcbCommandTopicEntryPoint_IntegrationTest.res

@@ -161,7 +161,7 @@ describe("DcbCommandTopicEntryPoint integration", () => {
   )
 
   // Residual composite-fence burst contention
-  // (docs/plans/dcb-composite-fence-residual-burst-contention.md).
+  // (docs/plans/done/dcb-composite-fence-residual-burst-contention.md).
   //
   // The entry point must derive `partitionTag = Composite(...)` and thread it
   // into the DynamoDB `append`, so a `@compositePartitionTag` slice collapses to

package/tests/integration/DcbEventLogStorage_DynamoDb_IntegrationTest.res

@@ -331,7 +331,7 @@ describe("DCB DynamoDb integration — optimistic concurrency primitives", () =>
 // on the WHOLE composite key, not on each member. Distinct entities sharing a
 // low-cardinality prefix (environment/platformName/pluginName) must therefore NOT
 // serialize on that prefix — the deploy-fan-out hot-fence regression. Plan:
-// docs/plans/Backlog/dcb-hot-tag-fence-contention.md § "Root-cause correction".
+// docs/plans/done/dcb-hot-tag-fence-contention.md § "Root-cause correction".
 describe("DCB DynamoDb integration — composite partition hot-fence fix", () => {
   let composite = (keys, seps): Reventless.DcbTag.derivedPartitionTag => Composite({keys, seps})
   let specKeys = ["environment", "platformName", "pluginName", "resourceName"]
@@ -464,7 +464,7 @@ describe("DCB DynamoDb integration — per-type fence granularity", () => {
 // DynamoDB used to reject the whole append: `tag_<key>` is a GSI hash key and a key
 // attribute cannot hold an empty string. The adapter now skips that one attribute,
 // leaving the index sparse — everything else about the event is unchanged.
-// See docs/plans/dcb-empty-tag-values-break-append.md.
+// See docs/plans/done/dcb-empty-tag-values-break-append.md.
 describe("DCB DynamoDb integration — an empty tag value does not break the append", () => {
   let tags = [tag("orderId", "O-empty"), tag("customerId", "")]