@reventlessdev/reventless-spec 3.0.0-alpha.64 → 3.0.0-alpha.66

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.66 (2026-07-05)
+
+### Bug Fixes
+
+* **spec:** republish DcbTag to ship [@schema-generated](https://github.com/schema-generated) derivedPartitionTagSchema ([c110c26](https://github.com/ReventlessDev/reventless-core/commit/c110c26ba54617a8455e205ed77aeba5212f6170))
+
+
+# 3.0.0-alpha.65 (2026-07-05)
+
+### Features
+
+* @[@reventless](https://github.com/reventless).systemCallable slice opt-in for deploy-time system callers ([c5ed537](https://github.com/ReventlessDev/reventless-core/commit/c5ed537309f8e4b7d4a4d4af1ed1ec83d060aea3))
+* **reventless-aws:** Postgres change-feed relay auto-wiring (B2.3d) ([62b430f](https://github.com/ReventlessDev/reventless-core/commit/62b430f1e6d8ec1f172de0cca324f7f26aaf5fcb))
+
+
 # 3.0.0-alpha.64 (2026-07-03)
 
 **Note:** Version bump only for package @reventlessdev/reventless-spec

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-spec",
-  "version": "3.0.0-alpha.64",
+  "version": "3.0.0-alpha.66",
   "description": "Specifications for Reventless",
   "license": "Apache-2.0",
   "bin": {

package/src/components/DcbTag.res

@@ -23,6 +23,7 @@ type tag = {key: string, value: string}
 Identifies which tag field is used as the storage partition key.
 The partition key determines how events are distributed across DynamoDB partitions.
 */
+@schema
 type partitionTag = {key: string}
 
 /**
@@ -238,12 +239,18 @@ let isCompositePartitionMember = (fieldSchema: S.t<unknown>): bool =>
 Composite partition key specification — the ordered field names and inter-field separators.
 `seps[i]` is placed between `keys[i]` and `keys[i+1]`; length is always `keys.length - 1`.
 */
+@schema
 type compositePartitionSpec = {
   keys: array<string>,
   seps: array<string>,
 }
 
+// Republish note: alpha.65 shipped a stale compiled interface that omitted the
+// @schema-generated `derivedPartitionTagSchema`, breaking downstream
+// `Reventless.DcbTag.derivedPartitionTagSchema` references (e.g. reventless-aws
+// PgChangeFeedRelay). This forces a clean rebuild + republish.
 /** Union of simple and composite partition tag strategies. */
+@schema
 type derivedPartitionTag =
   | Simple(partitionTag)
   | Composite(compositePartitionSpec)

package/src/components/DcbTag.res.mjs

@@ -14,6 +14,10 @@ let tagSchema = S.schema(s => ({
   value: s.m(S.string)
 }));
 
+let partitionTagSchema = S.schema(s => ({
+  key: s.m(S.string)
+}));
+
 let dcbTagId = S.Metadata.Id.make("dcb", "tag");
 
 let dcbPartitionTagId = S.Metadata.Id.make("dcb", "partitionTag");
@@ -48,6 +52,22 @@ function isCompositePartitionMember(fieldSchema) {
   return Stdlib_Option.isSome(S.Metadata.get(fieldSchema, dcbCompositePartitionMemberId));
 }
 
+let compositePartitionSpecSchema = S.schema(s => ({
+  keys: s.m(S.array(S.string)),
+  seps: s.m(S.array(S.string))
+}));
+
+let derivedPartitionTagSchema = S.union([
+  S.schema(s => ({
+    TAG: "Simple",
+    _0: s.m(partitionTagSchema)
+  })),
+  S.schema(s => ({
+    TAG: "Composite",
+    _0: s.m(compositePartitionSpecSchema)
+  }))
+]);
+
 function isTagged(fieldSchema) {
   return Stdlib_Option.isSome(S.Metadata.get(fieldSchema, dcbTagId));
 }
@@ -800,6 +820,7 @@ function getPartitionTagValue(query, pt) {
 
 export {
   tagSchema,
+  partitionTagSchema,
   dcbTagId,
   dcbPartitionTagId,
   dcbCrossPartitionId,
@@ -812,6 +833,8 @@ export {
   crossPartition,
   compositePartitionMember,
   isCompositePartitionMember,
+  compositePartitionSpecSchema,
+  derivedPartitionTagSchema,
   isTagged,
   isTaggedArray,
   isPartitionTag,

package/src/generator/Codegen.res

@@ -672,6 +672,16 @@ let renderComposition = (~config: Config.config, ~resolved: Pairing.resolved): s
       ~moduleSuffix="Slice",
     ),
     hasPluginStructure ? Some("      ~pluginStructure=pluginStructure,") : None,
+    // Components carrying `@@reventless.systemCallable` — only emitted when at
+    // least one opts in, so existing generated Plugin.res files stay identical.
+    resolved.systemCallableComponents->Array.length > 0
+      ? Some(
+          "      ~systemCallableComponents=[" ++
+          resolved.systemCallableComponents
+          ->Array.map(n => "\"" ++ n ++ "\"")
+          ->Array.join(", ") ++ "],",
+        )
+      : None,
   ]
 
   makeParams->Array.filterMap(x => x)->Array.forEach(line => lines->Array.push(line))

package/src/generator/Codegen.res.mjs

@@ -428,7 +428,8 @@ function renderComposition(config, resolved) {
     renderMakeParam("automationSlices", resolved.automationSlices, "Slice"),
     renderMakeParam("outboundTranslationSlices", resolved.outboundTranslationSlices, "Slice"),
     renderMakeParam("inboundTranslationSlices", resolved.inboundTranslationSlices, "Slice"),
-    hasPluginStructure ? "      ~pluginStructure=pluginStructure," : undefined
+    hasPluginStructure ? "      ~pluginStructure=pluginStructure," : undefined,
+    resolved.systemCallableComponents.length !== 0 ? "      ~systemCallableComponents=[" + resolved.systemCallableComponents.map(n => "\"" + n + "\"").join(", ") + "]," : undefined
   ];
   Stdlib_Array.filterMap(makeParams, x => x).forEach(line => {
     lines.push(line);

package/src/generator/Pairing.res

@@ -57,6 +57,12 @@ type resolved = {
   // StateChangeSlice stems carrying `@@reventless.async` — codegen emits
   // `Platform.StateChangeSlice.MakeAsync` for these (CommandPending response).
   asyncStateChangeSlices: Dict.t<bool>,
+  // Spec names of StateChangeSlices / StateViewSlices (incl. Stream) carrying
+  // `@@reventless.systemCallable` — codegen threads them as
+  // `~systemCallableComponents` on `Platform.Plugin.make` so the AWS provider
+  // emits the dual-auth `@aws_cognito_user_pools(...) @aws_iam` directive on
+  // their GraphQL fields (deploy-time SigV4 system callers). Sorted.
+  systemCallableComponents: array<string>,
   aggregates: array<aggregateDef>,
   readModels: array<readModelDef>,
   tasks: array<string>,
@@ -139,22 +145,21 @@ let extractTargetName = (filePath: string): option<string> => {
   }
 }
 
-// Returns true if the spec file declares `@@reventless.async` at the file
-// level (Aggregate or StateChangeSlice opt-in to CommandPending response).
-// Falls back to false on read errors so a transient FS failure can't flip
-// component to async — the safe default is sync.
-let hasAsyncAttribute = (filePath: string): bool => {
+// Returns true if the spec file declares the given file-level attribute
+// (e.g. `@@reventless.async`, `@@reventless.systemCallable`). Falls back to
+// false on read errors so a transient FS failure can't flip a component
+// into the opt-in behavior — the safe default is the attribute being absent.
+let hasFileAttribute = (filePath: string, ~attr: string): bool => {
   try {
     let content = Generator_Node.readFileSync(filePath)
     let found = ref(false)
     content->String.split("\n")->Array.forEach(line => {
       let trimmed = line->String.trimStart
-      // Match `@@reventless.async` and tolerate a payload arg in the future.
+      // Match the bare attribute and tolerate a payload arg in the future.
       if (
-        trimmed->String.startsWith("@@reventless.async ") ||
-        trimmed->String.startsWith("@@reventless.async(") ||
-        trimmed === "@@reventless.async" ||
-        trimmed->String.startsWith("@@reventless.async\n")
+        trimmed->String.startsWith(attr ++ " ") ||
+        trimmed->String.startsWith(attr ++ "(") ||
+        trimmed === attr
       ) {
         found := true
       }
@@ -165,6 +170,41 @@ let hasAsyncAttribute = (filePath: string): bool => {
   }
 }
 
+// `@@reventless.async` — Aggregate or StateChangeSlice opt-in to async
+// command dispatch (CommandPending response).
+let hasAsyncAttribute = (filePath: string): bool =>
+  hasFileAttribute(filePath, ~attr="@@reventless.async")
+
+// `@@reventless.systemCallable` — StateChangeSlice / StateViewSlice opt-in to
+// deploy-time IAM (SigV4) invocation of the component's GraphQL fields.
+let hasSystemCallableAttribute = (filePath: string): bool =>
+  hasFileAttribute(filePath, ~attr="@@reventless.systemCallable")
+
+// The effective spec name of a file: the explicit `@@reventless.spec("Name")`
+// payload when present, the filename stem otherwise (mirroring the PPX's name
+// derivation). Needed because `systemCallableComponents` is matched against
+// `Spec.name` at deploy time — a stem-only value would silently miss specs
+// with an explicit name override.
+let effectiveSpecName = (filePath: string, ~stem: string): string => {
+  try {
+    let content = Generator_Node.readFileSync(filePath)
+    let name = ref(None)
+    content->String.split("\n")->Array.forEach(line => {
+      let trimmed = line->String.trimStart
+      if trimmed->String.startsWith("@@reventless.spec(") {
+        let firstQuote = trimmed->String.indexOf("\"")
+        let lastQuote = trimmed->String.lastIndexOf("\"")
+        if firstQuote >= 0 && lastQuote > firstQuote {
+          name := Some(trimmed->String.slice(~start=firstQuote + 1, ~end=lastQuote))
+        }
+      }
+    })
+    name.contents->Option.getOr(stem)
+  } catch {
+  | _ => stem
+  }
+}
+
 // Partition the ExtensionPoint mapping files into flat (ungrouped) and grouped
 // `extensionPointDef`s: every mapping sharing an `epGroup` collects into one
 // grouped entry; the ungrouped ones share a single flat (`group: None`) entry.
@@ -213,6 +253,8 @@ let resolve = (discovered: array<Discovery.discoveredFile>, ~srcDir: string): re
   let aggregateSpecs: array<string> = []
   let aggregateSpecRelPaths: Dict.t<string> = Dict.make()
   let stateChangeSliceRelPaths: Dict.t<string> = Dict.make()
+  // Shared by StateViewSlice and StateViewSliceStream (stems are unique).
+  let stateViewSliceRelPaths: Dict.t<string> = Dict.make()
   let aggregateBehaviors: array<string> = []
   let readModelStems: array<string> = []
   // Stream-enabled read model spec stems (the `ReadModelStream/` folder).
@@ -236,9 +278,15 @@ let resolve = (discovered: array<Discovery.discoveredFile>, ~srcDir: string): re
         stateChangeSliceRelPaths->Dict.set(stem, relPath)
       }
     | StateViewSlice =>
-      if !isImplStem(stem) { stateViewSlices->Array.push(stem) }
+      if !isImplStem(stem) {
+        stateViewSlices->Array.push(stem)
+        stateViewSliceRelPaths->Dict.set(stem, relPath)
+      }
     | StateViewSliceStream =>
-      if !isImplStem(stem) { stateViewSlicesStream->Array.push(stem) }
+      if !isImplStem(stem) {
+        stateViewSlicesStream->Array.push(stem)
+        stateViewSliceRelPaths->Dict.set(stem, relPath)
+      }
     | AutomationSlice =>
       if !isImplStem(stem) {
         automationSlices->Array.push(stem)
@@ -385,6 +433,24 @@ let resolve = (discovered: array<Discovery.discoveredFile>, ~srcDir: string): re
       })
       d
     },
+    systemCallableComponents: {
+      let names = []
+      let collect = (stems: array<string>, relPaths: Dict.t<string>) =>
+        stems->Array.forEach(stem => {
+          switch Dict.get(relPaths, stem) {
+          | None => ()
+          | Some(relPath) =>
+            let filePath = Generator_Node.join([srcDir, relPath])
+            if hasSystemCallableAttribute(filePath) {
+              names->Array.push(effectiveSpecName(filePath, ~stem))
+            }
+          }
+        })
+      collect(stateChangeSlices, stateChangeSliceRelPaths)
+      collect(stateViewSlices, stateViewSliceRelPaths)
+      collect(stateViewSlicesStream, stateViewSliceRelPaths)
+      names->sortedStems
+    },
     aggregates,
     readModels,
     tasks: tasks->sortedStems,

package/src/generator/Pairing.res.mjs

@@ -3,6 +3,7 @@
 import * as Nodefs from "node:fs";
 import * as Nodepath from "node:path";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Generator_Node$Reventless from "./Generator_Node.res.mjs";
 
 let implSuffixForStateChange = "_Behavior";
@@ -112,7 +113,7 @@ function extractTargetName(filePath) {
   }
 }
 
-function hasAsyncAttribute(filePath) {
+function hasFileAttribute(filePath, attr) {
   try {
     let content = Nodefs.readFileSync(filePath, "utf8");
     let found = {
@@ -120,7 +121,7 @@ function hasAsyncAttribute(filePath) {
     };
     content.split("\n").forEach(line => {
       let trimmed = line.trimStart();
-      if (trimmed.startsWith("@@reventless.async ") || trimmed.startsWith("@@reventless.async(") || trimmed === "@@reventless.async" || trimmed.startsWith("@@reventless.async\n")) {
+      if (trimmed.startsWith(attr + " ") || trimmed.startsWith(attr + "(") || trimmed === attr) {
         found.contents = true;
         return;
       }
@@ -131,6 +132,38 @@ function hasAsyncAttribute(filePath) {
   }
 }
 
+function hasAsyncAttribute(filePath) {
+  return hasFileAttribute(filePath, "@@reventless.async");
+}
+
+function hasSystemCallableAttribute(filePath) {
+  return hasFileAttribute(filePath, "@@reventless.systemCallable");
+}
+
+function effectiveSpecName(filePath, stem) {
+  try {
+    let content = Nodefs.readFileSync(filePath, "utf8");
+    let name = {
+      contents: undefined
+    };
+    content.split("\n").forEach(line => {
+      let trimmed = line.trimStart();
+      if (!trimmed.startsWith("@@reventless.spec(")) {
+        return;
+      }
+      let firstQuote = trimmed.indexOf("\"");
+      let lastQuote = trimmed.lastIndexOf("\"");
+      if (firstQuote >= 0 && lastQuote > firstQuote) {
+        name.contents = trimmed.slice(firstQuote + 1 | 0, lastQuote);
+        return;
+      }
+    });
+    return Stdlib_Option.getOr(name.contents, stem);
+  } catch (exn) {
+    return stem;
+  }
+}
+
 function groupExtensionPoints(epFiles) {
   let epByGroup = {};
   let flatEpMappings = [];
@@ -178,6 +211,7 @@ function resolve(discovered, srcDir) {
   let aggregateSpecs = [];
   let aggregateSpecRelPaths = {};
   let stateChangeSliceRelPaths = {};
+  let stateViewSliceRelPaths = {};
   let aggregateBehaviors = [];
   let readModelStems = [];
   let readModelStreamStems = [];
@@ -201,6 +235,7 @@ function resolve(discovered, srcDir) {
       case "StateViewSlice" :
         if (!isImplStem(stem)) {
           stateViewSlices.push(stem);
+          stateViewSliceRelPaths[stem] = relPath;
           return;
         } else {
           return;
@@ -208,6 +243,7 @@ function resolve(discovered, srcDir) {
       case "StateViewSliceStream" :
         if (!isImplStem(stem)) {
           stateViewSlicesStream.push(stem);
+          stateViewSliceRelPaths[stem] = relPath;
           return;
         } else {
           return;
@@ -282,7 +318,7 @@ function resolve(discovered, srcDir) {
       );
     if (behaviorStem !== undefined) {
       let relPath = aggregateSpecRelPaths[spec];
-      let isAsync = relPath !== undefined ? hasAsyncAttribute(Nodepath.join(srcDir, relPath)) : false;
+      let isAsync = relPath !== undefined ? hasFileAttribute(Nodepath.join(srcDir, relPath), "@@reventless.async") : false;
       return {
         spec: spec,
         behavior: behaviorStem,
@@ -319,6 +355,20 @@ function resolve(discovered, srcDir) {
     return dict;
   };
   let d = {};
+  let names = [];
+  let collect = (stems, relPaths) => {
+    stems.forEach(stem => {
+      let relPath = relPaths[stem];
+      if (relPath === undefined) {
+        return;
+      }
+      let filePath = Nodepath.join(srcDir, relPath);
+      if (hasFileAttribute(filePath, "@@reventless.systemCallable")) {
+        names.push(effectiveSpecName(filePath, stem));
+        return;
+      }
+    });
+  };
   return {
     stateChangeSlices: sortedStems(stateChangeSlices),
     stateViewSlices: sortedStems(stateViewSlices),
@@ -331,11 +381,12 @@ function resolve(discovered, srcDir) {
     outboundTranslationSliceTargets: buildTargets(outboundTranslationSlices, outboundTranslationSliceRelPaths),
     asyncStateChangeSlices: (stateChangeSlices.forEach(stem => {
       let relPath = stateChangeSliceRelPaths[stem];
-      if (relPath !== undefined && hasAsyncAttribute(Nodepath.join(srcDir, relPath))) {
+      if (relPath !== undefined && hasFileAttribute(Nodepath.join(srcDir, relPath), "@@reventless.async")) {
         d[stem] = true;
         return;
       }
     }), d),
+    systemCallableComponents: (collect(stateChangeSlices, stateChangeSliceRelPaths), collect(stateViewSlices, stateViewSliceRelPaths), collect(stateViewSlicesStream, stateViewSliceRelPaths), sortedStems(names)),
     aggregates: aggregates,
     readModels: readModels,
     tasks: sortedStems(tasks),
@@ -354,7 +405,10 @@ export {
   findEventMappings,
   sortedStems,
   extractTargetName,
+  hasFileAttribute,
   hasAsyncAttribute,
+  hasSystemCallableAttribute,
+  effectiveSpecName,
   groupExtensionPoints,
   resolve,
 }