@reventlessdev/reventless-core 3.0.0-alpha.143 → 3.0.0-alpha.145

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.145 (2026-07-08)
+
+### Bug Fixes
+
+* **reventless-aws:** stop admin-base schema clobber of split-mode DomainApi ([afce85f](https://github.com/ReventlessDev/reventless-core/commit/afce85fa57474735cea3dcb1c2a151c2d8804f0e))
+
+
+# 3.0.0-alpha.144 (2026-07-07)
+
+### Bug Fixes
+
+* **reventless-aws:** thread inferred DCB scope into the deployed command handler ([4d8327f](https://github.com/ReventlessDev/reventless-core/commit/4d8327fad8659a1cde8c36098c72392737437af1))
+
+
 # 3.0.0-alpha.143 (2026-07-06)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.143",
+  "version": "3.0.0-alpha.145",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -29,16 +29,16 @@
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.25",
-    "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.11",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.10",
-    "@reventlessdev/rescript-node-streams": "1.1.0-alpha.10",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.6",
+    "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.11",
+    "@reventlessdev/rescript-node-streams": "1.1.0-alpha.10",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.89",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.67",
+    "@reventlessdev/rescript-ssh2": "1.1.0-alpha.11",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.90",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.68",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.24",
-    "@reventlessdev/rescript-uuid": "1.1.0-alpha.14",
-    "@reventlessdev/rescript-ssh2": "1.1.0-alpha.11"
+    "@reventlessdev/rescript-uuid": "1.1.0-alpha.14"
   },
   "devDependencies": {
     "rescript": "^12.3.0",

package/src/components/Api/GraphQL_Stitcher.res

@@ -218,21 +218,24 @@ let isIdentStart = (line: string): bool =>
   }
 
 /**
-Count the field definitions inside a root object type (`Mutation` / `Query`) of a
-full SDL string.
-
-Used by the runtime schema-update circuit breaker (AdminEventCollectorEntryPoint)
-to detect a catastrophic shrink before pushing a new schema to AppSync. Heuristic
-but adequate for a shrink guard: root operation fields are flat single-line
-declarations (`name(args): T` or `name: T`), so we slice the `type <typeName> {
-… }` block at its first `{`/`}` and count indented lines that begin with an
-identifier character, ignoring directive-only lines (`@…`), comments (`#…`) and
-braces.
+List the field NAMES defined inside a root object type (`Mutation` / `Query` /
+`Subscription`) of a full SDL string.
+
+This is the identity-aware primitive underlying every schema-clobber guard:
+`countRootTypeFields` is just its length, and the deploy-time repair / shrink
+guards compare the returned NAME SETS rather than cardinalities so they catch
+field *swaps* and equal-cardinality drift that a count comparison misses.
+
+Heuristic but adequate: root operation fields are flat single-line declarations
+(`name(args): T` or `name: T`), so we slice the `type <typeName> { … }` block at
+its first `{`/`}` and read the leading identifier of each indented line that
+begins with an identifier character, ignoring directive-only lines (`@…`),
+comments (`#…`) and braces.
 */
-let countRootTypeFields = (~sdl: string, ~typeName: string): int => {
+let rootTypeFieldNames = (~sdl: string, ~typeName: string): array<string> => {
   let marker = `type ${typeName}`
   switch sdl->String.indexOfOpt(marker) {
-  | None => 0
+  | None => []
   | Some(typeStart) =>
     let rest = sdl->String.slice(~start=typeStart)
     switch (rest->String.indexOfOpt("{"), rest->String.indexOfOpt("}")) {
@@ -240,32 +243,82 @@ let countRootTypeFields = (~sdl: string, ~typeName: string): int => {
       rest
       ->String.slice(~start=openIdx + 1, ~end=closeIdx)
       ->String.split("\n")
-      ->Array.filter(line => {
+      ->Array.filterMap(line => {
         let trimmed = line->String.trim
-        trimmed->String.length > 0 && isIdentStart(trimmed)
+        if trimmed->String.length > 0 && isIdentStart(trimmed) {
+          // `name(args): T` → extractLeadingName strips the arg list; `name: T`
+          // (no args) leaves a trailing colon on the token — drop it so a field
+          // reads the same whether or not it takes arguments.
+          let name = extractLeadingName(trimmed)
+          let name = name->String.endsWith(":")
+            ? name->String.slice(~start=0, ~end=name->String.length - 1)
+            : name
+          name->String.length > 0 ? Some(name) : None
+        } else {
+          None
+        }
       })
-      ->Array.length
-    | _ => 0
+    | _ => []
     }
   }
 }
 
+/**
+Count the field definitions inside a root object type (`Mutation` / `Query`) of a
+full SDL string. Length of `rootTypeFieldNames`.
+*/
+let countRootTypeFields = (~sdl: string, ~typeName: string): int =>
+  rootTypeFieldNames(~sdl, ~typeName)->Array.length
+
+// The three GraphQL root operation types every clobber guard reasons over.
+let rootTypeNames = ["Mutation", "Query", "Subscription"]
+
+/**
+Union of every root-operation field name across `Mutation` + `Query` +
+`Subscription`. The identity set the deploy-time repair and shrink guards diff.
+*/
+let allRootFieldNames = (~sdl: string): array<string> =>
+  rootTypeNames->Array.flatMap(typeName => rootTypeFieldNames(~sdl, ~typeName))
+
+/**
+Root-operation field names present in `expectedSdl` but MISSING from `liveSdl`
+(across Mutation + Query + Subscription). Non-empty ⇒ the live schema is not a
+superset of what we expect and a repair push is warranted — this heals field
+*swaps* and equal-cardinality drift that a bare count comparison would skip.
+*/
+let missingRootFields = (~expectedSdl: string, ~liveSdl: string): array<string> => {
+  let liveSet = allRootFieldNames(~sdl=liveSdl)->Set.fromArray
+  allRootFieldNames(~sdl=expectedSdl)->Array.filter(name => !(liveSet->Set.has(name)))
+}
+
 /**
 Decide whether replacing the live schema (`currentSdl`) with `newSdl` would drop
-so many root-type (`Mutation` + `Query`) fields that it is almost certainly a
+root-operation fields the pushing stack does not carry — i.e. an almost-certainly
 transient/incomplete stitch rather than an intentional removal.
 
-Returns `true` when the new root-field total is below `threshold` × the current
-total. When the current schema has no countable root fields (e.g. first deploy,
-or introspection was unavailable so `currentSdl` is empty) it returns `false` so
-the initial push always proceeds.
+Identity-based (across `Mutation` + `Query` + `Subscription`):
+- When `newSdl`'s field-name set is a SUPERSET of the live set — nothing is
+  dropped — it is purely additive (or unchanged) and never a clobber, so this
+  returns `false` even when the pushing stack is legitimately adding its own
+  fields.
+- Otherwise it falls back to the cardinality threshold on the union of the three
+  root types: `true` only when the new total drops below `threshold` × the
+  current total. A small intentional removal (above threshold) is allowed.
+
+When the current schema has no countable root fields (e.g. first deploy, or
+introspection was unavailable so `currentSdl` is empty) it returns `false` so the
+initial push always proceeds.
 */
 let isCatastrophicSchemaShrink = (~currentSdl: string, ~newSdl: string, ~threshold: float): bool => {
-  let current =
-    countRootTypeFields(~sdl=currentSdl, ~typeName="Mutation") +
-    countRootTypeFields(~sdl=currentSdl, ~typeName="Query")
-  let next =
-    countRootTypeFields(~sdl=newSdl, ~typeName="Mutation") +
-    countRootTypeFields(~sdl=newSdl, ~typeName="Query")
-  current > 0 && next->Int.toFloat < current->Int.toFloat *. threshold
+  let currentNames = allRootFieldNames(~sdl=currentSdl)
+  let newSet = allRootFieldNames(~sdl=newSdl)->Set.fromArray
+  let dropped = currentNames->Array.filter(name => !(newSet->Set.has(name)))
+  if dropped->Array.length == 0 {
+    // Additive or unchanged push — the new schema keeps every live field.
+    false
+  } else {
+    let current = currentNames->Array.length
+    let next = allRootFieldNames(~sdl=newSdl)->Array.length
+    current > 0 && next->Int.toFloat < current->Int.toFloat *. threshold
+  }
 }

package/src/components/Api/GraphQL_Stitcher.res.mjs

@@ -181,32 +181,68 @@ function isIdentStart(line) {
   }
 }
 
-function countRootTypeFields(sdl, typeName) {
+function rootTypeFieldNames(sdl, typeName) {
   let marker = `type ` + typeName;
   let typeStart = Stdlib_String.indexOfOpt(sdl, marker);
   if (typeStart === undefined) {
-    return 0;
+    return [];
   }
   let rest = sdl.slice(typeStart);
   let match = Stdlib_String.indexOfOpt(rest, "{");
   let match$1 = Stdlib_String.indexOfOpt(rest, "}");
-  if (match !== undefined && match$1 !== undefined && match$1 > match) {
-    return rest.slice(match + 1 | 0, match$1).split("\n").filter(line => {
-      let trimmed = line.trim();
-      if (trimmed.length > 0) {
-        return isIdentStart(trimmed);
+  if (match !== undefined) {
+    if (match$1 !== undefined) {
+      if (match$1 > match) {
+        return Stdlib_Array.filterMap(rest.slice(match + 1 | 0, match$1).split("\n"), line => {
+          let trimmed = line.trim();
+          if (!(trimmed.length > 0 && isIdentStart(trimmed))) {
+            return;
+          }
+          let name = extractLeadingName(trimmed);
+          let name$1 = name.endsWith(":") ? name.slice(0, name.length - 1 | 0) : name;
+          if (name$1.length > 0) {
+            return name$1;
+          }
+        });
       } else {
-        return false;
+        return [];
       }
-    }).length;
+    } else {
+      return [];
+    }
   } else {
-    return 0;
+    return [];
   }
 }
 
+function countRootTypeFields(sdl, typeName) {
+  return rootTypeFieldNames(sdl, typeName).length;
+}
+
+let rootTypeNames = [
+  "Mutation",
+  "Query",
+  "Subscription"
+];
+
+function allRootFieldNames(sdl) {
+  return rootTypeNames.flatMap(typeName => rootTypeFieldNames(sdl, typeName));
+}
+
+function missingRootFields(expectedSdl, liveSdl) {
+  let liveSet = new Set(allRootFieldNames(liveSdl));
+  return allRootFieldNames(expectedSdl).filter(name => !liveSet.has(name));
+}
+
 function isCatastrophicSchemaShrink(currentSdl, newSdl, threshold) {
-  let current = countRootTypeFields(currentSdl, "Mutation") + countRootTypeFields(currentSdl, "Query") | 0;
-  let next = countRootTypeFields(newSdl, "Mutation") + countRootTypeFields(newSdl, "Query") | 0;
+  let currentNames = allRootFieldNames(currentSdl);
+  let newSet = new Set(allRootFieldNames(newSdl));
+  let dropped = currentNames.filter(name => !newSet.has(name));
+  if (dropped.length === 0) {
+    return false;
+  }
+  let current = currentNames.length;
+  let next = allRootFieldNames(newSdl).length;
   if (current > 0) {
     return next < current * threshold;
   } else {
@@ -223,7 +259,11 @@ export {
   relayBaseQueries,
   stitch,
   isIdentStart,
+  rootTypeFieldNames,
   countRootTypeFields,
+  rootTypeNames,
+  allRootFieldNames,
+  missingRootFields,
   isCatastrophicSchemaShrink,
 }
 /* log Not a pure module */

package/src/components/Dcb/Dcb_Builder.res

@@ -289,11 +289,21 @@ module Make = (
 
         // All-or-nothing: thread the derived scope only when every slice resolved.
         // An ambiguous boundary keeps the annotated values (no partial inference).
-        let useInferred = inferred.ambiguities->Array.length == 0
-        let effectiveCrossPartitionTagKeys =
-          useInferred ? inferred.crossPartitionTagKeys : crossPartitionTagKeys
-        let effectiveTagKeysByEventType =
-          useInferred ? inferred.tagKeysByEventType : tagKeysByEventType
+        // Both this builder and the deployed command-handler entry point
+        // (DcbCommandTopicEntryPoint.mjs) route through `DcbTag.deriveEffectiveScope`
+        // so the runtime decision query cannot drift from this scope — see
+        // docs/analysis/dcb-runtime-scope-annotation-drift.md.
+        let {
+          crossPartitionTagKeys: effectiveCrossPartitionTagKeys,
+          tagKeysByEventType: effectiveTagKeysByEventType,
+        } = Reventless.DcbTag.deriveEffectiveScope(
+          stateChangeSlices->Array.map((module(Sc: StateChangeSlice.T)) => {
+            Reventless.DcbTag.name: Sc.Spec.name,
+            commandSchema: Sc.Spec.commandSchema->S.castToUnknown,
+            consumedEventSchema: Sc.Spec.consumedEventSchema->S.castToUnknown,
+            eventSchema: Sc.Spec.eventSchema->S.castToUnknown,
+          }),
+        )
 
         module DcbEventLog = DcbEventLog_Builder.Make(
           DcbEventLogStorage,

package/src/components/Dcb/Dcb_Builder.res.mjs

@@ -167,9 +167,14 @@ function Make(DcbEventLogStorage) {
       let scopeIssues = DcbValidation$Reventless.validateScopeVsInference(scopeAnnotations, inferred);
       scopeIssues.contradictions.forEach(e => log.warn("Dcb_Builder", undefined, `DCB scope contradiction (` + e.sliceName + `): ` + e.message));
       scopeIssues.redundancies.forEach(e => log.info("Dcb_Builder", undefined, `DCB scope (` + e.sliceName + `): ` + e.message));
-      let useInferred = inferred.ambiguities.length === 0;
-      let effectiveCrossPartitionTagKeys = useInferred ? inferred.crossPartitionTagKeys : crossPartitionTagKeys;
-      let effectiveTagKeysByEventType = useInferred ? inferred.tagKeysByEventType : tagKeysByEventType;
+      let match = DcbTag$Reventless.deriveEffectiveScope(stateChangeSlices.map(Sc => ({
+        name: Sc.Spec.name,
+        commandSchema: Sc.Spec.commandSchema,
+        consumedEventSchema: Sc.Spec.consumedEventSchema,
+        eventSchema: Sc.Spec.eventSchema
+      })));
+      let effectiveTagKeysByEventType = match.tagKeysByEventType;
+      let effectiveCrossPartitionTagKeys = match.crossPartitionTagKeys;
       let DcbEventLog = DcbEventLog_Builder$ReventlessCore.Make(DcbEventLogStorage)(DcbEventTopicPublisher);
       let dcbEventLog = DcbEventLog.make(name, indexes$1, partitionTag, effectiveCrossPartitionTagKeys, opts);
       Stdlib_Option.forEach(HooksConfig.hooks.onDcbEventLogCreated, hook => hook(dcbEventLog));

package/tests/api/GraphQL_StitcherTest.res

@@ -104,4 +104,97 @@ type Mutation {
       isCatastrophicSchemaShrink(~currentSdl=fullSchemaSdl, ~newSdl=fullSchemaSdl, ~threshold=0.5),
     )->toBe(false)
   })
+  testSync("allows a purely additive push even below threshold cardinality", () => {
+    // A tiny live schema growing into a big one drops nothing → never a clobber,
+    // regardless of the ratio.
+    expect(
+      isCatastrophicSchemaShrink(~currentSdl=collapsedSchemaSdl, ~newSdl=fullSchemaSdl, ~threshold=0.5),
+    )->toBe(false)
+  })
+  testSync("includes Subscription fields when judging a shrink", () => {
+    let withSubs = `type Query {
+  node(id: ID!): Node
+}
+
+type Mutation {
+  Ordering_placeOrder(input: OrderInput): Order
+}
+
+type Subscription {
+  onOrdering_Customer_Register: Customer
+  onOrdering_Customer_UpdateAddress: Customer
+  onCatalog_Product_Added: Product
+}`
+    // Dropping every Subscription field (and keeping Mutation/Query) is a shrink
+    // the Mutation+Query-only guard would have missed.
+    let subsGone = `type Query {
+  node(id: ID!): Node
+}
+
+type Mutation {
+  Ordering_placeOrder(input: OrderInput): Order
+}`
+    expect(
+      isCatastrophicSchemaShrink(~currentSdl=withSubs, ~newSdl=subsGone, ~threshold=0.5),
+    )->toBe(true)
+  })
+})
+
+describe("GraphQL_Stitcher.rootTypeFieldNames", () => {
+  testSync("lists Mutation field names", () => {
+    expect(rootTypeFieldNames(~sdl=fullSchemaSdl, ~typeName="Mutation"))->toEqual([
+      "Platform_connectPlugin",
+      "Catalog_addProduct",
+      "Catalog_updateProduct",
+      "Ordering_placeOrder",
+    ])
+  })
+  testSync("strips args and @aws_auth directive lines", () => {
+    expect(rootTypeFieldNames(~sdl=authAnnotatedSdl, ~typeName="Mutation"))->toEqual([
+      "Platform_connectPlugin",
+      "Catalog_addProduct",
+    ])
+  })
+  testSync("missing type returns []", () => {
+    expect(rootTypeFieldNames(~sdl=fullSchemaSdl, ~typeName="Subscription"))->toEqual([])
+  })
+})
+
+describe("GraphQL_Stitcher.missingRootFields", () => {
+  testSync("reports plugin fields absent from an admin-base clobber", () => {
+    // The alpha 2026-07-08 clobber: live schema is admin-base only. Every
+    // Catalog_*/Ordering_* field the deploy expects is missing → repair fires.
+    let missing = missingRootFields(~expectedSdl=fullSchemaSdl, ~liveSdl=collapsedSchemaSdl)
+    expect(missing->Array.includes("Catalog_addProduct"))->toBe(true)
+    expect(missing->Array.includes("Ordering_placeOrder"))->toBe(true)
+    expect(missing->Array.includes("Ordering_orders"))->toBe(true)
+  })
+  testSync("empty when live schema is a superset (intact)", () => {
+    expect(missingRootFields(~expectedSdl=fullSchemaSdl, ~liveSdl=fullSchemaSdl))->toEqual([])
+  })
+  testSync("detects an equal-cardinality field swap the count test misses", () => {
+    // Same number of root fields, but one Mutation field replaced by a foreign
+    // one — a swap. countRootTypeFields would report no drift; the name-set diff
+    // catches it.
+    let swapped = `type Query {
+  node(id: ID!): Node
+  Platform_plugins: [Plugin]
+  Catalog_products: [Product]
+  Ordering_orders: [Order]
+}
+
+type Mutation {
+  Platform_connectPlugin(input: ConnectInput): ConnectResult
+  Catalog_addProduct(input: AddInput): Product
+  Catalog_updateProduct(input: UpdateInput): Product
+  Foreign_strayField(input: OrderInput): Order
+}`
+    // Same count on both sides.
+    expect(countRootTypeFields(~sdl=swapped, ~typeName="Mutation"))->toBe(
+      countRootTypeFields(~sdl=fullSchemaSdl, ~typeName="Mutation"),
+    )
+    // But the expected Ordering_placeOrder is missing from the live (swapped) schema.
+    let missing = missingRootFields(~expectedSdl=fullSchemaSdl, ~liveSdl=swapped)
+    expect(missing->Array.includes("Ordering_placeOrder"))->toBe(true)
+  })
 })

package/tests/api/GraphQL_StitcherTest.res.mjs

@@ -89,6 +89,80 @@ type Mutation {
   globalThis.test("allows an unchanged re-push (same SDL)", () => {
     globalThis.expect(GraphQL_Stitcher$ReventlessCore.isCatastrophicSchemaShrink(fullSchemaSdl, fullSchemaSdl, 0.5)).toBe(false);
   });
+  globalThis.test("allows a purely additive push even below threshold cardinality", () => {
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.isCatastrophicSchemaShrink(collapsedSchemaSdl, fullSchemaSdl, 0.5)).toBe(false);
+  });
+  globalThis.test("includes Subscription fields when judging a shrink", () => {
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.isCatastrophicSchemaShrink(`type Query {
+  node(id: ID!): Node
+}
+
+type Mutation {
+  Ordering_placeOrder(input: OrderInput): Order
+}
+
+type Subscription {
+  onOrdering_Customer_Register: Customer
+  onOrdering_Customer_UpdateAddress: Customer
+  onCatalog_Product_Added: Product
+}`, `type Query {
+  node(id: ID!): Node
+}
+
+type Mutation {
+  Ordering_placeOrder(input: OrderInput): Order
+}`, 0.5)).toBe(true);
+  });
+});
+
+globalThis.describe("GraphQL_Stitcher.rootTypeFieldNames", () => {
+  globalThis.test("lists Mutation field names", () => {
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.rootTypeFieldNames(fullSchemaSdl, "Mutation")).toEqual([
+      "Platform_connectPlugin",
+      "Catalog_addProduct",
+      "Catalog_updateProduct",
+      "Ordering_placeOrder"
+    ]);
+  });
+  globalThis.test("strips args and @aws_auth directive lines", () => {
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.rootTypeFieldNames(authAnnotatedSdl, "Mutation")).toEqual([
+      "Platform_connectPlugin",
+      "Catalog_addProduct"
+    ]);
+  });
+  globalThis.test("missing type returns []", () => {
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.rootTypeFieldNames(fullSchemaSdl, "Subscription")).toEqual([]);
+  });
+});
+
+globalThis.describe("GraphQL_Stitcher.missingRootFields", () => {
+  globalThis.test("reports plugin fields absent from an admin-base clobber", () => {
+    let missing = GraphQL_Stitcher$ReventlessCore.missingRootFields(fullSchemaSdl, collapsedSchemaSdl);
+    globalThis.expect(missing.includes("Catalog_addProduct")).toBe(true);
+    globalThis.expect(missing.includes("Ordering_placeOrder")).toBe(true);
+    globalThis.expect(missing.includes("Ordering_orders")).toBe(true);
+  });
+  globalThis.test("empty when live schema is a superset (intact)", () => {
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.missingRootFields(fullSchemaSdl, fullSchemaSdl)).toEqual([]);
+  });
+  globalThis.test("detects an equal-cardinality field swap the count test misses", () => {
+    let swapped = `type Query {
+  node(id: ID!): Node
+  Platform_plugins: [Plugin]
+  Catalog_products: [Product]
+  Ordering_orders: [Order]
+}
+
+type Mutation {
+  Platform_connectPlugin(input: ConnectInput): ConnectResult
+  Catalog_addProduct(input: AddInput): Product
+  Catalog_updateProduct(input: UpdateInput): Product
+  Foreign_strayField(input: OrderInput): Order
+}`;
+    globalThis.expect(GraphQL_Stitcher$ReventlessCore.countRootTypeFields(swapped, "Mutation")).toBe(GraphQL_Stitcher$ReventlessCore.countRootTypeFields(fullSchemaSdl, "Mutation"));
+    let missing = GraphQL_Stitcher$ReventlessCore.missingRootFields(fullSchemaSdl, swapped);
+    globalThis.expect(missing.includes("Ordering_placeOrder")).toBe(true);
+  });
 });
 
 export {