@scelar/nodepod 1.0.2 → 1.0.3

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

@@ -0,0 +1,104 @@
+import { describe, bench } from "vitest";
+import { MemoryVolume } from "../../memory-volume";
+import { ScriptEngine } from "../../script-engine";
+
+function createEngine(files?: Record<string, string>): ScriptEngine {
+  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 new ScriptEngine(vol, { cwd: "/project" });
+}
+
+describe("ScriptEngine - execute", () => {
+  bench("simple expression", () => {
+    const engine = createEngine();
+    engine.execute("module.exports = 1 + 1;", "/index.js");
+  });
+
+  bench("console.log", () => {
+    const engine = createEngine();
+    engine.execute('console.log("hello");', "/index.js");
+  });
+
+  bench("require('path')", () => {
+    const engine = createEngine();
+    engine.execute(
+      'const path = require("path"); module.exports = path.join("/a", "b");',
+      "/index.js",
+    );
+  });
+
+  bench("require('events') + use", () => {
+    const engine = createEngine();
+    engine.execute(
+      'const { EventEmitter } = require("events"); const ee = new EventEmitter(); ee.on("x", () => {}); ee.emit("x");',
+      "/index.js",
+    );
+  });
+});
+
+describe("ScriptEngine - module resolution", () => {
+  bench("require local file", () => {
+    const engine = createEngine({
+      "/project/lib.js": "module.exports = { value: 42 };",
+      "/project/index.js":
+        'const lib = require("./lib"); module.exports = lib.value;',
+    });
+    engine.runFile("/project/index.js");
+  });
+
+  bench("require chain - 3 modules deep", () => {
+    const engine = createEngine({
+      "/project/a.js": "module.exports = { a: 1 };",
+      "/project/b.js":
+        'const a = require("./a"); module.exports = { ...a, b: 2 };',
+      "/project/c.js":
+        'const b = require("./b"); module.exports = { ...b, c: 3 };',
+    });
+    engine.runFile("/project/c.js");
+  });
+
+  bench("require with index.js resolution", () => {
+    const engine = createEngine({
+      "/project/mylib/index.js": "module.exports = { ok: true };",
+      "/project/index.js": 'module.exports = require("./mylib");',
+    });
+    engine.runFile("/project/index.js");
+  });
+
+  bench("require 10 builtins", () => {
+    const engine = createEngine();
+    engine.execute(
+      [
+        'require("path");',
+        'require("fs");',
+        'require("events");',
+        'require("util");',
+        'require("os");',
+        'require("url");',
+        'require("querystring");',
+        'require("buffer");',
+        'require("stream");',
+        'require("crypto");',
+      ].join("\n"),
+      "/index.js",
+    );
+  });
+});
+
+describe("ScriptEngine - cache", () => {
+  bench("execute + clearCache + re-execute", () => {
+    const engine = createEngine({
+      "/project/mod.js": "module.exports = Date.now();",
+    });
+    engine.runFile("/project/mod.js");
+    engine.clearCache();
+    engine.runFile("/project/mod.js");
+  });
+});

package/src/__tests__/bench/shell.bench.ts

