@reventlessdev/reventless-spec 3.0.0-alpha.63 → 3.0.0-alpha.65

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 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.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
+
+
+
+
+
 # 3.0.0-alpha.63 (2026-07-02)
 
 ### Bug Fixes

package/package.json

@@ -1,18 +1,28 @@
 {
   "name": "@reventlessdev/reventless-spec",
-  "version": "3.0.0-alpha.63",
+  "version": "3.0.0-alpha.65",
   "description": "Specifications for Reventless",
   "license": "Apache-2.0",
   "bin": {
     "generate-plugin": "./run-generator.mjs"
   },
+  "jest": {
+    "testMatch": [
+      "<rootDir>/tests/**/*Test.res.mjs"
+    ],
+    "moduleFileExtensions": [
+      "js",
+      "mjs"
+    ]
+  },
   "dependencies": {
     "jsonschema2graphql": "1.1.1",
     "sury": "11.0.0-alpha.4",
     "sury-ppx": "11.0.0-alpha.2"
   },
   "devDependencies": {
-    "rescript": "^12.3.0"
+    "rescript": "^12.3.0",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.5"
   },
   "peerDependencies": {
     "rescript": "^12.3.0"
@@ -28,6 +38,8 @@
   "scripts": {
     "build": "rescript build",
     "start": "rescript start",
-    "clean": "rescript clean"
+    "clean": "rescript clean",
+    "test": "NODE_OPTIONS='--experimental-vm-modules' jest",
+    "dev": "NODE_OPTIONS='--experimental-vm-modules' jest --watchAll"
   }
 }

package/rescript.json

@@ -15,10 +15,15 @@
     {
       "dir": "src",
       "subdirs": true
+    },
+    {
+      "dir": "tests",
+      "subdirs": true
     }
   ],
   "dependencies": [
-    "sury"
+    "sury",
+    "@reventlessdev/rescript-jest"
   ],
   "compiler-flags": [],
   "suffix": ".res.mjs"

package/src/components/ComponentKind.res

@@ -0,0 +1,99 @@
+// Single source of truth for the Reventless component-kind vocabulary: the kinds
+// themselves, every accepted folder spelling (singular / plural / short form),
+// the canonical folder name, and the body-file suffixes. The plugin generator
+// (`generator/Discovery`) and the external tooling that classifies files by
+// folder (`reventless-gwt`'s `ComponentMeta`) both derive from this, so the two
+// can't drift — previously the generator accepted plural/short folder names that
+// the gwt discovery silently didn't recognise.
+
+type t =
+  | StateChangeSlice
+  | StateViewSlice
+  | StateViewSliceStream
+  | AutomationSlice
+  | InboundTranslationSlice
+  | OutboundTranslationSlice
+  | Aggregate
+  | ReadModel
+  | ReadModelStream
+  | Task
+  | ExtensionPoint
+  | Extension
+
+let all = [
+  StateChangeSlice,
+  StateViewSlice,
+  StateViewSliceStream,
+  AutomationSlice,
+  InboundTranslationSlice,
+  OutboundTranslationSlice,
+  Aggregate,
+  ReadModel,
+  ReadModelStream,
+  Task,
+  ExtensionPoint,
+  Extension,
+]
+
+// The canonical (singular) folder name for a kind — the spelling the naming
+// conventions and the graph `kind` field use.
+let folderName = (t: t): string =>
+  switch t {
+  | StateChangeSlice => "StateChangeSlice"
+  | StateViewSlice => "StateViewSlice"
+  | StateViewSliceStream => "StateViewSliceStream"
+  | AutomationSlice => "AutomationSlice"
+  | InboundTranslationSlice => "InboundTranslationSlice"
+  | OutboundTranslationSlice => "OutboundTranslationSlice"
+  | Aggregate => "Aggregate"
+  | ReadModel => "ReadModel"
+  | ReadModelStream => "ReadModelStream"
+  | Task => "Task"
+  | ExtensionPoint => "ExtensionPoint"
+  | Extension => "Extension"
+  }
+
+// Every folder spelling that denotes a kind → the kind. Tolerates the singular,
+// plural, and (for slices) short forms the generator has always accepted.
+let folderToKind = (folder: string): option<t> =>
+  switch folder {
+  | "StateChange" | "StateChanges" | "StateChangeSlice" | "StateChangeSlices" =>
+    Some(StateChangeSlice)
+  | "StateView" | "StateViews" | "StateViewSlice" | "StateViewSlices" => Some(StateViewSlice)
+  | "StateViewSliceStream" | "StateViewSliceStreams" => Some(StateViewSliceStream)
+  | "Automation" | "Automations" | "AutomationSlice" | "AutomationSlices" => Some(AutomationSlice)
+  | "InboundTranslation"
+  | "InboundTranslations"
+  | "InboundTranslationSlice"
+  | "InboundTranslationSlices" =>
+    Some(InboundTranslationSlice)
+  | "OutboundTranslation"
+  | "OutboundTranslations"
+  | "OutboundTranslationSlice"
+  | "OutboundTranslationSlices" =>
+    Some(OutboundTranslationSlice)
+  | "Aggregate" | "Aggregates" => Some(Aggregate)
+  | "ReadModel" | "ReadModels" => Some(ReadModel)
+  | "ReadModelStream" | "ReadModelStreams" => Some(ReadModelStream)
+  | "Task" | "Tasks" => Some(Task)
+  | "ExtensionPoint" | "ExtensionPoints" => Some(ExtensionPoint)
+  | "Extension" | "Extensions" => Some(Extension)
+  | _ => None
+  }
+
+let isKindFolder = (folder: string): bool => folderToKind(folder)->Option.isSome
+
+// Body-file suffixes stripped to recover a component's spec stem (longest first,
+// so `_ExtensionPointMapping` is removed before `_ExtensionPoint`). Spec and body
+// files in one folder collapse to the same component name.
+let bodySuffixes = [
+  "_ExtensionPointMapping",
+  "_ExtensionPoint",
+  "_Extension",
+  "_Projections",
+  "_Projection",
+  "_Mappings",
+  "_Behavior",
+  "_Automation",
+  "_Translation",
+]

