@reventlessdev/reventless-spec 3.0.0-alpha.61

package/src/generator/Discovery.res

@@ -0,0 +1,204 @@
+// Directory scanner: walks src/, classifies .res files by parent folder name.
+
+type componentType =
+  | 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 = (folder: string): option<componentType> =>
+  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 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->Generator_Node.isFile {
+      let filename = entry->Generator_Node.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->Generator_Node.direntName
+    let relPath = if relDir === "" {entryName} else {relDir ++ "/" ++ entryName}
+
+    if isExcluded(relPath, exclude) {
+      ()
+    } else if entry->Generator_Node.isDirectory {
+      if isAlwaysExcludedDir(entryName) {
+        ()
+      } else {
+        switch folderToComponentType(entryName) {
+        | Some(ExtensionPoint) =>
+          let epDir = Generator_Node.join([dir, entryName])
+          let children = Generator_Node.readDir(epDir)
+          let hasSubDirs = children->Array.some(e => e->Generator_Node.isDirectory)
+          if hasSubDirs {
+            // Each subfolder is a named EP group
+            children->Array.forEach(child => {
+              if child->Generator_Node.isDirectory {
+                let groupName = child->Generator_Node.direntName
+                let groupDir = Generator_Node.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=Generator_Node.join([dir, entryName]),
+            ~relDir=relPath,
+            ~parentComponentType=Some(ct),
+            ~epGroup=None,
+            ~exclude,
+            ~acc,
+          )
+        | None =>
+          // Chapter folder or other — recurse inheriting parent context
+          walkDir(
+            ~dir=Generator_Node.join([dir, entryName]),
+            ~relDir=relPath,
+            ~parentComponentType,
+            ~epGroup,
+            ~exclude,
+            ~acc,
+          )
+        }
+      }
+    } else if entry->Generator_Node.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,213 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodepath from "node:path";
+import * as Generator_Node$Reventless from "./Generator_Node.res.mjs";
+
+function folderToComponentType(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 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 = folderToComponentType(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;
+}
+
+export {
+  folderToComponentType,
+  isAlwaysExcludedDir,
+  matchesGlob,
+  isExcluded,
+  stemOf,
+  isSkipped,
+  collectFiles,
+  walkDir,
+  scan,
+}
+/* node:path Not a pure module */

package/src/generator/Generator_Node.res

@@ -0,0 +1,49 @@
+// Node.js bindings for the plugin generator.
+
+// ── File system ──────────────────────────────────────────────────────────────
+
+@module("node:fs")
+external existsSync: string => bool = "existsSync"
+
+@module("node:fs")
+external readFileSync: (string, @as("utf8") _) => string = "readFileSync"
+
+@module("node:fs")
+external writeFileSync: (string, string, @as("utf8") _) => unit = "writeFileSync"
+
+type dirent
+@send external isDirectory: dirent => bool = "isDirectory"
+@send external isFile: dirent => bool = "isFile"
+@get external direntName: dirent => string = "name"
+
+type readdirOptions = {withFileTypes: bool}
+
+@module("node:fs")
+external readdirSyncRaw: (string, readdirOptions) => array<dirent> = "readdirSync"
+
+let readDir = (dir: string): array<dirent> =>
+  try readdirSyncRaw(dir, {withFileTypes: true}) catch {
+  | _ => []
+  }
+
+// ── Path ─────────────────────────────────────────────────────────────────────
+
+@module("node:path") @variadic
+external join: array<string> => string = "join"
+
+@module("node:path") @variadic
+external resolve: array<string> => string = "resolve"
+
+@module("node:path")
+external dirname: string => string = "dirname"
+
+@module("node:path")
+external basename: string => string = "basename"
+
+// ── Process ──────────────────────────────────────────────────────────────────
+
+@val @scope("process")
+external argv: array<string> = "argv"
+
+@val @scope("process")
+external cwd: unit => string = "cwd"

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 */