@somewhatabstract/x 0.0.1 → 0.1.0

package/src/__tests__/find-matching-bins.test.ts

@@ -0,0 +1,506 @@
+import {beforeEach, describe, expect, it, vi} from "vitest";
+import type {PackageInfo} from "../discover-packages";
+import {findMatchingBins} from "../find-matching-bins";
+
+// Mock the fs module
+vi.mock("node:fs/promises", () => ({
+    readFile: vi.fn(),
+}));
+
+import * as fs from "node:fs/promises";
+
+describe("findMatchingBins", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.spyOn(console, "warn").mockImplementation(() => {
+            /* shh */
+        });
+    });
+
+    it("should find one matching bin with object-style bin configuration", async () => {
+        // Arrange
+        const packages: PackageInfo[] = [
+            {
+                name: "@somewhatabstract/x",
+                path: "/test/path",
+                version: "1.0.0",
+            },
+        ];
+
+        vi.mocked(fs.readFile).mockResolvedValue(
+            JSON.stringify({
+                name: "@somewhatabstract/x",
+                bin: {
+                    x: "./dist/x.mjs",
+                },
+            }),
+        );
+
+        // Act
+        const matches = await findMatchingBins(packages, "x");
+
+        // Assert
+        expect(matches).toHaveLength(1);
+    });
+
+    it("should match the correct package name", async () => {
+        // Arrange
+        const packages: PackageInfo[] = [
+            {
+                name: "@somewhatabstract/x",
+                path: "/test/path",
+                version: "1.0.0",
+            },
+        ];
+
+        vi.mocked(fs.readFile).mockResolvedValue(
+            JSON.stringify({
+                name: "@somewhatabstract/x",
+                bin: {
+                    x: "./dist/x.mjs",
+                },
+            }),
+        );
+
+        // Act
+        const matches = await findMatchingBins(packages, "x");
+
+        // Assert
+        expect(matches[0].packageName).toBe("@somewhatabstract/x");
+    });
+
+    it("should match the correct bin name", async () => {
+        // Arrange
+        const packages: PackageInfo[] = [
+            {
+                name: "@somewhatabstract/x",
+                path: "/test/path",
+                version: "1.0.0",
+            },
+        ];
+
+        vi.mocked(fs.readFile).mockResolvedValue(
+            JSON.stringify({
+                name: "@somewhatabstract/x",
+                bin: {
+                    x: "./dist/x.mjs",
+                },
+            }),
+        );
+
+        // Act
+        const matches = await findMatchingBins(packages, "x");
+
+        // Assert
+        expect(matches[0].binName).toBe("x");
+    });
+
+    it("should include the bin path in the match", async () => {
+        // Arrange
+        const packages: PackageInfo[] = [
+            {
+                name: "@somewhatabstract/x",
+                path: "/test/path",
+                version: "1.0.0",
+            },
+        ];
+
+        vi.mocked(fs.readFile).mockResolvedValue(
+            JSON.stringify({
+                name: "@somewhatabstract/x",
+                bin: {
+                    x: "./dist/x.mjs",
+                },
+            }),
+        );
+
+        // Act
+        const matches = await findMatchingBins(packages, "x");
+
+        // Assert
+        expect(matches[0].binPath).toBe("/test/path/dist/x.mjs");
+    });
+
+    it("should return empty array when no bins match", async () => {
+        // Arrange
+        const packages: PackageInfo[] = [
+            {
+                name: "@somewhatabstract/x",
+                path: "/test/path",
+                version: "1.0.0",
+            },
+        ];
+
+        vi.mocked(fs.readFile).mockResolvedValue(
+            JSON.stringify({
+                name: "@somewhatabstract/x",
+                bin: {
+                    x: "./dist/x.mjs",
+                },
+            }),
+        );
+
+        // Act
+        const matches = await findMatchingBins(packages, "nonexistent");
+
+        // Assert
+        expect(matches).toHaveLength(0);
+    });
+
+    it("should handle packages without bin field", async () => {
+        // Arrange
+        const packages: PackageInfo[] = [
+            {
+                name: "no-bin-pkg",
+                path: "/test/path",
+                version: "1.0.0",
+            },
+        ];
+
+        vi.mocked(fs.readFile).mockResolvedValue(
+            JSON.stringify({
+                name: "no-bin-pkg",
+            }),
+        );
+
+        // Act
+        const matches = await findMatchingBins(packages, "anything");
+
+        // Assert
+        expect(matches).toHaveLength(0);
+    });
+
+    it("should handle packages with string-style bin configuration", async () => {
+        // Arrange
+        const packages: PackageInfo[] = [
+            {
+                name: "my-cli",
+                path: "/test/path",
+                version: "1.0.0",
+            },
+        ];
+
+        vi.mocked(fs.readFile).mockResolvedValue(
+            JSON.stringify({
+                name: "my-cli",
+                bin: "./bin/cli.js",
+            }),
+        );
+
+        // Act
+        const matches = await findMatchingBins(packages, "my-cli");
+
+        // Assert
+        expect(matches).toHaveLength(1);
+    });
+
+    it("should skip packages that cannot be read", async () => {
+        // Arrange
+        const packages: PackageInfo[] = [
+            {
+                name: "unreadable-pkg",
+                path: "/test/path",
+                version: "1.0.0",
+            },
+        ];
+
+        vi.mocked(fs.readFile).mockRejectedValue(
+            new Error("ENOENT: no such file or directory"),
+        );
+
+        // Act
+        const matches = await findMatchingBins(packages, "anything");
+
+        // Assert
+        expect(matches).toHaveLength(0);
+    });
+
+    it("should not match string-style bin when package name differs from binName", async () => {
+        // Arrange
+        const packages: PackageInfo[] = [
+            {
+                name: "my-package",
+                path: "/test/path",
+                version: "1.0.0",
+            },
+        ];
+
+        vi.mocked(fs.readFile).mockResolvedValue(
+            JSON.stringify({
+                name: "my-package",
+                bin: "./bin/script.js",
+            }),
+        );
+
+        // Act
+        const matches = await findMatchingBins(packages, "different-name");
+
+        // Assert
+        expect(matches).toHaveLength(0);
+    });
+
+    it("should not match object-style bin when binName not in object", async () => {
+        // Arrange
+        const packages: PackageInfo[] = [
+            {
+                name: "my-package",
+                path: "/test/path",
+                version: "1.0.0",
+            },
+        ];
+
+        vi.mocked(fs.readFile).mockResolvedValue(
+            JSON.stringify({
+                name: "my-package",
+                bin: {
+                    "other-bin": "./bin/other.js",
+                    "another-bin": "./bin/another.js",
+                },
+            }),
+        );
+
+        // Act
+        const matches = await findMatchingBins(packages, "missing-bin");
+
+        // Assert
+        expect(matches).toHaveLength(0);
+    });
+
+    it("should reject path traversal attempt with parent directory in string-style bin", async () => {
+        // Arrange
+        const packages: PackageInfo[] = [
+            {
+                name: "malicious-package",
+                path: "/test/package",
+                version: "1.0.0",
+            },
+        ];
+
+        vi.mocked(fs.readFile).mockResolvedValue(
+            JSON.stringify({
+                name: "malicious-package",
+                bin: "../../../etc/passwd",
+            }),
+        );
+
+        // Act
+        const matches = await findMatchingBins(packages, "malicious-package");
+
+        // Assert
+        expect(matches).toHaveLength(0);
+    });
+
+    it("should reject path traversal attempt with parent directory in object-style bin", async () => {
+        // Arrange
+        const packages: PackageInfo[] = [
+            {
+                name: "malicious-package",
+                path: "/test/package",
+                version: "1.0.0",
+            },
+        ];
+
+        vi.mocked(fs.readFile).mockResolvedValue(
+            JSON.stringify({
+                name: "malicious-package",
+                bin: {
+                    "evil-script": "../../../usr/bin/malicious",
+                },
+            }),
+        );
+
+        // Act
+        const matches = await findMatchingBins(packages, "evil-script");
+
+        // Assert
+        expect(matches).toHaveLength(0);
+    });
+
+    it("should reject absolute path in string-style bin", async () => {
+        // Arrange
+        const packages: PackageInfo[] = [
+            {
+                name: "malicious-package",
+                path: "/test/package",
+                version: "1.0.0",
+            },
+        ];
+
+        vi.mocked(fs.readFile).mockResolvedValue(
+            JSON.stringify({
+                name: "malicious-package",
+                bin: "/usr/bin/malicious",
+            }),
+        );
+
+        // Act
+        const matches = await findMatchingBins(packages, "malicious-package");
+
+        // Assert
+        expect(matches).toHaveLength(0);
+    });
+
+    it("should reject absolute path in object-style bin", async () => {
+        // Arrange
+        const packages: PackageInfo[] = [
+            {
+                name: "malicious-package",
+                path: "/test/package",
+                version: "1.0.0",
+            },
+        ];
+
+        vi.mocked(fs.readFile).mockResolvedValue(
+            JSON.stringify({
+                name: "malicious-package",
+                bin: {
+                    "evil-script": "/usr/bin/malicious",
+                },
+            }),
+        );
+
+        // Act
+        const matches = await findMatchingBins(packages, "evil-script");
+
+        // Assert
+        expect(matches).toHaveLength(0);
+    });
+
+    it("should accept bin path in subdirectory", async () => {
+        // Arrange
+        const packages: PackageInfo[] = [
+            {
+                name: "good-package",
+                path: "/test/package",
+                version: "1.0.0",
+            },
+        ];
+
+        vi.mocked(fs.readFile).mockResolvedValue(
+            JSON.stringify({
+                name: "good-package",
+                bin: {
+                    "good-script": "./bin/nested/script.js",
+                },
+            }),
+        );
+
+        // Act
+        const matches = await findMatchingBins(packages, "good-script");
+
+        // Assert
+        expect(matches).toHaveLength(1);
+    });
+
+    it("should accept bin path at package root", async () => {
+        // Arrange
+        const packages: PackageInfo[] = [
+            {
+                name: "good-package",
+                path: "/test/package",
+                version: "1.0.0",
+            },
+        ];
+
+        vi.mocked(fs.readFile).mockResolvedValue(
+            JSON.stringify({
+                name: "good-package",
+                bin: {
+                    "good-script": "./script.js",
+                },
+            }),
+        );
+
+        // Act
+        const matches = await findMatchingBins(packages, "good-script");
+
+        // Assert
+        expect(matches).toHaveLength(1);
+    });
+
+    it("should return empty array when package.json contains invalid JSON", async () => {
+        // Arrange
+        const packages: PackageInfo[] = [
+            {
+                name: "invalid-json-pkg",
+                path: "/test/path",
+                version: "1.0.0",
+            },
+        ];
+
+        vi.mocked(fs.readFile).mockResolvedValue("{ this is not valid json");
+
+        // Act
+        const matches = await findMatchingBins(packages, "invalid-json-pkg");
+
+        // Assert
+        expect(matches).toHaveLength(0);
+    });
+
+    it("should warn when package.json contains invalid JSON", async () => {
+        // Arrange
+        const packages: PackageInfo[] = [
+            {
+                name: "invalid-json-pkg",
+                path: "/test/path",
+                version: "1.0.0",
+            },
+        ];
+
+        vi.mocked(fs.readFile).mockResolvedValue("{ this is not valid json");
+
+        // Act
+        await findMatchingBins(packages, "invalid-json-pkg");
+
+        // Assert
+        expect(console.warn).toHaveBeenCalledWith(
+            expect.stringContaining("invalid JSON"),
+        );
+    });
+
+    it("should return empty array when package.json file is not found", async () => {
+        // Arrange
+        const packages: PackageInfo[] = [
+            {
+                name: "missing-pkg",
+                path: "/test/path",
+                version: "1.0.0",
+            },
+        ];
+
+        const enoentError = Object.assign(
+            new Error("ENOENT: no such file or directory"),
+            {code: "ENOENT"},
+        );
+        vi.mocked(fs.readFile).mockRejectedValue(enoentError);
+
+        // Act
+        const matches = await findMatchingBins(packages, "missing-pkg");
+
+        // Assert
+        expect(matches).toHaveLength(0);
+    });
+
+    it("should not warn when package.json file is not found", async () => {
+        // Arrange
+        const packages: PackageInfo[] = [
+            {
+                name: "missing-pkg",
+                path: "/test/path",
+                version: "1.0.0",
+            },
+        ];
+
+        const enoentError = Object.assign(
+            new Error("ENOENT: no such file or directory"),
+            {code: "ENOENT"},
+        );
+        vi.mocked(fs.readFile).mockRejectedValue(enoentError);
+
+        // Act
+        await findMatchingBins(packages, "missing-pkg");
+
+        // Assert
+        expect(console.warn).not.toHaveBeenCalled();
+    });
+});

