@reventlessdev/reventless-spec 3.0.0-alpha.100

package/src/generator/Config.res.mjs

@@ -0,0 +1,69 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodepath from "node:path";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+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 PluginName$Reventless from "../components/PluginName.res.mjs";
+
+function readJson(path) {
+  try {
+    return JSON.parse(Nodefs.readFileSync(path, "utf8"));
+  } catch (exn) {
+    return;
+  }
+}
+
+function getStrField(json, key) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d[key]), Stdlib_JSON.Decode.string);
+}
+
+function getIntField(json, key) {
+  return Stdlib_Option.map(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d[key]), Stdlib_JSON.Decode.float), prim => prim | 0);
+}
+
+function getStrArrayField(json, key) {
+  return Stdlib_Option.map(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d[key]), Stdlib_JSON.Decode.array), arr => Stdlib_Array.filterMap(arr, Stdlib_JSON.Decode.string));
+}
+
+function getComponentRuntime(json) {
+  let result = {};
+  Stdlib_Option.forEach(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["runtime"]), Stdlib_JSON.Decode.object), runtimeObj => {
+    Object.entries(runtimeObj).forEach(param => {
+      let entry = param[1];
+      result[param[0]] = {
+        memorySize: getIntField(entry, "memorySize"),
+        timeout: getIntField(entry, "timeout")
+      };
+    });
+  });
+  return result;
+}
+
+function read(srcDir) {
+  let packageJsonPath = Nodepath.join(Nodepath.dirname(srcDir), "package.json");
+  let packageJsonName = Stdlib_Option.flatMap(readJson(packageJsonPath), j => getStrField(j, "name"));
+  let pluginJsonPath = Nodepath.join(srcDir, "plugin.json");
+  let pluginJson = Nodefs.existsSync(pluginJsonPath) ? readJson(pluginJsonPath) : undefined;
+  return {
+    name: PluginName$Reventless.resolve(Stdlib_Option.flatMap(pluginJson, j => getStrField(j, "name")), packageJsonName),
+    heartbeatInterval: Stdlib_Option.getOr(Stdlib_Option.flatMap(pluginJson, j => getIntField(j, "heartbeatInterval")), 5),
+    exclude: Stdlib_Option.getOr(Stdlib_Option.flatMap(pluginJson, j => getStrArrayField(j, "exclude")), []),
+    componentRuntime: Stdlib_Option.getOr(Stdlib_Option.map(pluginJson, getComponentRuntime), {}),
+    variant: "Composition"
+  };
+}
+
+let packageNameToPluginName = PluginName$Reventless.fromPackageName;
+
+export {
+  packageNameToPluginName,
+  readJson,
+  getStrField,
+  getIntField,
+  getStrArrayField,
+  getComponentRuntime,
+  read,
+}
+/* node:fs Not a pure module */

package/src/generator/Discovery.res

