@reventlessdev/reventless-local 3.0.0-alpha.131 → 3.0.0-alpha.133

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.133 (2026-07-09)
+
+### Bug Fixes
+
+* **reventless-core:** DCB StateChangeSlice mutations use ${plugin}_${command}, not ${plugin}_${slice}_${command} ([c5874d2](https://github.com/ReventlessDev/reventless-core/commit/c5874d27ad63e6af5c639c8b6c6f8596fd7f682b))
+
+
+# 3.0.0-alpha.132 (2026-07-09)
+
+### Bug Fixes
+
+* **reventless-core:** DCB StateChangeSlices expose one mutation per command constructor ([136fe93](https://github.com/ReventlessDev/reventless-core/commit/136fe93c56c2e5115eb60d792e9d5e9c07eecc2b))
+
+
 # 3.0.0-alpha.131 (2026-07-08)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.131",
+  "version": "3.0.0-alpha.133",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "jest": {
@@ -31,16 +31,16 @@
     "graphql-yoga": "^5.21.0",
     "sury": "11.0.0-alpha.4",
     "ws": "^8.18.0",
-    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.18",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.6",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.25",
+    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.18",
     "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.17",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.147",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.92",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.6",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.94",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.91",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.69",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.11"
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.13",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.149"
   },
   "devDependencies": {
     "rescript": "^12.3.0",

package/src/adapter/CommandGenerator/CommandGeneratorResolvers_GraphQL.res

@@ -237,12 +237,20 @@ let registerDcb = (
   ~server: GraphQL_ServerInstance.t,
 ) => {
   ensureCommandResultTypes(server)
-  let variantSchema = extractVariantSchema(commandSchema)
+  // Derive the constructor from the field name's trailing `_` segment (mirrors the
+  // aggregate resolver). A single-command slice's `Plugin_Slice` resolves to its sole
+  // constructor (slice name == constructor); a multi-command slice's `Plugin_Ctor`
+  // resolves to `Ctor`. Position 0 was previously hardcoded, which dropped every
+  // non-first constructor of a multi-command slice.
+  let constructorNames = Reventless.DcbTag.extractAllVariantNames(commandSchema->Obj.magic)
+  let variantIndex = variantIndexForField(commandSchema, ~field=fieldName)
+  let variantSchema = extractVariantSchema(commandSchema, ~index=variantIndex >= 0 ? variantIndex : 0)
   let sdlFields = [deriveSdlField(~fieldName, variantSchema)]
 
   // Extract TAG (variant constructor name) for routing
-  let constructorNames = Reventless.DcbTag.extractAllVariantNames(commandSchema->Obj.magic)
-  let tag = constructorNames->Array.get(0)->Option.getOr(fieldName)
+  let tag =
+    (variantIndex >= 0 ? constructorNames->Array.get(variantIndex) : constructorNames->Array.get(0))
+    ->Option.getOr(fieldName)
   let hasPayload = Reventless.DcbTag.isVariantPayloadBearing(commandSchema->Obj.magic, tag)
 
   let handlerRef = ref(None)

package/src/adapter/CommandGenerator/CommandGeneratorResolvers_GraphQL.res.mjs

@@ -198,10 +198,11 @@ function register(fields, commandSchema, commandAuthorization, server) {
 
 function registerDcb(fieldName, commandSchema, commandAuthorization, server) {
   ensureCommandResultTypes(server);
-  let variantSchema = extractVariantSchema(commandSchema, undefined);
-  let sdlFields = [deriveSdlField(fieldName, variantSchema)];
   let constructorNames = DcbTag$Reventless.extractAllVariantNames(commandSchema);
-  let tag = Stdlib_Option.getOr(constructorNames[0], fieldName);
+  let variantIndex = variantIndexForField(commandSchema, fieldName);
+  let variantSchema = extractVariantSchema(commandSchema, variantIndex >= 0 ? variantIndex : 0);
+  let sdlFields = [deriveSdlField(fieldName, variantSchema)];
+  let tag = Stdlib_Option.getOr(variantIndex >= 0 ? constructorNames[variantIndex] : constructorNames[0], fieldName);
   let hasPayload = DcbTag$Reventless.isVariantPayloadBearing(commandSchema, tag);
   let handlerRef = {
     contents: undefined

package/tests/adapter/GraphQL_SchemaInspectorTest.res

@@ -38,6 +38,23 @@ type unionCommand =
   | Create({itemId: @s.matches(Reventless.DcbTag.string) string, name: string})
   | Rename({itemId: @s.matches(Reventless.DcbTag.string) string, newName: string})
 
+// DCB StateChangeSlice command shapes for the per-constructor mutation fan-out.
+// A single-variant union models a single-command slice (must keep the byte-identical
+// `Plugin_Slice` field); a multi-variant union models a multi-command slice (must
+// expose one `Plugin_Command` field per constructor).
+@schema
+type dcbSingleCommand =
+  | AddCategory({categoryId: @s.matches(Reventless.DcbTag.string) string, name: string})
+
+@schema
+type dcbMultiCommand =
+  | SyncNewProduct({
+      productId: @s.matches(Reventless.DcbTag.string) string,
+      name: string,
+      price: float,
+    })
+  | ChangeSyncedPrice({productId: @s.matches(Reventless.DcbTag.string) string, price: float})
+
 // State schemas exercising structural annotations (Phase 1 server capability)
 @schema
 type plainState = {
@@ -769,6 +786,106 @@ describe("GraphQL_SchemaInspector", () => {
 // the field must fold a `kindEq` equality filter into Platform_PluginFilter so the
 // admin console can page the main list vs the System/Infrastructure panel
 // server-side.
+// ── DCB StateChangeSlice: one mutation per command constructor ───────────────
+// A multi-command DCB slice must expose one GraphQL mutation per command
+// constructor (mirroring aggregates), each carrying its own argument shape and its
+// own subscription — not a single slice-named mutation that drops the extra
+// constructors. Single-command slices must stay byte-identical (no schema churn).
+describe("DCB StateChangeSlice — one mutation per command constructor", () => {
+  testPromise("single-command slice keeps the byte-identical Plugin_Slice field", async () => {
+    let fieldNames =
+      ReventlessCore.Api_Naming.sliceMutationFields(
+        ~plugin="Catalog",
+        ~slice="AddCategory",
+        ~commandSchema=dcbSingleCommandSchema->S.castToUnknown,
+      )->Array.map(((f, _)) => f)
+    expect(fieldNames)->toEqual(["Catalog_AddCategory"])
+  })
+
+  testPromise("multi-command slice emits one `${plugin}_${command}` field per constructor", async () => {
+    // The command constructor already names the operation; callers/plans expect
+    // `${plugin}_${command}` (e.g. Platform_SyncComponent / Platform_RemoveComponent),
+    // NOT the aggregate-style `${plugin}_${slice}_${command}` doubling — which both
+    // renamed the primary command and overflowed AppSync's subscription cap.
+    let fieldNames =
+      ReventlessCore.Api_Naming.sliceMutationFields(
+        ~plugin="Ordering",
+        ~slice="SyncCatalogProduct",
+        ~commandSchema=dcbMultiCommandSchema->S.castToUnknown,
+      )->Array.map(((f, _)) => f)
+    expect(fieldNames)->toEqual(["Ordering_SyncNewProduct", "Ordering_ChangeSyncedPrice"])
+  })
+
+  testPromise(
+    "multi-command slice: both mutations carry their own args, plus both subscriptions (each ≤ 50 chars)",
+    async () => {
+      let fieldNames =
+        ReventlessCore.Api_Naming.sliceMutationFields(
+          ~plugin="Ordering",
+          ~slice="SyncCatalogProduct",
+          ~commandSchema=dcbMultiCommandSchema->S.castToUnknown,
+        )->Array.map(((f, _)) => f)
+      let commandSchema = dcbMultiCommandSchema->S.castToUnknown
+
+      let fragment = ReventlessCore.GraphQL_FragmentGenerator.generate(
+        ~mutationEntries=[{fieldNames, commandSchema}],
+        ~queryEntries=[],
+      )
+      let sdl = ReventlessCore.GraphQL_SchemaInspector.inspectFragment(fragment).sdlPreview
+      // Each constructor's mutation carries that constructor's own argument shape.
+      expect(
+        sdl->String.includes(
+          "Ordering_SyncNewProduct(id: ID!, productId: ID!, name: String!, price: Float!)",
+        ),
+      )->toBe(true)
+      expect(
+        sdl->String.includes(
+          "Ordering_ChangeSyncedPrice(id: ID!, productId: ID!, price: Float!)",
+        ),
+      )->toBe(true)
+
+      // Subscriptions fan out one-per-field over the same entry.
+      let subs = ReventlessCore.Plugin_SubscriptionSchema.generate(
+        ~mutationEntries=[{fieldNames, commandSchema}],
+        ~eventLogEntries=[],
+      )
+      let subSdl = subs.subscriptionFields->Array.join("\n")
+      expect(subSdl->String.includes("onOrdering_SyncNewProduct"))->toBe(true)
+      expect(subSdl->String.includes("onOrdering_ChangeSyncedPrice"))->toBe(true)
+
+      // Every emitted subscription field name stays within AppSync's 50-char cap.
+      subs.subscriptionFields->Array.forEach(sub => {
+        // `sub` is the full SDL line `  on<Field>(id: ID): CommandResult\n ...`;
+        // extract the leading `on<Field>` token to length-check the field name itself.
+        let name =
+          sub->String.trim->String.split("(")->Array.getUnsafe(0)
+        expect(name->String.length <= 50)->toBe(true)
+      })
+    },
+  )
+
+  testPromise(
+    "regression: a slice whose plugin+command overflow the 50-char cap fails at build, not at AppSync",
+    async () => {
+      // `on` + `Platform_SyncExtensionWiring_RemoveExtensionWiring` (the old doubled
+      // shape) was 52 chars → AppSync rejected the schema push with an opaque 500.
+      // A field long enough to overflow must now throw an actionable build-time error.
+      let longPlugin = "PlatformIntegrationOrchestration"
+      let field = ReventlessCore.Api_Naming.dcbCommandMutationField(
+        ~plugin=longPlugin,
+        ~command="RemoveExtensionWiring",
+      )
+      let raised = try {
+        let _ = ReventlessCore.Api_Naming.assertSubscriptionNameFits(~fieldName=field)
+        false
+      } catch {
+      | JsExn(_) => true
+      }
+      expect(raised)->toBe(true)
+    },
+  )
+})
+
 describe("Plugin admin fragment — kind enum + kindEq filter", () => {
   testPromise("Platform_Plugin exposes a PluginKind enum and Platform_Plugins gains kindEq", async () => {
     let fragment = ReventlessCore.GraphQL_FragmentGenerator.generate(

package/tests/adapter/GraphQL_SchemaInspectorTest.res.mjs

@@ -3,6 +3,8 @@
 import * as S from "sury/src/S.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Api_Naming$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/Api_Naming.res.mjs";
 import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
 import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
 import * as GraphQL_Server$ReventlessLocal from "../../src/adapter/GraphQL_Server.res.mjs";
@@ -10,6 +12,7 @@ import * as GraphQL_Stitcher$ReventlessCore from "@reventlessdev/reventless-core
 import * as PluginBaseFragment$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/api/PluginBaseFragment.res.mjs";
 import * as GraphQL_SchemaInspector$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_SchemaInspector.res.mjs";
 import * as GraphQL_FragmentGenerator$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_FragmentGenerator.res.mjs";
+import * as Plugin_SubscriptionSchema$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_SubscriptionSchema.res.mjs";
 
 TestRunner$ReventlessLocal.setup();
 
@@ -44,6 +47,26 @@ let unionCommandSchema = S.union([
   }))
 ]);
 
+let dcbSingleCommandSchema = S.schema(s => ({
+  TAG: "AddCategory",
+  categoryId: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+let dcbMultiCommandSchema = S.union([
+  S.schema(s => ({
+    TAG: "SyncNewProduct",
+    productId: s.m(DcbTag$Reventless.string),
+    name: s.m(S.string),
+    price: s.m(S.float)
+  })),
+  S.schema(s => ({
+    TAG: "ChangeSyncedPrice",
+    productId: s.m(DcbTag$Reventless.string),
+    price: s.m(S.float)
+  }))
+]);
+
 let plainStateSchema = S.schema(s => ({
   productId: s.m(DcbTag$Reventless.string),
   name: s.m(S.string)
@@ -551,6 +574,57 @@ globalThis.describe("GraphQL_SchemaInspector", () => {
   });
 });
 
+globalThis.describe("DCB StateChangeSlice — one mutation per command constructor", () => {
+  globalThis.test("single-command slice keeps the byte-identical Plugin_Slice field", async () => {
+    let fieldNames = Api_Naming$ReventlessCore.sliceMutationFields("Catalog", "AddCategory", dcbSingleCommandSchema).map(param => param[0]);
+    globalThis.expect(fieldNames).toEqual(["Catalog_AddCategory"]);
+  });
+  globalThis.test("multi-command slice emits one `${plugin}_${command}` field per constructor", async () => {
+    let fieldNames = Api_Naming$ReventlessCore.sliceMutationFields("Ordering", "SyncCatalogProduct", dcbMultiCommandSchema).map(param => param[0]);
+    globalThis.expect(fieldNames).toEqual([
+      "Ordering_SyncNewProduct",
+      "Ordering_ChangeSyncedPrice"
+    ]);
+  });
+  globalThis.test("multi-command slice: both mutations carry their own args, plus both subscriptions (each ≤ 50 chars)", async () => {
+    let fieldNames = Api_Naming$ReventlessCore.sliceMutationFields("Ordering", "SyncCatalogProduct", dcbMultiCommandSchema).map(param => param[0]);
+    let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([{
+        fieldNames: fieldNames,
+        commandSchema: dcbMultiCommandSchema
+      }], []);
+    let sdl = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment).sdlPreview;
+    globalThis.expect(sdl.includes("Ordering_SyncNewProduct(id: ID!, productId: ID!, name: String!, price: Float!)")).toBe(true);
+    globalThis.expect(sdl.includes("Ordering_ChangeSyncedPrice(id: ID!, productId: ID!, price: Float!)")).toBe(true);
+    let subs = Plugin_SubscriptionSchema$ReventlessCore.generate([{
+        fieldNames: fieldNames,
+        commandSchema: dcbMultiCommandSchema
+      }], []);
+    let subSdl = subs.subscriptionFields.join("\n");
+    globalThis.expect(subSdl.includes("onOrdering_SyncNewProduct")).toBe(true);
+    globalThis.expect(subSdl.includes("onOrdering_ChangeSyncedPrice")).toBe(true);
+    subs.subscriptionFields.forEach(sub => {
+      let name = sub.trim().split("(")[0];
+      globalThis.expect(name.length <= 50).toBe(true);
+    });
+  });
+  globalThis.test("regression: a slice whose plugin+command overflow the 50-char cap fails at build, not at AppSync", async () => {
+    let field = Api_Naming$ReventlessCore.dcbCommandMutationField("PlatformIntegrationOrchestration", "RemoveExtensionWiring");
+    let raised;
+    try {
+      Api_Naming$ReventlessCore.assertSubscriptionNameFits(field);
+      raised = false;
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      if (exn.RE_EXN_ID === "JsExn") {
+        raised = true;
+      } else {
+        throw exn;
+      }
+    }
+    globalThis.expect(raised).toBe(true);
+  });
+});
+
 globalThis.describe("Plugin admin fragment — kind enum + kindEq filter", () => {
   globalThis.test("Platform_Plugin exposes a PluginKind enum and Platform_Plugins gains kindEq", async () => {
     let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], PluginBaseFragment$ReventlessCore.queryEntries);
@@ -579,6 +653,8 @@ export {
   svStateSchema,
   addCommandSchema,
   unionCommandSchema,
+  dcbSingleCommandSchema,
+  dcbMultiCommandSchema,
   plainStateSchema,
   indexedStateSchema,
   indexedStateSchemaWithAnnotations,