@reventlessdev/reventless-aws 3.0.0-alpha.340 → 3.0.0-alpha.341

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.341 (2026-09-08)
+
+### Bug Fixes
+
+* **aws:** the readiness gate waits for the collector's update, not its record ([c5a1d27](https://github.com/ReventlessDev/reventless-core/commit/c5a1d273be2c499bf1d1297a416d2cf6fce85ccf))
+
+
 # 3.0.0-alpha.340 (2026-09-08)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.340",
+  "version": "3.0.0-alpha.341",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "bin": {
@@ -17,15 +17,15 @@
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.15",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-node": "2.0.0-alpha.9",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.9",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
     "@reventlessdev/reventless-core": "3.0.0-alpha.259",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.160",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.35",
     "@reventlessdev/reventless-postgres": "3.0.0-alpha.123",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.160",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.132"
   },
   "devDependencies": {

package/src/plugin/runtime/PluginRuntime_Builder.res

@@ -677,7 +677,13 @@ module Make = (
       ~opts,
     )
 
-    eventCollectorReadyRef := runtime.parts.lambda->Pulumi.Output.apply(_ => ())
+    // Through an output property, not the resource. `apply` receives the Function
+    // record as soon as the outer Output carries it — at construction, fields
+    // still unresolved — so discarding it reported ready mid-update, and the
+    // re-detect reached a Lambda still serving the previous bundle. `flatMap`
+    // returns the Output itself, which Pulumi awaits.
+    eventCollectorReadyRef :=
+      runtime.parts.lambda->Pulumi.Output.flatMap(fn => fn.arn)->Pulumi.Output.apply(_ => ())
 
     // Admin-only cross-plugin SNS subscription permissions. The admin EC
     // Lambda's manageSubscriptions hook (Phase 3 Step 1) creates SNS

package/src/plugin/runtime/PluginRuntime_Builder.res.mjs

@@ -2,6 +2,7 @@
 
 import * as Aws from "@pulumi/aws";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Pulumi from "@pulumi/pulumi";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
@@ -413,7 +414,7 @@ function Make(EventCollectorChannel) {
         eventTopics: eventTopics,
         resources: resources
       }], runtime, opts);
