@reventlessdev/reventless-spec 3.0.0-alpha.143 → 3.0.0-alpha.144

package/src/generator/PlatformGenerator.res

@@ -22,12 +22,28 @@ let asObject = (json: JSON.t): option<dict<JSON.t>> => json->JSON.Decode.object
 let stringAt = (obj: dict<JSON.t>, field: string): option<string> =>
   obj->Dict.get(field)->Option.flatMap(JSON.Decode.string)
 
-let () = {
-  let manifestArg = NodeProcess.argv->Array.get(2)->Option.getOr("")
-  if manifestArg == "" {
-    Console.error("Usage: generate-platform <deploy-manifest.yaml>")
-    NodeProcess.exit(1)
-  } else {
+let usage = `Usage: generate-platform <deploy-manifest.yaml>
+
+  Reads the plugins the deploy manifest lists, unions their committed
+  capabilities.json manifests, and writes the platform's
+  src/PlatformCapabilities.res.`
+
+type args = {manifest: string}
+
+let parseArgs = (argv: array<string>): result<args, string> =>
+  CliArgs.parse(argv)
+  ->Result.flatMap(a => a->CliArgs.atMost(1))
+  ->Result.flatMap(a =>
+    switch a->CliArgs.positionals->Array.get(0) {
+    | None | Some("") => Error("<deploy-manifest.yaml> is required.")
+    | Some(manifest) => Ok({manifest: manifest})
+    }
+  )
+
+let cli: CliArgs.cli<args> = {bin: "generate-platform", usage, parse: parseArgs}
+
+let main = () =>
+  CliArgs.run(cli, async ({manifest: manifestArg}) => {
     let manifestPath = NodePath.resolve([manifestArg])
     if !NodeFs.existsSync(manifestPath) {
       fail(`${manifestPath} not found`)
@@ -52,16 +68,18 @@ let () = {
       ->Option.flatMap(m => m->Dict.get("plugins"))
       ->Option.flatMap(JSON.Decode.array)
       ->Option.map(entries =>
-        entries->Array.filterMap(entry => {
-          let obj = entry->asObject
-          switch (
-            obj->Option.flatMap(o => o->stringAt("name")),
-            obj->Option.flatMap(o => o->stringAt("path")),
-          ) {
-          | (Some(name), Some(path)) => Some((name, path))
-          | _ => None
-          }
-        })
+        entries->Array.filterMap(
+          entry => {
+            let obj = entry->asObject
+            switch (
+              obj->Option.flatMap(o => o->stringAt("name")),
+              obj->Option.flatMap(o => o->stringAt("path")),
+            ) {
+            | (Some(name), Some(path)) => Some((name, path))
+            | _ => None
+            }
+          },
+        )
       )
 
     switch (platformPath, plugins) {
@@ -89,20 +107,22 @@ let () = {
               []
             }
           | Manifests(manifests) =>
-            manifests->Array.map(({path, via}) => {
-              Console.log(
-                `Read: ${pluginName} — ${path} (via ${PlatformManifests.describeVia(via)})`,
-              )
-              let manifest = try NodeFs.readFileSync(path)
-              ->JSON.parseOrThrow
-              ->S.parseOrThrow(~to=CapabilityManifest.schema) catch {
-              | _ => {
-                  fail(`could not parse ${path} as a capability manifest`)
-                  ({capabilities: []}: CapabilityManifest.t)
+            manifests->Array.map(
+              ({path, via}) => {
+                Console.log(
+                  `Read: ${pluginName} — ${path} (via ${PlatformManifests.describeVia(via)})`,
+                )
+                let manifest = try NodeFs.readFileSync(path)
+                ->JSON.parseOrThrow
+                ->S.parseOrThrow(~to=CapabilityManifest.schema) catch {
+                | _ => {
+                    fail(`could not parse ${path} as a capability manifest`)
+                    ({capabilities: []}: CapabilityManifest.t)
+                  }
                 }
-              }
-              ({pluginName, manifest}: PlatformCodegen.pluginManifest)
-            })
+                ({pluginName, manifest}: PlatformCodegen.pluginManifest)
+              },
+            )
           }
         })
 
@@ -122,5 +142,4 @@ let () = {
       }
     | _ => fail(`${manifestPath} needs a \`platform.path\` and a \`plugins\` list with name + path`)
     }
-  }
-}
+  })

