@simplysm/sd-cli 13.0.99 → 14.0.1

package/tests/sd-cli-entry.spec.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect } from "vitest";
+
+describe("sd-cli-entry COMMAND_NAMES", () => {
+  it("does not include device command", async () => {
+    // Import the module to check COMMAND_NAMES indirectly via createCliParser
+    const { createCliParser } = await import("../src/sd-cli-entry");
+
+    // device command should not be registered — parsing "device" should fail
+    let errorThrown = false;
+    const origExit = process.exit;
+    const origError = console.error;
+    const origLog = console.log;
+
+    // Suppress yargs output during test
+    console.error = () => {};
+    console.log = () => {};
+    process.exit = (() => {
+      errorThrown = true;
+    }) as never;
+
+    try {
+      await createCliParser(["device"]).exitProcess(false).fail(() => {
+        errorThrown = true;
+      }).parse();
+    } catch {
+      errorThrown = true;
+    } finally {
+      process.exit = origExit;
+      console.error = origError;
+      console.log = origLog;
+    }
+
+    expect(errorThrown).toBe(true);
+  });
+
+  it("includes expected commands", async () => {
+    const { createCliParser } = await import("../src/sd-cli-entry");
+
+    // These commands should be registered without throwing
+    const expectedCommands = ["lint", "typecheck", "check", "watch", "dev", "build", "init", "publish", "replace-deps"];
+
+    for (const cmd of expectedCommands) {
+      // Verify command exists by checking help doesn't throw for "unknown command"
+      const parser = createCliParser([cmd, "--help"]).exitProcess(false);
+      // Just verify it can be created without error
+      expect(parser).toBeDefined();
+    }
+  });
+});

package/tests/utils/angular-build.spec.ts

