@reventlessdev/reventless-spec 3.0.0-alpha.88 → 3.0.0-alpha.90

package/src/PackageVersion.res

@@ -1,11 +1,5 @@
-@module("node:fs") external readFileSync: (string, string) => string = "readFileSync"
-@module("node:fs") external existsSync: string => bool = "existsSync"
-@module("node:url") external fileURLToPath: string => string = "fileURLToPath"
-@module("node:path") external dirname: string => string = "dirname"
-@module("node:path") external join: (string, string) => string = "join"
-
 let readVersion = (path: string) =>
-  readFileSync(path, "utf8")
+  NodeFs.readFileSync(path)
   ->JSON.parseOrThrow
   ->JSON.Decode.object
   ->Option.flatMap(o => o->Dict.get("version"))
@@ -16,11 +10,11 @@ let fromCwd = () => readVersion("./package.json")
 
 let findVersion = dir => {
   let rec find = dir => {
-    let candidate = join(dir, "package.json")
-    if existsSync(candidate) {
+    let candidate = NodePath.join([dir, "package.json"])
+    if NodeFs.existsSync(candidate) {
       readVersion(candidate)
     } else {
-      let parent = dirname(dir)
+      let parent = NodePath.dirname(dir)
       if parent == dir {
         "0.0.0"
       } else {
@@ -31,7 +25,7 @@ let findVersion = dir => {
   find(dir)
 }
 
-let fromModuleUrl = (url: string) => findVersion(url->fileURLToPath->dirname)
+let fromModuleUrl = (url: string) => findVersion(url->NodeUrl.fileURLToPath->NodePath.dirname)
 
 /** Detect the caller's file via V8 Structured Stack Trace API and read the
     version from the nearest package.json. Skips frames from framework packages
@@ -65,9 +59,9 @@ let fromCaller = () =>
   switch callerFile() {
   | Some(file) =>
     if file->String.startsWith("file://") {
-      findVersion(file->fileURLToPath->dirname)
+      findVersion(file->NodeUrl.fileURLToPath->NodePath.dirname)
     } else {
-      findVersion(file->dirname)
+      findVersion(file->NodePath.dirname)
     }
   | None => fromCwd()
   }

package/src/generator/Config.res

@@ -29,7 +29,7 @@ type config = {
 let packageNameToPluginName = PluginName.fromPackageName
 
 let readJson = (path: string): option<JSON.t> =>
-  try Some(Generator_Node.readFileSync(path)->JSON.parseOrThrow) catch {
+  try Some(NodeFs.readFileSync(path)->JSON.parseOrThrow) catch {
   | _ => None
   }
 
@@ -80,12 +80,12 @@ let getComponentRuntime = (json: JSON.t): dict<runtimeHints> => {
 
 let read = (~srcDir: string): config => {
   // Read package.json `name` from the parent of srcDir
-  let packageJsonPath = Generator_Node.join([Generator_Node.dirname(srcDir), "package.json"])
+  let packageJsonPath = NodePath.join([NodePath.dirname(srcDir), "package.json"])
   let packageJsonName = readJson(packageJsonPath)->Option.flatMap(j => getStrField(j, "name"))
 
   // Read plugin.json from srcDir (optional)
-  let pluginJsonPath = Generator_Node.join([srcDir, "plugin.json"])
-  let pluginJson = if Generator_Node.existsSync(pluginJsonPath) {
+  let pluginJsonPath = NodePath.join([srcDir, "plugin.json"])
+  let pluginJson = if NodeFs.existsSync(pluginJsonPath) {
     readJson(pluginJsonPath)
   } else {
     None

package/src/generator/Discovery.res

@@ -122,8 +122,8 @@ let collectFiles = (
   ~acc: array<discoveredFile>,
 ): unit =>
   Generator_Node.readDir(dir)->Array.forEach(entry => {
-    if entry->Generator_Node.isFile {
-      let filename = entry->Generator_Node.direntName
+    if entry->NodeFs.isFile {
+      let filename = entry->NodeFs.direntName
       let relPath = if relDir === "" {filename} else {relDir ++ "/" ++ filename}
       if !isExcluded(relPath, exclude) {
         switch stemOf(filename) {
@@ -144,26 +144,26 @@ let rec walkDir = (
   ~acc: array<discoveredFile>,
 ): unit =>
   Generator_Node.readDir(dir)->Array.forEach(entry => {
-    let entryName = entry->Generator_Node.direntName
+    let entryName = entry->NodeFs.direntName
     let relPath = if relDir === "" {entryName} else {relDir ++ "/" ++ entryName}
 
     if isExcluded(relPath, exclude) {
       ()
-    } else if entry->Generator_Node.isDirectory {
+    } else if entry->NodeFs.isDirectory {
       if isAlwaysExcludedDir(entryName) {
         ()
       } else {
         switch folderToComponentType(entryName) {
         | Some(ExtensionPoint) =>
-          let epDir = Generator_Node.join([dir, entryName])
+          let epDir = NodePath.join([dir, entryName])
           let children = Generator_Node.readDir(epDir)
-          let hasSubDirs = children->Array.some(e => e->Generator_Node.isDirectory)
+          let hasSubDirs = children->Array.some(e => e->NodeFs.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])
+              if child->NodeFs.isDirectory {
+                let groupName = child->NodeFs.direntName
+                let groupDir = NodePath.join([epDir, groupName])
                 let groupRelDir = relPath ++ "/" ++ groupName
                 collectFiles(
                   ~dir=groupDir,
@@ -189,7 +189,7 @@ let rec walkDir = (
         | Some(ct) =>
           // Recurse into component type folder, collecting files at any depth
           walkDir(
-            ~dir=Generator_Node.join([dir, entryName]),
+            ~dir=NodePath.join([dir, entryName]),
             ~relDir=relPath,
             ~parentComponentType=Some(ct),
             ~epGroup=None,
@@ -199,7 +199,7 @@ let rec walkDir = (
         | None =>
           // Chapter folder or other — recurse inheriting parent context
           walkDir(
-            ~dir=Generator_Node.join([dir, entryName]),
+            ~dir=NodePath.join([dir, entryName]),
             ~relDir=relPath,
             ~parentComponentType,
             ~epGroup,
@@ -208,7 +208,7 @@ let rec walkDir = (
           )
         }
       }
-    } else if entry->Generator_Node.isFile {
+    } else if entry->NodeFs.isFile {
       switch parentComponentType {
       | None => ()
       | Some(ct) =>

package/src/generator/Generator_Node.res

@@ -1,49 +1,14 @@
-// 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 {
+// What remains of the generator's own Node bindings after they moved to
+// `@reventlessdev/rescript-node`: one helper, which is not a binding.
+//
+// The generator walks directories that may legitimately not exist — an
+// `Extension/` folder is optional, and so is every other component folder — and
+// it treats "absent" and "empty" the same way. `readdirSync` throws on absent,
+// so every walk would otherwise carry its own try/catch. This does not belong in
+// the bindings package: a binding that swallows an error is a policy, and the
+// policy is the generator's.
+
+let readDir = (dir: string): array<NodeFs.dirent> =>
+  try NodeFs.readdirSync(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/Pairing.res

@@ -89,12 +89,12 @@ let findEventMappings = (~srcDir: string): Dict.t<string> => {
     }
   let rec walk = (dir: string, segments: array<string>) =>
     Generator_Node.readDir(dir)->Array.forEach(entry => {
-      let name = entry->Generator_Node.direntName
-      if entry->Generator_Node.isDirectory {
+      let name = entry->NodeFs.direntName
+      if entry->NodeFs.isDirectory {
         if name !== "Plugin" && name !== "tests" && name !== "lib" {
-          walk(Generator_Node.join([dir, name]), Array.concat(segments, [name]))
+          walk(NodePath.join([dir, name]), Array.concat(segments, [name]))
         }
-      } else if entry->Generator_Node.isFile {
+      } else if entry->NodeFs.isFile {
         if name->String.endsWith("_Mappings.res") && parentDirIsAggregate(segments) {
           let stem = name->String.slice(~start=0, ~end=name->String.length - 4)
           // "_Mappings" = 9 chars
@@ -112,7 +112,7 @@ let findEventMappings = (~srcDir: string): Dict.t<string> => {
         }
       }
     })
-  if Generator_Node.existsSync(srcDir) {
+  if NodeFs.existsSync(srcDir) {
     walk(srcDir, [])
   }
   dict
@@ -126,7 +126,7 @@ let sortedStems = (stems: array<string>): array<string> =>
 // or None for `let targetName = None` or when the line is absent.
 let extractTargetName = (filePath: string): option<string> => {
   try {
-    let content = Generator_Node.readFileSync(filePath)
+    let content = NodeFs.readFileSync(filePath)
     let result = ref(None)
     content->String.split("\n")->Array.forEach(line => {
       let trimmed = line->String.trimStart
@@ -151,7 +151,7 @@ let extractTargetName = (filePath: string): option<string> => {
 // into the opt-in behavior — the safe default is the attribute being absent.
 let hasFileAttribute = (filePath: string, ~attr: string): bool => {
   try {
-    let content = Generator_Node.readFileSync(filePath)
+    let content = NodeFs.readFileSync(filePath)
     let found = ref(false)
     content->String.split("\n")->Array.forEach(line => {
       let trimmed = line->String.trimStart
@@ -187,7 +187,7 @@ let hasSystemCallableAttribute = (filePath: string): bool =>
 // with an explicit name override.
 let effectiveSpecName = (filePath: string, ~stem: string): string => {
   try {
-    let content = Generator_Node.readFileSync(filePath)
+    let content = NodeFs.readFileSync(filePath)
     let name = ref(None)
     content->String.split("\n")->Array.forEach(line => {
       let trimmed = line->String.trimStart
@@ -347,7 +347,7 @@ let resolve = (discovered: array<Discovery.discoveredFile>, ~srcDir: string): re
       | Some(behavior) =>
         let isAsync = switch Dict.get(aggregateSpecRelPaths, spec) {
         | None => false
-        | Some(relPath) => hasAsyncAttribute(Generator_Node.join([srcDir, relPath]))
+        | Some(relPath) => hasAsyncAttribute(NodePath.join([srcDir, relPath]))
         }
         Some({
           spec,
@@ -397,7 +397,7 @@ let resolve = (discovered: array<Discovery.discoveredFile>, ~srcDir: string): re
     stems->Array.forEach(stem => {
       let target = switch Dict.get(relPaths, stem) {
       | None => None
-      | Some(relPath) => extractTargetName(Generator_Node.join([srcDir, relPath]))
+      | Some(relPath) => extractTargetName(NodePath.join([srcDir, relPath]))
       }
       dict->Dict.set(stem, target)
     })
@@ -426,7 +426,7 @@ let resolve = (discovered: array<Discovery.discoveredFile>, ~srcDir: string): re
         switch Dict.get(stateChangeSliceRelPaths, stem) {
         | None => ()
         | Some(relPath) =>
-          if hasAsyncAttribute(Generator_Node.join([srcDir, relPath])) {
+          if hasAsyncAttribute(NodePath.join([srcDir, relPath])) {
             d->Dict.set(stem, true)
           }
         }
@@ -440,7 +440,7 @@ let resolve = (discovered: array<Discovery.discoveredFile>, ~srcDir: string): re
           switch Dict.get(relPaths, stem) {
           | None => ()
           | Some(relPath) =>
-            let filePath = Generator_Node.join([srcDir, relPath])
+            let filePath = NodePath.join([srcDir, relPath])
             if hasSystemCallableAttribute(filePath) {
               names->Array.push(effectiveSpecName(filePath, ~stem))
             }

package/src/generator/PlatformGenerator.res

@@ -11,12 +11,11 @@
 // its head comment states the resolution order and why each arm exists; add a
 // fourth arm there, not here.
 
-@val external processExit: int => unit = "process.exit"
 @module("yaml") external parseYaml: string => JSON.t = "parse"
 
 let fail = (message: string) => {
   Console.error("generate-platform: " ++ message)
-  processExit(1)
+  NodeProcess.exit(1)
 }
 
 let asObject = (json: JSON.t): option<dict<JSON.t>> => json->JSON.Decode.object
@@ -24,17 +23,17 @@ let stringAt = (obj: dict<JSON.t>, field: string): option<string> =>
   obj->Dict.get(field)->Option.flatMap(JSON.Decode.string)
 
 let () = {
-  let manifestArg = Generator_Node.argv->Array.get(2)->Option.getOr("")
+  let manifestArg = NodeProcess.argv->Array.get(2)->Option.getOr("")
   if manifestArg == "" {
     Console.error("Usage: generate-platform <deploy-manifest.yaml>")
-    processExit(1)
+    NodeProcess.exit(1)
   } else {
-    let manifestPath = Generator_Node.resolve([manifestArg])
-    if !Generator_Node.existsSync(manifestPath) {
+    let manifestPath = NodePath.resolve([manifestArg])
+    if !NodeFs.existsSync(manifestPath) {
       fail(`${manifestPath} not found`)
     }
-    let manifestDir = Generator_Node.dirname(manifestPath)
-    let deployManifest = try Generator_Node.readFileSync(manifestPath)->parseYaml catch {
+    let manifestDir = NodePath.dirname(manifestPath)
+    let deployManifest = try NodeFs.readFileSync(manifestPath)->parseYaml catch {
     | _ => {
         fail(`could not parse ${manifestPath} as YAML`)
         JSON.Null
@@ -68,8 +67,8 @@ let () = {
     switch (platformPath, plugins) {
     | (Some(platformPath), Some(plugins)) => {
         let pluginManifests = plugins->Array.flatMap(((pluginName, pluginPath)) => {
-          let pluginDir = Generator_Node.resolve([manifestDir, pluginPath])
-          if !Generator_Node.existsSync(pluginDir) {
+          let pluginDir = NodePath.resolve([manifestDir, pluginPath])
+          if !NodeFs.existsSync(pluginDir) {
             fail(`plugin "${pluginName}" points at ${pluginDir}, which does not exist`)
           }
           switch PlatformManifests.resolve(~pluginDir) {
@@ -94,7 +93,7 @@ let () = {
               Console.log(
                 `Read: ${pluginName} — ${path} (via ${PlatformManifests.describeVia(via)})`,
               )
-              let manifest = try Generator_Node.readFileSync(path)
+              let manifest = try NodeFs.readFileSync(path)
               ->JSON.parseOrThrow
               ->S.parseOrThrow(CapabilityManifest.schema) catch {
               | _ => {
@@ -110,13 +109,13 @@ let () = {
         switch PlatformCodegen.render(pluginManifests) {
         | Error(message) => fail(message)
         | Ok(source) => {
-            let outputPath = Generator_Node.resolve([
+            let outputPath = NodePath.resolve([
               manifestDir,
               platformPath,
               "src",
               "PlatformCapabilities.res",
             ])
-            Generator_Node.writeFileSync(outputPath, source)
+            NodeFs.writeFileSync(outputPath, source)
             Console.log("Generated: " ++ outputPath)
           }
         }

package/src/generator/PlatformManifests.res

@@ -52,9 +52,9 @@ type fileSystem = {
 }
 
 let nodeFileSystem: fileSystem = {
-  exists: Generator_Node.existsSync,
+  exists: NodeFs.existsSync,
   readJson: path =>
-    try Some(Generator_Node.readFileSync(path)->JSON.parseOrThrow) catch {
+    try Some(NodeFs.readFileSync(path)->JSON.parseOrThrow) catch {
     | _ => None
     },
 }
@@ -69,7 +69,7 @@ let describeVia = (via: via): string =>
 let asObject = (json: JSON.t): option<dict<JSON.t>> => json->JSON.Decode.object
 
 let packageJsonAt = (~fs: fileSystem, ~dir: string): option<dict<JSON.t>> =>
-  fs.readJson(Generator_Node.join([dir, "package.json"]))->Option.flatMap(asObject)
+  fs.readJson(NodePath.join([dir, "package.json"]))->Option.flatMap(asObject)
 
 let scriptsOf = (pkg: dict<JSON.t>): array<string> =>
   pkg
@@ -129,11 +129,11 @@ let dependencyNames = (pkg: dict<JSON.t>): array<string> => {
     may be anywhere, and it is `src/capabilities.json` that is wanted. */
 let resolvePackageDir = (~fs: fileSystem, ~fromDir: string, ~name: string): option<string> => {
   let rec search = dir => {
-    let candidate = Generator_Node.join([dir, "node_modules", name])
-    if fs.exists(Generator_Node.join([candidate, "package.json"])) {
+    let candidate = NodePath.join([dir, "node_modules", name])
+    if fs.exists(NodePath.join([candidate, "package.json"])) {
       Some(candidate)
     } else {
-      let parent = Generator_Node.dirname(dir)
+      let parent = NodePath.dirname(dir)
       parent == dir ? None : search(parent)
     }
   }
@@ -152,7 +152,7 @@ let fromDependencies = (~fs: fileSystem, ~pluginDir: string, ~pkg: dict<JSON.t>)
     switch resolvePackageDir(~fs, ~fromDir=pluginDir, ~name) {
     | None => ()
     | Some(packageDir) => {
-        let candidate = Generator_Node.join([packageDir, "src", "capabilities.json"])
+        let candidate = NodePath.join([packageDir, "src", "capabilities.json"])
         if fs.exists(candidate) {
           found->Array.push({path: candidate, via: Dependency(name)})
         } else if packageJsonAt(~fs, ~dir=packageDir)->Option.mapOr(false, emitsCapabilities) {
@@ -177,7 +177,7 @@ let fromDependencies = (~fs: fileSystem, ~pluginDir: string, ~pkg: dict<JSON.t>)
 }
 
 let resolve = (~fs: fileSystem=nodeFileSystem, ~pluginDir: string): t => {
-  let direct = Generator_Node.join([pluginDir, "src", "capabilities.json"])
+  let direct = NodePath.join([pluginDir, "src", "capabilities.json"])
   if fs.exists(direct) {
     Manifests([{path: direct, via: Composition}])
   } else {
@@ -186,7 +186,7 @@ let resolve = (~fs: fileSystem=nodeFileSystem, ~pluginDir: string): t => {
     | Some(pkg) =>
       switch generatedSrcDir(pkg) {
       | Some(srcDir) => {
-          let expected = Generator_Node.resolve([pluginDir, srcDir, "capabilities.json"])
+          let expected = NodePath.resolve([pluginDir, srcDir, "capabilities.json"])
           if fs.exists(expected) {
             Manifests([{path: expected, via: Generated(srcDir)}])
           } else {

package/src/generator/PluginGenerator.res

@@ -2,12 +2,11 @@
 // Usage: generate-plugin <srcDir>
 //        generate-plugin --aws <Namespace> <srcDir>
 
-@val external processExit: int => unit = "process.exit"
 
 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 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 !== "" {
@@ -27,10 +26,10 @@ let () = {
     }
     // Exit non-zero on a usage error so `prebuild` (and CI) actually fail
     // instead of continuing green with no Plugin.res generated.
-    processExit(1)
+    NodeProcess.exit(1)
   } else {
     // Resolve to absolute path (handles relative paths and trailing slashes)
-    let srcDir = Generator_Node.resolve([srcDirArg])
+    let srcDir = NodePath.resolve([srcDirArg])
 
     let config = {...Config.read(~srcDir), variant}
     let discovered = Discovery.scan(~srcDir, ~exclude=config.exclude)
@@ -39,19 +38,19 @@ let () = {
 
     let outputDir = switch variant {
     | Config.Composition => srcDir
-    | Config.Aws(_) => Generator_Node.join([Generator_Node.cwd(), "src"])
+    | Config.Aws(_) => NodePath.join([NodeProcess.cwd(), "src"])
     }
 
-    let pluginPath = Generator_Node.join([outputDir, "Plugin.res"])
-    Generator_Node.writeFileSync(pluginPath, source)
+    let pluginPath = NodePath.join([outputDir, "Plugin.res"])
+    NodeFs.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)
+      let mainPath = NodePath.join([outputDir, "Main.res"])
+      NodeFs.writeFileSync(mainPath, mainSource)
       Console.log("Generated: " ++ mainPath)
     }
   }