@scelar/nodepod 1.0.2 → 1.0.4

package/src/__tests__/path.test.ts

@@ -0,0 +1,181 @@
+import { describe, it, expect } from "vitest";
+import * as path from "../polyfills/path";
+
+describe("path.normalize", () => {
+  it("resolves . and ..", () => {
+    expect(path.normalize("/foo/bar/../baz")).toBe("/foo/baz");
+    expect(path.normalize("/foo/./bar")).toBe("/foo/bar");
+  });
+
+  it("removes duplicate slashes", () => {
+    expect(path.normalize("/foo//bar///baz")).toBe("/foo/bar/baz");
+  });
+
+  it('returns "." for empty input', () => {
+    expect(path.normalize("")).toBe(".");
+  });
+
+  it("handles relative paths with ..", () => {
+    expect(path.normalize("a/b/../../c")).toBe("c");
+  });
+
+  it("does not go above root", () => {
+    expect(path.normalize("/../../foo")).toBe("/foo");
+  });
+});
+
+describe("path.join", () => {
+  it("joins segments with /", () => {
+    expect(path.join("/foo", "bar", "baz")).toBe("/foo/bar/baz");
+  });
+
+  it("normalizes result", () => {
+    expect(path.join("/foo", "../bar")).toBe("/bar");
+  });
+
+  it('returns "." for no args', () => {
+    expect(path.join()).toBe(".");
+  });
+
+  it("handles empty strings", () => {
+    expect(path.join("", "foo", "")).toBe("foo");
+  });
+});
+
+describe("path.resolve", () => {
+  it("resolves relative to absolute base", () => {
+    expect(path.resolve("/foo", "bar")).toBe("/foo/bar");
+  });
+
+  it("right-to-left resolution stops at absolute path", () => {
+    expect(path.resolve("a", "/b", "c")).toBe("/b/c");
+  });
+
+  it("normalizes the result", () => {
+    expect(path.resolve("/foo", "bar", "..", "baz")).toBe("/foo/baz");
+  });
+});
+
+describe("path.dirname", () => {
+  it("returns parent directory", () => {
+    expect(path.dirname("/foo/bar.txt")).toBe("/foo");
+  });
+
+  it('returns "/" for root-level file', () => {
+    expect(path.dirname("/file.txt")).toBe("/");
+  });
+
+  it('returns "." for bare filename', () => {
+    expect(path.dirname("file.txt")).toBe(".");
+  });
+});
+
+describe("path.basename", () => {
+  it("returns filename from path", () => {
+    expect(path.basename("/foo/bar.txt")).toBe("bar.txt");
+  });
+
+  it("strips suffix when provided", () => {
+    expect(path.basename("/foo/bar.txt", ".txt")).toBe("bar");
+  });
+
+  it("returns empty for empty string", () => {
+    expect(path.basename("")).toBe("");
+  });
+
+  it("returns last segment for directory path", () => {
+    expect(path.basename("/foo/bar/")).toBe("bar");
+  });
+});
+
+describe("path.extname", () => {
+  it("returns extension with dot", () => {
+    expect(path.extname("file.txt")).toBe(".txt");
+  });
+
+  it("returns empty for no extension", () => {
+    expect(path.extname("Makefile")).toBe("");
+  });
+
+  it("returns last extension for multiple dots", () => {
+    expect(path.extname("file.test.js")).toBe(".js");
+  });
+
+  it("returns empty for leading dot only", () => {
+    expect(path.extname(".gitignore")).toBe("");
+  });
+});
+
+describe("path.relative", () => {
+  it("computes relative path between two absolute paths", () => {
+    expect(path.relative("/a/b", "/a/c")).toBe("../c");
+  });
+
+  it("returns empty string for same path", () => {
+    expect(path.relative("/a/b", "/a/b")).toBe("");
+  });
+
+  it("handles deeply nested paths", () => {
+    expect(path.relative("/a/b/c", "/a/b/c/d/e")).toBe("d/e");
+  });
+});
+
+describe("path.isAbsolute", () => {
+  it("returns true for paths starting with /", () => {
+    expect(path.isAbsolute("/foo")).toBe(true);
+    expect(path.isAbsolute("/")).toBe(true);
+  });
+
+  it("returns false for relative paths", () => {
+    expect(path.isAbsolute("foo")).toBe(false);
+    expect(path.isAbsolute("./foo")).toBe(false);
+    expect(path.isAbsolute("../foo")).toBe(false);
+  });
+});
+
+describe("path.parse", () => {
+  it("decomposes path into parts", () => {
+    const result = path.parse("/home/user/file.txt");
+    expect(result.root).toBe("/");
+    expect(result.dir).toBe("/home/user");
+    expect(result.base).toBe("file.txt");
+    expect(result.ext).toBe(".txt");
+    expect(result.name).toBe("file");
+  });
+
+  it("handles root path", () => {
+    const result = path.parse("/");
+    expect(result.root).toBe("/");
+  });
+
+  it("handles relative path", () => {
+    const result = path.parse("foo/bar.js");
+    expect(result.root).toBe("");
+    expect(result.dir).toBe("foo");
+    expect(result.base).toBe("bar.js");
+  });
+});
+
+describe("path.format", () => {
+  it("reconstructs path from components", () => {
+    expect(path.format({ dir: "/home/user", base: "file.txt" })).toBe(
+      "/home/user/file.txt",
+    );
+  });
+
+  it("uses name + ext when base is missing", () => {
+    expect(path.format({ dir: "/home", name: "file", ext: ".txt" })).toBe(
+      "/home/file.txt",
+    );
+  });
+});
+
+describe("path constants", () => {
+  it('sep is "/"', () => {
+    expect(path.sep).toBe("/");
+  });
+
+  it('delimiter is ":"', () => {
+    expect(path.delimiter).toBe(":");
+  });
+});

