@reventlessdev/reventless-local 3.0.0-alpha.241 → 3.0.0-alpha.243

package/CHANGELOG.md

@@ -3,6 +3,28 @@
 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.243 (2026-09-02)
+
+* feat(aws)!: the messaging sender is configuration, and a stack can choose to only log ([23b8b4b](https://github.com/ReventlessDev/reventless-core/commit/23b8b4bfe9c70555de4d74266ca686cb427485ca))
+
+### BREAKING CHANGES
+
+* `Capability_Messaging_Ses.make` is replaced by
+`Capability_Messaging.make(~name)`, which reads the transport and the address
+from config; the SES module keeps only `emailSender`. A deployment that named its
+sender in code must move it to `platform:messagingEmailSender` or the deploy is
+refused.
+
+
+
+# 3.0.0-alpha.242 (2026-09-01)
+
+**Note:** Version bump only for package @reventlessdev/reventless-local
+
+
+
+
+
 # 3.0.0-alpha.241 (2026-09-01)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.241",
+  "version": "3.0.0-alpha.243",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -35,23 +35,23 @@
     "sury": "11.0.0-rc.2",
     "ws": "^8.18.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.27",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.8",
     "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.21",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.8",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.254",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.252",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.100",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.199",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.116",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.102",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.155",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.201",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.118",
     "@reventlessdev/reventless-seed": "1.0.0-alpha.18",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.153",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.125"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.127"
   },
   "devDependencies": {
     "rescript": "12.3.0",
     "sury-ppx": "11.0.0-rc.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.75"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.76"
   },
   "peerDependencies": {
     "rescript": "12.3.0"

package/src/Platform.res

@@ -1491,6 +1491,20 @@ module MakeWithConfig = (
         `backend: sqlite (${path}${resetOnStart ? ", resetOnStart" : ""})`
       },
     )
+    // The infrastructure half of `~hostUiBundle` that this platform does NOT
+    // ignore. A capability is the one kind of deployment declaration that has a
+    // local counterpart — the slice reaching it runs in this process, so there is
+    // something real to provide — and the seam is the AWS one: a handle from a
+    // `Capability_*` helper, registered before a slice can ask for it. `Input.t`
+    // is the identity function off Pulumi, so what comes back out is the string.
+    switch hostUiBundle->Option.flatMap(cfg => cfg.messagingSender) {
+    | Some({emailSender: ?Some(sender)}) =>
+      let address = sender->Pulumi.Output.fromInput->Pulumi.Output.unwrap
+      LocalCapabilities.registerMessagingSender(address)
+      log.info(~comp="Platform", `messaging: log transport as ${address} (nothing is sent)`)
+    | _ => ()
+    }
+
     // Runtime extension seam. Fired before anything is built, so an extension's
     // interception and publish hooks are registered before the first command or
     // query can reach them.

package/src/Platform.res.mjs

@@ -52,6 +52,7 @@ import * as Platform_AdminApi$ReventlessCore from "@reventlessdev/reventless-cor
 import * as PluginsProjection$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginsProjection.res.mjs";
 import * as Scheduler_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/Scheduler/Scheduler_Builder.res.mjs";
 import * as Aggregate_Builder$ReventlessLocal from "./components/Aggregate_Builder.res.mjs";
+import * as LocalCapabilities$ReventlessLocal from "./adapter/LocalCapabilities.res.mjs";
 import * as LocalClonerRunner$ReventlessLocal from "./adapter/Cloner/LocalClonerRunner.res.mjs";
 import * as PluginBaseFragment$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/api/PluginBaseFragment.res.mjs";
 import * as ProjectionPending$ReventlessLocal from "./adapter/ProjectionPending.res.mjs";
@@ -1230,6 +1231,14 @@ function MakeWithConfig(Config) {
           ) + `)` : `backend: postgres (` + match.connection + `, event-logs only)`
       );
     log.info("Platform", undefined, tmp);
