@reventlessdev/reventless-spec 3.0.0-alpha.61

package/src/generator/Pairing.res.mjs

@@ -0,0 +1,353 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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";
+
+let implSuffixForStateView = "_Projection";
+
+let implSuffixForAutomation = "_Automation";
+
+let implSuffixForTranslation = "_Translation";
+
+let mappingsSuffixForAutomation = "_Mappings";
+
+function isImplStem(stem) {
+  if (stem.endsWith(implSuffixForStateChange) || stem.endsWith(implSuffixForStateView) || stem.endsWith(implSuffixForAutomation) || stem.endsWith(implSuffixForTranslation)) {
+    return true;
+  } else {
+    return stem.endsWith(mappingsSuffixForAutomation);
+  }
+}
+
+function findEventMappings(srcDir) {
+  let dict = {};
+  let parentDirIsAggregate = relSegments => {
+    let n = relSegments.length;
+    if (n === 0) {
+      return false;
+    }
+    let parent = relSegments[n - 1 | 0];
+    if (parent === "Aggregate") {
+      return true;
+    } else {
+      return parent === "EventMappings";
+    }
+  };
+  let walk = (dir, segments) => {
+    Generator_Node$Reventless.readDir(dir).forEach(entry => {
+      let name = entry.name;
+      if (entry.isDirectory()) {
+        if (name !== "Plugin" && name !== "tests" && name !== "lib") {
+          return walk(Nodepath.join(dir, name), segments.concat([name]));
+        } else {
+          return;
+        }
+      }
+      if (!entry.isFile()) {
+        return;
+      }
+      if (name.endsWith("_Mappings.res") && parentDirIsAggregate(segments)) {
+        let stem = name.slice(0, name.length - 4 | 0);
+        let aggName = stem.slice(0, stem.length - 9 | 0);
+        dict[aggName] = stem;
+        return;
+      }
+      if (!name.endsWith("_EventMappings.res")) {
+        return;
+      }
+      let stem$1 = name.slice(0, name.length - 4 | 0);
+      let aggName$1 = stem$1.slice(0, stem$1.length - 14 | 0);
+      let match = dict[aggName$1];
+      if (match !== undefined) {
+        return;
+      } else {
+        dict[aggName$1] = stem$1;
+        return;
+      }
+    });
+  };
+  if (Nodefs.existsSync(srcDir)) {
+    walk(srcDir, []);
+  }
+  return dict;
+}
+
+function sortedStems(stems) {
+  return stems.toSorted((a, b) => {
+    if (a < b) {
+      return -1.0;
+    } else if (a > b) {
+      return 1.0;
+    } else {
+      return 0.0;
+    }
+  });
+}
+
+function extractTargetName(filePath) {
+  try {
+    let content = Nodefs.readFileSync(filePath, "utf8");
+    let result = {
+      contents: undefined
+    };
+    content.split("\n").forEach(line => {
+      let trimmed = line.trimStart();
+      if (!trimmed.startsWith("let targetName = ")) {
+        return;
+      }
+      let firstQuote = trimmed.indexOf("\"");
+      let lastQuote = trimmed.lastIndexOf("\"");
+      if (firstQuote >= 0 && lastQuote > firstQuote) {
+        result.contents = trimmed.slice(firstQuote + 1 | 0, lastQuote);
+        return;
+      }
+    });
+    return result.contents;
+  } catch (exn) {
+    return;
+  }
+}
+
+function hasAsyncAttribute(filePath) {
+  try {
+    let content = Nodefs.readFileSync(filePath, "utf8");
+    let found = {
+      contents: false
+    };
+    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")) {
+        found.contents = true;
+        return;
+      }
+    });
+    return found.contents;
+  } catch (exn) {
+    return false;
+  }
+}
+
+function resolve(discovered, srcDir) {
+  let eventMappings = findEventMappings(srcDir);
+  let stateChangeSlices = [];
+  let stateViewSlices = [];
+  let stateViewSlicesStream = [];
+  let automationSlices = [];
+  let inboundTranslationSlices = [];
+  let outboundTranslationSlices = [];
+  let automationSliceRelPaths = {};
+  let inboundTranslationSliceRelPaths = {};
+  let outboundTranslationSliceRelPaths = {};
+  let aggregateSpecs = [];
+  let aggregateSpecRelPaths = {};
+  let stateChangeSliceRelPaths = {};
+  let aggregateBehaviors = [];
+  let readModelStems = [];
+  let readModelStreamStems = [];
+  let projectionsByRelPath = {};
+  let tasks = [];
+  let epFiles = [];
+  let extensions = [];
+  discovered.forEach(param => {
+    let relPath = param.relPath;
+    let componentType = param.componentType;
+    let stem = param.stem;
+    switch (componentType) {
+      case "StateChangeSlice" :
+        if (!isImplStem(stem)) {
+          stateChangeSlices.push(stem);
+          stateChangeSliceRelPaths[stem] = relPath;
+          return;
+        } else {
+          return;
+        }
+      case "StateViewSlice" :
+        if (!isImplStem(stem)) {
+          stateViewSlices.push(stem);
+          return;
+        } else {
+          return;
+        }
+      case "StateViewSliceStream" :
+        if (!isImplStem(stem)) {
+          stateViewSlicesStream.push(stem);
+          return;
+        } else {
+          return;
+        }
+      case "AutomationSlice" :
+        if (!isImplStem(stem)) {
+          automationSlices.push(stem);
+          automationSliceRelPaths[stem] = relPath;
+          return;
+        } else {
+          return;
+        }
+      case "InboundTranslationSlice" :
+        if (!isImplStem(stem)) {
+          inboundTranslationSlices.push(stem);
+          inboundTranslationSliceRelPaths[stem] = relPath;
+          return;
+        } else {
+          return;
+        }
+      case "OutboundTranslationSlice" :
+        if (!isImplStem(stem)) {
+          outboundTranslationSlices.push(stem);
+          outboundTranslationSliceRelPaths[stem] = relPath;
+          return;
+        } else {
+          return;
+        }
+      case "Aggregate" :
+        if (stem.endsWith("Behavior")) {
+          aggregateBehaviors.push(stem);
+        } else {
+          aggregateSpecs.push(stem);
+          aggregateSpecRelPaths[stem] = relPath;
+        }
+        return;
+      case "ReadModel" :
+        if (stem.endsWith("Projections")) {
+          projectionsByRelPath[stem] = relPath;
+        } else {
+          readModelStems.push(stem);
+        }
+        return;
+      case "ReadModelStream" :
+        if (stem.endsWith("Projections")) {
+          projectionsByRelPath[stem] = relPath;
+        } else {
+          readModelStreamStems.push(stem);
+        }
+        return;
+      case "Task" :
+        tasks.push(stem);
+        return;
+      case "ExtensionPoint" :
+        epFiles.push({
+          stem: stem,
+          componentType: componentType,
+          epGroup: param.epGroup,
+          relPath: relPath
+        });
+        return;
+      case "Extension" :
+        extensions.push(stem);
+        return;
+    }
+  });
+  let aggregates = Stdlib_Array.filterMap(sortedStems(aggregateSpecs), spec => {
+    let underscored = spec + "_Behavior";
+    let bare = spec + "Behavior";
+    let behaviorStem = aggregateBehaviors.includes(underscored) ? underscored : (
+        aggregateBehaviors.includes(bare) ? bare : undefined
+      );
+    if (behaviorStem !== undefined) {
+      let relPath = aggregateSpecRelPaths[spec];
+      let isAsync = relPath !== undefined ? hasAsyncAttribute(Nodepath.join(srcDir, relPath)) : false;
+      return {
+        spec: spec,
+        behavior: behaviorStem,
+        eventMappings: eventMappings[spec],
+        isAsync: isAsync
+      };
+    }
+    console.warn("Generator: Aggregate spec `" + spec + "` has no matching `" + underscored + "` or `" + bare + "` — skipping");
+  });
+  let pairReadModel = (stream, rm) => {
+    let baseName = rm.endsWith("ReadModel") ? rm.slice(0, rm.length - 9 | 0) : rm;
+    let underscoredProj = baseName + "_Projections";
+    let match = projectionsByRelPath[underscoredProj];
+    if (match !== undefined) {
+      return {
+        readModel: rm,
+        projections: underscoredProj,
+        stream: stream
+      };
+    } else {
+      console.warn("Generator: ReadModel `" + rm + "` has no matching `" + underscoredProj + ".res` — skipping");
+      return;
+    }
+  };
+  let readModels = Stdlib_Array.filterMap(sortedStems(readModelStems), rm => pairReadModel(false, rm)).concat(Stdlib_Array.filterMap(sortedStems(readModelStreamStems), rm => pairReadModel(true, rm)));
+  let epByGroup = {};
+  let flatEpMappings = [];
+  epFiles.forEach(param => {
+    let epGroup = param.epGroup;
+    let stem = param.stem;
+    if (epGroup !== undefined) {
+      let a = [];
+      let arr = Stdlib_Option.getOr(epByGroup[epGroup], (epByGroup[epGroup] = a, a));
+      arr.push(stem);
+      return;
+    }
+    flatEpMappings.push(stem);
+  });
+  let extensionPoints = [];
+  if (flatEpMappings.length !== 0) {
+    extensionPoints.push({
+      group: undefined,
+      mappings: sortedStems(flatEpMappings)
+    });
+  }
+  Object.entries(epByGroup).forEach(param => {
+    extensionPoints.push({
+      group: param[0],
+      mappings: sortedStems(param[1])
+    });
+  });
+  let buildTargets = (stems, relPaths) => {
+    let dict = {};
+    stems.forEach(stem => {
+      let relPath = relPaths[stem];
+      let target = relPath !== undefined ? extractTargetName(Nodepath.join(srcDir, relPath)) : undefined;
+      dict[stem] = target;
+    });
+    return dict;
+  };
+  let d = {};
+  return {
+    stateChangeSlices: sortedStems(stateChangeSlices),
+    stateViewSlices: sortedStems(stateViewSlices),
+    stateViewSlicesStream: sortedStems(stateViewSlicesStream),
+    automationSlices: sortedStems(automationSlices),
+    inboundTranslationSlices: sortedStems(inboundTranslationSlices),
+    outboundTranslationSlices: sortedStems(outboundTranslationSlices),
+    automationSliceTargets: buildTargets(automationSlices, automationSliceRelPaths),
+    inboundTranslationSliceTargets: buildTargets(inboundTranslationSlices, inboundTranslationSliceRelPaths),
+    outboundTranslationSliceTargets: buildTargets(outboundTranslationSlices, outboundTranslationSliceRelPaths),
+    asyncStateChangeSlices: (stateChangeSlices.forEach(stem => {
+      let relPath = stateChangeSliceRelPaths[stem];
+      if (relPath !== undefined && hasAsyncAttribute(Nodepath.join(srcDir, relPath))) {
+        d[stem] = true;
+        return;
+      }
+    }), d),
+    aggregates: aggregates,
+    readModels: readModels,
+    tasks: sortedStems(tasks),
+    extensionPoints: extensionPoints,
+    extensions: sortedStems(extensions)
+  };
+}
+
+export {
+  implSuffixForStateChange,
+  implSuffixForStateView,
+  implSuffixForAutomation,
+  implSuffixForTranslation,
+  mappingsSuffixForAutomation,
+  isImplStem,
+  findEventMappings,
+  sortedStems,
+  extractTargetName,
+  hasAsyncAttribute,
+  resolve,
+}
+/* node:fs Not a pure module */

