Clean up

Author: nojaf

.github/workflows/ci.yml

@@ -91,29 +91,6 @@ jobs:
           cache: yarn
           node-version-file: .nvmrc
 
-      - run: corepack enable
-
-      - name: Show resolved npm via execPath
-        run: |
-          node -e 'import { dirname, join } from "node:path";
-                   import { execPath } from "node:process";
-                   import { spawnSync } from "node:child_process";
-                   const npmBin = join(dirname(execPath), "npm");
-                   console.log("Resolved npm:", npmBin);
-                   const res = spawnSync(npmBin, ["--version"], { stdio: "inherit" });
-                   process.exit(res.status);'
-
-      - name: Find and export npm path
-        run: |
-          which npm || echo "npm not found"
-          npm --version || echo "npm version check failed"
-
-      - name: Show node path
-        run: "which node"
-
-      - name: cat npm-cli
-        run: cat /opt/hostedtoolcache/node/22.19.0/x64/lib/node_modules/npm/bin/npm-cli.js
-
       - name: Install npm packages
         run: yarn install
 
@@ -365,13 +342,6 @@ jobs:
       - name: Run tests
         run: node scripts/test.js -all
 
-
-      - name: test outside of node tests
-        run: node tests/rewatch_tests/src/foo.mjs
-
-      - name: Run new rewatch tests
-        run: 'node --test "tests/rewatch_tests/tests/**/*.test.mjs"'
-
       - name: Check for diffs in tests folder
         run: git diff --ignore-cr-at-eol --exit-code tests
 

lib_dev/process.js

@@ -1,46 +1,8 @@
 import * as child_process from "node:child_process";
 import * as fs from "node:fs/promises";
-import os from "node:os";
 import * as path from "node:path";
-import { execPath } from "node:process";
 import { bsc_exe, rescript_legacy_exe } from "#cli/bins";
 
-function resolveBin(bin) {
-  try {
-    if (os.platform() === "win32") {
-      // `where` returns all matches, take the first line
-      return child_process
-        .execSync(`where ${bin}`, { encoding: "utf8" })
-        .split(/\r?\n/)[0]
-        .trim();
-    }
-    // `command -v` is POSIX standard
-    return child_process
-      .execSync(`command -v ${bin}`, { encoding: "utf8" })
-      .trim();
-  } catch (err) {
-    throw new Error(`Could not resolve binary: ${bin} ${err}`);
-  }
-}
-
-const gitBin = resolveBin("git");
-
-// Helpers to resolve node and npm-cli when needed
-function getNodeBin() {
-  try {
-    return resolveBin("node");
-  } catch (_err) {
-    return execPath;
-  }
-}
-
-function getNpmCli(nodeBin) {
-  return path.join(
-    path.dirname(nodeBin),
-    "../lib/node_modules/npm/bin/npm-cli.js",
-  );
-}
-
 /**
  * @typedef {{
  *   throwOnFail?: boolean,
@@ -88,26 +50,13 @@ export function setup(cwd = process.cwd()) {
   async function exec(command, args = [], options = {}) {
     const { throwOnFail = options.stdio === "inherit" } = options;
 
-    // Build env
-    const env = options.env
-      ? { ...process.env, ...options.env }
-      : { ...process.env };
-
     const stdoutChunks = [];
     const stderrChunks = [];
-    console.log("About to spawn", command, args, {
-      cwd,
-      // shell: process.platform === "win32",
-      stdio: ["ignore", "pipe", "pipe"],
-      env,
-      ...options,
-    });
 
     const subprocess = child_process.spawn(command, args, {
       cwd,
-      // shell: process.platform === "win32",
+      shell: process.platform === "win32",
       stdio: ["ignore", "pipe", "pipe"],
-      env,
       ...options,
     });
 
@@ -121,9 +70,6 @@ export function setup(cwd = process.cwd()) {
 
     return await new Promise((resolve, reject) => {
       subprocess.once("error", err => {
-        console.error(`Command failed: ${command} ${args.join(" ")}`);
-        console.error(`Working directory: ${options.cwd || cwd}`);
-        console.error("Error:", err);
         reject(err);
       });
 
@@ -138,12 +84,6 @@ export function setup(cwd = process.cwd()) {
         }
 
         if (throwOnFail && code !== 0) {
-          console.error(`Command failed: ${command} ${args.join(" ")}`);
-          console.error(`Working directory: ${options.cwd || cwd}`);
-          console.error(`Exit code: ${code}`);
-          console.error(`Signal: ${signal}`);
-          console.error("Stdout:", stdout);
-          console.error("Stderr:", stderr);
           reject(
             new Error(
               `Command ${command} exited with non-zero status: ${code}`,
@@ -232,7 +172,10 @@ export function setup(cwd = process.cwd()) {
      * `rescript` CLI
      */
     rewatch(command, args = [], options = {}) {
-      const cliPath = path.join(import.meta.dirname, "../cli/rescript.js");
+      const cliPath = path.join(
+        import.meta.dirname,
+        "../cli/rescript.js",
+      );
       return exec("node", [cliPath, command, ...args].filter(Boolean), options);
     },
 