package/src/components/ComponentKind.res.mjs

@@ -0,0 +1,125 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+let all = [
+  "StateChangeSlice",
+  "StateViewSlice",
+  "StateViewSliceStream",
+  "AutomationSlice",
+  "InboundTranslationSlice",
+  "OutboundTranslationSlice",
+  "Aggregate",
+  "ReadModel",
+  "ReadModelStream",
+  "Task",
+  "ExtensionPoint",
+  "Extension"
+];
+
+function folderName(t) {
+  switch (t) {
+    case "StateChangeSlice" :
+      return "StateChangeSlice";
+    case "StateViewSlice" :
+      return "StateViewSlice";
+    case "StateViewSliceStream" :
+      return "StateViewSliceStream";
+    case "AutomationSlice" :
+      return "AutomationSlice";
+    case "InboundTranslationSlice" :
+      return "InboundTranslationSlice";
+    case "OutboundTranslationSlice" :
+      return "OutboundTranslationSlice";
+    case "Aggregate" :
+      return "Aggregate";
+    case "ReadModel" :
+      return "ReadModel";
+    case "ReadModelStream" :
+      return "ReadModelStream";
+    case "Task" :
+      return "Task";
+    case "ExtensionPoint" :
+      return "ExtensionPoint";
+    case "Extension" :
+      return "Extension";
+  }
+}
+
+function folderToKind(folder) {
+  switch (folder) {
+    case "Aggregate" :
+    case "Aggregates" :
+      return "Aggregate";
+    case "Automation" :
+    case "AutomationSlice" :
+    case "AutomationSlices" :
+    case "Automations" :
+      return "AutomationSlice";
+    case "ExtensionPoint" :
+    case "ExtensionPoints" :
+      return "ExtensionPoint";
+    case "Extension" :
+    case "Extensions" :
+      return "Extension";
+    case "InboundTranslation" :
+    case "InboundTranslationSlice" :
+    case "InboundTranslationSlices" :
+    case "InboundTranslations" :
+      return "InboundTranslationSlice";
+    case "OutboundTranslation" :
+    case "OutboundTranslationSlice" :
+    case "OutboundTranslationSlices" :
+    case "OutboundTranslations" :
+      return "OutboundTranslationSlice";
+    case "ReadModelStream" :
+    case "ReadModelStreams" :
+      return "ReadModelStream";
+    case "ReadModel" :
+    case "ReadModels" :
+      return "ReadModel";
+    case "StateChange" :
+    case "StateChangeSlice" :
+    case "StateChangeSlices" :
+    case "StateChanges" :
+      return "StateChangeSlice";
+    case "StateViewSliceStream" :
+    case "StateViewSliceStreams" :
+      return "StateViewSliceStream";
+    case "StateView" :
+    case "StateViewSlice" :
+    case "StateViewSlices" :
+    case "StateViews" :
+      return "StateViewSlice";
+    case "Task" :
+    case "Tasks" :
+      return "Task";
+    default:
+      return;
+  }
+}
+
+function isKindFolder(folder) {
+  return Stdlib_Option.isSome(folderToKind(folder));
+}
+
+let bodySuffixes = [
+  "_ExtensionPointMapping",
+  "_ExtensionPoint",
+  "_Extension",
+  "_Projections",
+  "_Projection",
+  "_Mappings",
+  "_Behavior",
+  "_Automation",
+  "_Translation"
+];
+
+export {
+  all,
+  folderName,
+  folderToKind,
+  isKindFolder,
+  bodySuffixes,
+}
+/* No side effect */