@@ -0,0 +1,230 @@
+// Directory scanner: walks src/, classifies .res files by parent folder name.
+
+// Re-export the single-source `ComponentKind.t` (same constructors, so the bare
+// pattern matches in `Pairing` keep resolving via type inference) and derive the
+// folder classifier from it — one vocabulary shared with the gwt discovery.
+type componentType = ComponentKind.t =
+  | StateChangeSlice
+  | StateViewSlice
+  | StateViewSliceStream
+  | AutomationSlice
+  | InboundTranslationSlice
+  | OutboundTranslationSlice
+  | Aggregate
+  | ReadModel
+  | ReadModelStream
+  | Task
+  | ExtensionPoint
+  | Extension
+
+// relPath: path relative to srcDir (e.g. "ReadModel/ProductsProjections.res")
+type discoveredFile = {stem: string, componentType: componentType, epGroup: option<string>, relPath: string}
+
+let folderToComponentType = ComponentKind.folderToKind
+
+// The intra-plugin grouping band ("chapter") a file belongs to, derived from its
+// path relative to `src/`: the first directory segment that is not a recognised
+// kind-folder. `src/<Chapter>/<Kind>/<Component>.res` → `Some("<Chapter>")`; a file
+// directly under a kind-folder (`src/<Kind>/<Component>.res`) or at the src root →
+// `None`. Uses the single-source `ComponentKind.isKindFolder`, so a chapter read
+// here (build time, disk) agrees with the authoring tool's identical heuristic and
+// with a chapter reflected off the deployed plugin structure. See
+// docs/plans/deployed-chapter-grouping.md.
+let chapterOf = (relPath: string): option<string> => {
+  let segments = relPath->String.split("/")
+  // Need at least one directory segment before the filename.
+  if segments->Array.length < 2 {
+    None
+  } else {
+    switch segments->Array.get(0) {
+    | Some(first) if !ComponentKind.isKindFolder(first) => Some(first)
+    | _ => None
+    }
+  }
+}
+
+// Deduplicated (stem → chapter) pairs across the discovered files, sorted by stem
+// for deterministic codegen. Only files that carry a chapter are included; stems are
+// unique within a plugin (validated), so keying by stem cannot collide. Body files
+// (`_Behavior`, `_Projections`, …) share their component's chapter but are never
+// looked up by `Spec.name`, so their presence is harmless.
+let chaptersByStem = (discovered: array<discoveredFile>): array<(string, string)> => {
+  let byStem: Dict.t<string> = Dict.make()
+  discovered->Array.forEach(d =>
+    switch chapterOf(d.relPath) {
+    | Some(ch) => byStem->Dict.set(d.stem, ch)
+    | None => ()
+    }
+  )
+  byStem
+  ->Dict.toArray
+  ->Array.toSorted(((a, _), (b, _)) =>
+    if a < b {
+      -1.0
+    } else if a > b {
+      1.0
+    } else {
+      0.0
+    }
+  )
+}
+
+let isAlwaysExcludedDir = (name: string): bool =>
+  name === "Plugin" || name === "tests" || name === "lib"
+
+// Simple glob matching: supports exact match, `/**` prefix, and `/*` single level.
+let matchesGlob = (path: string, pattern: string): bool =>
+  if pattern === "**" {
+    true
+  } else if not(pattern->String.includes("*")) {
+    // Exact file match or directory prefix
+    path === pattern || path->String.startsWith(pattern ++ "/")
+  } else if pattern->String.endsWith("/**") {
+    let prefix = pattern->String.slice(~start=0, ~end=pattern->String.length - 3)
+    path === prefix || path->String.startsWith(prefix ++ "/")
+  } else if pattern->String.endsWith("/*") {
+    let prefix = pattern->String.slice(~start=0, ~end=pattern->String.length - 2)
+    path->String.startsWith(prefix ++ "/") &&
+      !(path
+      ->String.slice(~start=prefix->String.length + 1, ~end=path->String.length)
+      ->String.includes("/"))
+  } else {
+    path === pattern
+  }
+
+let isExcluded = (relPath: string, excludePatterns: array<string>): bool =>
+  excludePatterns->Array.some(p => matchesGlob(relPath, p))
+
+let stemOf = (filename: string): option<string> =>
+  if filename->String.endsWith(".res") {
+    Some(filename->String.slice(~start=0, ~end=filename->String.length - 4))
+  } else {
+    None
+  }
+
+let isSkipped = (stem: string): bool =>
+  stem->String.endsWith("Test")
+  || stem->String.endsWith("Fixtures")
+  // `_EventMappings` and `_Mappings` files in per-entity Aggregate/ folders
+  // are picked up by the dedicated [Pairing.findEventMappings] walker;
+  // treating them as Aggregate specs would hunt for a non-existent
+  // `_EventMappingsBehavior` / `_MappingsBehavior`.
+  || stem->String.endsWith("_EventMappings")
+  || stem->String.endsWith("_Mappings")
+
+// Collect .res files directly in dir (non-recursive) into acc.
+let collectFiles = (
+  ~dir: string,
+  ~relDir: string,
+  ~componentType: componentType,
+  ~epGroup: option<string>,
+  ~exclude: array<string>,
+  ~acc: array<discoveredFile>,
+): unit =>
+  Generator_Node.readDir(dir)->Array.forEach(entry => {
+    if entry->NodeFs.isFile {
+      let filename = entry->NodeFs.direntName
+      let relPath = if relDir === "" {filename} else {relDir ++ "/" ++ filename}
+      if !isExcluded(relPath, exclude) {
+        switch stemOf(filename) {
+        | Some(stem) if !isSkipped(stem) => acc->Array.push({stem, componentType, epGroup, relPath})
+        | _ => ()
+        }
+      }
+    }
+  })
+
+// Recursively walk srcDir, classifying files into acc.
+let rec walkDir = (
+  ~dir: string,
+  ~relDir: string,
+  ~parentComponentType: option<componentType>,
+  ~epGroup: option<string>,
+  ~exclude: array<string>,
+  ~acc: array<discoveredFile>,
+): unit =>
+  Generator_Node.readDir(dir)->Array.forEach(entry => {
+    let entryName = entry->NodeFs.direntName
+    let relPath = if relDir === "" {entryName} else {relDir ++ "/" ++ entryName}
+
+    if isExcluded(relPath, exclude) {
+      ()
+    } else if entry->NodeFs.isDirectory {
+      if isAlwaysExcludedDir(entryName) {
+        ()
+      } else {
+        switch folderToComponentType(entryName) {
+        | Some(ExtensionPoint) =>
+          let epDir = NodePath.join([dir, entryName])
+          let children = Generator_Node.readDir(epDir)
+          let hasSubDirs = children->Array.some(e => e->NodeFs.isDirectory)
+          if hasSubDirs {
+            // Each subfolder is a named EP group
+            children->Array.forEach(child => {
+              if child->NodeFs.isDirectory {
+                let groupName = child->NodeFs.direntName
+                let groupDir = NodePath.join([epDir, groupName])
+                let groupRelDir = relPath ++ "/" ++ groupName
+                collectFiles(
+                  ~dir=groupDir,
+                  ~relDir=groupRelDir,
+                  ~componentType=ExtensionPoint,
+                  ~epGroup=Some(groupName),
+                  ~exclude,
+                  ~acc,
+                )
+              }
+            })
+          } else {
+            // Flat EP folder — all .res files are for one extension point
+            collectFiles(
+              ~dir=epDir,
+              ~relDir=relPath,
+              ~componentType=ExtensionPoint,
+              ~epGroup=None,
+              ~exclude,
+              ~acc,
+            )
+          }
+        | Some(ct) =>
+          // Recurse into component type folder, collecting files at any depth
+          walkDir(
+            ~dir=NodePath.join([dir, entryName]),
+            ~relDir=relPath,
+            ~parentComponentType=Some(ct),
+            ~epGroup=None,
+            ~exclude,
+            ~acc,
+          )
+        | None =>
+          // Chapter folder or other — recurse inheriting parent context
+          walkDir(
+            ~dir=NodePath.join([dir, entryName]),
+            ~relDir=relPath,
+            ~parentComponentType,
+            ~epGroup,
+            ~exclude,
+            ~acc,
+          )
+        }
+      }
+    } else if entry->NodeFs.isFile {
+      switch parentComponentType {
+      | None => ()
+      | Some(ct) =>
+        let filename = entryName
+        if !isExcluded(relPath, exclude) {
+          switch stemOf(filename) {
+          | Some(stem) if !isSkipped(stem) => acc->Array.push({stem, componentType: ct, epGroup, relPath})
+          | _ => ()
+          }
+        }
+      }
+    }
+  })
+
+let scan = (~srcDir: string, ~exclude: array<string>): array<discoveredFile> => {
+  let acc: array<discoveredFile> = []
+  walkDir(~dir=srcDir, ~relDir="", ~parentComponentType=None, ~epGroup=None, ~exclude, ~acc)
+  acc
+}

