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

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 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.342 (2026-09-08)
+
+### Bug Fixes
+
+* **aws:** the boot files a deploy rewrites in place carry no-cache ([01a4d21](https://github.com/ReventlessDev/reventless-core/commit/01a4d21a50a7890fcbd541f8a336b1333100148a))
+
+
+# 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.342",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "bin": {
@@ -15,18 +15,18 @@
     "@aws-sdk/s3-request-presigner": "3.970.0",
     "sury": "11.0.0-rc.2",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.15",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.16",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.9",
-    "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.9",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.10",
+    "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.10",
     "@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-core": "3.0.0-alpha.260",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.124",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.133",
     "@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"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.161"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/Platform.res

@@ -2321,6 +2321,11 @@ module MakeWithConfig = (
           ->JSON.stringify
         })
 
+      // `Plugin_Stack.cacheControlFor`'s rule, for this file and the two below:
+      // the content changes across deploys while the URL does not, so without it
+      // CloudFront and the browser serve the previous deploy's answer.
+      let bootFileCacheControl = Pulumi.Input.make("no-cache")
+
       let _ = PulumiAws.S3.BucketObject.make(
         ~name="host-ui-config-json",
         ~args={
@@ -2328,6 +2333,7 @@ module MakeWithConfig = (
           key: Pulumi.Input.make("config.json"),
           content: configJsonContent->Pulumi.Output.asInput,
           contentType: Pulumi.Input.make("application/json"),
+          cacheControl: bootFileCacheControl,
         },
       )
 
@@ -2350,6 +2356,7 @@ module MakeWithConfig = (
             key: Pulumi.Input.make("ui-hints.json"),
             content: Pulumi.Input.make(hintsContent),
             contentType: Pulumi.Input.make("application/json"),
+            cacheControl: bootFileCacheControl,
           },
         )
       }
@@ -2386,6 +2393,7 @@ module MakeWithConfig = (
             key: Pulumi.Input.make(ReventlessCore.Platform_UiSlots.fileName),
             content: Pulumi.Input.make(slotsContent),
             contentType: Pulumi.Input.make("application/javascript; charset=utf-8"),
+            cacheControl: bootFileCacheControl,
           },
         )
       }

package/src/Platform.res.mjs

@@ -1251,11 +1251,13 @@ function MakeWithConfig(Config) {
           ]) : computed;
         return JSON.stringify(Util_ShellConfig$ReventlessAws.fields(withEvents, hostUiBundle.viewModes, hostUiBundle.bakedManifest, hostUiBundle.uiSlotsFile, hostUiBundle.shellConfig));
       });
+      let bootFileCacheControl = "no-cache";
       new (Aws.s3.BucketObject)("host-ui-config-json", {
         bucket: bucketName,
         key: "config.json",
         content: configJsonContent,
-        contentType: "application/json"
+        contentType: "application/json",
+        cacheControl: bootFileCacheControl
       });
       let hintsPath = hostUiBundle.uiHintsFile;
       if (hintsPath !== undefined) {
@@ -1264,7 +1266,8 @@ function MakeWithConfig(Config) {
           bucket: bucketName,
           key: "ui-hints.json",
           content: hintsContent,
-          contentType: "application/json"
+          contentType: "application/json",
+          cacheControl: bootFileCacheControl
         });
       }
       let slotsPath = hostUiBundle.uiSlotsFile;
@@ -1274,7 +1277,8 @@ function MakeWithConfig(Config) {
           bucket: bucketName,
           key: Platform_UiSlots$ReventlessCore.fileName,
           content: slotsContent,
-          contentType: "application/javascript; charset=utf-8"
+          contentType: "application/javascript; charset=utf-8",
+          cacheControl: bootFileCacheControl
         });
       }
       let match$9 = hostUiBundle.bakedManifest;
@@ -2623,11 +2627,13 @@ function Make($star) {
           ]) : computed;
         return JSON.stringify(Util_ShellConfig$ReventlessAws.fields(withEvents, hostUiBundle.viewModes, hostUiBundle.bakedManifest, hostUiBundle.uiSlotsFile, hostUiBundle.shellConfig));
       });
+      let bootFileCacheControl = "no-cache";
       new (Aws.s3.BucketObject)("host-ui-config-json", {
         bucket: bucketName,
         key: "config.json",
         content: configJsonContent,
-        contentType: "application/json"
+        contentType: "application/json",
+        cacheControl: bootFileCacheControl
       });
       let hintsPath = hostUiBundle.uiHintsFile;
       if (hintsPath !== undefined) {
@@ -2636,7 +2642,8 @@ function Make($star) {
           bucket: bucketName,
           key: "ui-hints.json",
           content: hintsContent,
-          contentType: "application/json"
+          contentType: "application/json",
+          cacheControl: bootFileCacheControl
         });
       }
       let slotsPath = hostUiBundle.uiSlotsFile;
@@ -2646,7 +2653,8 @@ function Make($star) {
           bucket: bucketName,
           key: Platform_UiSlots$ReventlessCore.fileName,
           content: slotsContent,
-          contentType: "application/javascript; charset=utf-8"
+          contentType: "application/javascript; charset=utf-8",
+          cacheControl: bootFileCacheControl
         });
       }
       let match$9 = hostUiBundle.bakedManifest;

package/src/adapter/Api/Platform_ComponentDefinitions_Lambda_Ops.res

@@ -645,6 +645,11 @@ let runBake = async (
         key,
         body: AwsSdk.S3.PutObjectCommand.bodyFromString(body),
         contentType: "application/json",
+        // Stable-named, rewritten in place every deploy — `Plugin_Stack.cacheControlFor`'s
+        // rule. This file needs it most: it is written AFTER the deploy's `/*`
+        // invalidation, so nothing else dislodges a stale copy, and a shell
+        // holding one queries fields the API no longer has.
+        cacheControl: "no-cache",
       })->AwsSdk.S3.PutObjectCommand.send
       let report = Dict.fromArray([
         ("baked", JSON.Encode.bool(true)),

package/src/adapter/Api/Platform_ComponentDefinitions_Lambda_Ops.res.mjs

@@ -550,7 +550,8 @@ async function runBake(target, structures) {
       Bucket: target.bucket,
       Key: key,
       Body: body,
-      ContentType: "application/json"
+      ContentType: "application/json",
+      CacheControl: "no-cache"
     }));
     let report = Object.fromEntries([
       [

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 */