package/src/generator/PluginGenerator.res

@@ -0,0 +1,53 @@
+// Entry point for the plugin generator.
+// Usage: generate-plugin <srcDir>
+//        generate-plugin --aws <Namespace> <srcDir>
+
+let () = {
+  let argv2 = Generator_Node.argv->Array.get(2)->Option.getOr("")
+  let argv3 = Generator_Node.argv->Array.get(3)->Option.getOr("")
+  let argv4 = Generator_Node.argv->Array.get(4)->Option.getOr("")
+
+  let (variant, srcDirArg) = if argv2 === "--aws" {
+    if argv3 !== "" && argv4 !== "" {
+      (Config.Aws({compositionNamespace: argv3}), argv4)
+    } else {
+      Console.error("Usage: generate-plugin --aws <Namespace> <srcDir>")
+      (Config.Composition, "")
+    }
+  } else {
+    (Config.Composition, argv2)
+  }
+
+  if srcDirArg === "" {
+    if argv2 !== "--aws" {
+      Console.error("Usage: generate-plugin <srcDir>")
+      Console.error("       generate-plugin --aws <Namespace> <srcDir>")
+    }
+  } else {
+    // Resolve to absolute path (handles relative paths and trailing slashes)
+    let srcDir = Generator_Node.resolve([srcDirArg])
+
+    let config = {...Config.read(~srcDir), variant}
+    let discovered = Discovery.scan(~srcDir, ~exclude=config.exclude)
+    let resolved = Pairing.resolve(discovered, ~srcDir)
+    let source = Codegen.render(~config, ~resolved, ~discovered)
+
+    let outputDir = switch variant {
+    | Config.Composition => srcDir
+    | Config.Aws(_) => Generator_Node.join([Generator_Node.cwd(), "src"])
+    }
+
+    let pluginPath = Generator_Node.join([outputDir, "Plugin.res"])
+    Generator_Node.writeFileSync(pluginPath, source)
+    Console.log("Generated: " ++ pluginPath)
+
+    switch variant {
+    | Config.Composition => ()
+    | Config.Aws(_) =>
+      let mainSource = Codegen.renderMain(~config)
+      let mainPath = Generator_Node.join([outputDir, "Main.res"])
+      Generator_Node.writeFileSync(mainPath, mainSource)
+      Console.log("Generated: " ++ mainPath)
+    }
+  }
+}