@@ -291,7 +234,7 @@ export function setup(cwd = process.cwd()) {
      * @return {Promise<ExecResult>}
      */
     git(args = [], options = {}) {
-      return exec(gitBin, args, options);
+      return exec("git", args, options);
     },
 
     /**
@@ -301,47 +244,8 @@ export function setup(cwd = process.cwd()) {
      * @param {ExecOptions} [options]
      * @return {Promise<ExecResult>}
      */
-    async npm(args = [], options = {}) {
-      console.log("the options", options);
-      // Validate working directory to avoid confusing ENOENT from invalid cwd
-      if (options.cwd) {
-        try {
-          await fs.stat(options.cwd);
-        } catch (e) {
-          console.error("Invalid cwd for npm", options.cwd, e);
-          throw e;
-        }
-      }
-
-      // 1) Prefer corepack to resolve the correct npm
-      try {
-        return await exec("corepack", ["npm", ...args], options);
-      } catch (_corepackErr) {
-        // ignore and try next
-      }
-
-      // 2) Try PATH npm
-      try {
-        return await exec("npm", args, options);
-      } catch (_npmErr) {
-        // ignore and try fallback
-      }
-
-      // 3) Fallback: node + npm-cli resolved at call time
-      const nodeBin = getNodeBin();
-      const npmCli = getNpmCli(nodeBin);
-      try {
-        await fs.access(nodeBin);
-      } catch (e) {
-        console.error("nodeBin not accessible", nodeBin, e);
-      }
-      try {
-        await fs.access(npmCli);
-      } catch (e) {
-        console.error("npmCli not accessible", npmCli, e);
-      }
-      console.log("Falling back to node+cli", { nodeBin, npmCli });
-      return exec(nodeBin, [npmCli, ...args], options);
+    npm(args = [], options = {}) {
+      return exec("npm", args, options);
     },
   };
 }

scripts/test.js

@@ -9,6 +9,7 @@ import {
   docstringTestDir,
   ounitTestBin,
   projectDir,
+  rewatchTestDir,
 } from "#dev/paths";
 
 import {
@@ -19,13 +20,15 @@ import {
   node,
   rescript,
   shell,
+  yarn,
 } from "#dev/process";
 
 let ounitTest = false;
 let mochaTest = false;
 let bsbTest = false;
 let formatTest = false;
 let runtimeDocstrings = false;
+let rewatch = false;
 
 if (process.argv.includes("-ounit")) {
   ounitTest = true;
@@ -47,12 +50,17 @@ if (process.argv.includes("-docstrings")) {
   runtimeDocstrings = true;
 }
 
+if (process.argv.includes("-rewatch")) {
+  rewatch = true;
+}
+
 if (process.argv.includes("-all")) {
   ounitTest = true;
   mochaTest = true;
   bsbTest = true;
   formatTest = true;
   runtimeDocstrings = true;
+  rewatch = true;
 }
 
 if (formatTest) {
@@ -195,3 +203,20 @@ if (runtimeDocstrings) {
     });
   }
 }