-    eventCollectorReadyRef.contents = runtime.parts.lambda.apply(param => {});
+    eventCollectorReadyRef.contents = Output$Pulumi.flatMap(runtime.parts.lambda, fn => fn.arn).apply(param => {});
     let isAdminEventCollector = Stdlib_Option.isNone(Plugin_Helpers$ReventlessCore.eventCollectorContextRef.contents[name]);
     if (isAdminEventCollector) {
       new (Aws.iam.RolePolicy)(name + `-snsManageSubs`, {

package/tests/EventCollectorReadyGateTest.res

@@ -0,0 +1,89 @@
+open JestGlobals
+
+// Guards what `eventCollectorReadyRef` waits for.
+//
+// The deploy publishes a synthetic re-detect once the EventCollector Lambda is
+// ready, because that Lambda is what ANSWERS the handshake: reached while it is
+// still serving the previous bundle, it replies with the previous definition,
+// Connect sees a definition it already holds and emits nothing, and the
+// registration keeps the old structure — with no second re-detect coming.
+//
+// The gate used to be `lambda->Output.apply(_ => ())`. `apply` receives the
+// Function record as soon as the OUTER Output carries it, which is at
+// construction, with every field inside still an unresolved Output — so the gate
+// settled while the update was in flight and the whole barrier was inert. No
+// deploy-shaped test catches it: the answer is only stale when a deploy changes a
+// structure, and the race is won more often than it is lost.
+//
+// So this asserts the barrier directly — the gate must not settle until the
+// resource's own outputs do.
+
+// The engine's Output constructor, so a field can be left genuinely pending
+// rather than faked. A resolved promise would settle on the next tick either
+// way, which is the difference under test.
+@module("@pulumi/pulumi") @new
+external makeOutput: (
+  Set.t<unit>,
+  promise<'a>,
+  promise<bool>,
+  promise<bool>,
+  promise<Set.t<unit>>,
+) => Pulumi.Output.t<'a> = "Output"
+
+let pending = (value: 'a): (Pulumi.Output.t<'a>, unit => unit) => {
+  let settle = ref(() => ())
+  let p = Promise.make((resolve, _) => settle := () => resolve(value))
+  (
+    makeOutput(Set.make(), p, Promise.resolve(true), Promise.resolve(false), Promise.resolve(Set.make())),
+    settle.contents,
+  )
+}
+
+let ticks = async () => await Promise.make((resolve, _) => {
+  let _ = setTimeout(() => resolve(), 50)
+})
+
+// A Lambda mid-update: the resource record exists, its outputs do not yet.
+let deploying = (): (Pulumi.Output.t<PulumiAws.Lambda.Function.t>, unit => unit) => {
+  let (arn, complete) = pending("arn:aws:lambda:eu-west-1:123456789012:function:CatalogPluginEventColl")
+  let fn: PulumiAws.Lambda.Function.t = {
+    arn,
+    id: "CatalogPluginEventColl"->Pulumi.Output.make,
+    name: "CatalogPluginEventColl"->Pulumi.Output.make,
+    invokeArn: "arn:aws:apigateway:invoke"->Pulumi.Output.make,
+  }
+  // `apply` preserves the nested Outputs, which is how the real resource arrives.
+  (()->Pulumi.Output.make->Pulumi.Output.apply(_ => fn), complete)
+}
+
+let observe = (gate: Pulumi.Output.t<unit>): ref<bool> => {
+  let settled = ref(false)
+  let _ = gate->Pulumi.Output.apply(_ => settled := true)
+  settled
+}
+
+describe("the EventCollector readiness gate", () => {
+  testAsync("does not settle while the function's outputs are still pending", async () => {
+    let (lambda, _complete) = deploying()
+    let settled = lambda->Pulumi.Output.flatMap(fn => fn.arn)->Pulumi.Output.apply(_ => ())->observe
+    await ticks()
+    expect(settled.contents)->toBe(false)
+  })
+
+  testAsync("settles once they resolve", async () => {
+    let (lambda, complete) = deploying()
+    let settled = lambda->Pulumi.Output.flatMap(fn => fn.arn)->Pulumi.Output.apply(_ => ())->observe
+    complete()
+    await ticks()
+    expect(settled.contents)->toBe(true)
+  })
+
+  // The shape that shipped, kept as the reason the one above is written the way it
+  // is: applying to the resource settles against a Lambda still being updated.
+  testAsync("settles immediately when taken off the resource instead", async () => {
+    let (lambda, _complete) = deploying()
+    let settled = lambda->Pulumi.Output.apply(_ => ())->observe
+    await ticks()
+    expect(settled.contents)->toBe(true)
+  })
+})

package/tests/EventCollectorReadyGateTest.res.mjs

@@ -0,0 +1,81 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+import * as Pulumi from "@pulumi/pulumi";
+
+function pending(value) {
+  let settle = {
+    contents: () => {}
+  };
+  let p = new Promise((resolve, param) => {
+    settle.contents = () => resolve(value);
+  });
+  return [
+    new Pulumi.Output(new Set(), p, Promise.resolve(true), Promise.resolve(false), Promise.resolve(new Set())),
+    settle.contents
+  ];
+}
+
+async function ticks() {
+  return await new Promise((resolve, param) => {
+    setTimeout(() => resolve(), 50);
+  });
+}
+
+function deploying() {
+  let match = pending("arn:aws:lambda:eu-west-1:123456789012:function:CatalogPluginEventColl");
+  let fn_arn = match[0];
+  let fn_id = Pulumi.output("CatalogPluginEventColl");
+  let fn_name = Pulumi.output("CatalogPluginEventColl");
+  let fn_invokeArn = Pulumi.output("arn:aws:apigateway:invoke");
+  let fn = {
+    arn: fn_arn,
+    id: fn_id,
+    name: fn_name,
+    invokeArn: fn_invokeArn
+  };
+  return [
+    Pulumi.output().apply(() => fn),
+    match[1]
+  ];
+}
+
+function observe(gate) {
+  let settled = {
+    contents: false
+  };
+  gate.apply(() => {
+    settled.contents = true;
+  });
+  return settled;
+}
+
+globalThis.describe("the EventCollector readiness gate", () => {
+  globalThis.test("does not settle while the function's outputs are still pending", async () => {
+    let match = deploying();
+    let settled = observe(Output$Pulumi.flatMap(match[0], fn => fn.arn).apply(param => {}));
+    await ticks();
+    globalThis.expect(settled.contents).toBe(false);
+  });
+  globalThis.test("settles once they resolve", async () => {
+    let match = deploying();
+    let settled = observe(Output$Pulumi.flatMap(match[0], fn => fn.arn).apply(param => {}));
+    match[1]();
+    await ticks();
+    globalThis.expect(settled.contents).toBe(true);
+  });
+  globalThis.test("settles immediately when taken off the resource instead", async () => {
+    let match = deploying();
+    let settled = observe(match[0].apply(param => {}));
+    await ticks();
+    globalThis.expect(settled.contents).toBe(true);
+  });
+});
+
+export {
+  pending,
+  ticks,
+  deploying,
+  observe,
+}
+/*  Not a pure module */