@simplysm/sd-cli 13.0.68 → 13.0.70

package/tests/infra/ResultCollector.spec.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect } from "vitest";
+import { ResultCollector, type BuildResult } from "../../src/infra/ResultCollector";
+
+describe("ResultCollector", () => {
+  it("adds and retrieves result", () => {
+    const collector = new ResultCollector();
+    const result: BuildResult = {
+      name: "core-common",
+      target: "neutral",
+      type: "build",
+      status: "success",
+    };
+
+    collector.add(result);
+
+    expect(collector.get("core-common:build")).toEqual(result);
+  });
+
+  it("overwrites result when added with same key", () => {
+    const collector = new ResultCollector();
+    collector.add({ name: "pkg1", target: "node", type: "build", status: "pending" });
+    collector.add({ name: "pkg1", target: "node", type: "build", status: "success" });
+
+    const result = collector.get("pkg1:build");
+
+    expect(result?.status).toBe("success");
+    expect(collector.toMap().size).toBe(1);
+  });
+
+  it("returns internal Map", () => {
+    const collector = new ResultCollector();
+    collector.add({ name: "pkg1", target: "node", type: "build", status: "success" });
+
+    const map = collector.toMap();
+
+    expect(map).toBeInstanceOf(Map);
+    expect(map.size).toBe(1);
+  });
+});

package/tests/infra/SignalHandler.spec.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { SignalHandler } from "../../src/infra/SignalHandler";
+
+describe("SignalHandler", () => {
+  afterEach(() => {
+    // Clean up process listeners between tests
+    process.removeAllListeners("SIGINT");
+    process.removeAllListeners("SIGTERM");
+  });
+
+  it("resolves waitForTermination when termination is requested", async () => {
+    const handler = new SignalHandler();
+
+    // Request termination asynchronously
+    setTimeout(() => handler.requestTermination(), 10);
+
+    await expect(handler.waitForTermination()).resolves.toBeUndefined();
+  });
+
+  it("returns termination status correctly", () => {
+    const handler = new SignalHandler();
+
+    expect(handler.isTerminated()).toBe(false);
+
+    handler.requestTermination();
+
+    expect(handler.isTerminated()).toBe(true);
+  });
+
+  it("ignores duplicate termination requests", () => {
+    const handler = new SignalHandler();
+
+    handler.requestTermination();
+    handler.requestTermination(); // Second call is ignored
+
+    expect(handler.isTerminated()).toBe(true);
+  });
+});

package/tests/infra/WorkerManager.spec.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { WorkerManager } from "../../src/infra/WorkerManager";
+
+// Worker 모킹
+vi.mock("@simplysm/core-node", () => ({
+  Worker: {
+    create: vi.fn(() => ({
+      on: vi.fn(),
+      off: vi.fn(),
+      terminate: vi.fn().mockResolvedValue(undefined),
+    })),
+  },
+}));
+
+describe("WorkerManager", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("creates a Worker and retrieves it by ID", () => {
+    const manager = new WorkerManager();
+
+    const worker = manager.create("test-worker", "/path/to/worker.ts");
+
+    expect(worker).toBeDefined();
+    expect(manager.get("test-worker")).toBe(worker);
+  });
+
+  it("returns undefined when retrieving a non-existent Worker", () => {
+    const manager = new WorkerManager();
+
+    expect(manager.get("nonexistent")).toBeUndefined();
+  });
+
+  it("terminates all Workers", async () => {
+    const manager = new WorkerManager();
+    const worker1 = manager.create("worker1", "/path/to/worker.ts");
+    const worker2 = manager.create("worker2", "/path/to/worker.ts");
+
+    await manager.terminateAll();
+
+    expect(worker1.terminate).toHaveBeenCalled();
+    expect(worker2.terminate).toHaveBeenCalled();
+    expect(manager.size).toBe(0);
+  });
+
+  it("terminates a specific Worker only", async () => {
+    const manager = new WorkerManager();
+    const worker1 = manager.create("worker1", "/path/to/worker.ts");
+    const worker2 = manager.create("worker2", "/path/to/worker.ts");
+
+    await manager.terminate("worker1");
+
+    expect(worker1.terminate).toHaveBeenCalled();
+    expect(worker2.terminate).not.toHaveBeenCalled();
+    expect(manager.get("worker1")).toBeUndefined();
+    expect(manager.get("worker2")).toBe(worker2);
+  });
+
+  it("handles terminating a non-existent Worker without error", async () => {
+    const manager = new WorkerManager();
+
+    await expect(manager.terminate("nonexistent")).resolves.toBeUndefined();
+  });
+
+  it("retrieves the count of managed Workers", () => {
+    const manager = new WorkerManager();
+
+    expect(manager.size).toBe(0);
+
+    manager.create("worker1", "/path/to/worker.ts");
+    expect(manager.size).toBe(1);
+
+    manager.create("worker2", "/path/to/worker.ts");
+    expect(manager.size).toBe(2);
+  });
+
+  it("retrieves list of all Worker IDs", () => {
+    const manager = new WorkerManager();
+    manager.create("worker1", "/path/to/worker.ts");
+    manager.create("worker2", "/path/to/worker.ts");
+
+    const ids = manager.ids;
+
+    expect(ids).toEqual(["worker1", "worker2"]);
+  });
+
+  it("overwrites existing Worker when creating with the same ID", () => {
+    const manager = new WorkerManager();
+    const worker1 = manager.create("same-id", "/path/to/worker1.ts");
+    const worker2 = manager.create("same-id", "/path/to/worker2.ts");
+
+    expect(manager.get("same-id")).toBe(worker2);
+    expect(manager.get("same-id")).not.toBe(worker1);
+    expect(manager.size).toBe(1);
+  });
+});

package/tests/load-ignore-patterns.spec.ts

@@ -0,0 +1,188 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+import { loadIgnorePatterns } from "../src/commands/lint";
+import path from "path";
+
+// Mock core-node functions and jiti
+vi.mock("@simplysm/core-node", () => ({
+  fsExists: vi.fn(),
+  pathPosix: vi.fn(),
+}));
+
+const mockJitiImportFn = vi.fn();
+vi.mock("jiti", () => ({
+  createJiti: vi.fn(() => ({
+    import: mockJitiImportFn,
+  })),
+}));
+
+import { fsExists } from "@simplysm/core-node";
+
+describe("loadIgnorePatterns", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("extracts globalIgnores pattern from eslint.config.ts", async () => {
+    const cwd = "/project";
+    const mockExists = vi.mocked(fsExists);
+
+    mockExists.mockImplementation((filePath: string) => {
+      return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
+    });
+
+    mockJitiImportFn.mockResolvedValue({
+      default: [{ ignores: ["node_modules/**", "dist/**"] }, { files: ["**/*.ts"], rules: {} }],
+    });
+
+    const patterns = await loadIgnorePatterns(cwd);
+
+    expect(patterns).toEqual(["node_modules/**", "dist/**"]);
+  });
+
+  it("does not extract as globalIgnores if files is present", async () => {
+    const cwd = "/project";
+    const mockExists = vi.mocked(fsExists);
+
+    mockExists.mockImplementation((filePath: string) => {
+      return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
+    });
+
+    mockJitiImportFn.mockResolvedValue({
+      default: [
+        { ignores: ["global/**"] },
+        { files: ["**/*.ts"], ignores: ["local/**"], rules: {} },
+      ],
+    });
+
+    const patterns = await loadIgnorePatterns(cwd);
+
+    expect(patterns).toEqual(["global/**"]);
+    expect(patterns).not.toContain("local/**");
+  });
+
+  it("throws error if config file not found", async () => {
+    const cwd = "/project";
+    const mockExists = vi.mocked(fsExists);
+
+    mockExists.mockResolvedValue(false);
+
+    await expect(loadIgnorePatterns(cwd)).rejects.toThrow("Cannot find ESLint config file");
+  });
+
+  it("throws error if config is not array", async () => {
+    const cwd = "/project";
+    const mockExists = vi.mocked(fsExists);
+
+    mockExists.mockImplementation((filePath: string) => {
+      return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
+    });
+
+    mockJitiImportFn.mockResolvedValue({
+      default: { rules: {} },
+    });
+
+    await expect(loadIgnorePatterns(cwd)).rejects.toThrow("ESLint config is not an array");
+  });
+
+  it("merges multiple globalIgnores settings", async () => {
+    const cwd = "/project";
+    const mockExists = vi.mocked(fsExists);
+
+    mockExists.mockImplementation((filePath: string) => {
+      return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
+    });
+
+    mockJitiImportFn.mockResolvedValue({
+      default: [{ ignores: ["node_modules/**"] }, { ignores: ["dist/**", ".cache/**"] }],
+    });
+
+    const patterns = await loadIgnorePatterns(cwd);
+
+    expect(patterns).toEqual(["node_modules/**", "dist/**", ".cache/**"]);
+  });
+
+  it("handles config that directly exports array", async () => {
+    const cwd = "/project";
+    const mockExists = vi.mocked(fsExists);
+
+    mockExists.mockImplementation((filePath: string) => {
+      return Promise.resolve(filePath === path.join(cwd, "eslint.config.js"));
+    });
+
+    mockJitiImportFn.mockResolvedValue([{ ignores: ["build/**"] }]);
+
+    const patterns = await loadIgnorePatterns(cwd);
+
+    expect(patterns).toEqual(["build/**"]);
+  });
+
+  it("throws error if config has no default and is not array", async () => {
+    const cwd = "/project";
+    const mockExists = vi.mocked(fsExists);
+
+    mockExists.mockImplementation((filePath: string) => {
+      return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
+    });
+
+    mockJitiImportFn.mockResolvedValue({
+      config: [{ ignores: ["test/**"] }],
+    });
+
+    await expect(loadIgnorePatterns(cwd)).rejects.toThrow(
+      /ESLint config file is not .* format/,
+    );
+  });
+
+  it("uses mts file if eslint.config.ts not found", async () => {
+    const cwd = "/project";
+    const mockExists = vi.mocked(fsExists);
+
+    mockExists.mockImplementation((filePath: string) => {
+      // eslint.config.ts does not exist, only eslint.config.mts
+      return Promise.resolve(filePath === path.join(cwd, "eslint.config.mts"));
+    });
+
+    mockJitiImportFn.mockResolvedValue({
+      default: [{ ignores: ["mts-ignore/**"] }],
+    });
+
+    const patterns = await loadIgnorePatterns(cwd);
+
+    expect(patterns).toEqual(["mts-ignore/**"]);
+    expect(mockJitiImportFn).toHaveBeenCalledWith(expect.stringContaining("eslint.config.mts"));
+  });
+
+  it("returns empty pattern array if empty array exported", async () => {
+    const cwd = "/project";
+    const mockExists = vi.mocked(fsExists);
+
+    mockExists.mockImplementation((filePath: string) => {
+      return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
+    });
+
+    mockJitiImportFn.mockResolvedValue({
+      default: [],
+    });
+
+    const patterns = await loadIgnorePatterns(cwd);
+
+    expect(patterns).toEqual([]);
+  });
+
+  it("propagates error if jiti import fails", async () => {
+    const cwd = "/project";
+    const mockExists = vi.mocked(fsExists);
+
+    mockExists.mockImplementation((filePath: string) => {
+      return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
+    });
+
+    mockJitiImportFn.mockRejectedValue(new Error("Syntax error in config file"));
+
+    await expect(loadIgnorePatterns(cwd)).rejects.toThrow("Syntax error in config file");
+  });
+});

package/tests/load-sd-config.spec.ts

@@ -0,0 +1,137 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+
+const mockJitiImport = vi.fn();
+
+vi.mock("@simplysm/core-node", () => ({
+  fsExists: vi.fn(),
+}));
+
+vi.mock("jiti", () => ({
+  createJiti: vi.fn(() => ({
+    import: mockJitiImport,
+  })),
+}));
+
+import { fsExists } from "@simplysm/core-node";
+import { loadSdConfig } from "../src/utils/sd-config";
+
+describe("loadSdConfig", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("throws error if sd.config.ts file not found", async () => {
+    vi.mocked(fsExists).mockResolvedValue(false);
+
+    await expect(loadSdConfig({ cwd: "/project", dev: false, opt: [] })).rejects.toThrow(
+      "sd.config.ts file not found",
+    );
+  });
+
+  it("throws error if no default export", async () => {
+    vi.mocked(fsExists).mockResolvedValue(true);
+    mockJitiImport.mockResolvedValue({
+      someOtherExport: () => ({}),
+    });
+
+    await expect(loadSdConfig({ cwd: "/project", dev: false, opt: [] })).rejects.toThrow(
+      "sd.config.ts must export a function as default",
+    );
+  });
+
+  it("throws error if default export is not function", async () => {
+    vi.mocked(fsExists).mockResolvedValue(true);
+    mockJitiImport.mockResolvedValue({
+      default: { packages: {} }, // object not function
+    });
+
+    await expect(loadSdConfig({ cwd: "/project", dev: false, opt: [] })).rejects.toThrow(
+      "sd.config.ts must export a function as default",
+    );
+  });
+
+  it("throws error if return value is wrong format (missing packages)", async () => {
+    vi.mocked(fsExists).mockResolvedValue(true);
+    mockJitiImport.mockResolvedValue({
+      default: () => ({}), // missing packages property
+    });
+
+    await expect(loadSdConfig({ cwd: "/project", dev: false, opt: [] })).rejects.toThrow(
+      /sd\.config\.ts return value is not in .* correct format/,
+    );
+  });
+
+  it("throws error if return value is wrong format (packages is array)", async () => {
+    vi.mocked(fsExists).mockResolvedValue(true);
+    mockJitiImport.mockResolvedValue({
+      default: () => ({ packages: [] }), // packages is array
+    });
+
+    await expect(loadSdConfig({ cwd: "/project", dev: false, opt: [] })).rejects.toThrow(
+      /sd\.config\.ts return value is not in .* correct format/,
+    );
+  });
+
+  it("throws error if return value is wrong format (packages is null)", async () => {
+    vi.mocked(fsExists).mockResolvedValue(true);
+    mockJitiImport.mockResolvedValue({
+      default: () => ({ packages: null }),
+    });
+
+    await expect(loadSdConfig({ cwd: "/project", dev: false, opt: [] })).rejects.toThrow(
+      /sd\.config\.ts return value is not in .* correct format/,
+    );
+  });
+
+  it("returns correct config", async () => {
+    vi.mocked(fsExists).mockResolvedValue(true);
+    mockJitiImport.mockResolvedValue({
+      default: () => ({
+        packages: {
+          "core-common": { target: "neutral" },
+          "core-node": { target: "node" },
+        },
+      }),
+    });
+
+    const config = await loadSdConfig({ cwd: "/project", dev: false, opt: [] });
+
+    expect(config.packages).toEqual({
+      "core-common": { target: "neutral" },
+      "core-node": { target: "node" },
+    });
+  });
+
+  it("empty packages object is valid", async () => {
+    vi.mocked(fsExists).mockResolvedValue(true);
+    mockJitiImport.mockResolvedValue({
+      default: () => ({ packages: {} }),
+    });
+
+    const config = await loadSdConfig({ cwd: "/project", dev: false, opt: [] });
+
+    expect(config.packages).toEqual({});
+  });
+
+  it("handles async function default export correctly", async () => {
+    vi.mocked(fsExists).mockResolvedValue(true);
+    mockJitiImport.mockResolvedValue({
+      // eslint-disable-next-line @typescript-eslint/require-await
+      default: async () => ({
+        packages: {
+          "core-common": { target: "neutral" },
+        },
+      }),
+    });
+
+    const config = await loadSdConfig({ cwd: "/project", dev: false, opt: [] });
+
+    expect(config.packages).toEqual({
+      "core-common": { target: "neutral" },
+    });
+  });
+});

