@reventlessdev/reventless-local 3.0.0-alpha.180 → 3.0.0-alpha.181

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 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.181 (2026-07-30)
+
+### Features
+
+* **spec,local:** resolve capability manifests beyond the example topology ([8bfadd5](https://github.com/ReventlessDev/reventless-core/commit/8bfadd5beef90c0c9f6f6f3fbb753c8b789469ed))
+
+
 # 3.0.0-alpha.180 (2026-07-30)
 
 ### Bug Fixes

package/emit-capabilities.mjs

@@ -1,53 +1,3 @@
 #!/usr/bin/env node
-// Emit `capabilities.json` beside a plugin's generated `Plugin.res`.
-//
-// Applies the plugin's compiled composition root to the local platform and
-// renders the structure-derived capability manifest — the same
-// `pluginStructure.requiredStores` walk the deployed plugin reports at
-// runtime, never a second scan of the sources. Untyped by necessity: a
-// dynamically imported module cannot be functor-applied from ReScript, so the
-// reflection lives here and everything typed lives in
-// `Reventless.CapabilityManifest`.
-//
-// Usage: emit-capabilities <srcDir>   (run from the plugin package, after `rescript build`)
-
-import fs from "node:fs";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-
-// The local platform defaults to Debug-level logging; a build step should not.
-if (process.env.LOG_LEVEL === undefined) process.env.LOG_LEVEL = "warn";
-
-const srcDirArg = process.argv[2];
-if (srcDirArg === undefined || srcDirArg === "") {
-  console.error("Usage: emit-capabilities <srcDir>");
-  process.exit(1);
-}
-
-const srcDir = path.resolve(srcDirArg);
-const pluginModulePath = path.join(srcDir, "Plugin.res.mjs");
-if (!fs.existsSync(pluginModulePath)) {
-  console.error(
-    `emit-capabilities: ${pluginModulePath} not found — run \`rescript build\` first.`,
-  );
-  process.exit(1);
-}
-
-const LocalPlatform = await import(
-  new URL("./src/Platform.res.mjs", import.meta.url)
-);
-const CapabilityManifest = await import(
-  "@reventlessdev/reventless-spec/src/components/CapabilityManifest.res.mjs"
-);
-
-const Platform = LocalPlatform.Make();
-const Plugin = await import(pathToFileURL(pluginModulePath));
-const { pluginStructure } = Plugin.Make(Platform);
-
-const manifestPath = path.join(srcDir, "capabilities.json");
-fs.writeFileSync(manifestPath, CapabilityManifest.renderForStructure(pluginStructure));
-console.log("Generated: " + manifestPath);
-
-// Applying the platform functor wires in-process infrastructure; exit
-// explicitly so no lingering handle keeps the build step alive.
-process.exit(0);
+import { main } from "./src/EmitCapabilities.res.mjs"
+await main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.180",
+  "version": "3.0.0-alpha.181",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -39,12 +39,12 @@
     "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
     "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.20",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.192",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.40",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.139",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.56",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.85",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.110"
+    "@reventlessdev/reventless-core": "3.0.0-alpha.193",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.140",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.41",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.57",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.111",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.86"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/EmitCapabilities.res

@@ -0,0 +1,113 @@
+// Emit `capabilities.json` beside a plugin's compiled composition root.
+//
+// Applies the plugin's composition root to the local platform and renders the
+// structure-derived capability manifest — the same `pluginStructure` walk the
+// deployed plugin reports at runtime, never a second scan of the sources.
+//
+// The two dynamically imported modules are the only untyped surface, and they
+// are typed *at the boundary*: `Platform.res.mjs` and every composition root
+// emit exactly the exports declared below, so `pluginStructure` arrives as
+// `Reventless.Plugin.pluginStructure` and everything downstream is ordinary
+// typed ReScript. Same shape as `ReventlessGwt.LocalHost`, which reflects the
+// domain graph this way.
+//
+// The platform is reached through a dynamic import rather than by applying
+// `Platform.Make` directly: a composition root's `Make` is a JS function
+// expecting the platform *value*, and a ReScript module is not one. Importing
+// it puts both sides on the same footing, and it keeps `LOG_LEVEL` (set below)
+// in force before the platform's logger initialises.
+//
+// Usage: emit-capabilities <srcDir> [<compositionModule>]
+//   (run from the plugin package, after `rescript build`)
+
+// ── Node ─────────────────────────────────────────────────────────────────────
+
+@module("node:fs") external existsSync: string => bool = "existsSync"
+@module("node:fs") external writeFileSync: (string, string, @as("utf8") _) => unit = "writeFileSync"
+
+@module("node:path") @variadic external join: array<string> => string = "join"
+@module("node:path") @variadic external resolve: array<string> => string = "resolve"
+@module("node:path") @val external sep: string = "sep"
+
+@module("node:url") external pathToFileURL: string => {"href": string} = "pathToFileURL"
+
+@val @scope("process") external argv: array<string> = "argv"
+@val @scope("process") external env: Dict.t<string> = "env"
+@val external processExit: int => unit = "process.exit"
+
+// Emitted by ReScript as a literal `import(...)` expression — the composition
+// root's path is only known at run time, so it cannot be a static binding.
+@val external dynImport: string => promise<'a> = "import"
+
+// ── The dynamic-import boundary ──────────────────────────────────────────────
+
+type platform
+type localPlatformExports = {"Make": unit => platform}
+type builtPlugin = {"pluginStructure": Reventless.Plugin.pluginStructure}
+type compositionExports = {"Make": platform => builtPlugin}
+
+// ── Which module holds the composition root ──────────────────────────────────
+
+/** `Plugin.res.mjs` is what `generate-plugin` emits, so it is the default and
+    every existing caller is unaffected. A hand-written composition root is
+    named after its plugin instead and says so: a bare module name (`Catalog`)
+    resolves inside `<srcDir>`, a path (`../lib/Catalog.res.mjs`) from the
+    working directory. */
+let compositionModulePath = (~srcDir: string, ~moduleArg: option<string>): string => {
+  let withExtension = name => name->String.endsWith(".mjs") ? name : name ++ ".res.mjs"
+  switch moduleArg {
+  | None | Some("") => join([srcDir, "Plugin.res.mjs"])
+  | Some(name) =>
+    name->String.includes("/") || name->String.includes(sep)
+      ? resolve([withExtension(name)])
+      : join([srcDir, withExtension(name)])
+  }
+}
+
+// ── Entry point ──────────────────────────────────────────────────────────────
+
+let fail = (message: string) => {
+  Console.error("emit-capabilities: " ++ message)
+  processExit(1)
+}
+
+let main = async () => {
+  // The local platform defaults to Debug-level logging; a build step should not.
+  switch env->Dict.get("LOG_LEVEL") {
+  | Some(_) => ()
+  | None => env->Dict.set("LOG_LEVEL", "warn")
+  }
+
+  switch argv->Array.get(2) {
+  | None | Some("") => {
+      Console.error("Usage: emit-capabilities <srcDir> [<compositionModule>]")
+      processExit(1)
+    }
+  | Some(srcDirArg) => {
+      let srcDir = resolve([srcDirArg])
+      let modulePath = compositionModulePath(~srcDir, ~moduleArg=argv->Array.get(3))
+      if !existsSync(modulePath) {
+        fail(`${modulePath} not found — run \`rescript build\` first.`)
+      }
+
+      // Relative specifier: resolved against this module, so it finds the
+      // sibling compiled platform whatever the working directory is.
+      let platformModule: localPlatformExports = await dynImport("./Platform.res.mjs")
+      let platform = platformModule["Make"]()
+
+      let composition: compositionExports = await dynImport(pathToFileURL(modulePath)["href"])
+      let built = composition["Make"](platform)
+
+      let manifestPath = join([srcDir, "capabilities.json"])
+      writeFileSync(
+        manifestPath,
+        Reventless.CapabilityManifest.renderForStructure(built["pluginStructure"]),
+      )
+      Console.log("Generated: " ++ manifestPath)
+
+      // Applying the platform functor wires in-process infrastructure; exit
+      // explicitly so no lingering handle keeps the build step alive.
+      processExit(0)
+    }
+  }
+}

package/src/EmitCapabilities.res.mjs

@@ -0,0 +1,70 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodeurl from "node:url";
+import * as Nodepath from "node:path";
+import * as CapabilityManifest$Reventless from "@reventlessdev/reventless-spec/src/components/CapabilityManifest.res.mjs";
+
+function compositionModulePath(srcDir, moduleArg) {
+  let withExtension = name => {
+    if (name.endsWith(".mjs")) {
+      return name;
+    } else {
+      return name + ".res.mjs";
+    }
+  };
+  if (moduleArg !== undefined && moduleArg !== "") {
+    if (moduleArg.includes("/") || moduleArg.includes(Nodepath.sep)) {
+      return Nodepath.resolve(withExtension(moduleArg));
+    } else {
+      return Nodepath.join(srcDir, withExtension(moduleArg));
+    }
+  } else {
+    return Nodepath.join(srcDir, "Plugin.res.mjs");
+  }
+}
+
+function fail(message) {
+  console.error("emit-capabilities: " + message);
+  process.exit(1);
+}
+
+async function main() {
+  let match = process.env["LOG_LEVEL"];
+  if (match !== undefined) {
+    
+  } else {
+    process.env["LOG_LEVEL"] = "warn";
+  }
+  let srcDirArg = process.argv[2];
+  if (srcDirArg !== undefined) {
+    if (srcDirArg === "") {
+      console.error("Usage: emit-capabilities <srcDir> [<compositionModule>]");
+      process.exit(1);
+      return;
+    }
+    let srcDir = Nodepath.resolve(srcDirArg);
+    let modulePath = compositionModulePath(srcDir, process.argv[3]);
+    if (!Nodefs.existsSync(modulePath)) {
+      fail(modulePath + ` not found — run \`rescript build\` first.`);
+    }
+    let platformModule = await import("./Platform.res.mjs");
+    let platform = platformModule.Make();
+    let composition = await import(Nodeurl.pathToFileURL(modulePath).href);
+    let built = composition.Make(platform);
+    let manifestPath = Nodepath.join(srcDir, "capabilities.json");
+    Nodefs.writeFileSync(manifestPath, CapabilityManifest$Reventless.renderForStructure(built.pluginStructure), "utf8");
+    console.log("Generated: " + manifestPath);
+    process.exit(0);
+    return;
+  }
+  console.error("Usage: emit-capabilities <srcDir> [<compositionModule>]");
+  process.exit(1);
+}
+
+export {
+  compositionModulePath,
+  fail,
+  main,
+}
+/* node:fs Not a pure module */