package/src/generator/PluginGenerator.res.mjs

@@ -0,0 +1,70 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodepath from "node:path";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Config$Reventless from "./Config.res.mjs";
+import * as Codegen$Reventless from "./Codegen.res.mjs";
+import * as Pairing$Reventless from "./Pairing.res.mjs";
+import * as Discovery$Reventless from "./Discovery.res.mjs";
+
+let argv2 = Stdlib_Option.getOr(process.argv[2], "");
+
+let argv3 = Stdlib_Option.getOr(process.argv[3], "");
+
+let argv4 = Stdlib_Option.getOr(process.argv[4], "");
+
+let match = argv2 === "--aws" ? (
+    argv3 !== "" && argv4 !== "" ? [
+        {
+          TAG: "Aws",
+          compositionNamespace: argv3
+        },
+        argv4
+      ] : (console.error("Usage: generate-plugin --aws <Namespace> <srcDir>"), [
+        "Composition",
+        ""
+      ])
+  ) : [
+    "Composition",
+    argv2
+  ];
+
+let srcDirArg = match[1];
+
+let variant = match[0];
+
+if (srcDirArg === "") {
+  if (argv2 !== "--aws") {
+    console.error("Usage: generate-plugin <srcDir>");
+    console.error("       generate-plugin --aws <Namespace> <srcDir>");
+  }
+} else {
+  let srcDir = Nodepath.resolve(srcDirArg);
+  let init = Config$Reventless.read(srcDir);
+  let config_name = init.name;
+  let config_heartbeatInterval = init.heartbeatInterval;
+  let config_exclude = init.exclude;
+  let config = {
+    name: config_name,
+    heartbeatInterval: config_heartbeatInterval,
+    exclude: config_exclude,
+    variant: variant
+  };
+  let discovered = Discovery$Reventless.scan(srcDir, config_exclude);
+  let resolved = Pairing$Reventless.resolve(discovered, srcDir);
+  let source = Codegen$Reventless.render(config, resolved, discovered);
+  let outputDir;
+  outputDir = typeof variant !== "object" ? srcDir : Nodepath.join(process.cwd(), "src");
+  let pluginPath = Nodepath.join(outputDir, "Plugin.res");
+  Nodefs.writeFileSync(pluginPath, source, "utf8");
+  console.log("Generated: " + pluginPath);
+  if (typeof variant === "object") {
+    let mainSource = Codegen$Reventless.renderMain(config);
+    let mainPath = Nodepath.join(outputDir, "Main.res");
+    Nodefs.writeFileSync(mainPath, mainSource, "utf8");
+    console.log("Generated: " + mainPath);
+  }
+}
+
+/* argv2 Not a pure module */

