@simplysm/sd-cli 13.0.99 → 14.0.1

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

@@ -1,163 +0,0 @@
-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", () => ({
-  fsx: {
-    exists: vi.fn(),
-  },
-  pathx: {
-    posix: vi.fn(),
-  },
-}));
-
-const mockJitiImportFn = vi.fn();
-vi.mock("jiti", () => ({
-  createJiti: vi.fn(() => ({
-    import: mockJitiImportFn,
-  })),
-}));
-
-import { fsx } 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(fsx.exists);
-
-    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(fsx.exists);
-
-    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(fsx.exists);
-
-    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(fsx.exists);
-
-    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(fsx.exists);
-
-    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(fsx.exists);
-
-    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(fsx.exists);
-
-    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(fsx.exists);
-
-    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"));
-  });
-
-});

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

@@ -1,100 +0,0 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
-
-const mockJitiImport = vi.fn();
-
-vi.mock("@simplysm/core-node", () => ({
-  fsx: {
-    exists: vi.fn(),
-  },
-}));
-
-vi.mock("jiti", () => ({
-  createJiti: vi.fn(() => ({
-    import: mockJitiImport,
-  })),
-}));
-
-import { fsx } 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(fsx.exists).mockResolvedValue(false);
-
-    await expect(loadSdConfig({ cwd: "/project", dev: false, options: [] })).rejects.toThrow(
-      "sd.config.ts file not found",
-    );
-  });
-
-  it("throws error if no default export", async () => {
-    vi.mocked(fsx.exists).mockResolvedValue(true);
-    mockJitiImport.mockResolvedValue({
-      someOtherExport: () => ({}),
-    });
-
-    await expect(loadSdConfig({ cwd: "/project", dev: false, options: [] })).rejects.toThrow(
-      "sd.config.ts must export a function as default",
-    );
-  });
-
-  it("throws error if default export is not function", async () => {
-    vi.mocked(fsx.exists).mockResolvedValue(true);
-    mockJitiImport.mockResolvedValue({
-      default: { packages: {} }, // object not function
-    });
-
-    await expect(loadSdConfig({ cwd: "/project", dev: false, options: [] })).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(fsx.exists).mockResolvedValue(true);
-    mockJitiImport.mockResolvedValue({
-      default: () => ({}), // missing packages property
-    });
-
-    await expect(loadSdConfig({ cwd: "/project", dev: false, options: [] })).rejects.toThrow(
-      /sd\.config\.ts return value is not in .* correct format/,
-    );
-  });
-
-  it("returns correct config", async () => {
-    vi.mocked(fsx.exists).mockResolvedValue(true);
-    mockJitiImport.mockResolvedValue({
-      default: () => ({
-        packages: {
-          "core-common": { target: "neutral" },
-          "core-node": { target: "node" },
-        },
-      }),
-    });
-
-    const config = await loadSdConfig({ cwd: "/project", dev: false, options: [] });
-
-    expect(config.packages).toEqual({
-      "core-common": { target: "neutral" },
-      "core-node": { target: "node" },
-    });
-  });
-
-  it("empty packages object is valid", async () => {
-    vi.mocked(fsx.exists).mockResolvedValue(true);
-    mockJitiImport.mockResolvedValue({
-      default: () => ({ packages: {} }),
-    });
-
-    const config = await loadSdConfig({ cwd: "/project", dev: false, options: [] });
-
-    expect(config.packages).toEqual({});
-  });
-
-});

package/tests/package-utils.spec.ts

@@ -1,188 +0,0 @@
-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([]);
-  });
-});

package/tests/parse-root-tsconfig.spec.ts

@@ -1,89 +0,0 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
-import path from "path";
-import ts from "typescript";
-
-// Mock typescript
-vi.mock("typescript", async (importOriginal) => {
-  const actual = await importOriginal<typeof ts>();
-  return {
-    ...actual,
-    default: {
-      ...actual,
-      readConfigFile: vi.fn(),
-      parseJsonConfigFileContent: vi.fn(),
-      flattenDiagnosticMessageText: actual.flattenDiagnosticMessageText,
-      sys: actual.sys,
-    },
-  };
-});
-
-import { parseRootTsconfig } from "../src/utils/tsconfig";
-
-describe("parseRootTsconfig", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("successfully parses valid tsconfig.json", () => {
-    const cwd = "/project";
-    const mockConfig = { compilerOptions: { strict: true } };
-    const mockParsedConfig: ts.ParsedCommandLine = {
-      options: { strict: true },
-      fileNames: ["/project/src/index.ts"],
-      errors: [],
-    };
-
-    vi.mocked(ts.readConfigFile).mockReturnValue({ config: mockConfig });
-    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue(mockParsedConfig);
-
-    const result = parseRootTsconfig(cwd);
-
-    expect(ts.readConfigFile).toHaveBeenCalledWith(
-      path.join("/project", "tsconfig.json"),
-      ts.sys.readFile,
-    );
-    expect(result).toEqual(mockParsedConfig);
-  });
-
-  it("throws error when tsconfig.json fails to read", () => {
-    const cwd = "/project";
-    const mockError: ts.Diagnostic = {
-      category: ts.DiagnosticCategory.Error,
-      code: 5083,
-      messageText: "Cannot read file",
-      file: undefined,
-      start: undefined,
-      length: undefined,
-    };
-
-    vi.mocked(ts.readConfigFile).mockReturnValue({ error: mockError });
-
-    expect(() => parseRootTsconfig(cwd)).toThrow("Failed to read tsconfig.json");
-  });
-
-  it("throws error when tsconfig.json fails to parse", () => {
-    const cwd = "/project";
-    const mockConfig = { compilerOptions: { strict: true } };
-    const mockError: ts.Diagnostic = {
-      category: ts.DiagnosticCategory.Error,
-      code: 5024,
-      messageText: "Invalid option",
-      file: undefined,
-      start: undefined,
-      length: undefined,
-    };
-
-    vi.mocked(ts.readConfigFile).mockReturnValue({ config: mockConfig });
-    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue({
-      options: {},
-      fileNames: [],
-      errors: [mockError],
-    });
-
-    expect(() => parseRootTsconfig(cwd)).toThrow("Failed to parse tsconfig.json");
-  });
-});

package/tests/publish-config-narrowing.spec.ts

@@ -1,20 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { SdPublishConfig, SdNpmPublishConfig } from "../src/sd-config.types";
-
-describe("SdPublishConfig", () => {
-  it("all variants have .type field for uniform narrowing", () => {
-    const configs: SdPublishConfig[] = [
-      { type: "npm" },
-      { type: "local-directory", path: "/deploy" },
-      { type: "ftp", host: "example.com" },
-    ];
-
-    const types = configs.map((c) => c.type);
-    expect(types).toEqual(["npm", "local-directory", "ftp"]);
-  });
-
-  it("npm config is an object with type field", () => {
-    const npmConfig: SdNpmPublishConfig = { type: "npm" };
-    expect(npmConfig.type).toBe("npm");
-  });
-});