package/src/generator/PlatformGenerator.res.mjs

@@ -7,6 +7,8 @@ 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 Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as CliArgs$Reventless from "../CliArgs.res.mjs";
 import * as PlatformCodegen$Reventless from "./PlatformCodegen.res.mjs";
 import * as PlatformManifests$Reventless from "./PlatformManifests.res.mjs";
 import * as CapabilityManifest$Reventless from "../components/CapabilityManifest.res.mjs";
@@ -24,91 +26,120 @@ function stringAt(obj, field) {
   return Stdlib_Option.flatMap(obj[field], Stdlib_JSON.Decode.string);
 }
 
-let manifestArg = Stdlib_Option.getOr(process.argv[2], "");
+let usage = `Usage: generate-platform <deploy-manifest.yaml>
 
-if (manifestArg === "") {
-  console.error("Usage: generate-platform <deploy-manifest.yaml>");
-  process.exit(1);
-} else {
-  let manifestPath = Nodepath.resolve(manifestArg);
-  if (!Nodefs.existsSync(manifestPath)) {
-    fail(manifestPath + ` not found`);
-  }
-  let manifestDir = Nodepath.dirname(manifestPath);
-  let deployManifest;
-  try {
-    deployManifest = Yaml.parse(Nodefs.readFileSync(manifestPath, "utf8"));
-  } catch (exn) {
-    fail(`could not parse ` + manifestPath + ` as YAML`);
-    deployManifest = null;
-  }
-  let platformPath = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(deployManifest), m => m["platform"]), asObject), p => stringAt(p, "path"));
-  let plugins = Stdlib_Option.map(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(deployManifest), m => m["plugins"]), Stdlib_JSON.Decode.array), entries => Stdlib_Array.filterMap(entries, entry => {
-    let obj = Stdlib_JSON.Decode.object(entry);
-    let match = Stdlib_Option.flatMap(obj, o => stringAt(o, "name"));
-    let match$1 = Stdlib_Option.flatMap(obj, o => stringAt(o, "path"));
-    if (match !== undefined && match$1 !== undefined) {
-      return [
-        match,
-        match$1
-      ];
-    }
-  }));
-  if (platformPath !== undefined) {
-    if (plugins !== undefined) {
-      let pluginManifests = plugins.flatMap(param => {
-        let pluginName = param[0];
-        let pluginDir = Nodepath.resolve(manifestDir, param[1]);
-        if (!Nodefs.existsSync(pluginDir)) {
-          fail(`plugin "` + pluginName + `" points at ` + pluginDir + `, which does not exist`);
-        }
-        let manifests = PlatformManifests$Reventless.resolve(undefined, pluginDir);
-        if (typeof manifests !== "object") {
-          console.log(`Skipped: ` + pluginName + ` (` + pluginDir + `) — no plugin composition`);
-          return [];
-        }
-        if (manifests.TAG === "Manifests") {
-          return manifests._0.map(param => {
-            let path = param.path;
-            console.log(`Read: ` + pluginName + ` — ` + path + ` (via ` + PlatformManifests$Reventless.describeVia(param.via) + `)`);
-            let manifest;
-            try {
-              manifest = Sury.parseOrThrow(JSON.parse(Nodefs.readFileSync(path, "utf8")), CapabilityManifest$Reventless.schema);
-            } catch (exn) {
-              fail(`could not parse ` + path + ` as a capability manifest`);
-              manifest = {
-                capabilities: []
-              };
-            }
-            return {
-              pluginName: pluginName,
-              manifest: manifest
-            };
-          });
+  Reads the plugins the deploy manifest lists, unions their committed
+  capabilities.json manifests, and writes the platform's
+  src/PlatformCapabilities.res.`;
+
+function parseArgs(argv) {
+  return Stdlib_Result.flatMap(Stdlib_Result.flatMap(CliArgs$Reventless.parse(undefined, undefined, undefined, undefined, argv), a => CliArgs$Reventless.atMost(a, 1)), a => {
+    let manifest = CliArgs$Reventless.positionals(a)[0];
+    if (manifest !== undefined && manifest !== "") {
+      return {
+        TAG: "Ok",
+        _0: {
+          manifest: manifest
         }
-        let match = manifests._0;
-        fail(`no capabilities.json found for plugin "` + pluginName + `" (` + pluginDir + `) — build the plugin first; its build emits src/capabilities.json beside Plugin.res ` + (`(` + match.evidence + `; expected ` + match.expected + `)`));
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: "<deploy-manifest.yaml> is required."
+      };
+    }
+  });
+}
+
+let cli = {
+  bin: "generate-platform",
+  usage: usage,
+  parse: parseArgs
+};
+
+function main() {
+  return CliArgs$Reventless.run(cli, undefined, undefined, async param => {
+    let manifestPath = Nodepath.resolve(param.manifest);
+    if (!Nodefs.existsSync(manifestPath)) {
+      fail(manifestPath + ` not found`);
+    }
+    let manifestDir = Nodepath.dirname(manifestPath);
+    let deployManifest;
+    try {
+      deployManifest = Yaml.parse(Nodefs.readFileSync(manifestPath, "utf8"));
+    } catch (exn) {
+      fail(`could not parse ` + manifestPath + ` as YAML`);
+      deployManifest = null;
+    }
+    let platformPath = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(deployManifest), m => m["platform"]), asObject), p => stringAt(p, "path"));
+    let plugins = Stdlib_Option.map(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(deployManifest), m => m["plugins"]), Stdlib_JSON.Decode.array), entries => Stdlib_Array.filterMap(entries, entry => {
+      let obj = Stdlib_JSON.Decode.object(entry);
+      let match = Stdlib_Option.flatMap(obj, o => stringAt(o, "name"));
+      let match$1 = Stdlib_Option.flatMap(obj, o => stringAt(o, "path"));
+      if (match !== undefined && match$1 !== undefined) {
+        return [
+          match,
+          match$1
+        ];
+      }
+    }));
+    if (platformPath === undefined) {
+      return fail(manifestPath + ` needs a \`platform.path\` and a \`plugins\` list with name + path`);
+    }
+    if (plugins === undefined) {
+      return fail(manifestPath + ` needs a \`platform.path\` and a \`plugins\` list with name + path`);
+    }
+    let pluginManifests = plugins.flatMap(param => {
+      let pluginName = param[0];
+      let pluginDir = Nodepath.resolve(manifestDir, param[1]);
+      if (!Nodefs.existsSync(pluginDir)) {
+        fail(`plugin "` + pluginName + `" points at ` + pluginDir + `, which does not exist`);
+      }
+      let manifests = PlatformManifests$Reventless.resolve(undefined, pluginDir);
+      if (typeof manifests !== "object") {
+        console.log(`Skipped: ` + pluginName + ` (` + pluginDir + `) — no plugin composition`);
         return [];
-      });
-      let message = PlatformCodegen$Reventless.render(pluginManifests);
-      if (message.TAG === "Ok") {
-        let outputPath = Nodepath.resolve(manifestDir, platformPath, "src", "PlatformCapabilities.res");
-        Nodefs.writeFileSync(outputPath, message._0, "utf8");
-        console.log("Generated: " + outputPath);
-      } else {
-        fail(message._0);
       }
-    } else {
-      fail(manifestPath + ` needs a \`platform.path\` and a \`plugins\` list with name + path`);
+      if (manifests.TAG === "Manifests") {
+        return manifests._0.map(param => {
+          let path = param.path;
+          console.log(`Read: ` + pluginName + ` — ` + path + ` (via ` + PlatformManifests$Reventless.describeVia(param.via) + `)`);
+          let manifest;
+          try {
+            manifest = Sury.parseOrThrow(JSON.parse(Nodefs.readFileSync(path, "utf8")), CapabilityManifest$Reventless.schema);
+          } catch (exn) {
+            fail(`could not parse ` + path + ` as a capability manifest`);
+            manifest = {
+              capabilities: []
+            };
+          }
+          return {
+            pluginName: pluginName,
+            manifest: manifest
+          };
+        });
+      }
+      let match = manifests._0;
+      fail(`no capabilities.json found for plugin "` + pluginName + `" (` + pluginDir + `) — build the plugin first; its build emits src/capabilities.json beside Plugin.res ` + (`(` + match.evidence + `; expected ` + match.expected + `)`));
+      return [];
+    });
+    let message = PlatformCodegen$Reventless.render(pluginManifests);
+    if (message.TAG !== "Ok") {
+      return fail(message._0);
     }