package/src/__tests__/find-workspace-root.test.ts

@@ -0,0 +1,73 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import {afterEach, beforeEach, describe, expect, it} from "vitest";
+import {HandledError} from "../errors";
+import {findWorkspaceRoot} from "../find-workspace-root";
+
+describe("findWorkspaceRoot", () => {
+    const testDir = path.join("/tmp", "test-workspace-root");
+    const workspaceDir = path.join(testDir, "workspace");
+    const nestedDir = path.join(workspaceDir, "nested", "deep");
+
+    beforeEach(async () => {
+        // Create test directory structure
+        await fs.mkdir(nestedDir, {recursive: true});
+        await fs.writeFile(
+            path.join(workspaceDir, "pnpm-workspace.yaml"),
+            "packages:\n  - 'packages/*'\n",
+        );
+    });
+
+    afterEach(async () => {
+        // Clean up
+        await fs.rm(testDir, {recursive: true, force: true});
+    });
+
+    it("should find workspace root from nested directory", async () => {
+        // Arrange
+        const searchDir = nestedDir;
+
+        // Act
+        const result = await findWorkspaceRoot(searchDir);
+
+        // Assert
+        expect(result).toBe(workspaceDir);
+    });
+
+    it("should find workspace root from workspace directory itself", async () => {
+        // Arrange
+        const searchDir = workspaceDir;
+
+        // Act
+        const result = await findWorkspaceRoot(searchDir);
+
+        // Assert
+        expect(result).toBe(workspaceDir);
+    });
+
+    it("should throw HandledError when not in a workspace", async () => {
+        // Arrange
+        const nonWorkspaceDir = path.join(testDir, "non-workspace");
+        await fs.mkdir(nonWorkspaceDir, {recursive: true});
+
+        // Act
+        const underTest = () => findWorkspaceRoot(nonWorkspaceDir);
+
+        // Assert
+        await expect(underTest).rejects.toThrow(HandledError);
+    });
+
+    it("should provide meaningful error message when not in a workspace", async () => {
+        // Arrange
+        const nonWorkspaceDir = path.join(testDir, "non-workspace");
+        await fs.mkdir(nonWorkspaceDir, {recursive: true});
+
+        // Act
+        const underTest = () => findWorkspaceRoot(nonWorkspaceDir);
+
+        // Assert
+        await expect(underTest).rejects.toThrow(
+            "Could not find workspace root",
+        );
+    });
+});

