@reventlessdev/reventless-local 3.0.0-alpha.261 → 3.0.0-alpha.263

package/CHANGELOG.md

@@ -3,6 +3,27 @@
 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.263 (2026-09-24)
+
+**Note:** Version bump only for package @reventlessdev/reventless-local
+
+
+
+
+
+# 3.0.0-alpha.262 (2026-09-23)
+
+* feat(node)!: every command-line tool reads its arguments through parseArgs ([2e41979](https://github.com/ReventlessDev/reventless-core/commit/2e41979b73646c46356e197e17eb4a3da0154c73))
+
+### BREAKING CHANGES
+
+* NodeProcess.onSignal takes the new NodeProcess.signal
+variant (SIGINT | SIGTERM | SIGHUP) instead of a polymorphic variant:
+write onSignal(SIGINT, …) for onSignal(#SIGINT, …). Node receives the
+same string.
+
+
+
 # 3.0.0-alpha.261 (2026-09-23)
 
 **Note:** Version bump only for package @reventlessdev/reventless-local

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.261",
+  "version": "3.0.0-alpha.263",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -34,24 +34,24 @@
     "graphql-yoga": "^5.21.0",
     "sury": "11.0.0",
     "ws": "^8.18.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.34",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.11",
     "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.29",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.14",
     "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.23",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.34",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.15",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.273",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.22",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.271",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.218",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.119",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.135",
-    "@reventlessdev/reventless-seed": "1.0.0-alpha.25",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.143",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.171"
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.121",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.220",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.173",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.137",
+    "@reventlessdev/reventless-seed": "1.0.0-alpha.26",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.145"
   },
   "devDependencies": {
     "rescript": "12.3.1",
     "sury-ppx": "11.0.0",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.89"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.92"
   },
   "peerDependencies": {
     "rescript": "^12.3.1"

package/src/EmitCapabilities.res

@@ -16,9 +16,6 @@
 // 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`)
 
 // 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.
@@ -56,45 +53,59 @@ let fail = (message: string) => {
   NodeProcess.exit(1)
 }
 
-let main = async () => {
-  // The local platform defaults to Debug-level logging; a build step should not.
-  switch NodeProcess.env->Dict.get("LOG_LEVEL") {
-  | Some(_) => ()
-  | None => NodeProcess.env->Dict.set("LOG_LEVEL", "warn")
-  }
+let usage = `Usage: emit-capabilities <srcDir> [<compositionModule>]
+
+  <srcDir>             the plugin's sources; capabilities.json is written there
+  <compositionModule>  the composition root, when it is not the generated
+                       Plugin.res: a module name inside <srcDir>, or a path
+
+  Run from the plugin package, after rescript build.`
 
-  switch NodeProcess.argv->Array.get(2) {
-  | None | Some("") => {
-      Console.error("Usage: emit-capabilities <srcDir> [<compositionModule>]")
-      NodeProcess.exit(1)
+type args = {srcDir: string, compositionModule: option<string>}
+
+let parseArgs = (argv: array<string>): result<args, string> =>
+  Reventless.CliArgs.parse(argv)
+  ->Result.flatMap(a => a->Reventless.CliArgs.atMost(2))
+  ->Result.flatMap(a => {
+    let positionals = a->Reventless.CliArgs.positionals
+    switch positionals->Array.get(0) {
+    | None | Some("") => Error("<srcDir> is required.")
+    | Some(srcDir) => Ok({srcDir, compositionModule: positionals->Array.get(1)})
     }
-  | Some(srcDirArg) => {
-      let srcDir = NodePath.resolve([srcDirArg])
-      let modulePath = compositionModulePath(~srcDir, ~moduleArg=NodeProcess.argv->Array.get(3))
-      if !NodeFs.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(
-        NodeUrl.pathToFileURL(modulePath)["href"],
-      )
-      let built = composition["Make"](platform)
-
-      let manifestPath = NodePath.join([srcDir, "capabilities.json"])
-      NodeFs.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.
-      NodeProcess.exit(0)
+  })
+
+let cli: Reventless.CliArgs.cli<args> = {bin: "emit-capabilities", usage, parse: parseArgs}
+
+let main = () =>
+  Reventless.CliArgs.run(cli, async ({srcDir: srcDirArg, compositionModule}) => {
+    // The local platform defaults to Debug-level logging; a build step should not.
+    switch NodeProcess.env->Dict.get("LOG_LEVEL") {
+    | Some(_) => ()
+    | None => NodeProcess.env->Dict.set("LOG_LEVEL", "warn")
     }
-  }
-}
+
+    let srcDir = NodePath.resolve([srcDirArg])
+    let modulePath = compositionModulePath(~srcDir, ~moduleArg=compositionModule)
+    if !NodeFs.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(NodeUrl.pathToFileURL(modulePath)["href"])
+    let built = composition["Make"](platform)
+
+    let manifestPath = NodePath.join([srcDir, "capabilities.json"])
+    NodeFs.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.
+    NodeProcess.exit(0)
+  })

package/src/EmitCapabilities.res.mjs

@@ -3,6 +3,8 @@
 import * as Nodefs from "node:fs";
 import * as Nodeurl from "node:url";
 import * as Nodepath from "node:path";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as CliArgs$Reventless from "@reventlessdev/reventless-spec/src/CliArgs.res.mjs";
 import * as CapabilityManifest$Reventless from "@reventlessdev/reventless-spec/src/components/CapabilityManifest.res.mjs";
 
 function compositionModulePath(srcDir, moduleArg) {
@@ -29,22 +31,51 @@ function fail(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 usage = `Usage: emit-capabilities <srcDir> [<compositionModule>]
+
+  <srcDir>             the plugin's sources; capabilities.json is written there
+  <compositionModule>  the composition root, when it is not the generated
+                       Plugin.res: a module name inside <srcDir>, or a path
+
+  Run from the plugin package, after rescript build.`;
+
+function parseArgs(argv) {
+  return Stdlib_Result.flatMap(Stdlib_Result.flatMap(CliArgs$Reventless.parse(undefined, undefined, undefined, undefined, argv), a => CliArgs$Reventless.atMost(a, 2)), a => {
+    let positionals = CliArgs$Reventless.positionals(a);
+    let srcDir = positionals[0];
+    if (srcDir !== undefined && srcDir !== "") {
+      return {
+        TAG: "Ok",
+        _0: {
+          srcDir: srcDir,
+          compositionModule: positionals[1]
+        }
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: "<srcDir> is required."
+      };
     }
-    let srcDir = Nodepath.resolve(srcDirArg);
-    let modulePath = compositionModulePath(srcDir, process.argv[3]);
+  });
+}
+
+let cli = {
+  bin: "emit-capabilities",
+  usage: usage,
+  parse: parseArgs
+};
+
+function main() {
+  return CliArgs$Reventless.run(cli, undefined, undefined, async param => {
+    let match = process.env["LOG_LEVEL"];
+    if (match !== undefined) {
+      
+    } else {
+      process.env["LOG_LEVEL"] = "warn";
+    }
+    let srcDir = Nodepath.resolve(param.srcDir);
+    let modulePath = compositionModulePath(srcDir, param.compositionModule);
     if (!Nodefs.existsSync(modulePath)) {
       fail(modulePath + ` not found — run \`rescript build\` first.`);
     }
@@ -56,15 +87,15 @@ async function main() {
     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,
+  usage,
+  parseArgs,
+  cli,
   main,
 }
 /* node:fs Not a pure module */

package/src/LocalPlatformRegistry.res

@@ -171,11 +171,11 @@ let register = (
 ): unit => {
   let path = write(~port, ~endpoint, ~loginEndpoint, ~store, ~tapPort?)
   NodeProcess.onExit(_ => removeQuietly(path))
-  NodeProcess.onSignal(#SIGINT, () => {
+  NodeProcess.onSignal(SIGINT, () => {
     removeQuietly(path)
     NodeProcess.exit(130)
   })
-  NodeProcess.onSignal(#SIGTERM, () => {
+  NodeProcess.onSignal(SIGTERM, () => {
     removeQuietly(path)
     NodeProcess.exit(143)
   })

package/tests/EmitCapabilitiesTest.res

@@ -0,0 +1,45 @@
+open JestGlobals
+
+// `emit-capabilities <srcDir> [<compositionModule>]` runs in the `postbuild` of
+// every plugin package.
+
+describe("EmitCapabilities.parseArgs", () => {
+  testSync("a plugin's postbuild: emit-capabilities src/", () =>
+    expect(EmitCapabilities.parseArgs(["src/"]))->toEqual(
+      Ok({EmitCapabilities.srcDir: "src/", compositionModule: None}),
+    )
+  )
+
+  testSync("a hand-written composition root is named after the source directory", () =>
+    expect(EmitCapabilities.parseArgs(["src", "Catalog"]))->toEqual(
+      Ok({EmitCapabilities.srcDir: "src", compositionModule: Some("Catalog")}),
+    )
+  )
+
+  testSync("no source directory is refused", () =>
+    expect(EmitCapabilities.parseArgs([])->Result.isError)->toBe(true)
+  )
+})
+
+describe("emit-capabilities on the command line", () => {
+  module CliArgs = Reventless.CliArgs
+  let usage = EmitCapabilities.usage->String.trim
+
+  test("--help anywhere prints the usage to stdout and exits 0", async () =>
+    expect(await CliArgs.observe(EmitCapabilities.cli, ["src/", "--help"]))->toEqual({
+      CliArgs.stdout: [usage],
+      stderr: [],
+      exitCode: Some(0),
+      reachedMain: false,
+    })
+  )
+
+  test("a usage mistake names itself, shows the usage on stderr and exits 2", async () =>
+    expect(await CliArgs.observe(EmitCapabilities.cli, ["src", "Catalog", "extra"]))->toEqual({
+      CliArgs.stdout: [],
+      stderr: [`emit-capabilities: unknown argument "extra"\n\n${usage}`],
+      exitCode: Some(2),
+      reachedMain: false,
+    })
+  )
+})

package/tests/EmitCapabilitiesTest.res.mjs

@@ -0,0 +1,61 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as CliArgs$Reventless from "@reventlessdev/reventless-spec/src/CliArgs.res.mjs";
+import * as EmitCapabilities$ReventlessLocal from "../src/EmitCapabilities.res.mjs";
+
+globalThis.describe("EmitCapabilities.parseArgs", () => {
+  globalThis.test("a plugin's postbuild: emit-capabilities src/", () => {
+    globalThis.expect(EmitCapabilities$ReventlessLocal.parseArgs(["src/"])).toEqual({
+      TAG: "Ok",
+      _0: {
+        srcDir: "src/",
+        compositionModule: undefined
+      }
+    });
+  });
+  globalThis.test("a hand-written composition root is named after the source directory", () => {
+    globalThis.expect(EmitCapabilities$ReventlessLocal.parseArgs([
+      "src",
+      "Catalog"
+    ])).toEqual({
+      TAG: "Ok",
+      _0: {
+        srcDir: "src",
+        compositionModule: "Catalog"
+      }
+    });
+  });
+  globalThis.test("no source directory is refused", () => {
+    globalThis.expect(Stdlib_Result.isError(EmitCapabilities$ReventlessLocal.parseArgs([]))).toBe(true);
+  });
+});
+
+globalThis.describe("emit-capabilities on the command line", () => {
+  let usage = EmitCapabilities$ReventlessLocal.usage.trim();
+  globalThis.test("--help anywhere prints the usage to stdout and exits 0", async () => {
+    globalThis.expect(await CliArgs$Reventless.observe(EmitCapabilities$ReventlessLocal.cli, [
+      "src/",
+      "--help"
+    ])).toEqual({
+      stdout: [usage],
+      stderr: [],
+      exitCode: 0,
+      reachedMain: false
+    });
+  });
+  globalThis.test("a usage mistake names itself, shows the usage on stderr and exits 2", async () => {
+    globalThis.expect(await CliArgs$Reventless.observe(EmitCapabilities$ReventlessLocal.cli, [
+      "src",
+      "Catalog",
+      "extra"
+    ])).toEqual({
+      stdout: [],
+      stderr: [`emit-capabilities: unknown argument "extra"\n\n` + usage],
+      exitCode: 2,
+      reachedMain: false
+    });
+  });
+});
+
+/*  Not a pure module */