-  } else {
-    fail(manifestPath + ` needs a \`platform.path\` and a \`plugins\` list with name + path`);
-  }
+    let outputPath = Nodepath.resolve(manifestDir, platformPath, "src", "PlatformCapabilities.res");
+    Nodefs.writeFileSync(outputPath, message._0, "utf8");
+    console.log("Generated: " + outputPath);
+  });
 }
 
 export {
   fail,
   asObject,
   stringAt,
+  usage,
+  parseArgs,
+  cli,
+  main,
 }
-/* manifestArg Not a pure module */
+/* sury Not a pure module */

package/src/generator/PluginGenerator.res

@@ -1,32 +1,33 @@
 // Entry point for the plugin generator.
-// Usage: generate-plugin <srcDir>
-//        generate-plugin --aws <Namespace> <srcDir>
-
-let () = {
-  let argv2 = NodeProcess.argv->Array.get(2)->Option.getOr("")
-  let argv3 = NodeProcess.argv->Array.get(3)->Option.getOr("")
-  let argv4 = NodeProcess.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>")
+
+let usage = `Usage: generate-plugin [--aws <Namespace>] <srcDir>
+
+  <srcDir>           the plugin's sources; Plugin.res is written into it
+  --aws <Namespace>  generate an -aws package instead: Plugin.res and Main.res
+                     are written into ./src, composing the plugin whose sources
+                     are <srcDir> under <Namespace>`
+
+type args = {variant: Config.variant, srcDir: string}
+
+let parseArgs = (argv: array<string>): result<args, string> =>
+  CliArgs.parse(~strings=["aws"], argv)
+  ->Result.flatMap(a => a->CliArgs.atMost(1))
+  ->Result.flatMap(a =>
+    switch (a->CliArgs.string("aws"), a->CliArgs.positionals->Array.get(0)) {
+    | (Some(""), _) => Error("--aws needs a value")
+    | (_, None | Some("")) => Error("<srcDir> is required.")
+    | (None, Some(srcDir)) => Ok({variant: Config.Composition, srcDir})
+    | (Some(compositionNamespace), Some(srcDir)) =>
+      Ok({variant: Config.Aws({compositionNamespace: compositionNamespace}), srcDir})
     }
-    // Exit non-zero on a usage error so `prebuild` (and CI) actually fail
-    // instead of continuing green with no Plugin.res generated.
-    NodeProcess.exit(1)
-  } else {
+  )
+
+let cli: CliArgs.cli<args> = {bin: "generate-plugin", usage, parse: parseArgs}
+
+// A usage mistake exits non-zero, so `prebuild` (and CI) fail instead of
+// continuing green with no Plugin.res generated.
+let main = () =>
+  CliArgs.run(cli, async ({variant, srcDir: srcDirArg}) => {
     // Resolve to absolute path (handles relative paths and trailing slashes)
     let srcDir = NodePath.resolve([srcDirArg])
 
@@ -55,5 +56,4 @@ let () = {
       NodeFs.writeFileSync(mainPath, mainSource)
       Console.log("Generated: " ++ mainPath)
     }
-  }
-}
+  })