package/src/types/Authorization.res

@@ -0,0 +1,23 @@
+// Provider-agnostic authorization rules. Evaluated against the
+// `Identity.t` resolved by an `Auth_Adapter.Provider.authenticate` call.
+//
+// `array<string>` for groups (not a parameterised variant) keeps the
+// framework decoupled from any application's specific group set —
+// applications can define their own typed `group` variant and convert via
+// a thin helper, see docs/analysis/authentication-authorization.md §4.2.
+
+@schema
+type permission =
+  | AllowGroups(array<string>)
+  | AllowAuthenticated
+  | AllowAnonymous
+  | DenyAll
+
+let isAllowed = (rule: permission, identity: Identity.t): bool =>
+  switch rule {
+  | DenyAll => false
+  | AllowAnonymous => true
+  | AllowAuthenticated => identity.userId !== "anonymous"
+  | AllowGroups(groups) =>
+    groups->Array.some(group => identity.groups->Array.includes(group))
+  }

package/src/types/Authorization.res.mjs

@@ -0,0 +1,33 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+
+let permissionSchema = S.union([
+  S.schema(s => ({
+    TAG: "AllowGroups",
+    _0: s.m(S.array(S.string))
+  })),
+  S.literal("AllowAuthenticated"),
+  S.literal("AllowAnonymous"),
+  S.literal("DenyAll")
+]);
+
+function isAllowed(rule, identity) {
+  if (typeof rule === "object") {
+    return rule._0.some(group => identity.groups.includes(group));
+  }
+  switch (rule) {
+    case "AllowAuthenticated" :
+      return identity.userId !== "anonymous";
+    case "AllowAnonymous" :
+      return true;
+    case "DenyAll" :
+      return false;
+  }
+}
+
+export {
+  permissionSchema,
+  isAllowed,
+}
+/* permissionSchema Not a pure module */