+
+if (rewatch) {
+  await execClean([], {
+    cwd: rewatchTestDir,
+    stdio: "inherit",
+  });
+
+  await execBuild([], {
+    cwd: rewatchTestDir,
+    stdio: "inherit",
+  });
+
+  await yarn("test", [], {
+    cwd: rewatchTestDir,
+    stdio: "inherit",
+  });
+}

tests/rewatch_tests/src/Node.mjs

@@ -5,11 +5,14 @@ let Path = {};
 
 let Url = {};
 
+let FsPromises = {};
+
 let Test = {};
 
 export {
   Path,
   Url,
+  FsPromises,
   Test,
 }
 /* No side effect */

tests/rewatch_tests/src/Node.res

@@ -11,6 +11,11 @@ module Url = {
   external fileURLToPath: string => string = "fileURLToPath"
 }
 
+module FsPromises = {
+  @module("node:fs/promises")
+  external access: string => promise<unit> = "access"
+}
+
 module Test = {
   @module("node:test")
   external describe: (string, unit => unit) => unit = "describe"

tests/rewatch_tests/src/Setup.mjs

@@ -2,10 +2,20 @@
 
 import * as Nodeurl from "node:url";
 import * as Nodepath from "node:path";
+import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
+import * as Promises from "node:fs/promises";
 
 let processUtils = await import(Nodepath.resolve(Nodepath.dirname(Nodeurl.fileURLToPath(import.meta.url)), "../../../lib_dev/process.js"));
 
-function commands(workingDirectory) {
+async function commands(workingDirectory) {
+  let pwdExists = await Stdlib_Promise.$$catch(Promises.access(workingDirectory).then(() => true), param => Promise.resolve(false));
+  if (!pwdExists) {
+    throw {
+      RE_EXN_ID: "Failure",
+      _1: "Working directory does not exist: " + workingDirectory,
+      Error: new Error()
+    };
+  }
   let build = async () => {
     await processUtils.rewatch("build", [], {
       cwd: workingDirectory

tests/rewatch_tests/src/Setup.res

@@ -32,7 +32,14 @@ type commands = {
 }
 
 /// Returns a set of helpers to invoke cli/rescript.js in a working directory
-let commands = (workingDirectory: string): commands => {
+let commands = async (workingDirectory: string): commands => {
+  // Ensure working directory exists before invoking any process
+  let pwdExists = await FsPromises.access(workingDirectory)->Promise.thenResolve(_ => true)->Promise.catch(_ => Promise.resolve(false))
+
+  if (!pwdExists) {
+    throw(Failure("Working directory does not exist: " ++ workingDirectory))
+  }
+  
   let rescript = {
     let build = async () => {
       let _ = await processUtils.rewatch("build", [], {cwd: workingDirectory})

tests/rewatch_tests/tests/SingleRepo.test.mjs

@@ -7,7 +7,7 @@ import * as Nodetest from "node:test";
 
 let repo = Nodepath.resolve(Nodepath.dirname(Nodeurl.fileURLToPath(import.meta.url)), "../repos/npm/single-project");
 
-let commands = Setup.commands(repo);
+let commands = await Setup.commands(repo);
 
 Nodetest.describe("A single ReScript project using npm as package manager", () => {
   Nodetest.before(async () => await commands.npm.install());

tests/rewatch_tests/tests/SingleRepo.test.res

@@ -5,7 +5,7 @@ let repo = Path.resolve(
   Path.dirname(Url.fileURLToPath(Node.importMetaUrl)),
   "../repos/npm/single-project",
 )
-let commands = Setup.commands(repo)
+let commands = await Setup.commands(repo)
 
 describe("A single ReScript project using npm as package manager", () => {
   before(async () => {