@@ -0,0 +1,251 @@
+import { describe, it, expect, vi, beforeAll } from "vitest";
+import fs from "node:fs";
+import path from "node:path";
+import {
+  buildApplicationInternal,
+  createAngularBuilderContext,
+  ResultKind,
+} from "../../src/utils/angular-build";
+
+describe("Angular Build Adapter - Slice 1", () => {
+  // Rule: 어댑터는 @angular/build/private 임포트를 단일 모듈에 격리한다
+  it("exports buildApplicationInternal from adapter module", () => {
+    expect(typeof buildApplicationInternal).toBe("function");
+  });
+
+  it("exports ResultKind enum from adapter module", () => {
+    expect(ResultKind.Failure).toBeDefined();
+    expect(ResultKind.Full).toBeDefined();
+    expect(ResultKind.Incremental).toBeDefined();
+    expect(ResultKind.ComponentUpdate).toBeDefined();
+  });
+
+  // Rule: 어댑터는 BuilderContext를 내부적으로 생성한다
+  describe("createAngularBuilderContext", () => {
+    const baseOptions = {
+      workspaceRoot: "/test/workspace",
+      projectName: "test-app",
+      projectRoot: "packages/test-app",
+      buildOptions: { tsConfig: "./tsconfig.json", aot: true },
+    };
+
+    it("creates context with workspaceRoot", () => {
+      const ctx = createAngularBuilderContext(baseOptions);
+      expect(ctx.workspaceRoot).toBe("/test/workspace");
+    });
+
+    it("creates context with target containing project name", () => {
+      const ctx = createAngularBuilderContext(baseOptions);
+      expect(ctx.target.project).toBe("test-app");
+    });
+
+    it("creates context with logger that has info/warn/error methods", () => {
+      const ctx = createAngularBuilderContext(baseOptions);
+      expect(typeof ctx.logger.info).toBe("function");
+      expect(typeof ctx.logger.warn).toBe("function");
+      expect(typeof ctx.logger.error).toBe("function");
+    });
+
+    it("getProjectMetadata returns root and sourceRoot", async () => {
+      const ctx = createAngularBuilderContext(baseOptions);
+      const metadata = await ctx.getProjectMetadata("test-app");
+      expect(metadata).toEqual(
+        expect.objectContaining({
+          root: "packages/test-app",
+          sourceRoot: "src",
+        }),
+      );
+    });
+
+    it("getProjectMetadata uses custom sourceRoot when provided", async () => {
+      const ctx = createAngularBuilderContext({
+        ...baseOptions,
+        sourceRoot: "lib",
+      });
+      const metadata = await ctx.getProjectMetadata("test-app");
+      expect(metadata).toEqual(
+        expect.objectContaining({
+          root: "packages/test-app",
+          sourceRoot: "lib",
+        }),
+      );
+    });
+
+    it("addTeardown registers cleanup callback and disposeTeardowns executes them", async () => {
+      const ctx = createAngularBuilderContext(baseOptions);
+      const teardownFn1 = vi.fn();
+      const teardownFn2 = vi.fn();
+      ctx.addTeardown(teardownFn1);
+      ctx.addTeardown(teardownFn2);
+
+      expect(teardownFn1).not.toHaveBeenCalled();
+      expect(teardownFn2).not.toHaveBeenCalled();
+
+      await ctx.disposeTeardowns();
+
+      expect(teardownFn1).toHaveBeenCalledOnce();
+      expect(teardownFn2).toHaveBeenCalledOnce();
+    });
+
+    it("passes signal to context when provided", () => {
+      const controller = new AbortController();
+      const ctx = createAngularBuilderContext({
+        ...baseOptions,
+        signal: controller.signal as AbortSignal,
+      }) as { signal?: AbortSignal };
+      expect(ctx.signal).toBe(controller.signal);
+    });
+  });
+
+  // Rule: 어댑터는 AOT 전용이다
+  it("exports checkPort utility from adapter module", async () => {
+    const { checkPort } = await import("../../src/utils/angular-build");
+    expect(typeof checkPort).toBe("function");
+  });
+
+  it("exports emitFilesToDisk utility from adapter module", async () => {
+    const { emitFilesToDisk } = await import("../../src/utils/angular-build");
+    expect(typeof emitFilesToDisk).toBe("function");
+  });
+});
+
+describe("Angular Build Adapter - Library Compilation API", () => {
+  // Rule: 어댑터는 Library 빌드에 필요한 Angular 컴파일러 API를 노출한다
+
+  it("exports NgtscProgram from adapter module", async () => {
+    const { NgtscProgram } = await import("../../src/utils/angular-build");
+    expect(typeof NgtscProgram).toBe("function");
+  });
+
+  it("exports OptimizeFor enum from adapter module", async () => {
+    const { OptimizeFor } = await import("../../src/utils/angular-build");
+    expect(OptimizeFor.WholeProgram).toBeDefined();
+    expect(OptimizeFor.SingleFile).toBeDefined();
+  });
+
+  it("NgtscProgram accepts ts.CompilerHost augmented with AngularLibraryHostExtensions", async () => {
+    const mod = await import("../../src/utils/angular-build");
+    // AngularLibraryHostExtensions는 타입 전용이므로 런타임 값은 없다.
+    // NgtscProgram이 export되어 있으면 소비자가 타입을 조합하여 host를 만들 수 있다.
+    expect(typeof mod.NgtscProgram).toBe("function");
+    // 타입 검증: AngularLibraryHostExtensions가 export되는지는 TypeScript 컴파일로 확인
+  });
+});
+
+describe("Angular Build Adapter - Slice 2", () => {
+  // Rule: 어댑터는 Dev Server API를 제공한다
+  it("exports serveWithVite from adapter module", async () => {
+    const { serveWithVite } = await import("../../src/utils/angular-build");
+    expect(typeof serveWithVite).toBe("function");
+  });
+
+  it("exports normalizeDevServerOptions from adapter module", async () => {
+    const { normalizeDevServerOptions } = await import("../../src/utils/angular-build");
+    expect(typeof normalizeDevServerOptions).toBe("function");
+  });
+
+  // Rule: 어댑터는 IndexHtmlGenerator를 제공한다
+  it("exports IndexHtmlGenerator from adapter module", async () => {
+    const { IndexHtmlGenerator } = await import("../../src/utils/angular-build");
+    expect(typeof IndexHtmlGenerator).toBe("function");
+  });
+
+  // BuilderContext dev server 필드 테스트
+  describe("createAngularBuilderContext - dev server fields", () => {
+    const baseOptions = {
+      workspaceRoot: "/test/workspace",
+      projectName: "test-app",
+      projectRoot: "packages/test-app",
+      buildOptions: { tsConfig: "./tsconfig.json", aot: true, browser: "./src/main.ts" },
+    };
+
+    it("getTargetOptions returns provided buildOptions", async () => {
+      const ctx = createAngularBuilderContext(baseOptions);
+      const opts = await ctx.getTargetOptions({ project: "test-app", target: "build" });
+      expect(opts).toEqual(baseOptions.buildOptions);
+    });
+
+    it("getBuilderNameForTarget returns @angular/build:application", async () => {
+      const ctx = createAngularBuilderContext(baseOptions);
+      const name = await ctx.getBuilderNameForTarget({ project: "test-app", target: "build" });
+      expect(name).toBe("@angular/build:application");
+    });
+
+    it("validateOptions returns options as passthrough", async () => {
+      const ctx = createAngularBuilderContext(baseOptions);
+      const input = { tsConfig: "./tsconfig.json", aot: true };
+      const result = await ctx.validateOptions(input, "@angular/build:application");
+      expect(result).toEqual(input);
+    });
+  });
+});
+
+describe("Angular Build Adapter - Isolation & Scope", () => {
+  const sdCliSrcDir = path.resolve(import.meta.dirname, "../../src");
+  const adapterFileName = "angular-build.ts";
+  let srcFiles: string[];
+
+  beforeAll(() => {
+    const collectFiles = (dir: string): string[] => {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      return entries.flatMap((e) =>
+        e.isDirectory()
+          ? collectFiles(path.join(dir, e.name))
+          : e.name.endsWith(".ts")
+            ? [path.join(dir, e.name)]
+            : [],
+      );
+    };
+    srcFiles = collectFiles(sdCliSrcDir).filter(
+      (f) => !f.endsWith(adapterFileName),
+    );
+  });
+
+  // Rule: 모든 Angular private/internal API 접근은 어댑터 모듈을 통해서만 한다
+  it("no src file outside adapter imports @angular/build/private", () => {
+    for (const file of srcFiles) {
+      const content = fs.readFileSync(file, "utf-8");
+      expect(
+        content.includes("@angular/build/private"),
+        `${path.relative(sdCliSrcDir, file)} imports @angular/build/private directly`,
+      ).toBe(false);
+    }
+  });
+
+  it("no src file outside adapter imports @angular/compiler-cli", () => {
+    for (const file of srcFiles) {
+      const content = fs.readFileSync(file, "utf-8");
+      expect(
+        content.includes("@angular/compiler-cli"),
+        `${path.relative(sdCliSrcDir, file)} imports @angular/compiler-cli directly`,
+      ).toBe(false);
+    }
+  });
+
+  // Rule: @angular/compiler-cli는 sd-cli의 직접 의존성이다
+  it("package.json includes @angular/compiler-cli in dependencies", () => {
+    const pkgJson = JSON.parse(
+      fs.readFileSync(
+        path.resolve(import.meta.dirname, "../../package.json"),
+        "utf-8",
+      ),
+    );
+    expect(pkgJson.dependencies["@angular/compiler-cli"]).toBeDefined();
+  });
+
+  // Rule: 래핑 범위는 현재 필요한 API만 포함한다
+  it("adapter does not export browserslist/PostCSS APIs", async () => {
+    const mod = await import("../../src/utils/angular-build");
+    const exports = Object.keys(mod);
+    expect(exports).not.toContain("transformSupportedBrowsersToTargets");
+    expect(exports).not.toContain("getSupportedBrowsers");
+    expect(exports).not.toContain("loadPostcssConfiguration");
+  });
+
+  it("adapter does not export ServiceWorker/i18n APIs", async () => {
+    const mod = await import("../../src/utils/angular-build");
+    const exports = Object.keys(mod);
+    expect(exports).not.toContain("augmentAppWithServiceWorker");
+    expect(exports).not.toContain("createI18nOptions");
+  });
+});