@@ -0,0 +1,101 @@
+import { describe, bench, beforeEach } from "vitest";
+import { parse, expandVariables } from "../../shell/shell-parser";
+import { NodepodShell } from "../../shell/shell-interpreter";
+import { MemoryVolume } from "../../memory-volume";
+
+const ENV = {
+  HOME: "/home/user",
+  PATH: "/usr/bin",
+  PWD: "/",
+  NODE_ENV: "production",
+};
+
+describe("Shell parser", () => {
+  bench("simple: echo hello", () => {
+    parse("echo hello", ENV, 0);
+  });
+
+  bench("pipe: ls | grep foo | wc -l", () => {
+    parse("ls | grep foo | wc -l", ENV, 0);
+  });
+
+  bench("compound: cd /tmp && ls -la && echo done", () => {
+    parse("cd /tmp && ls -la && echo done", ENV, 0);
+  });
+
+  bench("redirects: cat file.txt > output.txt 2>&1", () => {
+    parse("cat file.txt > output.txt 2>&1", ENV, 0);
+  });
+
+  bench("variable expansion: echo $HOME $PWD $NODE_ENV", () => {
+    parse("echo $HOME $PWD $NODE_ENV", ENV, 0);
+  });
+
+  bench("complex: VAR=hello echo ${VAR:-default} | cat && echo $?", () => {
+    parse("VAR=hello echo ${VAR:-default} | cat && echo $?", ENV, 0);
+  });
+
+  bench("quoted strings: echo 'hello world' \"$HOME/path\"", () => {
+    parse(`echo 'hello world' "$HOME/path"`, ENV, 0);
+  });
+});
+
+describe("Shell expandVariables", () => {
+  bench("simple $VAR", () => {
+    expandVariables("$HOME", ENV, 0);
+  });
+
+  bench("${VAR:-default}", () => {
+    expandVariables("${MISSING:-fallback}", ENV, 0);
+  });
+
+  bench("multiple vars in string", () => {
+    expandVariables("$HOME/.config/$NODE_ENV/settings", ENV, 0);
+  });
+});
+
+describe("Shell interpreter - builtins", () => {
+  let shell: NodepodShell;
+
+  beforeEach(() => {
+    const vol = new MemoryVolume();
+    vol.mkdirSync("/project/src", { recursive: true });
+    for (let i = 0; i < 20; i++) {
+      vol.writeFileSync(
+        `/project/src/file-${i}.ts`,
+        `export const x = ${i};`,
+      );
+    }
+    vol.writeFileSync(
+      "/project/readme.md",
+      "# Project\nThis is a readme.\nLine 3.\n",
+    );
+    shell = new NodepodShell(vol, { cwd: "/project", env: { ...ENV } });
+  });
+
+  bench("echo hello world", async () => {
+    await shell.exec("echo hello world");
+  });
+
+  bench("ls /project/src (20 files)", async () => {
+    await shell.exec("ls /project/src");
+  });
+
+  bench("cat readme.md", async () => {
+    await shell.exec("cat /project/readme.md");
+  });
+
+  bench("pwd", async () => {
+    await shell.exec("pwd");
+  });
+
+  bench("pipe: echo hello | cat", async () => {
+    await shell.exec("echo hello | cat");
+  });
+
+  bench("mkdir -p + echo redirect + rm", async () => {
+    await shell.exec(
+      "mkdir -p /tmp/bench && echo test > /tmp/bench/f.txt && rm /tmp/bench/f.txt",
+    );
+  });
+});

package/src/__tests__/bench/syntax-transforms.bench.ts

@@ -0,0 +1,82 @@
+import { describe, bench } from "vitest";
+import { esmToCjs, hasTopLevelAwait, stripTopLevelAwait } from "../../syntax-transforms";
+
+const SIMPLE_ESM = `
+import { readFileSync } from 'fs';
+import path from 'path';
+export const data = readFileSync(path.join(__dirname, 'data.json'), 'utf8');
+export default data;
+`;
+
+const COMPLEX_ESM = `
+import express from 'express';
+import { Router } from 'express';
+import * as http from 'http';
+import path, { join, resolve, dirname } from 'path';
+import { readFileSync, writeFileSync } from 'fs';
+
+export const app = express();
+const router = Router();
+
+router.get('/', (req, res) => {
+  res.json({ status: 'ok' });
+});
+
+app.use('/api', router);
+
+export function startServer(port) {
+  return new Promise((resolve) => {
+    const server = http.createServer(app);
+    server.listen(port, () => resolve(server));
+  });
+}
+
+export default app;
+`;
+
+const LARGE_ESM =
+  Array.from(
+    { length: 20 },
+    (_, i) => `import mod${i} from './mod${i}';\nexport const val${i} = mod${i}.process();`,
+  ).join("\n") + "\nexport default { total: 20 };";
+
+const TLA_SOURCE = `
+import fs from 'fs';
+const data = await fetch('/api');
+const json = await data.json();
+export default json;
+`;
+
+const PLAIN_CJS = 'const x = require("fs"); module.exports = x;';
+
+describe("esmToCjs", () => {
+  bench("simple ESM (2 imports, 2 exports)", () => {
+    esmToCjs(SIMPLE_ESM);
+  });
+
+  bench("complex ESM (5 imports, mixed exports)", () => {
+    esmToCjs(COMPLEX_ESM);
+  });
+
+  bench("large ESM (20 imports, 20 exports)", () => {
+    esmToCjs(LARGE_ESM);
+  });
+
+  bench("passthrough - plain CJS", () => {
+    esmToCjs(PLAIN_CJS);
+  });
+});
+
+describe("Top-level await", () => {
+  bench("hasTopLevelAwait - with TLA", () => {
+    hasTopLevelAwait(TLA_SOURCE);
+  });
+
+  bench("hasTopLevelAwait - without TLA", () => {
+    hasTopLevelAwait(COMPLEX_ESM);
+  });
+
+  bench("stripTopLevelAwait", () => {
+    stripTopLevelAwait(TLA_SOURCE);
+  });
+});