package/src/components/DcbDecode.res

@@ -18,16 +18,7 @@ let buildVariantLookup = (schema: S.t<unknown>): dict<variantKind> => {
     anyOf->Array.forEach(variantSchema =>
       switch variantSchema {
       | Object({items, properties}) =>
-        let tagName =
-          items
-          ->Array.find(item => item.location == "TAG")
-          ->Option.flatMap(item =>
-            switch item.schema {
-            | String({const}) => Some(const)
-            | _ => None
-            }
-          )
-        switch tagName {
+        switch DcbTag.variantTagName(items) {
         | Some(name) =>
           let kind = if properties->Dict.keysToArray->Array.length == 0 {
             PayloadLess
@@ -45,16 +36,7 @@ let buildVariantLookup = (schema: S.t<unknown>): dict<variantKind> => {
     )
   | Object({items}) =>
     // Single-variant schema with fields
-    let tagName =
-      items
-      ->Array.find(item => item.location == "TAG")
-      ->Option.flatMap(item =>
-        switch item.schema {
-        | String({const}) => Some(const)
-        | _ => None
-        }
-      )
-    switch tagName {
+    switch DcbTag.variantTagName(items) {
     | Some(name) => lookup->Dict.set(name, WithFields)
     | None => ()
     }

package/src/components/DcbDecode.res.mjs

@@ -1,8 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as S from "sury/src/S.res.mjs";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as DcbTag$Reventless from "./DcbTag.res.mjs";
 
 function buildVariantLookup(schema) {
   let lookup = {};
@@ -14,18 +14,9 @@ function buildVariantLookup(schema) {
       }
       break;
     case "object" :
-      let tagName = Stdlib_Option.flatMap(schema.items.find(item => item.location === "TAG"), item => {
-        let match = item.schema;
-        if (match.type !== "string") {
-          return;
-        }
-        let $$const = match.const;
-        if ($$const !== undefined) {
-          return $$const;
-        }
-      });
-      if (tagName !== undefined) {
-        lookup[tagName] = "WithFields";
+      let name$1 = DcbTag$Reventless.variantTagName(schema.items);
+      if (name$1 !== undefined) {
+        lookup[name$1] = "WithFields";
       }
       break;
     case "union" :
@@ -40,21 +31,12 @@ function buildVariantLookup(schema) {
               return;
             }
           case "object" :
-            let tagName = Stdlib_Option.flatMap(variantSchema.items.find(item => item.location === "TAG"), item => {
-              let match = item.schema;
-              if (match.type !== "string") {
-                return;
-              }
-              let $$const = match.const;
-              if ($$const !== undefined) {
-                return $$const;
-              }
-            });
-            if (tagName === undefined) {
+            let name$1 = DcbTag$Reventless.variantTagName(variantSchema.items);
+            if (name$1 === undefined) {
               return;
             }
             let kind = Object.keys(variantSchema.properties).length === 0 ? "PayloadLess" : "WithFields";
-            lookup[tagName] = kind;
+            lookup[name$1] = kind;
             return;
           default:
             return;

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,14 @@ 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>,
 }
 
 /** Union of simple and composite partition tag strategies. */
+@schema
 type derivedPartitionTag =
   | Simple(partitionTag)
   | Composite(compositePartitionSpec)
@@ -331,6 +334,22 @@ let extractTagsFromProperties = (properties: dict<S.t<unknown>>, jsonDict: dict<
     }
   )
 
+// Extract the discriminating TAG constructor name from a variant Object schema's
+// `items`. sury compiles a record-payload variant `Foo({...})` to an Object whose
+// `items` carry one entry at location "TAG" holding a `String` const = "Foo".
+// Returns None for a non-tagged object (no TAG item, or a non-const schema).
+// Single source for the ~dozen previously-inlined identical extractions across
+// this file, DcbDecode and DcbValidation.
+let variantTagName = (items: array<S.item>): option<string> =>
+  items
+  ->Array.find(item => item.location == "TAG")
+  ->Option.flatMap(item =>
+    switch item.schema {
+    | String({const}) => Some(const)
+    | _ => None
+    }
+  )
+
 /**
 Extracts DCB tags from an event JSON value using the event's sury schema.
 
@@ -354,15 +373,7 @@ let extractTagsFromJson = (schema: S.t<unknown>, json: JSON.t): array<tag> =>
         } else {
           switch variantSchema {
           | Object({items, properties}) =>
-            let variantTag = items
-              ->Array.find(item => item.location == "TAG")
-              ->Option.flatMap(item =>
-                switch item.schema {
-                | String({const}) => Some(const)
-                | _ => None
-                }
-              )
-            if variantTag == jsonTag {
+            if variantTagName(items) == jsonTag {
               extractTagsFromProperties(properties, jsonDict)
             } else {
               []
@@ -417,15 +428,7 @@ let extractVariantNames = (schema: S.t<'a>): array<string> => {
   | Union({anyOf}) =>
     anyOf->Array.filterMap(variantSchema =>
       switch variantSchema {
-      | Object({items}) =>
-        items
-        ->Array.find(item => item.location == "TAG")
-        ->Option.flatMap(item =>
-          switch item.schema {
-          | String({const}) => Some(const)
-          | _ => None
-          }
-        )
+      | Object({items}) => variantTagName(items)
       // Payload-less variants (sury-compiled `S.literal("Name")` strings) are
       // intentionally excluded here: DCB event-type lookups can't WHERE-clause
       // on bare-string events, so Plugin_Structure.consumedEventTypes and
@@ -437,16 +440,7 @@ let extractVariantNames = (schema: S.t<'a>): array<string> => {
       | _ => None
       }
     )
-  | Object({items}) =>
-    items
-    ->Array.find(item => item.location == "TAG")
-    ->Option.flatMap(item =>
-      switch item.schema {
-      | String({const}) => Some([const])
-      | _ => None
-      }
-    )
-    ->Option.getOr([])
+  | Object({items}) => variantTagName(items)->Option.mapOr([], t => [t])
   | _ => []
   }
 }
@@ -466,29 +460,12 @@ let extractAllVariantNames = (schema: S.t<'a>): array<string> => {
   | Union({anyOf}) =>
     anyOf->Array.filterMap(variantSchema =>
       switch variantSchema {
-      | Object({items}) =>
-        items
-        ->Array.find(item => item.location == "TAG")
-        ->Option.flatMap(item =>
-          switch item.schema {
-          | String({const}) => Some(const)
-          | _ => None
-          }
-        )
+      | Object({items}) => variantTagName(items)
       | String({const}) => Some(const)
       | _ => None
       }
     )
-  | Object({items}) =>
-    items
-    ->Array.find(item => item.location == "TAG")
-    ->Option.flatMap(item =>
-      switch item.schema {
-      | String({const}) => Some([const])
-      | _ => None
-      }
-    )
-    ->Option.getOr([])
+  | Object({items}) => variantTagName(items)->Option.mapOr([], t => [t])
   | String({const: ?Some(name)}) => [name]
   | _ => []
   }
@@ -514,29 +491,11 @@ let isVariantPayloadBearing = (schema: S.t<'a>, name: string): bool => {
     | Union({anyOf}) =>
       anyOf->Array.some(variantSchema =>
         switch variantSchema {
-        | Object({items}) =>
-          items
-          ->Array.find(item => item.location == "TAG")
-          ->Option.flatMap(item =>
-            switch item.schema {
-            | String({const}) => Some(const == name)
-            | _ => None
-            }
-          )
-          ->Option.getOr(false)
+        | Object({items}) => variantTagName(items)->Option.mapOr(false, t => t == name)
         | _ => false
         }
       )
-    | Object({items}) =>
-      items
-      ->Array.find(item => item.location == "TAG")
-      ->Option.flatMap(item =>
-        switch item.schema {
-        | String({const}) => Some(const == name)
-        | _ => None
-        }
-      )
-      ->Option.getOr(false)
+    | Object({items}) => variantTagName(items)->Option.mapOr(false, t => t == name)
     | _ => false
     }
   }
@@ -602,15 +561,7 @@ let extractTagsFromJsonExpanded = (schema: S.t<unknown>, json: JSON.t): array<ta
         } else {
           switch variantSchema {
           | Object({items, properties}) =>
-            let variantTag = items
-              ->Array.find(item => item.location == "TAG")
-              ->Option.flatMap(item =>
-                switch item.schema {
-                | String({const}) => Some(const)
-                | _ => None
-                }
-              )
-            if variantTag == jsonTag {
+            if variantTagName(items) == jsonTag {
               extractTagsFromPropertiesExpanded(properties, jsonDict)
             } else {
               []
@@ -703,15 +654,9 @@ let extractTagKeysByEventType = (schema: S.t<'a>): dict<array<string>> => {
   let addVariant = (variantSchema: S.t<unknown>) =>
     switch variantSchema {
     | Object({items, properties}) =>
-      items
-      ->Array.find(item => item.location == "TAG")
-      ->Option.flatMap(item =>
-        switch item.schema {
-        | String({const}) => Some(const)
-        | _ => None
-        }
+      variantTagName(items)->Option.forEach(eventType =>
+        result->Dict.set(eventType, tagKeysOfProperties(properties))
       )
-      ->Option.forEach(eventType => result->Dict.set(eventType, tagKeysOfProperties(properties)))
     | _ => ()
     }
   switch schema->toUnknownSchema {
@@ -957,15 +902,10 @@ let eventShapesOfSchema = (schema: S.t<'a>): array<DcbScopeInference.eventShape>
   let ofVariant = (variantSchema: S.t<unknown>): option<DcbScopeInference.eventShape> =>
     switch variantSchema {
     | Object({items, properties}) =>
-      items
-      ->Array.find(item => item.location == "TAG")
-      ->Option.flatMap(item =>
-        switch item.schema {
-        | String({const}) => Some(const)
-        | _ => None
-        }
-      )
-      ->Option.map(eventType => {DcbScopeInference.eventType, idFields: idFieldsOfProperties(properties)})
+      variantTagName(items)->Option.map(eventType => {
+        DcbScopeInference.eventType,
+        idFields: idFieldsOfProperties(properties),
+      })
     | String({const}) => Some({DcbScopeInference.eventType: const, idFields: []})
     | _ => None
     }
@@ -1091,17 +1031,7 @@ let findMultiTagVariantNames = (schema: S.t<unknown>): array<string> => {
           ->Array.filter(((_, fieldSchema)) => isTagged(fieldSchema))
           ->Array.length
         if tagCount > 1 {
-          Some(
-            items
-            ->Array.find(item => item.location == "TAG")
-            ->Option.flatMap(item =>
-              switch item.schema {
-              | String({const}) => Some(const)
-              | _ => None
-              }
-            )
-            ->Option.getOr("(unknown)"),
-          )
+          Some(variantTagName(items)->Option.getOr("(unknown)"))
         } else {
           None
         }