package/tests/utils/build-env.spec.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { getVersion } from "../../src/utils/build-env";
+import path from "path";
+import fs from "fs/promises";
+import os from "os";
+
+describe("getVersion", () => {
+  const tmpDirs: string[] = [];
+
+  async function createTmpDir(pkgJson: Record<string, unknown>): Promise<string> {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "sd-cli-test-"));
+    tmpDirs.push(dir);
+    await fs.writeFile(path.join(dir, "package.json"), JSON.stringify(pkgJson));
+    return dir;
+  }
+
+  afterEach(async () => {
+    for (const dir of tmpDirs) {
+      await fs.rm(dir, { recursive: true, force: true });
+    }
+    tmpDirs.length = 0;
+  });
+
+  it("returns version from package.json", async () => {
+    const dir = await createTmpDir({ version: "14.0.0" });
+    expect(await getVersion(dir)).toBe("14.0.0");
+  });
+
+  it("returns '0.0.0' when version field is missing", async () => {
+    const dir = await createTmpDir({ name: "test-pkg" });
+    expect(await getVersion(dir)).toBe("0.0.0");
+  });
+});

package/tests/utils/concurrency.spec.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect } from "vitest";
+
+describe("runWithConcurrency", () => {
+  it("limits concurrent task execution to specified concurrency", async () => {
+    const { runWithConcurrency } = await import("../../src/utils/concurrency");
+
+    let activeTasks = 0;
+    let maxActiveTasks = 0;
+
+    const tasks = Array.from({ length: 10 }, () => async () => {
+      activeTasks++;
+      maxActiveTasks = Math.max(maxActiveTasks, activeTasks);
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      activeTasks--;
+      return "done";
+    });
+
+    const results = await runWithConcurrency(tasks, 3);
+
+    expect(maxActiveTasks).toBeLessThanOrEqual(3);
+    expect(results).toHaveLength(10);
+    expect(results.every((r) => r.status === "fulfilled")).toBe(true);
+  });
+
+  it("returns all results in order even when individual tasks fail", async () => {
+    const { runWithConcurrency } = await import("../../src/utils/concurrency");
+
+    const tasks = [
+      () => Promise.resolve("a"),
+      () => { throw new Error("fail"); },
+      () => Promise.resolve("c"),
+    ];
+
+    const results = await runWithConcurrency(tasks, 2);
+
+    expect(results).toHaveLength(3);
+    expect(results[0]).toEqual({ status: "fulfilled", value: "a" });
+    expect(results[1].status).toBe("rejected");
+    expect(results[2]).toEqual({ status: "fulfilled", value: "c" });
+  });
+
+  it("handles empty task list", async () => {
+    const { runWithConcurrency } = await import("../../src/utils/concurrency");
+
+    const results = await runWithConcurrency([], 3);
+    expect(results).toHaveLength(0);
+  });
+
+  it("works when concurrency exceeds task count", async () => {
+    const { runWithConcurrency } = await import("../../src/utils/concurrency");
+
+    const tasks = [() => Promise.resolve(1), () => Promise.resolve(2)];
+    const results = await runWithConcurrency(tasks, 10);
+
+    expect(results).toHaveLength(2);
+    expect(results.every((r) => r.status === "fulfilled")).toBe(true);
+  });
+});
+
+describe("getMaxConcurrency", () => {
+  it("returns at least 1", async () => {
+    const { getMaxConcurrency } = await import("../../src/utils/concurrency");
+    expect(getMaxConcurrency()).toBeGreaterThanOrEqual(1);
+  });
+});