package/src/__tests__/process.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect, vi } from "vitest";
+import { buildProcessEnv } from "../polyfills/process";
+
+describe("process polyfill", () => {
+  describe("basic properties", () => {
+    it('has platform "linux"', () => {
+      const proc = buildProcessEnv();
+      expect(proc.platform).toBe("linux");
+    });
+
+    it('has arch "x64"', () => {
+      const proc = buildProcessEnv();
+      expect(proc.arch).toBe("x64");
+    });
+
+    it('has version string starting with "v"', () => {
+      const proc = buildProcessEnv();
+      expect(proc.version).toMatch(/^v\d+/);
+    });
+
+    it("has pid as a number", () => {
+      const proc = buildProcessEnv();
+      expect(typeof proc.pid).toBe("number");
+    });
+
+    it("has argv as an array", () => {
+      const proc = buildProcessEnv();
+      expect(Array.isArray(proc.argv)).toBe(true);
+    });
+  });
+
+  describe("cwd / chdir", () => {
+    it("cwd() returns initial cwd", () => {
+      const proc = buildProcessEnv({ cwd: "/mydir" });
+      expect(proc.cwd()).toBe("/mydir");
+    });
+
+    it("chdir changes cwd", () => {
+      const proc = buildProcessEnv({ cwd: "/" });
+      proc.chdir("/other");
+      expect(proc.cwd()).toBe("/other");
+    });
+  });
+
+  describe("env", () => {
+    it("includes default env vars", () => {
+      const proc = buildProcessEnv();
+      expect(proc.env.PATH).toBeDefined();
+      expect(proc.env.HOME).toBeDefined();
+    });
+
+    it("includes custom env vars passed in config", () => {
+      const proc = buildProcessEnv({ env: { MY_VAR: "hello" } });
+      expect(proc.env.MY_VAR).toBe("hello");
+    });
+
+    it("includes NAPI_RS_FORCE_WASM=1", () => {
+      const proc = buildProcessEnv();
+      expect(proc.env.NAPI_RS_FORCE_WASM).toBe("1");
+    });
+
+    it("is mutable", () => {
+      const proc = buildProcessEnv();
+      proc.env.CUSTOM = "value";
+      expect(proc.env.CUSTOM).toBe("value");
+    });
+  });
+
+  describe("hrtime", () => {
+    it("returns [seconds, nanoseconds] tuple", () => {
+      const proc = buildProcessEnv();
+      const hr = proc.hrtime();
+      expect(Array.isArray(hr)).toBe(true);
+      expect(hr.length).toBe(2);
+      expect(typeof hr[0]).toBe("number");
+      expect(typeof hr[1]).toBe("number");
+    });
+
+    it("hrtime.bigint() returns bigint", () => {
+      const proc = buildProcessEnv();
+      const result = proc.hrtime.bigint();
+      expect(typeof result).toBe("bigint");
+    });
+  });
+
+  describe("nextTick", () => {
+    it("schedules callback asynchronously", async () => {
+      const proc = buildProcessEnv();
+      let called = false;
+      proc.nextTick(() => {
+        called = true;
+      });
+      expect(called).toBe(false);
+      await new Promise((r) => setTimeout(r, 10));
+      expect(called).toBe(true);
+    });
+  });
+
+  describe("memoryUsage", () => {
+    it("returns object with expected shape", () => {
+      const proc = buildProcessEnv();
+      const mem = proc.memoryUsage();
+      expect(typeof mem.rss).toBe("number");
+      expect(typeof mem.heapTotal).toBe("number");
+      expect(typeof mem.heapUsed).toBe("number");
+      expect(typeof mem.external).toBe("number");
+      expect(typeof mem.arrayBuffers).toBe("number");
+    });
+  });
+
+  describe("stdout.write", () => {
+    it("calls onStdout callback when provided", () => {
+      const output: string[] = [];
+      const proc = buildProcessEnv({ onStdout: (text) => output.push(text) });
+      proc.stdout.write("test");
+      expect(output).toContain("test");
+    });
+  });
+
+  describe("kill / signals", () => {
+    it("kill emits signal on process", () => {
+      const proc = buildProcessEnv();
+      const fn = vi.fn();
+      proc.on("SIGTERM", fn);
+      proc.kill(proc.pid, "SIGTERM");
+      expect(fn).toHaveBeenCalled();
+    });
+  });
+});

