@simplysm/sd-cli 14.0.38 → 14.0.39

package/tests/workers/server-esbuild-context.spec.ts

@@ -5,6 +5,15 @@ import { describe, it, expect, vi, afterEach } from "vitest";
 const mockRebuild = vi.fn();
 const mockDispose = vi.fn();
 
+const mockTscPlugin = {
+  plugin: { name: "sd-tsc", setup: vi.fn() },
+  getProgram: vi.fn(),
+  getAffectedFiles: vi.fn(),
+  getDiagnostics: vi.fn((): unknown[] => []),
+  getErrors: vi.fn(),
+  resetBuilderProgram: vi.fn(),
+};
+
 vi.mock("esbuild", () => ({
   default: {
     context: vi.fn(() =>
@@ -21,12 +30,19 @@ vi.mock("../../src/esbuild/esbuild-config", async (importOriginal) => {
   };
 });
 
+vi.mock("../../src/esbuild/esbuild-tsc-plugin", () => ({
+  createTscPlugin: vi.fn(() => mockTscPlugin),
+}));
+
 //#endregion
 
 const esbuild = (await import("esbuild")).default;
 const { writeChangedOutputFiles } = await import("../../src/esbuild/esbuild-config");
-const { createContext, rebuild, recreateContext, dispose, getMetafile, hasContext } =
-  await import("../../src/workers/server-esbuild-context");
+const {
+  createContext, rebuild, recreateContext, dispose, getMetafile, hasContext,
+  getTscProgram, getTscAffectedFiles, getTscDiagnostics,
+} = await import("../../src/workers/server-esbuild-context");
+const { createTscPlugin } = await import("../../src/esbuild/esbuild-tsc-plugin");
 
 const baseOptions = {
   pkgDir: "/workspace/packages/my-server",
@@ -38,8 +54,14 @@ describe("createContext", () => {
   afterEach(async () => {
     mockRebuild.mockReset();
     mockDispose.mockReset();
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
     vi.mocked(esbuild.context).mockClear();
     vi.mocked(writeChangedOutputFiles).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
     await dispose();
   });
 
@@ -72,8 +94,14 @@ describe("rebuild", () => {
   afterEach(async () => {
     mockRebuild.mockReset();
     mockDispose.mockReset();
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
     vi.mocked(esbuild.context).mockClear();
     vi.mocked(writeChangedOutputFiles).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
     await dispose();
   });
 
@@ -128,8 +156,14 @@ describe("recreateContext", () => {
   afterEach(async () => {
     mockRebuild.mockReset();
     mockDispose.mockReset();
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
     vi.mocked(esbuild.context).mockClear();
     vi.mocked(writeChangedOutputFiles).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
     await dispose();
   });
 
@@ -169,8 +203,14 @@ describe("dispose", () => {
   afterEach(() => {
     mockRebuild.mockReset();
     mockDispose.mockReset();
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
     vi.mocked(esbuild.context).mockClear();
     vi.mocked(writeChangedOutputFiles).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
   });
 
   it("is safe to call when no context exists", async () => {
@@ -195,4 +235,282 @@ describe("dispose", () => {
     expect(hasContext()).toBe(false);
     expect(getMetafile()).toBeUndefined();
   });
+
+  it("clears tscPlugin reference on dispose", async () => {
+    mockTscPlugin.getProgram.mockReturnValue({ id: "prog" });
+
+    await createContext({
+      ...baseOptions,
+      tsc: { cwd: "/workspace", output: { dts: true } },
+    });
+    expect(getTscProgram()).toEqual({ id: "prog" });
+
+    await dispose();
+
+    expect(getTscProgram()).toBeUndefined();
+    expect(getTscAffectedFiles()).toBeUndefined();
+    expect(getTscDiagnostics()).toEqual([]);
+  });
+});
+
+describe("createContext — tsc plugin", () => {
+  afterEach(async () => {
+    mockRebuild.mockReset();
+    mockDispose.mockReset();
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
+    vi.mocked(esbuild.context).mockClear();
+    vi.mocked(writeChangedOutputFiles).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
+    await dispose();
+  });
+
+  it("includes tsc plugin in esbuild context when tsc options provided", async () => {
+    await createContext({
+      ...baseOptions,
+      tsc: { cwd: "/workspace", output: { dts: true } },
+    });
+
+    expect(esbuild.context).toHaveBeenCalledWith(
+      expect.objectContaining({
+        plugins: [mockTscPlugin.plugin],
+      }),
+    );
+  });
+
+  it("creates esbuild context without plugins when no tsc options and no existing plugin", async () => {
+    await createContext(baseOptions);
+
+    expect(esbuild.context).toHaveBeenCalledWith(
+      expect.objectContaining({
+        plugins: [],
+      }),
+    );
+  });
+
+  it("reuses existing tsc plugin when tsc options absent in subsequent createContext", async () => {
+    // First: create with tsc
+    await createContext({
+      ...baseOptions,
+      tsc: { cwd: "/workspace", output: { dts: true } },
+    });
+
+    // Dispose context only (not module-level dispose — use recreateContext pattern)
+    vi.mocked(esbuild.context).mockClear();
+
+    // Second: create without tsc — should reuse existing plugin
+    await recreateContext(baseOptions);
+
+    expect(esbuild.context).toHaveBeenCalledWith(
+      expect.objectContaining({
+        plugins: [mockTscPlugin.plugin],
+      }),
+    );
+  });
+
+  it("passes tsc env and includeTests options to createTscPlugin", async () => {
+    await createContext({
+      ...baseOptions,
+      tsc: {
+        cwd: "/workspace",
+        output: { dts: false },
+        env: "node",
+        includeTests: true,
+      },
+    });
+
+    expect(createTscPlugin).toHaveBeenCalledWith({
+      pkgDir: baseOptions.pkgDir,
+      cwd: "/workspace",
+      output: { dts: false },
+      env: "node",
+      includeTests: true,
+    });
+  });
+});
+
+describe("delegation methods", () => {
+  afterEach(async () => {
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
+    vi.mocked(esbuild.context).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
+    await dispose();
+  });
+
+  it("getTscProgram returns plugin value when plugin exists", async () => {
+    const fakeProgram = { getSourceFiles: () => [] };
+    mockTscPlugin.getProgram.mockReturnValue(fakeProgram);
+
+    await createContext({
+      ...baseOptions,
+      tsc: { cwd: "/workspace", output: { dts: true } },
+    });
+
+    expect(getTscProgram()).toBe(fakeProgram);
+  });
+
+  it("getTscAffectedFiles returns plugin value when plugin exists", async () => {
+    const fakeFiles = new Set(["/src/main.ts"]);
+    mockTscPlugin.getAffectedFiles.mockReturnValue(fakeFiles);
+
+    await createContext({
+      ...baseOptions,
+      tsc: { cwd: "/workspace", output: { dts: true } },
+    });
+
+    expect(getTscAffectedFiles()).toBe(fakeFiles);
+  });
+
+  it("getTscDiagnostics returns plugin value when plugin exists", async () => {
+    const fakeDiag = [{ category: 1, code: 2322, messageText: "err" }];
+    mockTscPlugin.getDiagnostics.mockReturnValue(fakeDiag);
+
+    await createContext({
+      ...baseOptions,
+      tsc: { cwd: "/workspace", output: { dts: true } },
+    });
+
+    expect(getTscDiagnostics()).toEqual(fakeDiag);
+  });
+
+});
+
+describe("rebuild — tsc error merge", () => {
+  afterEach(async () => {
+    mockRebuild.mockReset();
+    mockDispose.mockReset();
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
+    vi.mocked(esbuild.context).mockClear();
+    vi.mocked(writeChangedOutputFiles).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
+    await dispose();
+  });
+
+  it("returns success when both esbuild and tsc have no errors", async () => {
+    mockRebuild.mockResolvedValue({
+      errors: [],
+      warnings: [],
+      outputFiles: [],
+      metafile: { inputs: {}, outputs: {} },
+    });
+    mockTscPlugin.getErrors.mockReturnValue(undefined);
+
+    await createContext({ ...baseOptions, tsc: { cwd: "/workspace", output: { dts: true } } });
+    const result = await rebuild();
+
+    expect(result).toEqual({
+      success: true,
+      errors: undefined,
+      warnings: undefined,
+    });
+  });
+
+  it("returns tsc errors only when esbuild succeeds but tsc fails", async () => {
+    mockRebuild.mockResolvedValue({
+      errors: [],
+      warnings: [],
+      outputFiles: [],
+      metafile: { inputs: {}, outputs: {} },
+    });
+    mockTscPlugin.getErrors.mockReturnValue(["TS2322: type mismatch"]);
+
+    await createContext({ ...baseOptions, tsc: { cwd: "/workspace", output: { dts: true } } });
+    const result = await rebuild();
+
+    expect(result).toEqual({
+      success: false,
+      errors: ["TS2322: type mismatch"],
+      warnings: undefined,
+    });
+  });
+
+  it("returns esbuild errors only when esbuild fails but tsc succeeds", async () => {
+    mockRebuild.mockResolvedValue({
+      errors: [{ text: "syntax error" }],
+      warnings: [],
+      outputFiles: [],
+      metafile: undefined,
+    });
+    mockTscPlugin.getErrors.mockReturnValue(undefined);
+
+    await createContext({ ...baseOptions, tsc: { cwd: "/workspace", output: { dts: true } } });
+    const result = await rebuild();
+
+    expect(result).toEqual({
+      success: false,
+      errors: ["syntax error"],
+      warnings: undefined,
+    });
+  });
+
+  it("merges esbuild and tsc errors when both fail", async () => {
+    mockRebuild.mockResolvedValue({
+      errors: [{ text: "esbuild error" }],
+      warnings: [{ text: "warning" }],
+      outputFiles: [],
+      metafile: undefined,
+    });
+    mockTscPlugin.getErrors.mockReturnValue(["tsc error 1", "tsc error 2"]);
+
+    await createContext({ ...baseOptions, tsc: { cwd: "/workspace", output: { dts: true } } });
+    const result = await rebuild();
+
+    expect(result).toEqual({
+      success: false,
+      errors: ["esbuild error", "tsc error 1", "tsc error 2"],
+      warnings: ["warning"],
+    });
+  });
+
+  it("returns esbuild-only result when no tsc plugin exists", async () => {
+    mockRebuild.mockResolvedValue({
+      errors: [{ text: "error" }],
+      warnings: [],
+      outputFiles: [],
+      metafile: undefined,
+    });
+
+    await createContext(baseOptions);
+    const result = await rebuild();
+
+    expect(result).toEqual({
+      success: false,
+      errors: ["error"],
+      warnings: undefined,
+    });
+  });
+});
+
+describe("recreateContext — tsc reset", () => {
+  afterEach(async () => {
+    mockRebuild.mockReset();
+    mockDispose.mockReset();
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
+    vi.mocked(esbuild.context).mockClear();
+    vi.mocked(writeChangedOutputFiles).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
+    await dispose();
+  });
+
+  it("does not fail when recreateContext is called without tsc plugin", async () => {
+    await createContext(baseOptions);
+
+    await expect(recreateContext(baseOptions)).resolves.not.toThrow();
+    expect(hasContext()).toBe(true);
+  });
 });