package/src/types/Behavior.res

@@ -0,0 +1,78 @@
+// Behavior module type for aggregate business logic.
+// Lives in reventless-spec so application domain code can define behaviors
+// without importing the reventless implementation package.
+
+/**
+Module type that application code must implement to define aggregate business logic.
+
+A `Behavior.T` module contains the `Spec` (command / event / error types), the
+aggregate `state`, and two pure functions plus an initial state value:
+
+- `initialState` — the starting state before any events (represents "not yet created")
+- `evolve` — fold an event into the current state
+- `decide` — handle a command on the current state, returning `Ok(events)` or `Error(error)`
+
+@example
+```rescript
+// CategoryBehavior.res
+module Spec = Category
+
+@schema
+type state = NotCreated | Active({name: string}) | Archived
+
+let initialState = NotCreated
+
+let evolve = (state, event) => switch (state, event) {
+  | (NotCreated, CategoryAdded({name})) => Active({name})
+  | (Active(_), CategoryRenamed({name})) => Active({name})
+  | (Active(_), CategoryArchived(_)) => Archived
+  | _ => state
+}
+
+let decide = (state, cmd) => switch (state, cmd) {
+  | (NotCreated, AddCategory({categoryId, name})) => Ok([CategoryAdded({categoryId, name})])
+  | (NotCreated, _) => Error(CategoryNotFound)
+  | (Active(_), AddCategory(_)) => Error(CategoryAlreadyExists)
+  | (Active(_), RenameCategory({categoryId, name})) => Ok([CategoryRenamed({categoryId, name})])
+  | (Active(_), ArchiveCategory({categoryId})) => Ok([CategoryArchived({categoryId})])
+  | (Archived, _) => Error(CategoryAlreadyArchived)
+}
+```
+*/
+module type T = {
+  module Spec: {
+    /** The command type. Must carry a `@schema` attribute. */
+    @schema
+    type command
+
+    /** The event type. Must carry a `@schema` attribute. */
+    @schema
+    type event
+
+    /** The error type returned when business rules are violated. */
+    @schema
+    type error
+  }
+
+  /** The aggregate's internal state type. Not persisted; rebuilt by replaying events. */
+  type state
+
+  /** The starting state before any events have been applied. */
+  let initialState: state
+
+  /**
+  Fold one event into the current state. Called for every event during replay.
+  Must be a pure function — no side effects.
+  */
+  let evolve: (state, Spec.event) => state
+
+  /**
+  Handle a command on the current state.
+  Return `Ok(events)` to emit events, or `Error(error)` to reject the command.
+  */
+  let decide: (state, Spec.command) => result<array<Spec.event>, Spec.error>
+
+  /** File URL of this module (`import.meta.url`). Used by AWS builders to derive
+      the npm specifier for runtime dynamic imports. */
+  let moduleUrl: string
+}

package/src/types/Behavior.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */