@simplysm/sd-cli 13.0.68 → 13.0.70

package/templates/add-client/__CLIENT__/package.json.hbs

@@ -4,7 +4,7 @@
   "type": "module",
   "private": true,
   "dependencies": {
-    "@simplysm/solid": "~13.0.68",
+    "@simplysm/solid": "~13.0.70",
 {{#if router}}
     "@solidjs/router": "^0.15.4",
 {{/if}}

package/templates/add-server/__SERVER__/package.json.hbs

@@ -4,7 +4,7 @@
   "type": "module",
   "private": true,
   "dependencies": {
-    "@simplysm/core-common": "~13.0.68",
-    "@simplysm/service-server": "~13.0.68"
+    "@simplysm/core-common": "~13.0.70",
+    "@simplysm/service-server": "~13.0.70"
   }
 }

package/templates/init/package.json.hbs

@@ -15,9 +15,9 @@
     "vitest": "vitest"
   },
   "devDependencies": {
-    "@simplysm/sd-cli": "~13.0.68",
-    "@simplysm/sd-claude": "~13.0.68",
-    "@simplysm/lint": "~13.0.68",
+    "@simplysm/sd-cli": "~13.0.70",
+    "@simplysm/sd-claude": "~13.0.70",
+    "@simplysm/lint": "~13.0.70",
     "@types/node": "^20.19.33",
     "eslint": "^9.39.2",
     "prettier": "^3.8.1",

package/tests/config-editor.spec.ts

@@ -0,0 +1,160 @@
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import path from "path";
+import fs from "fs";
+import os from "os";
+import {
+  addPackageToSdConfig,
+  setClientServerInSdConfig,
+  addTailwindToEslintConfig,
+} from "../src/utils/config-editor";
+
+describe("config-editor", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sd-cli-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  describe("addPackageToSdConfig", () => {
+    test("adds client package to empty packages object", () => {
+      const configPath = path.join(tmpDir, "sd.config.ts");
+      fs.writeFileSync(
+        configPath,
+        [
+          'import type { SdConfigFn } from "@simplysm/sd-cli";',
+          "",
+          "const config: SdConfigFn = () => ({",
+          "  packages: {},",
+          "});",
+          "",
+          "export default config;",
+        ].join("\n"),
+      );
+
+      addPackageToSdConfig(configPath, "client-web", { target: "client" });
+
+      const result = fs.readFileSync(configPath, "utf-8");
+      expect(result).toContain('"client-web"');
+      expect(result).toContain('"client"');
+    });
+
+    test("adds server package to existing packages", () => {
+      const configPath = path.join(tmpDir, "sd.config.ts");
+      fs.writeFileSync(
+        configPath,
+        [
+          'import type { SdConfigFn } from "@simplysm/sd-cli";',
+          "",
+          "const config: SdConfigFn = () => ({",
+          "  packages: {",
+          '    "client-web": { target: "client" },',
+          "  },",
+          "});",
+          "",
+          "export default config;",
+        ].join("\n"),
+      );
+
+      addPackageToSdConfig(configPath, "server", { target: "server" });
+
+      const result = fs.readFileSync(configPath, "utf-8");
+      expect(result).toContain('"client-web"');
+      expect(result).toContain('"server"');
+    });
+
+    test("returns false if package already exists", () => {
+      const configPath = path.join(tmpDir, "sd.config.ts");
+      fs.writeFileSync(
+        configPath,
+        [
+          'import type { SdConfigFn } from "@simplysm/sd-cli";',
+          "",
+          "const config: SdConfigFn = () => ({",
+          "  packages: {",
+          '    "client-web": { target: "client" },',
+          "  },",
+          "});",
+          "",
+          "export default config;",
+        ].join("\n"),
+      );
+
+      const result = addPackageToSdConfig(configPath, "client-web", { target: "client" });
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("setClientServerInSdConfig", () => {
+    test("adds server field to client config", () => {
+      const configPath = path.join(tmpDir, "sd.config.ts");
+      fs.writeFileSync(
+        configPath,
+        [
+          'import type { SdConfigFn } from "@simplysm/sd-cli";',
+          "",
+          "const config: SdConfigFn = () => ({",
+          "  packages: {",
+          '    "client-web": { target: "client" },',
+          "  },",
+          "});",
+          "",
+          "export default config;",
+        ].join("\n"),
+      );
+
+      setClientServerInSdConfig(configPath, "client-web", "server");
+
+      const result = fs.readFileSync(configPath, "utf-8");
+      expect(result).toContain('server: "server"');
+    });
+  });
+
+  describe("addTailwindToEslintConfig", () => {
+    test("adds tailwind settings to eslint config without tailwind", () => {
+      const configPath = path.join(tmpDir, "eslint.config.ts");
+      fs.writeFileSync(
+        configPath,
+        [
+          'import simplysmEslintRecommended from "@simplysm/lint/eslint-recommended";',
+          "",
+          "export default [",
+          "  ...simplysmEslintRecommended,",
+          "];",
+        ].join("\n"),
+      );
+
+      addTailwindToEslintConfig(configPath, "client-web");
+
+      const result = fs.readFileSync(configPath, "utf-8");
+      expect(result).toContain("tailwindcss");
+      expect(result).toContain("packages/client-web/tailwind.config.ts");
+    });
+
+    test("does nothing if tailwind settings already exist", () => {
+      const configPath = path.join(tmpDir, "eslint.config.ts");
+      const original = [
+        'import simplysmEslintRecommended from "@simplysm/lint/eslint-recommended";',
+        "",
+        "export default [",
+        "  ...simplysmEslintRecommended,",
+        "  {",
+        '    files: ["**/*.{ts,tsx}"],',
+        "    settings: {",
+        "      tailwindcss: {",
+        '        config: "packages/client-old/tailwind.config.ts",',
+        "      },",
+        "    },",
+        "  },",
+        "];",
+      ].join("\n");
+      fs.writeFileSync(configPath, original);
+
+      const result = addTailwindToEslintConfig(configPath, "client-web");
+      expect(result).toBe(false);
+    });
+  });
+});

package/tests/copy-src.spec.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import path from "path";
+import os from "os";
+import fs from "fs/promises";
+import { copySrcFiles } from "../src/utils/copy-src";
+
+describe("copySrcFiles", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "copysrc-"));
+    // Create src/ structure
+    await fs.mkdir(path.join(tmpDir, "src", "components"), { recursive: true });
+    await fs.mkdir(path.join(tmpDir, "dist"), { recursive: true });
+    await fs.writeFile(path.join(tmpDir, "src", "base.css"), "body {}");
+    await fs.writeFile(path.join(tmpDir, "src", "components", "Card.css"), ".card {}");
+    await fs.writeFile(path.join(tmpDir, "src", "index.ts"), "export {}");
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("copies files matching glob pattern from src/ to dist/", async () => {
+    await copySrcFiles(tmpDir, ["**/*.css"]);
+
+    const base = await fs.readFile(path.join(tmpDir, "dist", "base.css"), "utf-8");
+    expect(base).toBe("body {}");
+
+    const card = await fs.readFile(path.join(tmpDir, "dist", "components", "Card.css"), "utf-8");
+    expect(card).toBe(".card {}");
+  });
+
+  it("does not copy files that don't match pattern", async () => {
+    await copySrcFiles(tmpDir, ["**/*.css"]);
+
+    const exists = await fs.access(path.join(tmpDir, "dist", "index.ts")).then(
+      () => true,
+      () => false,
+    );
+    expect(exists).toBe(false);
+  });
+
+  it("copies nothing if pattern is empty array", async () => {
+    await copySrcFiles(tmpDir, []);
+
+    const files = await fs.readdir(path.join(tmpDir, "dist"));
+    expect(files).toHaveLength(0);
+  });
+});

package/tests/get-compiler-options-for-package.spec.ts

@@ -0,0 +1,139 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+import type ts from "typescript";
+
+// Mock core-node functions
+vi.mock("@simplysm/core-node", () => ({
+  fsExists: vi.fn(),
+  fsReadJson: vi.fn(),
+  pathPosix: vi.fn((p: string) => p.replace(/\\/g, "/")),
+}));
+
+import { fsExists, fsReadJson } from "@simplysm/core-node";
+import { getCompilerOptionsForPackage } from "../src/utils/tsconfig";
+
+describe("getCompilerOptionsForPackage", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  const baseOptions: ts.CompilerOptions = {
+    lib: ["ES2024", "DOM", "DOM.Iterable", "WebWorker"],
+    types: [],
+    strict: true,
+  };
+
+  it("node target: removes DOM lib, includes node in types", async () => {
+    const packageDir = "/project/packages/core-node";
+    vi.mocked(fsExists).mockResolvedValue(true);
+    vi.mocked(fsReadJson).mockResolvedValue({
+      devDependencies: {
+        "@types/express": "^4.17.0",
+      },
+    });
+
+    const result = await getCompilerOptionsForPackage(baseOptions, "node", packageDir);
+
+    // DOM, WebWorker lib removed
+    expect(result.lib).toEqual(["ES2024"]);
+    // types includes node and express
+    expect(result.types).toContain("node");
+    expect(result.types).toContain("express");
+  });
+
+  it("browser target: keeps lib, removes node from types", async () => {
+    const packageDir = "/project/packages/core-browser";
+    vi.mocked(fsExists).mockResolvedValue(true);
+    vi.mocked(fsReadJson).mockResolvedValue({
+      devDependencies: {
+        "@types/node": "^20.0.0",
+        "@types/react": "^18.0.0",
+      },
+    });
+
+    const result = await getCompilerOptionsForPackage(baseOptions, "browser", packageDir);
+
+    // lib is preserved
+    expect(result.lib).toEqual(["ES2024", "DOM", "DOM.Iterable", "WebWorker"]);
+    // types removes node, includes react only
+    expect(result.types).not.toContain("node");
+    expect(result.types).toContain("react");
+  });
+
+  it("neutral target: keeps lib, includes node in types", async () => {
+    const packageDir = "/project/packages/core-common";
+    vi.mocked(fsExists).mockResolvedValue(true);
+    vi.mocked(fsReadJson).mockResolvedValue({
+      devDependencies: {
+        "@types/lodash": "^4.0.0",
+      },
+    });
+
+    const result = await getCompilerOptionsForPackage(baseOptions, "neutral", packageDir);
+
+    // lib is preserved (includes DOM)
+    expect(result.lib).toEqual(["ES2024", "DOM", "DOM.Iterable", "WebWorker"]);
+    // types includes node and lodash
+    expect(result.types).toContain("node");
+    expect(result.types).toContain("lodash");
+  });
+
+  it("node target: removes duplicate node types", async () => {
+    const packageDir = "/project/packages/core-node";
+    vi.mocked(fsExists).mockResolvedValue(true);
+    vi.mocked(fsReadJson).mockResolvedValue({
+      devDependencies: {
+        "@types/node": "^20.0.0",
+      },
+    });
+
+    const result = await getCompilerOptionsForPackage(baseOptions, "node", packageDir);
+
+    // node type is included only once without duplicates
+    expect(result.types?.filter((t) => t === "node")).toHaveLength(1);
+  });
+
+  it("handles missing package.json with empty types", async () => {
+    const packageDir = "/project/packages/unknown";
+    vi.mocked(fsExists).mockResolvedValue(false);
+
+    const result = await getCompilerOptionsForPackage(baseOptions, "node", packageDir);
+
+    // includes only node (types from package are empty array)
+    expect(result.types).toEqual(["node"]);
+  });
+
+  it("handles undefined lib correctly", async () => {
+    const optionsWithoutLib: ts.CompilerOptions = {
+      strict: true,
+    };
+    const packageDir = "/project/packages/core-node";
+    vi.mocked(fsExists).mockResolvedValue(false);
+
+    const result = await getCompilerOptionsForPackage(optionsWithoutLib, "node", packageDir);
+
+    // handles undefined lib without error
+    expect(result.lib).toBeUndefined();
+    expect(result.types).toEqual(["node"]);
+  });
+
+  it("does not mutate original baseOptions (immutability)", async () => {
+    const originalOptions: ts.CompilerOptions = {
+      lib: ["ES2024", "DOM"],
+      types: ["original"],
+      strict: true,
+    };
+    const packageDir = "/project/packages/core-node";
+    vi.mocked(fsExists).mockResolvedValue(false);
+
+    await getCompilerOptionsForPackage(originalOptions, "node", packageDir);
+
+    // original options are not changed
+    expect(originalOptions.lib).toEqual(["ES2024", "DOM"]);
+    expect(originalOptions.types).toEqual(["original"]);
+    expect(originalOptions.noEmit).toBeUndefined();
+  });
+});

package/tests/get-package-source-files.spec.ts

@@ -0,0 +1,181 @@
+import { describe, expect, it } from "vitest";
+import path from "path";
+import type ts from "typescript";
+import { getPackageSourceFiles, getPackageFiles } from "../src/utils/tsconfig";
+
+describe("getPackageSourceFiles", () => {
+  const sep = path.sep;
+
+  it("filters files within package src directory only", () => {
+    const pkgDir = `/project/packages/core-common`;
+    const parsedConfig = {
+      fileNames: [
+        `/project/packages/core-common/src/index.ts`,
+        `/project/packages/core-common/src/utils/string.ts`,
+        `/project/packages/core-common/tests/utils.spec.ts`,
+        `/project/packages/core-node/src/index.ts`,
+      ],
+    } as ts.ParsedCommandLine;
+
+    const result = getPackageSourceFiles(pkgDir, parsedConfig);
+
+    expect(result).toEqual([
+      `/project/packages/core-common/src/index.ts`,
+      `/project/packages/core-common/src/utils/string.ts`,
+    ]);
+  });
+
+  it("excludes files from similar package names (core vs core-common)", () => {
+    const pkgDir = `/project/packages/core`;
+    const parsedConfig = {
+      fileNames: [
+        `/project/packages/core/src/index.ts`,
+        `/project/packages/core-common/src/index.ts`,
+        `/project/packages/core-node/src/index.ts`,
+      ],
+    } as ts.ParsedCommandLine;
+
+    const result = getPackageSourceFiles(pkgDir, parsedConfig);
+
+    // core-common, core-node are excluded, only core is included
+    expect(result).toEqual([`/project/packages/core/src/index.ts`]);
+  });
+
+  it("excludes files outside src directory (tests, scripts, etc)", () => {
+    const pkgDir = `/project/packages/cli`;
+    const parsedConfig = {
+      fileNames: [
+        `/project/packages/cli/src/index.ts`,
+        `/project/packages/cli/src/commands/lint.ts`,
+        `/project/packages/cli/tests/lint.spec.ts`,
+        `/project/packages/cli/scripts/build.ts`,
+      ],
+    } as ts.ParsedCommandLine;
+
+    const result = getPackageSourceFiles(pkgDir, parsedConfig);
+
+    expect(result).toEqual([
+      `/project/packages/cli/src/index.ts`,
+      `/project/packages/cli/src/commands/lint.ts`,
+    ]);
+  });
+
+  it("returns empty array if no files", () => {
+    const pkgDir = `/project/packages/empty`;
+    const parsedConfig = {
+      fileNames: [
+        `/project/packages/core/src/index.ts`,
+        `/project/packages/core-common/src/index.ts`,
+      ],
+    } as ts.ParsedCommandLine;
+
+    const result = getPackageSourceFiles(pkgDir, parsedConfig);
+
+    expect(result).toEqual([]);
+  });
+
+  it("handles path separators correctly", () => {
+    // use path.sep for platform-independent test
+    const pkgDir = `${sep}project${sep}packages${sep}core`;
+    const parsedConfig = {
+      fileNames: [
+        `${sep}project${sep}packages${sep}core${sep}src${sep}index.ts`,
+        `${sep}project${sep}packages${sep}core-common${sep}src${sep}index.ts`,
+      ],
+    } as ts.ParsedCommandLine;
+
+    const result = getPackageSourceFiles(pkgDir, parsedConfig);
+
+    expect(result).toEqual([`${sep}project${sep}packages${sep}core${sep}src${sep}index.ts`]);
+  });
+
+  it("handles forward slash paths from TypeScript API correctly (Windows compatible)", () => {
+    // TypeScript API returns forward slash paths even on Windows
+    // pkgDir is created with path.join using OS-native separator
+    const pkgDir = path.resolve("/project/packages/core-common");
+    const parsedConfig = {
+      fileNames: [
+        "/project/packages/core-common/src/index.ts",
+        "/project/packages/core-common/src/utils/string.ts",
+        "/project/packages/core-common/tests/utils.spec.ts",
+        "/project/packages/core-node/src/index.ts",
+      ],
+    } as ts.ParsedCommandLine;
+
+    const result = getPackageSourceFiles(pkgDir, parsedConfig);
+
+    expect(result).toHaveLength(2);
+    expect(result.every((f) => f.includes("core-common") && f.includes("src"))).toBe(true);
+  });
+});
+
+describe("getPackageFiles", () => {
+  it("filters all files within package directory (src + tests)", () => {
+    const pkgDir = `/project/packages/core-common`;
+    const parsedConfig = {
+      fileNames: [
+        `/project/packages/core-common/src/index.ts`,
+        `/project/packages/core-common/src/utils/string.ts`,
+        `/project/packages/core-common/tests/utils.spec.ts`,
+        `/project/packages/core-common/tests/setup/helpers.ts`,
+        `/project/packages/core-node/src/index.ts`,
+        `/project/packages/core-node/tests/fs.spec.ts`,
+      ],
+    } as ts.ParsedCommandLine;
+
+    const result = getPackageFiles(pkgDir, parsedConfig);
+
+    expect(result).toEqual([
+      `/project/packages/core-common/src/index.ts`,
+      `/project/packages/core-common/src/utils/string.ts`,
+      `/project/packages/core-common/tests/utils.spec.ts`,
+      `/project/packages/core-common/tests/setup/helpers.ts`,
+    ]);
+  });
+
+  it("excludes files from similar package names (core vs core-common)", () => {
+    const pkgDir = `/project/packages/core`;
+    const parsedConfig = {
+      fileNames: [
+        `/project/packages/core/src/index.ts`,
+        `/project/packages/core/tests/utils.spec.ts`,
+        `/project/packages/core-common/src/index.ts`,
+        `/project/packages/core-common/tests/utils.spec.ts`,
+      ],
+    } as ts.ParsedCommandLine;
+
+    const result = getPackageFiles(pkgDir, parsedConfig);
+
+    expect(result).toEqual([
+      `/project/packages/core/src/index.ts`,
+      `/project/packages/core/tests/utils.spec.ts`,
+    ]);
+  });
+
+  it("returns empty array if no files", () => {
+    const pkgDir = `/project/packages/empty`;
+    const parsedConfig = {
+      fileNames: [`/project/packages/core/src/index.ts`],
+    } as ts.ParsedCommandLine;
+
+    const result = getPackageFiles(pkgDir, parsedConfig);
+
+    expect(result).toEqual([]);
+  });
+
+  it("handles forward slash paths from TypeScript API correctly (Windows compatible)", () => {
+    const pkgDir = path.resolve("/project/packages/core-common");
+    const parsedConfig = {
+      fileNames: [
+        "/project/packages/core-common/src/index.ts",
+        "/project/packages/core-common/tests/utils.spec.ts",
+        "/project/packages/core-node/src/index.ts",
+      ],
+    } as ts.ParsedCommandLine;
+
+    const result = getPackageFiles(pkgDir, parsedConfig);
+
+    expect(result).toHaveLength(2);
+    expect(result.every((f) => f.includes("core-common"))).toBe(true);
+  });
+});

package/tests/get-types-from-package-json.spec.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+import path from "path";
+
+// Mock core-node functions
+vi.mock("@simplysm/core-node", () => ({
+  fsExists: vi.fn(),
+  fsReadJson: vi.fn(),
+  pathPosix: vi.fn((p: string) => p.replace(/\\/g, "/")),
+}));
+
+import { fsExists, fsReadJson } from "@simplysm/core-node";
+import { getTypesFromPackageJson } from "../src/utils/tsconfig";
+
+describe("getTypesFromPackageJson", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("converts @types/* devDependencies to types list", async () => {
+    const packageDir = "/project/packages/core-common";
+    const mockFsExists = vi.mocked(fsExists);
+    const mockFsReadJson = vi.mocked(fsReadJson);
+
+    mockFsExists.mockResolvedValue(true);
+    mockFsReadJson.mockResolvedValue({
+      devDependencies: {
+        "@types/node": "^20.0.0",
+        "@types/express": "^4.17.0",
+        "typescript": "^5.0.0",
+        "vitest": "^1.0.0",
+      },
+    });
+
+    const result = await getTypesFromPackageJson(packageDir);
+
+    expect(mockFsExists).toHaveBeenCalledWith(path.join(packageDir, "package.json"));
+    expect(result).toEqual(["node", "express"]);
+  });
+
+  it("returns empty array if package.json does not exist", async () => {
+    const packageDir = "/project/packages/unknown";
+    const mockFsExists = vi.mocked(fsExists);
+
+    mockFsExists.mockResolvedValue(false);
+
+    const result = await getTypesFromPackageJson(packageDir);
+
+    expect(result).toEqual([]);
+  });
+
+  it("returns empty array if devDependencies does not exist", async () => {
+    const packageDir = "/project/packages/core-common";
+    const mockFsExists = vi.mocked(fsExists);
+    const mockFsReadJson = vi.mocked(fsReadJson);
+
+    mockFsExists.mockResolvedValue(true);
+    mockFsReadJson.mockResolvedValue({
+      name: "@simplysm/core-common",
+      version: "1.0.0",
+    });
+
+    const result = await getTypesFromPackageJson(packageDir);
+
+    expect(result).toEqual([]);
+  });
+
+  it("filters out dependencies that are not @types/*", async () => {
+    const packageDir = "/project/packages/core-common";
+    const mockFsExists = vi.mocked(fsExists);
+    const mockFsReadJson = vi.mocked(fsReadJson);
+
+    mockFsExists.mockResolvedValue(true);
+    mockFsReadJson.mockResolvedValue({
+      devDependencies: {
+        typescript: "^5.0.0",
+        vitest: "^1.0.0",
+        eslint: "^9.0.0",
+      },
+    });
+
+    const result = await getTypesFromPackageJson(packageDir);
+
+    expect(result).toEqual([]);
+  });
+
+  it("handles scoped @types packages correctly", async () => {
+    const packageDir = "/project/packages/core-common";
+    const mockFsExists = vi.mocked(fsExists);
+    const mockFsReadJson = vi.mocked(fsReadJson);
+
+    mockFsExists.mockResolvedValue(true);
+    mockFsReadJson.mockResolvedValue({
+      devDependencies: {
+        "@types/node": "^20.0.0",
+        "@types/babel__core": "^7.0.0",
+      },
+    });
+
+    const result = await getTypesFromPackageJson(packageDir);
+
+    expect(result).toEqual(["node", "babel__core"]);
+  });
+});