@reventlessdev/reventless-infra 3.0.0-alpha.162 → 3.0.0-alpha.164

package/CHANGELOG.md

@@ -3,6 +3,34 @@
 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.164 (2026-09-16)
+
+* feat(spec)!: infer the DCB partition key per slice, and drop @partitionTag where inference agrees ([6c10161](https://github.com/ReventlessDev/reventless-core/commit/6c101611d438beea4bc9175ae8ea0ea1f6f7493b))
+### Features
+
+* **core:** fail the build when an extension cannot find its slice's partition key ([cf2b093](https://github.com/ReventlessDev/reventless-core/commit/cf2b093dd5dc7cf9425cdac919cd3910fc4aeefd))
+* **spec:** let a slice's chapter break a partition-key tie ([2b9ae77](https://github.com/ReventlessDev/reventless-core/commit/2b9ae77e98eb42177d2bdd4977bc62bb7c7911aa))
+
+### BREAKING CHANGES
+
+* DcbTag.derivePartitionTag is removed; a boundary whose
+partition cannot be inferred no longer deploys.
+
+
+
+# 3.0.0-alpha.163 (2026-09-11)
+
+* feat(spec)!: making a principal is a capability, so the provider is replaceable ([3e59b9b](https://github.com/ReventlessDev/reventless-core/commit/3e59b9b665cc7e4b6b6f156b63b1b6bd0c6181ca))
+
+### BREAKING CHANGES
+
+* Capabilities.t gains an identityProvider member. A platform
+that builds the record literally no longer compiles until it supplies one;
+Capabilities.none.identityProvider is the refusing value to pass while no
+backend exists. Code that spreads Capabilities.none is unaffected.
+
+
+
 # 3.0.0-alpha.162 (2026-09-09)
 
 **Note:** Version bump only for package @reventlessdev/reventless-infra

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-infra",
-  "version": "3.0.0-alpha.162",
+  "version": "3.0.0-alpha.164",
   "description": "Infrastructure types for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -17,8 +17,8 @@
     "sury-ppx": "11.0.0-rc.2",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.33",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.20",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.134",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.136",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.21",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0"
   },
   "devDependencies": {

package/src/components/StateChangeSlice.res

@@ -40,6 +40,8 @@ module type T = {
         a cross-partition scalar command tag fans out into its own single-tag
         decision-read clause. */
     ~crossPartitionTagKeys: array<string>=?,
+    /** This slice's partition, as `Dcb_Builder` derives it for the whole boundary. */
+    ~partitionTag: Reventless.DcbTag.derivedPartitionTag=?,
     ~runtime: RuntimeHints.t=?,
     ~opts: Pulumi.ComponentResource.options=?,
   ) => component

package/src/types/ExtensionMapping.res

@@ -10,7 +10,7 @@ type id = string
 
 /** What `mapIncomingEvent` can do with a published event: command the wrapped
     aggregate or slice, command the extension point, forward, or run a directive.
-    The slice forms take no id — the FIFO group comes from `@partitionTag`. */
+    The slice forms take no id — the FIFO group is the slice's partition key. */
 type incomingCommandAction<'aggregateCommand, 'extensionPointCommand, 'directive> =
   | PublishAggregateCommand(id, 'aggregateCommand)
   | PublishAggregateCommandAsync(promise<(id, 'aggregateCommand)>)
@@ -182,6 +182,11 @@ module type T = {
   let delegateCommandNames: array<string>
   let delegateEventNames: array<string>
 
+  /** The partition key slice commands to the Delegate are grouped by, inferred
+      from the Delegate alone — or why it cannot tell. Checked at assembly against
+      the plugin's own derivation, which sees what the slice reads. */
+  let delegatePartition: unit => result<Reventless.DcbTag.derivedPartitionTag, string>
+
   let mapIncomingEvent: (
     Reventless.Message.event'<string, ExtensionPoint.event>,
     pluginDefinition,
@@ -216,28 +221,35 @@ module Make = (MappingImpl: Mapping): (
   let acceptedTags = Reventless.DcbTag.extractAllVariantNames(Delegate.eventSchema)
   let delegateEventNames = acceptedTags
 
-  // Partition tag for `PublishStateChangeSliceCommand*`. Throws when the Delegate
-  // declares none — an Aggregate, where `PublishAggregateCommand` is the right form.
+  // Partition for `PublishStateChangeSliceCommand*`, which becomes the command's
+  // FIFO group. Inferred from the Delegate alone: its consumed arms are not in
+  // view, so a slice whose key only they decide needs `@partitionTag`. Throws
+  // when unresolved — an Aggregate, where `PublishAggregateCommand` is right.
   let derivedPartitionTagLazy = ref(None)
   let getDerivedPartitionTag = () =>
     switch derivedPartitionTagLazy.contents {
     | Some(d) => d
     | None =>
-      let d = Reventless.DcbTag.derivePartitionTag([
-        (Delegate.name, Delegate.moduleUrl, Delegate.commandSchema->S.castToUnknown),
-      ])
+      let d = Reventless.DcbTag.deriveSlicePartition({
+        name: Delegate.name,
+        commandSchema: Delegate.commandSchema->S.castToUnknown,
+        consumedEventSchema: S.unknown,
+        eventSchema: Delegate.eventSchema->S.castToUnknown,
+        moduleUrl: Delegate.moduleUrl,
+      })
       derivedPartitionTagLazy := Some(d)
       d
     }
-  let derivePartitionId = (targetCmd: Delegate.command): string =>
+  let delegatePartition = () =>
     switch getDerivedPartitionTag() {
-    | Simple(pt) =>
-      let tags = Reventless.DcbTag.extractTags(Delegate.commandSchema, targetCmd)
-      Reventless.DcbTag.getPartitionTagValue([{tags: tags}], pt)->Option.getOr("")
-    | Composite(spec) =>
-      let tags = Reventless.DcbTag.extractTags(Delegate.commandSchema, targetCmd)
-      Reventless.DcbTag.getCompositePartitionKeyValue(tags, spec)
+    | tag => Ok(tag)
+    | exception JsExn(err) => Error(err->JsExn.message->Option.getOr("no partition key"))
     }
+  let derivePartitionId = (targetCmd: Delegate.command): string =>
+    Reventless.DcbTag.extractTags(
+      Delegate.commandSchema,
+      targetCmd,
+    )->Reventless.DcbTag.partitionValueOfTags(getDerivedPartitionTag())
 
   // `comp` as an Effect log annotation; EffectLogger.install lifts it to the
   // top-level JSON field.

package/src/types/ExtensionMapping.res.mjs

@@ -3,12 +3,14 @@
 import * as Sury from "sury";
 import * as Uuid from "uuid";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.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 Effect from "effect/Effect";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
 import * as AnsiStyle$Reventless from "@reventlessdev/reventless-spec/src/AnsiStyle.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as PluginExtensionPointSpec$ReventlessInfra from "./PluginExtensionPointSpec.res.mjs";
 
 let schema = Sury.string;
@@ -65,25 +67,36 @@ function Make(MappingImpl) {
     if (d !== undefined) {
       return d;
     }
-    let d$1 = DcbTag$Reventless.derivePartitionTag([[
-        Delegate.name,
-        Delegate.moduleUrl,
-        Delegate.commandSchema
-      ]]);
+    let d$1 = DcbTag$Reventless.deriveSlicePartition({
+      name: Delegate.name,
+      commandSchema: Delegate.commandSchema,
+      consumedEventSchema: Sury.unknown,
+      eventSchema: Delegate.eventSchema,
+      moduleUrl: Delegate.moduleUrl
+    });
     derivedPartitionTagLazy.contents = d$1;
     return d$1;
   };
-  let derivePartitionId = targetCmd => {
-    let pt = getDerivedPartitionTag();
-    if (pt.TAG === "Simple") {
-      let tags = DcbTag$Reventless.extractTags(Delegate.commandSchema, targetCmd);
-      return Stdlib_Option.getOr(DcbTag$Reventless.getPartitionTagValue([{
-          tags: tags
-        }], pt._0), "");
+  let delegatePartition = () => {
+    let tag;
+    try {
+      tag = getDerivedPartitionTag();
+    } catch (raw_err) {
+      let err = Primitive_exceptions.internalToException(raw_err);
+      if (err.RE_EXN_ID === "JsExn") {
+        return {
+          TAG: "Error",
+          _0: Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "no partition key")
+        };
+      }
+      throw err;
     }
-    let tags$1 = DcbTag$Reventless.extractTags(Delegate.commandSchema, targetCmd);
-    return DcbTag$Reventless.getCompositePartitionKeyValue(tags$1, pt._0);
+    return {
+      TAG: "Ok",
+      _0: tag
+    };
   };
+  let derivePartitionId = targetCmd => DcbTag$Reventless.partitionValueOfTags(DcbTag$Reventless.extractTags(Delegate.commandSchema, targetCmd), getDerivedPartitionTag());
   let compLog = (comp, msg) => Effect.runSync(Effect.annotateLogs(Effect.logInfo(msg), "comp", comp));
   let encodeMeta = (meta, service) => {
     let newrecord = {...meta};
@@ -261,6 +274,7 @@ function Make(MappingImpl) {
     issuedCommands: MappingImpl.issuedCommands,
     delegateCommandNames: delegateCommandNames,
     delegateEventNames: acceptedTags,
+    delegatePartition: delegatePartition,
     mapIncomingEvent: mapIncomingEvent,
     mapOutgoingEvent: mapOutgoingEvent
   };

package/src/types/Platform.res

@@ -109,6 +109,7 @@ type capability =
   | ObjectStore({plugin: string, store: string})
   | Geocoding
   | Messaging
+  | IdentityProvider
 
 // A provisioned geocoding place index, as returned by the framework's geocoding
 // capability helper. A record rather than a bare name so the handle can grow