package/src/__tests__/script-engine.test.ts

@@ -0,0 +1,229 @@
+import { describe, it, expect } from "vitest";
+import { ScriptEngine } from "../script-engine";
+import { MemoryVolume } from "../memory-volume";
+
+function createEngine(files?: Record<string, string>) {
+  const vol = new MemoryVolume();
+  vol.mkdirSync("/project", { recursive: true });
+  if (files) {
+    for (const [path, content] of Object.entries(files)) {
+      const dir = path.substring(0, path.lastIndexOf("/")) || "/";
+      if (dir !== "/") vol.mkdirSync(dir, { recursive: true });
+      vol.writeFileSync(path, content);
+    }
+  }
+  return { vol, engine: new ScriptEngine(vol, { cwd: "/project" }) };
+}
+
+describe("ScriptEngine", () => {
+  describe("execute()", () => {
+    it("runs basic JS and returns exports", () => {
+      const { engine } = createEngine();
+      const result = engine.execute("module.exports = 42;", "/index.js");
+      expect(result.exports).toBe(42);
+    });
+
+    it("module.exports = object", () => {
+      const { engine } = createEngine();
+      const result = engine.execute(
+        "module.exports = { x: 1 };",
+        "/index.js",
+      );
+      expect(result.exports).toEqual({ x: 1 });
+    });
+
+    it("exports.x = value shorthand", () => {
+      const { engine } = createEngine();
+      const result = engine.execute("exports.x = 1;", "/index.js");
+      expect((result.exports as any).x).toBe(1);
+    });
+
+    it("has access to __dirname and __filename", () => {
+      const { engine } = createEngine();
+      const result = engine.execute(
+        "module.exports = { dir: __dirname, file: __filename };",
+        "/project/test.js",
+      );
+      expect((result.exports as any).dir).toBe("/project");
+      expect((result.exports as any).file).toBe("/project/test.js");
+    });
+
+    it("has access to process object", () => {
+      const { engine } = createEngine();
+      const result = engine.execute(
+        "module.exports = process.platform;",
+        "/index.js",
+      );
+      expect(result.exports).toBe("linux");
+    });
+
+    it("handles syntax errors by throwing", () => {
+      const { engine } = createEngine();
+      expect(() => engine.execute("const {", "/bad.js")).toThrow();
+    });
+  });
+
+  describe("runFile()", () => {
+    it("reads file from volume and executes", () => {
+      const { engine } = createEngine({
+        "/project/app.js": 'module.exports = "hello";',
+      });
+      const result = engine.runFile("/project/app.js");
+      expect(result.exports).toBe("hello");
+    });
+
+    it("throws for nonexistent file", () => {
+      const { engine } = createEngine();
+      expect(() => engine.runFile("/nonexistent.js")).toThrow();
+    });
+  });
+
+  describe("require()", () => {
+    it("requires a local file with relative path", () => {
+      const { engine } = createEngine({
+        "/project/lib.js": "module.exports = 10;",
+      });
+      const result = engine.execute(
+        'const lib = require("./lib"); module.exports = lib;',
+        "/project/index.js",
+      );
+      expect(result.exports).toBe(10);
+    });
+
+    it("requires chained files (A requires B requires C)", () => {
+      const { engine } = createEngine({
+        "/project/c.js": "module.exports = 3;",
+        "/project/b.js":
+          'module.exports = require("./c") * 2;',
+        "/project/a.js":
+          'module.exports = require("./b") + 1;',
+      });
+      const result = engine.runFile("/project/a.js");
+      expect(result.exports).toBe(7);
+    });
+
+    it("caches modules (same object returned on second require)", () => {
+      const { engine } = createEngine({
+        "/project/mod.js": "module.exports = { count: 0 };",
+      });
+      const result = engine.execute(
+        'const a = require("./mod"); const b = require("./mod"); a.count++; module.exports = b.count;',
+        "/project/test.js",
+      );
+      expect(result.exports).toBe(1);
+    });
+
+    it("requires built-in modules: path", () => {
+      const { engine } = createEngine();
+      const result = engine.execute(
+        'const p = require("path"); module.exports = p.join("/a", "b");',
+        "/index.js",
+      );
+      expect(result.exports).toBe("/a/b");
+    });
+
+    it("requires built-in modules: events", () => {
+      const { engine } = createEngine();
+      const result = engine.execute(
+        'const EE = require("events"); module.exports = typeof EE;',
+        "/index.js",
+      );
+      expect(result.exports).toBe("function");
+    });
+
+    it("requires JSON files", () => {
+      const { engine } = createEngine({
+        "/project/data.json": '{"key": "value"}',
+      });
+      const result = engine.execute(
+        'module.exports = require("./data.json");',
+        "/project/index.js",
+      );
+      expect(result.exports).toEqual({ key: "value" });
+    });
+
+    it("throws for missing module", () => {
+      const { engine } = createEngine();
+      expect(() =>
+        engine.execute('require("./nonexistent");', "/index.js"),
+      ).toThrow();
+    });
+  });
+
+  describe("ESM auto-conversion", () => {
+    it("auto-converts import/export to CJS when required", () => {
+      const { engine } = createEngine({
+        "/project/mod.js": "export const x = 42;",
+      });
+      const result = engine.execute(
+        'const m = require("./mod"); module.exports = m.x;',
+        "/project/index.js",
+      );
+      expect(result.exports).toBe(42);
+    });
+
+    it("handles export function containing dynamic import() without corruption", () => {
+      const { engine } = createEngine({
+        "/project/plugin.js": [
+          'import path from "path";',
+          "export function helper() { return 1; }",
+          "export function main() {",
+          "  const loader = () => import('./other.js');",
+          "  return { loader, val: path.join('a', 'b') };",
+          "}",
+        ].join("\n"),
+      });
+      const result = engine.execute(
+        'const m = require("./plugin"); module.exports = m.main().val;',
+        "/project/index.js",
+      );
+      expect(result.exports).toBe("a/b");
+    });
+  });
+
+  describe("clearCache()", () => {
+    it("clears module cache so modules are re-evaluated", () => {
+      const { engine } = createEngine({
+        "/project/counter.js":
+          "let c = 0; module.exports = { inc() { return ++c; } };",
+      });
+      engine.execute(
+        'module.exports = require("./counter").inc();',
+        "/project/a.js",
+      );
+      engine.clearCache();
+      const result = engine.execute(
+        'module.exports = require("./counter").inc();',
+        "/project/b.js",
+      );
+      // c resets to 0 after cache clear
+      expect(result.exports).toBe(1);
+    });
+  });
+
+  describe("createREPL()", () => {
+    it("evaluates expressions", () => {
+      const { engine } = createEngine();
+      const repl = engine.createREPL();
+      expect(repl.eval("1 + 1")).toBe(2);
+    });
+
+    it("evaluates variable declarations across calls", () => {
+      const { engine } = createEngine();
+      const repl = engine.createREPL();
+      repl.eval("var x = 10");
+      expect(repl.eval("x")).toBe(10);
+    });
+  });
+
+  describe("shebang handling", () => {
+    it("strips shebang line", () => {
+      const { engine } = createEngine({
+        "/project/script.js":
+          "#!/usr/bin/env node\nmodule.exports = 42;",
+      });
+      const result = engine.runFile("/project/script.js");
+      expect(result.exports).toBe(42);
+    });
+  });
+});