package/src/__tests__/bench/version-resolver.bench.ts

@@ -0,0 +1,95 @@
+import { describe, bench } from "vitest";
+import {
+  parseSemver,
+  compareSemver,
+  satisfiesRange,
+  pickBestMatch,
+} from "../../packages/version-resolver";
+
+const VERSIONS = [
+  "1.0.0", "1.0.1", "1.1.0", "1.2.0", "1.2.3",
+  "2.0.0", "2.0.1", "2.1.0", "2.3.4",
+  "3.0.0-alpha.1", "3.0.0-beta.1", "3.0.0", "3.1.0", "3.2.1",
+  "4.0.0", "4.1.0", "4.2.0", "4.3.0", "4.4.0", "4.5.0",
+  "5.0.0", "5.1.0", "5.2.0", "5.3.0", "5.4.0", "5.5.0",
+];
+
+describe("parseSemver", () => {
+  bench("simple version", () => {
+    parseSemver("3.2.1");
+  });
+
+  bench("with prerelease", () => {
+    parseSemver("3.0.0-alpha.1");
+  });
+
+  bench("invalid (returns null)", () => {
+    parseSemver("not-a-version");
+  });
+});
+
+describe("compareSemver", () => {
+  bench("equal versions", () => {
+    compareSemver("1.2.3", "1.2.3");
+  });
+
+  bench("different major", () => {
+    compareSemver("1.2.3", "2.0.0");
+  });
+
+  bench("different patch", () => {
+    compareSemver("1.2.3", "1.2.4");
+  });
+
+  bench("with prerelease", () => {
+    compareSemver("3.0.0-alpha.1", "3.0.0-beta.1");
+  });
+});
+
+describe("satisfiesRange", () => {
+  bench("caret: ^1.2.0", () => {
+    satisfiesRange("1.5.0", "^1.2.0");
+  });
+
+  bench("tilde: ~1.2.0", () => {
+    satisfiesRange("1.2.5", "~1.2.0");
+  });
+
+  bench("compound: >=2.0.0 <4.0.0", () => {
+    satisfiesRange("3.1.0", ">=2.0.0 <4.0.0");
+  });
+
+  bench("OR union: ^1.0.0 || ^2.0.0", () => {
+    satisfiesRange("2.1.0", "^1.0.0 || ^2.0.0");
+  });
+
+  bench("x-range: 1.x", () => {
+    satisfiesRange("1.5.0", "1.x");
+  });
+
+  bench("wildcard: *", () => {
+    satisfiesRange("5.0.0", "*");
+  });
+
+  bench("exact: 1.2.3", () => {
+    satisfiesRange("1.2.3", "1.2.3");
+  });
+});
+
+describe("pickBestMatch", () => {
+  bench("^1.0.0 from 26 versions", () => {
+    pickBestMatch(VERSIONS, "^1.0.0");
+  });
+
+  bench(">=2.0.0 <5.0.0 from 26 versions", () => {
+    pickBestMatch(VERSIONS, ">=2.0.0 <5.0.0");
+  });
+
+  bench("* from 26 versions", () => {
+    pickBestMatch(VERSIONS, "*");
+  });
+
+  bench("no match: ^99.0.0", () => {
+    pickBestMatch(VERSIONS, "^99.0.0");
+  });
+});

package/src/__tests__/buffer.test.ts