package/src/generator/PluginGenerator.res.mjs

@@ -2,73 +2,105 @@
 
 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 Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
 import * as Config$Reventless from "./Config.res.mjs";
+import * as CliArgs$Reventless from "../CliArgs.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 usage = `Usage: generate-plugin [--aws <Namespace>] <srcDir>
 
-let argv3 = Stdlib_Option.getOr(process.argv[3], "");
+  <srcDir>           the plugin's sources; Plugin.res is written into it
+  --aws <Namespace>  generate an -aws package instead: Plugin.res and Main.res
+                     are written into ./src, composing the plugin whose sources
+                     are <srcDir> under <Namespace>`;
 
-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];
+function parseArgs(argv) {
+  return Stdlib_Result.flatMap(Stdlib_Result.flatMap(CliArgs$Reventless.parse(["aws"], undefined, undefined, undefined, argv), a => CliArgs$Reventless.atMost(a, 1)), a => {
+    let match = CliArgs$Reventless.string(a, "aws");
+    let match$1 = CliArgs$Reventless.positionals(a)[0];
+    if (match === "") {
+      return {
+        TAG: "Error",
+        _0: "--aws needs a value"
+      };
+    }
+    if (match$1 !== undefined && match$1 !== "") {
+      if (match !== undefined) {
+        return {
+          TAG: "Ok",
+          _0: {
+            variant: {
+              TAG: "Aws",
+              compositionNamespace: match
+            },
+            srcDir: match$1
+          }
+        };
+      } else {
+        return {
+          TAG: "Ok",
+          _0: {
+            variant: "Composition",
+            srcDir: match$1
+          }
+        };
+      }
+    } else {
+      return {
+        TAG: "Error",
+        _0: "<srcDir> is required."
+      };
+    }
+  });
+}
 
-let variant = match[0];
+let cli = {
+  bin: "generate-plugin",
+  usage: usage,
+  parse: parseArgs
+};
 
-if (srcDirArg === "") {
-  if (argv2 !== "--aws") {
-    console.error("Usage: generate-plugin <srcDir>");
-    console.error("       generate-plugin --aws <Namespace> <srcDir>");
-  }
-  process.exit(1);
-} 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_componentRuntime = init.componentRuntime;
-  let config = {
-    name: config_name,
-    heartbeatInterval: config_heartbeatInterval,
-    exclude: config_exclude,
-    componentRuntime: config_componentRuntime,
-    variant: variant
-  };
-  let discovered = Discovery$Reventless.scan(srcDir, config_exclude);
-  let resolved = Pairing$Reventless.resolve(discovered, srcDir);
-  let hasLifecycleModel = Nodefs.existsSync(Nodepath.join(srcDir, "LifecycleModel.res"));
-  let source = Codegen$Reventless.render(config, resolved, discovered, hasLifecycleModel);
-  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") {
+function main() {
+  return CliArgs$Reventless.run(cli, undefined, undefined, async param => {
+    let variant = param.variant;
+    let srcDir = Nodepath.resolve(param.srcDir);
+    let init = Config$Reventless.read(srcDir);
+    let config_name = init.name;
+    let config_heartbeatInterval = init.heartbeatInterval;
+    let config_exclude = init.exclude;
+    let config_componentRuntime = init.componentRuntime;
+    let config = {
+      name: config_name,
+      heartbeatInterval: config_heartbeatInterval,
+      exclude: config_exclude,
+      componentRuntime: config_componentRuntime,
+      variant: variant
+    };
+    let discovered = Discovery$Reventless.scan(srcDir, config_exclude);
+    let resolved = Pairing$Reventless.resolve(discovered, srcDir);
+    let hasLifecycleModel = Nodefs.existsSync(Nodepath.join(srcDir, "LifecycleModel.res"));
+    let source = Codegen$Reventless.render(config, resolved, discovered, hasLifecycleModel);
+    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") {
+      return;
+    }
     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 */
+export {
+  usage,
+  parseArgs,
+  cli,
+  main,
+}
+/* node:fs Not a pure module */