package/src/__tests__/is-node-executable.test.ts

@@ -0,0 +1,125 @@
+import {describe, expect, it} from "vitest";
+import {isNodeExecutable} from "../is-node-executable";
+
+describe("isNodeExecutable", () => {
+    it("should return true for .js files", () => {
+        // Arrange
+        const binPath = "/path/to/script.js";
+
+        // Act
+        const result = isNodeExecutable(binPath);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    it("should return true for .mjs files", () => {
+        // Arrange
+        const binPath = "/path/to/script.mjs";
+
+        // Act
+        const result = isNodeExecutable(binPath);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    it("should return true for .cjs files", () => {
+        // Arrange
+        const binPath = "/path/to/script.cjs";
+
+        // Act
+        const result = isNodeExecutable(binPath);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    it("should return true for .JS files (case-insensitive)", () => {
+        // Arrange
+        const binPath = "/path/to/script.JS";
+
+        // Act
+        const result = isNodeExecutable(binPath);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    it("should return true for .Js files (case-insensitive)", () => {
+        // Arrange
+        const binPath = "/path/to/script.Js";
+
+        // Act
+        const result = isNodeExecutable(binPath);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    it("should return true for .MJS files (case-insensitive)", () => {
+        // Arrange
+        const binPath = "/path/to/script.MJS";
+
+        // Act
+        const result = isNodeExecutable(binPath);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    it("should return true for .CJS files (case-insensitive)", () => {
+        // Arrange
+        const binPath = "/path/to/script.CJS";
+
+        // Act
+        const result = isNodeExecutable(binPath);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    it("should return true for .Mjs files (case-insensitive)", () => {
+        // Arrange
+        const binPath = "/path/to/script.Mjs";
+
+        // Act
+        const result = isNodeExecutable(binPath);
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    it("should return false for files with no extension", () => {
+        // Arrange
+        const binPath = "/path/to/script";
+
+        // Act
+        const result = isNodeExecutable(binPath);
+
+        // Assert
+        expect(result).toBe(false);
+    });
+
+    it("should return false for .sh files", () => {
+        // Arrange
+        const binPath = "/path/to/script.sh";
+
+        // Act
+        const result = isNodeExecutable(binPath);
+
+        // Assert
+        expect(result).toBe(false);
+    });
+
+    it("should return false for files with .js in the middle (e.g. script.js.bak)", () => {
+        // Arrange
+        const binPath = "/path/to/script.js.bak";
+
+        // Act
+        const result = isNodeExecutable(binPath);
+
+        // Assert
+        expect(result).toBe(false);
+    });
+});