@@ -0,0 +1,273 @@
+import { describe, it, expect } from "vitest";
+
+import { Buffer } from "../polyfills/buffer";
+
+describe("Buffer", () => {
+  describe("Buffer.from(string)", () => {
+    it("creates buffer from utf8 string", () => {
+      const buf = Buffer.from("hello");
+      expect(buf.toString()).toBe("hello");
+      expect(buf.length).toBe(5);
+    });
+
+    it("creates buffer from hex string", () => {
+      const buf = Buffer.from("48656c6c6f", "hex");
+      expect(buf.toString()).toBe("Hello");
+    });
+
+    it("creates buffer from base64 string", () => {
+      const buf = Buffer.from("SGVsbG8=", "base64");
+      expect(buf.toString()).toBe("Hello");
+    });
+
+    it("creates buffer from latin1 string", () => {
+      const buf = Buffer.from("hello", "latin1");
+      expect(buf.toString()).toBe("hello");
+    });
+
+    it("creates buffer from base64url", () => {
+      const buf = Buffer.from("SGVsbG8", "base64url");
+      expect(buf.toString()).toBe("Hello");
+    });
+  });
+
+  describe("Buffer.from(array/Uint8Array)", () => {
+    it("creates buffer from number array", () => {
+      const buf = Buffer.from([72, 101, 108, 108, 111]);
+      expect(buf.toString()).toBe("Hello");
+    });
+
+    it("creates buffer from Uint8Array", () => {
+      const arr = new Uint8Array([1, 2, 3]);
+      const buf = Buffer.from(arr);
+      expect(buf.length).toBe(3);
+      expect(buf[0]).toBe(1);
+    });
+  });
+
+  describe("Buffer.alloc", () => {
+    it("creates zero-filled buffer", () => {
+      const buf = Buffer.alloc(10);
+      expect(buf.length).toBe(10);
+      expect(buf.every((b: number) => b === 0)).toBe(true);
+    });
+
+    it("creates buffer filled with specified value", () => {
+      const buf = Buffer.alloc(5, 0xff);
+      expect(buf.every((b: number) => b === 255)).toBe(true);
+    });
+  });
+
+  describe("Buffer.concat", () => {
+    it("concatenates multiple buffers", () => {
+      const result = Buffer.concat([Buffer.from("hel"), Buffer.from("lo")]);
+      expect(result.toString()).toBe("hello");
+    });
+
+    it("handles empty array", () => {
+      const result = Buffer.concat([]);
+      expect(result.length).toBe(0);
+    });
+
+    it("handles single buffer", () => {
+      const buf = Buffer.from("only");
+      const result = Buffer.concat([buf]);
+      expect(result.toString()).toBe("only");
+    });
+  });
+
+  describe("toString", () => {
+    it("defaults to utf8", () => {
+      expect(Buffer.from("test").toString()).toBe("test");
+    });
+
+    it("encodes as hex", () => {
+      expect(Buffer.from("Hello").toString("hex")).toBe("48656c6c6f");
+    });
+
+    it("encodes as base64", () => {
+      expect(Buffer.from("Hello").toString("base64")).toBe("SGVsbG8=");
+    });
+
+    it("encodes as latin1", () => {
+      const buf = Buffer.from([0xe9]);
+      expect(buf.toString("latin1")).toBe("\xe9");
+    });
+  });
+
+  describe("slice / subarray", () => {
+    it("returns a sub-buffer", () => {
+      const buf = Buffer.from("hello");
+      expect(buf.slice(1, 3).toString()).toBe("el");
+    });
+
+    it("slice result is a Buffer-like", () => {
+      const buf = Buffer.from("test");
+      const sliced = buf.slice(0, 2);
+      expect(sliced).toBeInstanceOf(Uint8Array);
+    });
+  });
+
+  describe("compare / equals", () => {
+    it("returns 0 for equal buffers", () => {
+      expect(Buffer.from("abc").compare(Buffer.from("abc"))).toBe(0);
+    });
+
+    it("returns negative for lesser buffer", () => {
+      expect(Buffer.from("abc").compare(Buffer.from("abd"))).toBeLessThan(0);
+    });
+
+    it("returns positive for greater buffer", () => {
+      expect(Buffer.from("abd").compare(Buffer.from("abc"))).toBeGreaterThan(0);
+    });
+
+    it("equals returns true for same content", () => {
+      expect(Buffer.from("test").equals(Buffer.from("test"))).toBe(true);
+    });
+
+    it("equals returns false for different content", () => {
+      expect(Buffer.from("test").equals(Buffer.from("nope"))).toBe(false);
+    });
+  });
+
+  describe("indexOf", () => {
+    it("finds byte in buffer", () => {
+      const buf = Buffer.from([1, 2, 3, 4, 5]);
+      expect(buf.indexOf(3)).toBe(2);
+    });
+
+    it("returns -1 when not found", () => {
+      const buf = Buffer.from([1, 2, 3]);
+      expect(buf.indexOf(99)).toBe(-1);
+    });
+  });
+
+  describe("write", () => {
+    it("writes string into buffer at offset", () => {
+      const buf = Buffer.alloc(10);
+      buf.write("hi", 0);
+      expect(buf.slice(0, 2).toString()).toBe("hi");
+    });
+
+    it("returns number of bytes written", () => {
+      const buf = Buffer.alloc(10);
+      const written = buf.write("hello", 0);
+      expect(written).toBe(5);
+    });
+  });
+
+  describe("copy", () => {
+    it("copies bytes between buffers", () => {
+      const src = Buffer.from("hello");
+      const dst = Buffer.alloc(5);
+      src.copy(dst);
+      expect(dst.toString()).toBe("hello");
+    });
+  });
+
+  describe("integer read/write", () => {
+    it("readUInt8 / writeUInt8 round-trip", () => {
+      const buf = Buffer.alloc(1);
+      buf.writeUInt8(200, 0);
+      expect(buf.readUInt8(0)).toBe(200);
+    });
+
+    it("readUInt16BE / writeUInt16BE round-trip", () => {
+      const buf = Buffer.alloc(2);
+      buf.writeUInt16BE(0x1234, 0);
+      expect(buf.readUInt16BE(0)).toBe(0x1234);
+    });
+
+    it("readUInt32LE / writeUInt32LE round-trip", () => {
+      const buf = Buffer.alloc(4);
+      buf.writeUInt32LE(0xdeadbeef, 0);
+      expect(buf.readUInt32LE(0)).toBe(0xdeadbeef);
+    });
+
+    it("readInt8 handles signed values", () => {
+      const buf = Buffer.alloc(1);
+      buf.writeInt8(-42, 0);
+      expect(buf.readInt8(0)).toBe(-42);
+    });
+
+    it("readInt16BE handles negative values", () => {
+      const buf = Buffer.alloc(2);
+      buf.writeInt16BE(-1000, 0);
+      expect(buf.readInt16BE(0)).toBe(-1000);
+    });
+  });
+
+  describe("Float/Double read/write", () => {
+    it("readFloatLE / writeFloatLE round-trip", () => {
+      const buf = Buffer.alloc(4);
+      buf.writeFloatLE(3.14, 0);
+      expect(buf.readFloatLE(0)).toBeCloseTo(3.14, 2);
+    });
+
+    it("readDoubleLE / writeDoubleLE round-trip", () => {
+      const buf = Buffer.alloc(8);
+      buf.writeDoubleLE(Math.PI, 0);
+      expect(buf.readDoubleLE(0)).toBeCloseTo(Math.PI, 10);
+    });
+  });
+
+  describe("swap methods", () => {
+    it("swap16 swaps pairs of bytes", () => {
+      const buf = Buffer.from([0x01, 0x02, 0x03, 0x04]);
+      buf.swap16();
+      expect(Array.from(buf)).toEqual([0x02, 0x01, 0x04, 0x03]);
+    });
+
+    it("swap32 reverses 4-byte groups", () => {
+      const buf = Buffer.from([0x01, 0x02, 0x03, 0x04]);
+      buf.swap32();
+      expect(Array.from(buf)).toEqual([0x04, 0x03, 0x02, 0x01]);
+    });
+
+    it("swap16 throws on odd-length buffer", () => {
+      const buf = Buffer.from([1, 2, 3]);
+      expect(() => buf.swap16()).toThrow();
+    });
+  });
+
+  describe("static methods", () => {
+    it("isBuffer returns true for Buffer instances", () => {
+      expect(Buffer.isBuffer(Buffer.from("x"))).toBe(true);
+    });
+
+    it("isBuffer returns true for Uint8Array", () => {
+      expect(Buffer.isBuffer(new Uint8Array(1))).toBe(true);
+    });
+
+    it("isEncoding returns true for valid encodings", () => {
+      expect(Buffer.isEncoding("utf8")).toBe(true);
+      expect(Buffer.isEncoding("hex")).toBe(true);
+      expect(Buffer.isEncoding("base64")).toBe(true);
+    });
+
+    it("isEncoding returns false for invalid encoding", () => {
+      expect(Buffer.isEncoding("garbage")).toBe(false);
+    });
+
+    it("byteLength returns correct length for utf8", () => {
+      expect(Buffer.byteLength("hello", "utf8")).toBe(5);
+    });
+
+    it("byteLength returns correct length for hex", () => {
+      expect(Buffer.byteLength("aabb", "hex")).toBe(2);
+    });
+
+    it("byteLength returns correct length for base64", () => {
+      expect(Buffer.byteLength("SGVsbG8=", "base64")).toBe(5);
+    });
+  });
+
+  describe("toJSON", () => {
+    it('returns { type: "Buffer", data: [...] }', () => {
+      const buf = Buffer.from([1, 2, 3]);
+      const json = buf.toJSON();
+      expect(json.type).toBe("Buffer");
+      expect(json.data).toEqual([1, 2, 3]);
+    });
+  });
+});