package/tests/package-utils.spec.ts

@@ -0,0 +1,188 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { collectDeps } from "../src/utils/package-utils";
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+describe("collectDeps", () => {
+  let tmpDir: string;
+
+  function writePkgJson(dir: string, content: object): void {
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify(content));
+  }
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "collectDeps-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("collects workspace direct dependencies", () => {
+    // root package.json with scope
+    writePkgJson(tmpDir, { name: "@myapp/root" });
+
+    // workspace package: packages/core
+    writePkgJson(path.join(tmpDir, "packages", "core"), {
+      name: "@myapp/core",
+    });
+
+    // target package that depends on @myapp/core
+    const pkgDir = path.join(tmpDir, "packages", "app");
+    writePkgJson(pkgDir, {
+      name: "@myapp/app",
+      dependencies: { "@myapp/core": "workspace:*" },
+    });
+
+    const result = collectDeps(pkgDir, tmpDir);
+    expect(result.workspaceDeps).toEqual(["core"]);
+    expect(result.replaceDeps).toEqual([]);
+  });
+
+  it("collects workspace transitive dependencies", () => {
+    writePkgJson(tmpDir, { name: "@myapp/root" });
+
+    // packages/utils (no deps)
+    writePkgJson(path.join(tmpDir, "packages", "utils"), {
+      name: "@myapp/utils",
+    });
+
+    // packages/core depends on @myapp/utils
+    writePkgJson(path.join(tmpDir, "packages", "core"), {
+      name: "@myapp/core",
+      dependencies: { "@myapp/utils": "workspace:*" },
+    });
+
+    // packages/app depends on @myapp/core
+    const pkgDir = path.join(tmpDir, "packages", "app");
+    writePkgJson(pkgDir, {
+      name: "@myapp/app",
+      dependencies: { "@myapp/core": "workspace:*" },
+    });
+
+    const result = collectDeps(pkgDir, tmpDir);
+    expect(result.workspaceDeps).toContain("core");
+    expect(result.workspaceDeps).toContain("utils");
+    expect(result.replaceDeps).toEqual([]);
+  });
+
+  it("handles replaceDeps glob pattern matching", () => {
+    writePkgJson(tmpDir, { name: "@myapp/root" });
+
+    const pkgDir = path.join(tmpDir, "packages", "app");
+    writePkgJson(pkgDir, {
+      name: "@myapp/app",
+      dependencies: { "@external/lib-a": "^1.0.0" },
+    });
+
+    const result = collectDeps(pkgDir, tmpDir, { "@external/*": "../external/packages/*" });
+    expect(result.replaceDeps).toEqual(["@external/lib-a"]);
+    expect(result.workspaceDeps).toEqual([]);
+  });
+
+  it("handles workspace to replaceDeps transitive tracking", () => {
+    writePkgJson(tmpDir, { name: "@myapp/root" });
+
+    // packages/core depends on @external/lib-a
+    writePkgJson(path.join(tmpDir, "packages", "core"), {
+      name: "@myapp/core",
+      dependencies: { "@external/lib-a": "^1.0.0" },
+    });
+
+    const pkgDir = path.join(tmpDir, "packages", "app");
+    writePkgJson(pkgDir, {
+      name: "@myapp/app",
+      dependencies: { "@myapp/core": "workspace:*" },
+    });
+
+    const result = collectDeps(pkgDir, tmpDir, { "@external/*": "../external/packages/*" });
+    expect(result.workspaceDeps).toEqual(["core"]);
+    expect(result.replaceDeps).toEqual(["@external/lib-a"]);
+  });
+
+  it("handles replaceDeps to replaceDeps transitive tracking", () => {
+    writePkgJson(tmpDir, { name: "@myapp/root" });
+
+    // node_modules/@external/lib-a depends on @external/lib-b
+    writePkgJson(path.join(tmpDir, "node_modules", "@external", "lib-a"), {
+      name: "@external/lib-a",
+      dependencies: { "@external/lib-b": "^1.0.0" },
+    });
+
+    // node_modules/@external/lib-b exists
+    writePkgJson(path.join(tmpDir, "node_modules", "@external", "lib-b"), {
+      name: "@external/lib-b",
+    });
+
+    const pkgDir = path.join(tmpDir, "packages", "app");
+    writePkgJson(pkgDir, {
+      name: "@myapp/app",
+      dependencies: { "@external/lib-a": "^1.0.0" },
+    });
+
+    const result = collectDeps(pkgDir, tmpDir, { "@external/*": "../external/packages/*" });
+    expect(result.replaceDeps).toContain("@external/lib-a");
+    expect(result.replaceDeps).toContain("@external/lib-b");
+  });
+
+  it("prevents infinite loop in circular dependency (visited set)", () => {
+    writePkgJson(tmpDir, { name: "@myapp/root" });
+
+    // packages/a depends on @myapp/b
+    writePkgJson(path.join(tmpDir, "packages", "a"), {
+      name: "@myapp/a",
+      dependencies: { "@myapp/b": "workspace:*" },
+    });
+
+    // packages/b depends on @myapp/a (circular)
+    writePkgJson(path.join(tmpDir, "packages", "b"), {
+      name: "@myapp/b",
+      dependencies: { "@myapp/a": "workspace:*" },
+    });
+
+    const pkgDir = path.join(tmpDir, "packages", "a");
+    const result = collectDeps(pkgDir, tmpDir);
+    expect(result.workspaceDeps).toContain("b");
+    // Should not infinite loop - a is already visited
+  });
+
+  it("handles replaceDeps exact pattern matching", () => {
+    writePkgJson(tmpDir, { name: "@myapp/root" });
+
+    const pkgDir = path.join(tmpDir, "packages", "app");
+    writePkgJson(pkgDir, {
+      name: "@myapp/app",
+      dependencies: {
+        "exact-pkg": "^1.0.0",
+        "exact-pkg-extra": "^1.0.0",
+      },
+    });
+
+    const result = collectDeps(pkgDir, tmpDir, { "exact-pkg": "../exact-pkg" });
+    expect(result.replaceDeps).toEqual(["exact-pkg"]);
+  });
+
+  it("ignores external packages", () => {
+    writePkgJson(tmpDir, { name: "@myapp/root" });
+
+    const pkgDir = path.join(tmpDir, "packages", "app");
+    writePkgJson(pkgDir, {
+      name: "@myapp/app",
+      dependencies: {
+        "lodash": "^4.0.0",
+        "express": "^4.0.0",
+        "@myapp/core": "workspace:*",
+      },
+    });
+
+    writePkgJson(path.join(tmpDir, "packages", "core"), {
+      name: "@myapp/core",
+    });
+
+    const result = collectDeps(pkgDir, tmpDir);
+    expect(result.workspaceDeps).toEqual(["core"]);
+    expect(result.replaceDeps).toEqual([]);
+  });
+});