package/src/generator/Discovery.res.mjs

@@ -0,0 +1,198 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodepath from "node:path";
+import * as ComponentKind$Reventless from "../components/ComponentKind.res.mjs";
+import * as Generator_Node$Reventless from "./Generator_Node.res.mjs";
+
+function chapterOf(relPath) {
+  let segments = relPath.split("/");
+  if (segments.length < 2) {
+    return;
+  }
+  let first = segments[0];
+  if (first !== undefined && !ComponentKind$Reventless.isKindFolder(first)) {
+    return first;
+  }
+}
+
+function chaptersByStem(discovered) {
+  let byStem = {};
+  discovered.forEach(d => {
+    let ch = chapterOf(d.relPath);
+    if (ch !== undefined) {
+      byStem[d.stem] = ch;
+      return;
+    }
+  });
+  return Object.entries(byStem).toSorted((param, param$1) => {
+    let b = param$1[0];
+    let a = param[0];
+    if (a < b) {
+      return -1.0;
+    } else if (a > b) {
+      return 1.0;
+    } else {
+      return 0.0;
+    }
+  });
+}
+
+function isAlwaysExcludedDir(name) {
+  if (name === "Plugin" || name === "tests") {
+    return true;
+  } else {
+    return name === "lib";
+  }
+}
+
+function matchesGlob(path, pattern) {
+  if (pattern === "**") {
+    return true;
+  }
+  if (!pattern.includes("*")) {
+    if (path === pattern) {
+      return true;
+    } else {
+      return path.startsWith(pattern + "/");
+    }
+  }
+  if (pattern.endsWith("/**")) {
+    let prefix = pattern.slice(0, pattern.length - 3 | 0);
+    if (path === prefix) {
+      return true;
+    } else {
+      return path.startsWith(prefix + "/");
+    }
+  }
+  if (!pattern.endsWith("/*")) {
+    return path === pattern;
+  }
+  let prefix$1 = pattern.slice(0, pattern.length - 2 | 0);
+  if (path.startsWith(prefix$1 + "/")) {
+    return !path.slice(prefix$1.length + 1 | 0, path.length).includes("/");
+  } else {
+    return false;
+  }
+}
+
+function isExcluded(relPath, excludePatterns) {
+  return excludePatterns.some(p => matchesGlob(relPath, p));
+}
+
+function stemOf(filename) {
+  if (filename.endsWith(".res")) {
+    return filename.slice(0, filename.length - 4 | 0);
+  }
+}
+
+function isSkipped(stem) {
+  if (stem.endsWith("Test") || stem.endsWith("Fixtures") || stem.endsWith("_EventMappings")) {
+    return true;
+  } else {
+    return stem.endsWith("_Mappings");
+  }
+}
+
+function collectFiles(dir, relDir, componentType, epGroup, exclude, acc) {
+  Generator_Node$Reventless.readDir(dir).forEach(entry => {
+    if (!entry.isFile()) {
+      return;
+    }
+    let filename = entry.name;
+    let relPath = relDir === "" ? filename : relDir + "/" + filename;
+    if (isExcluded(relPath, exclude)) {
+      return;
+    }
+    let stem = stemOf(filename);
+    if (stem !== undefined && !isSkipped(stem)) {
+      acc.push({
+        stem: stem,
+        componentType: componentType,
+        epGroup: epGroup,
+        relPath: relPath
+      });
+      return;
+    }
+  });
+}
+
+function walkDir(dir, relDir, parentComponentType, epGroup, exclude, acc) {
+  Generator_Node$Reventless.readDir(dir).forEach(entry => {
+    let entryName = entry.name;
+    let relPath = relDir === "" ? entryName : relDir + "/" + entryName;
+    if (isExcluded(relPath, exclude)) {
+      return;
+    }
+    if (entry.isDirectory()) {
+      if (isAlwaysExcludedDir(entryName)) {
+        return;
+      }
+      let ct = ComponentKind$Reventless.folderToKind(entryName);
+      if (ct === undefined) {
+        return walkDir(Nodepath.join(dir, entryName), relPath, parentComponentType, epGroup, exclude, acc);
+      }
+      if (ct !== "ExtensionPoint") {
+        return walkDir(Nodepath.join(dir, entryName), relPath, ct, undefined, exclude, acc);
+      }
+      let epDir = Nodepath.join(dir, entryName);
+      let children = Generator_Node$Reventless.readDir(epDir);
+      let hasSubDirs = children.some(e => e.isDirectory());
+      if (hasSubDirs) {
+        children.forEach(child => {
+          if (!child.isDirectory()) {
+            return;
+          }
+          let groupName = child.name;
+          let groupDir = Nodepath.join(epDir, groupName);
+          let groupRelDir = relPath + "/" + groupName;
+          collectFiles(groupDir, groupRelDir, "ExtensionPoint", groupName, exclude, acc);
+        });
+        return;
+      } else {
+        return collectFiles(epDir, relPath, "ExtensionPoint", undefined, exclude, acc);
+      }
+    }
+    if (!entry.isFile()) {
+      return;
+    }
+    if (parentComponentType === undefined) {
+      return;
+    }
+    if (isExcluded(relPath, exclude)) {
+      return;
+    }
+    let stem = stemOf(entryName);
+    if (stem !== undefined && !isSkipped(stem)) {
+      acc.push({
+        stem: stem,
+        componentType: parentComponentType,
+        epGroup: epGroup,
+        relPath: relPath
+      });
+      return;
+    }
+  });
+}
+
+function scan(srcDir, exclude) {
+  let acc = [];
+  walkDir(srcDir, "", undefined, undefined, exclude, acc);
+  return acc;
+}
+
+let folderToComponentType = ComponentKind$Reventless.folderToKind;
+
+export {
+  folderToComponentType,
+  chapterOf,
+  chaptersByStem,
+  isAlwaysExcludedDir,
+  matchesGlob,
+  isExcluded,
+  stemOf,
+  isSkipped,
+  collectFiles,
+  walkDir,
+  scan,
+}
+/* node:path Not a pure module */

package/src/generator/Generator_Node.res

@@ -0,0 +1,14 @@
+// What remains of the generator's own Node bindings after they moved to
+// `@reventlessdev/rescript-node`: one helper, which is not a binding.
+//
+// The generator walks directories that may legitimately not exist — an
+// `Extension/` folder is optional, and so is every other component folder — and
+// it treats "absent" and "empty" the same way. `readdirSync` throws on absent,
+// so every walk would otherwise carry its own try/catch. This does not belong in
+// the bindings package: a binding that swallows an error is a policy, and the
+// policy is the generator's.
+
+let readDir = (dir: string): array<NodeFs.dirent> =>
+  try NodeFs.readdirSync(dir, {withFileTypes: true}) catch {
+  | _ => []
+  }

package/src/generator/Generator_Node.res.mjs

@@ -0,0 +1,18 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+
+function readDir(dir) {
+  try {
+    return Nodefs.readdirSync(dir, {
+      withFileTypes: true
+    });
+  } catch (exn) {
+    return [];
+  }
+}
+
+export {
+  readDir,
+}
+/* node:fs Not a pure module */