+    let match$1 = Stdlib_Option.flatMap(hostUiBundle, cfg => cfg.messagingSender);
+    if (match$1 !== undefined) {
+      let sender = match$1.emailSender;
+      if (sender !== undefined) {
+        LocalCapabilities$ReventlessLocal.registerMessagingSender(sender);
+        log.info("Platform", undefined, `messaging: log transport as ` + sender + ` (nothing is sent)`);
+      }
+    }
     RuntimeExtension$ReventlessCore.notifyColdStart("Platform", "LocalPlatform", ResourceAttribution$ReventlessCore.current.contents.plugin, ResourceAttribution$ReventlessCore.current.contents.platform);
     let projectionCatchup = Stdlib_Option.map(BackendState$ReventlessLocal.getSqliteDb(), db => [
       db,
@@ -2959,6 +2968,14 @@ function Make($star) {
           ) + `)` : `backend: postgres (` + backend.connection + `, event-logs only)`
       );
     log.info("Platform", undefined, tmp);
+    let match = Stdlib_Option.flatMap(hostUiBundle, cfg => cfg.messagingSender);
+    if (match !== undefined) {
+      let sender = match.emailSender;
+      if (sender !== undefined) {
+        LocalCapabilities$ReventlessLocal.registerMessagingSender(sender);
+        log.info("Platform", undefined, `messaging: log transport as ` + sender + ` (nothing is sent)`);
+      }
+    }
     RuntimeExtension$ReventlessCore.notifyColdStart("Platform", "LocalPlatform", ResourceAttribution$ReventlessCore.current.contents.plugin, ResourceAttribution$ReventlessCore.current.contents.platform);
     let projectionCatchup = Stdlib_Option.map(BackendState$ReventlessLocal.getSqliteDb(), db => [
       db,

package/src/adapter/LocalCapabilities.res

@@ -1,16 +1,30 @@
 // What the local platform hands a slice's `translate`.
 //
-// Nothing, today — and that is the honest answer rather than a placeholder. The
-// local platform provisions neither a geocoder nor a mailer (a place index and a
-// verified sender identity are each an account and a bill), so
-// `Capabilities.none` reports `Unavailable`, which `translate` maps to a
-// retryable `Error` and the sweep surfaces. A dev running a geocoding slice sees
-// its items stay queued, which is true, instead of seeing them written off as
-// unresolvable addresses, which would not be. Messaging additionally publishes an
-// empty channel list, so a preference surface offers nothing rather than offering
-// a channel that cannot deliver.
+// No geocoder: the local platform provisions none (a place index is an account
+// and a bill), so `Capabilities.none`'s `geocode` reports `Unavailable`, which
+// `translate` maps to a retryable `Error` and the sweep surfaces. A dev running a
+// geocoding slice sees its items stay queued, which is true, instead of seeing
+// them written off as unresolvable addresses, which would not be.
 //
-// This is the one place to change when local grows a real one — a fixture, a
-// stub keyed by address, Nominatim, a mailbox on disk. Slices reach them through
-// the injected record, so nothing in a plugin moves on that day.
-let capabilities = () => Reventless.Capabilities.none
+// Messaging is provisioned when a root asks for it, exactly as on AWS: a
+// `Capability_Messaging_Log.make()` handle passed as `~messagingSender`
+// reaches `registerMessagingSender` and the transport becomes the provider. A root
+// that passes nothing keeps the old answer — an empty sender yields no channels
+// and a retryable `Unavailable`, which is what an unprovisioned platform is.
+//
+// The sender is a ref read per call rather than a value captured once, mirroring
+// the Lambda side: there `capabilities()` re-reads `MESSAGING_EMAIL_SENDER` on
+// every invocation so a reconfigured function needs no cold start. Here it means
+// the order of `makePlatform`'s work is not a thing to get right.
+
+let messagingSenderRef = ref("")
+
+/** Provision the messaging capability. Called by `makePlatform` from the handle
+    a root declared — the local half of the seam whose AWS half is
+    `PluginRuntime_Builder.registerMessagingSender`. */
+let registerMessagingSender = (sender: string) => messagingSenderRef := sender
+
+let capabilities = (): Reventless.Capabilities.t => {
+  geocode: Reventless.Capabilities.none.geocode,
+  messaging: ReventlessCore.Messaging_Log_Backend.provider(~sender=messagingSenderRef.contents),
+}

package/src/adapter/LocalCapabilities.res.mjs

@@ -1,12 +1,26 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Capabilities$Reventless from "@reventlessdev/reventless-spec/src/semantic/Capabilities.res.mjs";
+import * as Messaging_Log_Backend$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Messaging/Messaging_Log_Backend.res.mjs";
+
+let messagingSenderRef = {
+  contents: ""
+};
+
+function registerMessagingSender(sender) {
+  messagingSenderRef.contents = sender;
+}
 
 function capabilities() {
-  return Capabilities$Reventless.none;
+  return {
+    geocode: Capabilities$Reventless.none.geocode,
+    messaging: Messaging_Log_Backend$ReventlessCore.provider(messagingSenderRef.contents)
+  };
 }
 
 export {
+  messagingSenderRef,
+  registerMessagingSender,
   capabilities,
 }
-/* No side effect */
+/* Messaging_Log_Backend-ReventlessCore Not a pure module */

package/src/capability/Capability_Messaging_Log.res

@@ -0,0 +1,39 @@
+// The messaging sender a dev platform provisions — the local counterpart to
+// `Capability_Messaging_Ses`, and reached the same way: a root calls `make`,
+// passes the handle as `~messagingSender` in `~hostUiBundle`, and the platform
+// puts a provider on the capability record every slice's `translate` receives.
+// Nothing about a plugin changes between the two.
+//
+// **The address is hard-coded here, where on AWS it is configuration.** That is
+// the one deliberate difference, and it follows from what the value is for. A
+// verified identity is a per-account fact a repository cannot know, so the AWS
+// helper refuses to invent one; a logged message reaches nobody, so there is
+// nothing to verify, nothing that differs per developer, and nothing a setting
+// would buy. `.test` is reserved for exactly this (RFC 6761) — it can never
+// resolve, so an address escaping into a fixture cannot reach a real inbox.
+
+/** The `From:` this platform's mail would carry. Named for the platform rather
+    than the shop: what a dev is looking at when they read it is the local
+    log transport, and a name that impersonated the deployment would make a screenshot
+    of a dev run indistinguishable from one of production. */
+let senderName = "Online Shop (local)"
+let senderAddress = "notifications@online-shop.test"
+
+/**
+The handle, in the shape the platform config takes.
+
+`Pulumi.Input.t` in a platform that runs no Pulumi is not an accident: the field
+belongs to the shared `Platform.messagingSender`, so both platforms carry the
+sender in one type and a root moving between them changes which helper it calls
+and nothing else. `Input.make` is the identity function, so what travels is the
+string.
+
+The header is built by `Messaging.fromHeader`, the same function the SES helper
+applies to its verified address — one formatter, so the two platforms cannot
+present the same deployment under two differently-escaped names.
+*/
+let make = (): ReventlessInfra.Platform.messagingSender => {
+  emailSender: Pulumi.Input.make(
+    Reventless.Messaging.fromHeader(~displayName=Some(senderName), ~address=senderAddress),
+  ),
+}

package/src/capability/Capability_Messaging_Log.res.mjs

@@ -0,0 +1,20 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Messaging$Reventless from "@reventlessdev/reventless-spec/src/semantic/Messaging.res.mjs";
+
+let senderName = "Online Shop (local)";
+
+let senderAddress = "notifications@online-shop.test";
+
+function make() {
+  return {
+    emailSender: Messaging$Reventless.fromHeader(senderName, senderAddress)
+  };
+}
+
+export {
+  senderName,
+  senderAddress,
+  make,
+}
+/* No side effect */

package/src/components/OutboundTranslationSlice_Builder.res.mjs

@@ -33,7 +33,9 @@ function Make(Bus) {
     make: QueryDbStorage.make
   })({
     make: QueryDbResolvers.make
-  })(EventCollectorChannel)(EventCollectorRuntimeBuilder)(Api)(LocalCapabilities$ReventlessLocal);
+  })(EventCollectorChannel)(EventCollectorRuntimeBuilder)(Api)({
+    capabilities: LocalCapabilities$ReventlessLocal.capabilities
+  });
   let Make$1 = Spec => (Translation => {
     let Inner = CoreMaker.Make(Spec)(Translation);
     return {