@reventlessdev/reventless-aws 3.0.0-alpha.422 → 3.0.0-alpha.424

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 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.424 (2026-11-06)
+
+### Bug Fixes
+
+* **deps:** update sury to 11.1.0 ([512bc78](https://github.com/ReventlessDev/reventless-core/commit/512bc78da92c03664fa52fb3ab32df65f5e49b19))
+
+
+# 3.0.0-alpha.423 (2026-11-05)
+
+### Bug Fixes
+
+* **aws:** a line logged outside its invocation's fiber still names the plugin ([8e6f553](https://github.com/ReventlessDev/reventless-core/commit/8e6f553cc8ac2e439862bf1f3636ac86a4a22137))
+* **aws:** an extension's lines name its extension point once ([b448c59](https://github.com/ReventlessDev/reventless-core/commit/b448c5976feafd7d49ae8c04a67dcfbb72e973b5))
+
+
 # 3.0.0-alpha.422 (2026-11-05)
 
 **Note:** Version bump only for package @reventlessdev/reventless-aws

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.422",
+  "version": "3.0.0-alpha.424",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "bin": {
@@ -19,26 +19,26 @@
     "@aws-sdk/client-location": "3.970.0",
     "@aws-sdk/client-s3": "3.970.0",
     "@aws-sdk/s3-request-presigner": "3.970.0",
-    "sury": "11.0.0",
+    "sury": "11.1.0",
     "uuid": "^13.0.0",
     "yaml": "^2.8.3",
     "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.39",
     "@reventlessdev/rescript-effect": "1.0.0-alpha.1",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.26",
-    "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.39",
+    "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.40",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.13",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.26",
     "@reventlessdev/rescript-pulumi-pulumi": "3.0.0-alpha.0",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.1",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.331",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.224",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.43",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.195",
     "@reventlessdev/rescript-web": "1.0.0-alpha.8",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.223",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.42",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.194",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.193",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.329"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.195"
   },
   "devDependencies": {
     "rescript": "12.3.1",
-    "sury-ppx": "11.0.0"
+    "sury-ppx": "11.1.0"
   },
   "peerDependencies": {
     "rescript": "^12.3.1"

package/scripts/DeployApp.res

@@ -495,22 +495,30 @@ let outputString = (outputs: dict<Automation.outputValue>, name: string): option
 /** The stack's own accounts file beside the platform, started from the app's
     template, or `None` when the app has no template — then there is nothing to
     create. Per stack because the file records the ids one pool minted: sharing
-    `accounts.yaml` would overwrite another deployment's record of its accounts. A stack deployed
-    before the file was renamed keeps its `users.<stack>.yaml` until it is renamed. */
+    `accounts.yaml` would overwrite another deployment's record of its accounts. */
 let accountsFileName = stack => `accounts.${stack}.yaml`
-let oldAccountsFileName = stack => `users.${stack}.yaml`
 
-let accountsFile = (~platformDir: string, ~stack: string): option<string> => {
-  let file = {
-    let current = NodePath.join([platformDir, ".reventless", accountsFileName(stack)])
-    let old = NodePath.join([platformDir, ".reventless", oldAccountsFileName(stack)])
-    if !NodeFs.existsSync(current) && NodeFs.existsSync(old) {
-      Manifest.noticeOldName(old)
-      old
-    } else {
-      current
-    }
+let _accountsPath = (~platformDir, ~stack) =>
+  NodePath.join([platformDir, ".reventless", accountsFileName(stack)])
+
+/** The refusal when the stack's record or the template is still under its old name. Checked
+    before deploying: copying the template over a record left as `users.<stack>.yaml` would
+    lose the ids its pool minted. */
+let oldAccountsNameLeft = (~platformDir: string, ~stack: string): option<string> =>
+  switch Manifest.oldNameLeft(
+    ~current=_accountsPath(~platformDir, ~stack),
+    ~old=NodePath.join([platformDir, ".reventless", `users.${stack}.yaml`]),
+  ) {
+  | Some(_) as refusal => refusal
+  | None =>
+    Manifest.oldNameLeft(
+      ~current=NodePath.join([platformDir, Manifest.templateName]),
+      ~old=NodePath.join([platformDir, Manifest.oldTemplateName]),
+    )
   }
+
+let accountsFile = (~platformDir: string, ~stack: string): option<string> => {
+  let file = _accountsPath(~platformDir, ~stack)
   let template = Manifest.templateIn(platformDir)
   switch (NodeFs.existsSync(file), NodeFs.existsSync(template)) {
   | (false, false) => None
@@ -533,7 +541,12 @@ let signInLines = (entries: array<Manifest.entry>): array<string> => {
 // ── up / down ────────────────────────────────────────────────────────────────
 
 let up = async (~manifest: DeployManifest.resolved, ~stack: string): result<unit, string> =>
-  switch projectsOf(manifest) {
+  switch projectsOf(manifest)->Result.flatMap(((platform, _) as projects) =>
+    switch oldAccountsNameLeft(~platformDir=platform.dir, ~stack) {
+    | Some(refusal) => Error(refusal)
+    | None => Ok(projects)
+    }
+  ) {
   | Error(_) as e => e
   | Ok((platform, plugins)) =>
     switch await check(~projects=[platform]->Array.concat(plugins)) {

package/scripts/DeployApp.res.mjs

@@ -614,14 +614,21 @@ function accountsFileName(stack) {
   return `accounts.` + stack + `.yaml`;
 }
 
-function oldAccountsFileName(stack) {
-  return `users.` + stack + `.yaml`;
+function _accountsPath(platformDir, stack) {
+  return Nodepath.join(platformDir, ".reventless", accountsFileName(stack));
+}
+
+function oldAccountsNameLeft(platformDir, stack) {
+  let refusal = AccountsManifest$Reventless.oldNameLeft(_accountsPath(platformDir, stack), Nodepath.join(platformDir, ".reventless", `users.` + stack + `.yaml`));
+  if (refusal !== undefined) {
+    return refusal;
+  } else {
+    return AccountsManifest$Reventless.oldNameLeft(Nodepath.join(platformDir, AccountsManifest$Reventless.templateName), Nodepath.join(platformDir, AccountsManifest$Reventless.oldTemplateName));
+  }
 }
 
 function accountsFile(platformDir, stack) {
-  let current = Nodepath.join(platformDir, ".reventless", accountsFileName(stack));
-  let old = Nodepath.join(platformDir, ".reventless", oldAccountsFileName(stack));
-  let file = !Nodefs.existsSync(current) && Nodefs.existsSync(old) ? (AccountsManifest$Reventless.noticeOldName(old), old) : current;
+  let file = _accountsPath(platformDir, stack);
   let template = AccountsManifest$Reventless.templateIn(platformDir);
   let match = Nodefs.existsSync(file);
   let match$1 = Nodefs.existsSync(template);
@@ -645,7 +652,20 @@ function signInLines(entries) {
 }
 
 async function up(manifest, stack) {
-  let e = projectsOf(manifest);
+  let e = Stdlib_Result.flatMap(projectsOf(manifest), projects => {
+    let refusal = oldAccountsNameLeft(projects[0].dir, stack);
+    if (refusal !== undefined) {
+      return {
+        TAG: "Error",
+        _0: refusal
+      };
+    } else {
+      return {
+        TAG: "Ok",
+        _0: projects
+      };
+    }
+  });
   if (e.TAG !== "Ok") {
     return e;
   }
@@ -952,7 +972,8 @@ export {
   deploy,
   outputString,
   accountsFileName,
-  oldAccountsFileName,
+  _accountsPath,
+  oldAccountsNameLeft,
   accountsFile,
   signInLines,
   up,

package/src/adapter/Runtime/EventCollectorEntryPoint.mjs

@@ -218,7 +218,7 @@ async function buildHandler() {
     };
     const transformedMapping = extensionMappingMake(fullMapping);
     const mappingsModule = {
-      name: ext.name,
+      name: Ops.mappingsName(ext),
       moduleUrl: ext.mappingsModule,
       mappings: [transformedMapping],
     };

package/src/adapter/Runtime/EventCollectorEntryPoint_Ops.res

@@ -561,6 +561,16 @@ let extensionPublishDicts = (names: queueUrlNames, ext: extensionConfig): extens
   {publishToAggregates: resolve(ext.aggregateNames, names.publishToAggregates)}
 }
 
+/** The name an extension's mappings carry, as at deploy: its plugin's. The config names the
+    extension component, `<extension point>.<plugin>`, and `Extension_Operations` prefixes the
+    extension point itself. */
+let mappingsName = (ext: extensionConfig): string => {
+  let prefix = ext.extensionPointName ++ "."
+  ext.name->String.startsWith(prefix)
+    ? ext.name->String.slice(~start=prefix->String.length, ~end=ext.name->String.length)
+    : ext.name
+}
+
 let warnSkippedExtension = (ext: extensionConfig) =>
   logWarn(
     `extension '${ext.name}' missing module specifier(s); skipping. specModule=${ext.specModule}, mappingsModule=${ext.mappingsModule}, delegateModule=${ext.delegateModule}`,

package/src/adapter/Runtime/EventCollectorEntryPoint_Ops.res.mjs

@@ -445,6 +445,15 @@ function extensionPublishDicts(names, ext) {
   };
 }
 
+function mappingsName(ext) {
+  let prefix = ext.extensionPointName + ".";
+  if (ext.name.startsWith(prefix)) {
+    return ext.name.slice(prefix.length, ext.name.length);
+  } else {
+    return ext.name;
+  }
+}
+
 function warnSkippedExtension(ext) {
   HandlerFactoryHelpersMjs.log.warn(`extension '` + ext.name + `' missing module specifier(s); skipping. specModule=` + ext.specModule + `, mappingsModule=` + ext.mappingsModule + `, delegateModule=` + ext.delegateModule, {
     comp: "EventCollectorEntryPoint"
@@ -592,6 +601,7 @@ export {
   makePublishJsons,
   buildPublishToAggregates,
   extensionPublishDicts,
+  mappingsName,
   warnSkippedExtension,
   assetPath,
   loadPluginDefinition,

package/src/adapter/Runtime/HandlerFactoryHelpers.mjs

@@ -6,6 +6,7 @@ import {
   tag as requestContextTag,
   fromOptions as makeRequestContext,
 } from "@reventlessdev/reventless-core/src/RequestContext.res.mjs";
+import { currentPluginName } from "@reventlessdev/reventless-spec/src/LogPrefix.res.mjs";
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClient, ScanCommand } from "@aws-sdk/lib-dynamodb";
 
@@ -120,6 +121,19 @@ export function runEffect(effect, opts = {}) {
   // Only annotate a redelivery. A constant "1" on every line is noise, and its
   // absence is what makes `filter retryCount > 1` a usable query.
   if (retryCount > 1) e = e.pipe(Effect.annotateLogs("retryCount", String(retryCount)));
+  // A line run on a fiber of its own (`->Effect.runSync`) misses these annotations, and the
+  // component→plugin registry is empty in a Lambda: it names its plugin from the ambient one,
+  // set for the invocation and restored after it.
+  if (resolvedPlugin) {
+    const inner = e;
+    e = Effect.suspend(() => {
+      const before = currentPluginName.contents;
+      currentPluginName.contents = resolvedPlugin;
+      return inner.pipe(
+        Effect.ensuring(Effect.sync(() => { currentPluginName.contents = before; })),
+      );
+    });
+  }
   return e
     .pipe(
       Effect.provideService(

package/tests/EventCollectorEntryPoint_OpsTest.res

@@ -226,3 +226,23 @@ describe("EventCollectorEntryPoint_Ops.parseHandlerConfig", () => {
     expect((c.extensions->Array.getUnsafe(0)).extensionPointName)->toBe("Ordering.Orders")
   })
 })
+
+describe("EventCollectorEntryPoint_Ops.mappingsName", () => {
+  let ext = (~name): EventCollectorEntryPoint_Ops.extensionConfig => {
+    name,
+    specModule: "",
+    mappingsModule: "",
+    delegateModule: "",
+    extensionPointName: "Ordering.Orders",
+    aggregateNames: [],
+  }
+  // The component is `Extension(<point>.<name>)`: the point is not named twice.
+  testSync("is the plugin's name, as at deploy", () =>
+    expect(EventCollectorEntryPoint_Ops.mappingsName(ext(~name="Ordering.Orders.Catalog")))->toBe(
+      "Catalog",
+    )
+  )
+  testSync("keeps a name that does not start with its extension point", () =>
+    expect(EventCollectorEntryPoint_Ops.mappingsName(ext(~name="Catalog")))->toBe("Catalog")
+  )
+})

package/tests/EventCollectorEntryPoint_OpsTest.res.mjs

@@ -315,6 +315,29 @@ globalThis.describe("EventCollectorEntryPoint_Ops.parseHandlerConfig", () => {
   });
 });
 
+globalThis.describe("EventCollectorEntryPoint_Ops.mappingsName", () => {
+  globalThis.test("is the plugin's name, as at deploy", () => {
+    globalThis.expect(EventCollectorEntryPoint_Ops$ReventlessAws.mappingsName({
+      name: "Ordering.Orders.Catalog",
+      specModule: "",
+      mappingsModule: "",
+      delegateModule: "",
+      extensionPointName: "Ordering.Orders",
+      aggregateNames: []
+    })).toBe("Catalog");
+  });
+  globalThis.test("keeps a name that does not start with its extension point", () => {
+    globalThis.expect(EventCollectorEntryPoint_Ops$ReventlessAws.mappingsName({
+      name: "Catalog",
+      specModule: "",
+      mappingsModule: "",
+      delegateModule: "",
+      extensionPointName: "Ordering.Orders",
+      aggregateNames: []
+    })).toBe("Catalog");
+  });
+});
+
 let project = EventCollectorEntryPoint_Ops$ReventlessAws.projectPluginRow;
 
 export {

package/tests/HandlerFactoryDispatchTest.res

@@ -200,6 +200,23 @@ describe("entry-point dispatch boundary", () => {
       },
     )
 
+    // A line run on a fiber of its own (`->Effect.runSync`) misses the invocation's annotations,
+    // and a Lambda's component→plugin registry is empty: the ambient plugin names it.
+    test(
+      "a line logged on a fiber of its own names the invocation's plugin",
+      async () => {
+        let before = Reventless.LogPrefix.currentPluginName.contents
+        let seen = await runEffect(
+          Effect.sync(
+            () => Reventless.LogPrefix.resolvePlugin(~comp="StateChangeSlice(PlaceOrder)", ()),
+          ),
+          {correlationId: "c", comp: "StateChangeSlice(PlaceOrder)", plugin: "Ordering"},
+        )
+        expect(seen)->Expect.toEqual(Some("Ordering"))
+        expect(Reventless.LogPrefix.currentPluginName.contents)->Expect.toEqual(before)
+      },
+    )
+
     // A constant "1" on every line is noise; its absence is what makes
     // `filter retryCount > 1` a usable CloudWatch query.
     test(

package/tests/HandlerFactoryDispatchTest.res.mjs

@@ -3,6 +3,7 @@
 import * as Effect from "@reventlessdev/rescript-effect/src/Effect.res.mjs";
 import * as Effect$1 from "effect/Effect";
 import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
+import * as LogPrefix$Reventless from "@reventlessdev/reventless-spec/src/LogPrefix.res.mjs";
 import * as RequestContext$ReventlessCore from "@reventlessdev/reventless-core/src/RequestContext.res.mjs";
 import * as HandlerFactoryHelpersMjs from "@reventlessdev/reventless-aws/src/adapter/Runtime/HandlerFactoryHelpers.mjs";
 
@@ -112,6 +113,16 @@ globalThis.describe("entry-point dispatch boundary", () => {
       globalThis.expect(annotated$1["correlationId"]).toEqual("corr-1");
       globalThis.expect(annotated$1["requestId"]).toEqual("req-abc");
     });
+    globalThis.test("a line logged on a fiber of its own names the invocation's plugin", async () => {
+      let before = LogPrefix$Reventless.currentPluginName.contents;
+      let seen = await HandlerFactoryHelpersMjs.runEffect(Effect$1.sync(() => LogPrefix$Reventless.resolvePlugin("StateChangeSlice(PlaceOrder)", undefined)), {
+        correlationId: "c",
+        comp: "StateChangeSlice(PlaceOrder)",
+        plugin: "Ordering"
+      });
+      globalThis.expect(seen).toEqual("Ordering");
+      globalThis.expect(LogPrefix$Reventless.currentPluginName.contents).toEqual(before);
+    });
     globalThis.test("annotates retryCount only on a redelivery", async () => {
       let first = await HandlerFactoryHelpersMjs.runEffect(Effect$1.logAnnotations, {
         correlationId: "c",