package/tests/utils/copy-src.spec.ts

@@ -0,0 +1,144 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import path from "path";
+
+const mockOnChange = vi.fn();
+const mockWatcherClose = vi.fn();
+
+vi.mock("@simplysm/core-node", () => ({
+  fsx: {
+    glob: vi.fn(),
+    mkdir: vi.fn(),
+    copy: vi.fn(),
+    rm: vi.fn(),
+  },
+  FsWatcher: {
+    watch: vi.fn(() => Promise.resolve({
+      onChange: mockOnChange,
+      close: mockWatcherClose,
+    })),
+  },
+}));
+
+const { fsx, FsWatcher } = await import("@simplysm/core-node");
+const { copySrcFiles, watchCopySrcFiles } = await import("../../src/utils/copy-src");
+
+const pkgDir = path.resolve("/workspace/packages/my-pkg");
+const srcDir = path.join(pkgDir, "src");
+const distDir = path.join(pkgDir, "dist");
+
+describe("copySrcFiles", () => {
+  beforeEach(() => {
+    vi.mocked(fsx.glob).mockReset();
+    vi.mocked(fsx.mkdir).mockReset();
+    vi.mocked(fsx.copy).mockReset();
+    vi.mocked(fsx.mkdir).mockResolvedValue(undefined as any);
+    vi.mocked(fsx.copy).mockResolvedValue(undefined as any);
+  });
+
+  it("copies files matching glob patterns preserving relative paths", async () => {
+    vi.mocked(fsx.glob).mockResolvedValue([
+      path.join(srcDir, "styles", "app.css"),
+    ]);
+
+    await copySrcFiles(pkgDir, ["**/*.css"]);
+
+    expect(fsx.glob).toHaveBeenCalledWith("**/*.css", { cwd: srcDir, absolute: true });
+    expect(fsx.mkdir).toHaveBeenCalledWith(path.join(distDir, "styles"));
+    expect(fsx.copy).toHaveBeenCalledWith(
+      path.join(srcDir, "styles", "app.css"),
+      path.join(distDir, "styles", "app.css"),
+    );
+  });
+
+  it("handles multiple patterns", async () => {
+    vi.mocked(fsx.glob)
+      .mockResolvedValueOnce([path.join(srcDir, "a.css")])
+      .mockResolvedValueOnce([path.join(srcDir, "b.json")]);
+
+    await copySrcFiles(pkgDir, ["**/*.css", "**/*.json"]);
+
+    expect(fsx.glob).toHaveBeenCalledTimes(2);
+    expect(fsx.copy).toHaveBeenCalledTimes(2);
+  });
+
+  it("does nothing when no files match", async () => {
+    vi.mocked(fsx.glob).mockResolvedValue([]);
+
+    await copySrcFiles(pkgDir, ["**/*.css"]);
+
+    expect(fsx.copy).not.toHaveBeenCalled();
+  });
+});
+
+describe("watchCopySrcFiles", () => {
+  beforeEach(() => {
+    vi.mocked(fsx.glob).mockReset();
+    vi.mocked(fsx.mkdir).mockReset();
+    vi.mocked(fsx.copy).mockReset();
+    vi.mocked(fsx.rm).mockReset();
+    mockOnChange.mockReset();
+    vi.mocked(fsx.glob).mockResolvedValue([]);
+    vi.mocked(fsx.mkdir).mockResolvedValue(undefined as any);
+    vi.mocked(fsx.copy).mockResolvedValue(undefined as any);
+    vi.mocked(fsx.rm).mockResolvedValue(undefined as any);
+  });
+
+  it("performs initial copy then starts watch", async () => {
+    const watcher = await watchCopySrcFiles(pkgDir, ["**/*.css"]);
+
+    expect(fsx.glob).toHaveBeenCalledWith("**/*.css", { cwd: srcDir, absolute: true });
+    expect(FsWatcher.watch).toHaveBeenCalledWith([path.join(srcDir, "**/*.css")]);
+    expect(mockOnChange).toHaveBeenCalledWith({ delay: 300 }, expect.any(Function));
+    expect(watcher).toBeDefined();
+  });
+
+  it("copies file on add/change event", async () => {
+    await watchCopySrcFiles(pkgDir, ["**/*.css"]);
+
+    // Get the onChange callback
+    const onChangeCallback = mockOnChange.mock.calls[0][1] as (
+      changes: Array<{ event: string; path: string }>,
+    ) => Promise<void>;
+
+    await onChangeCallback([
+      { event: "change", path: path.join(srcDir, "styles", "app.css") },
+    ]);
+
+    expect(fsx.mkdir).toHaveBeenCalledWith(path.join(distDir, "styles"));
+    expect(fsx.copy).toHaveBeenCalledWith(
+      path.join(srcDir, "styles", "app.css"),
+      path.join(distDir, "styles", "app.css"),
+    );
+  });
+
+  it("deletes dist file on unlink event", async () => {
+    await watchCopySrcFiles(pkgDir, ["**/*.css"]);
+
+    const onChangeCallback = mockOnChange.mock.calls[0][1] as (
+      changes: Array<{ event: string; path: string }>,
+    ) => Promise<void>;
+
+    await onChangeCallback([
+      { event: "unlink", path: path.join(srcDir, "styles", "old.css") },
+    ]);
+
+    expect(fsx.rm).toHaveBeenCalledWith(path.join(distDir, "styles", "old.css"));
+  });
+
+  it("handles add event same as change event", async () => {
+    await watchCopySrcFiles(pkgDir, ["**/*.css"]);
+
+    const onChangeCallback = mockOnChange.mock.calls[0][1] as (
+      changes: Array<{ event: string; path: string }>,
+    ) => Promise<void>;
+
+    await onChangeCallback([
+      { event: "add", path: path.join(srcDir, "new.css") },
+    ]);
+
+    expect(fsx.copy).toHaveBeenCalledWith(
+      path.join(srcDir, "new.css"),
+      path.join(distDir, "new.css"),
+    );
+  });
+});