swallowkit 1.1.2 → 2.0.0-alpha.10

package/src/__tests__/python-uv.test.ts

@@ -1,20 +1,22 @@
 import * as path from "path";
+import * as fs from "fs";
+import * as os from "os";
 import {
-  buildProjectLocalUvEnv,
+  buildProjectLocalUvInstallerEnv,
   buildUvPipInstallArgs,
   buildUvVenvArgs,
   getProjectLocalUvPaths,
   getPythonProjectRoot,
+  ensureUvVirtualEnvironment,
+  buildPythonCodegenInstallEnv,
 } from "../utils/python-uv";
 
 describe("python uv helpers", () => {
-  it("keeps uv-managed state inside the project", () => {
+  it("keeps only the fallback uv binary inside the project", () => {
     const projectRoot = "C:\\repo";
     const uvPaths = getProjectLocalUvPaths(projectRoot);
 
     expect(uvPaths.stateDir).toBe(path.join(projectRoot, ".uv"));
-    expect(uvPaths.cacheDir).toBe(path.join(projectRoot, ".uv", "cache"));
-    expect(uvPaths.pythonInstallDir).toBe(path.join(projectRoot, ".uv", "python"));
     expect(uvPaths.localUvExecutable.endsWith(process.platform === "win32" ? path.join(".uv", "bin", "uv.exe") : path.join(".uv", "bin", "uv"))).toBe(true);
   });
 
@@ -22,20 +24,47 @@ describe("python uv helpers", () => {
     expect(getPythonProjectRoot(path.join("C:\\repo", "functions"))).toBe("C:\\repo");
   });
 
-  it("builds project-local uv environment variables", () => {
-    const env = buildProjectLocalUvEnv({ PATH: "C:\\Windows\\System32" }, "C:\\repo");
+  it("leaves uv interpreter discovery, cache paths and user settings unchanged during bootstrap", () => {
+    const configured = {
+      PATH: "system-path",
+      UV_PYTHON: "3.15",
+      UV_CACHE_DIR: "user-cache",
+      UV_PYTHON_INSTALL_DIR: "user-python",
+      UV_PYTHON_PREFERENCE: "system",
+      UV_PYTHON_DOWNLOADS: "never",
+      UV_PYTHON_NO_REGISTRY: "false",
+    };
+    expect(buildProjectLocalUvInstallerEnv(configured, "C:\\repo")).toMatchObject(configured);
+    expect(buildProjectLocalUvInstallerEnv({}, "C:\\repo").UV_PYTHON_PREFERENCE).toBeUndefined();
+    expect(buildProjectLocalUvInstallerEnv({}, "C:\\repo").UV_PYTHON_NO_REGISTRY).toBeUndefined();
+  });
+
+  it("limits bootstrap changes to a project-local uv binary and its child environment", () => {
+    const base = { PSModulePath: "powershell-7-modules", UV_PYTHON: "3.15" };
+    const env = buildProjectLocalUvInstallerEnv(base, "C:\\repo");
+    expect(env.UV_UNMANAGED_INSTALL).toBe(path.join("C:\\repo", ".uv", "bin"));
+    expect(env.UV_NO_MODIFY_PATH).toBe("1");
+    expect(env.UV_PYTHON).toBe("3.15");
+    expect(env.PSModulePath).toBe(process.platform === "win32" ? undefined : base.PSModulePath);
+    expect(base.PSModulePath).toBe("powershell-7-modules");
+  });
 
-    expect(env.UV_CACHE_DIR).toBe(path.join("C:\\repo", ".uv", "cache"));
-    expect(env.UV_PYTHON_INSTALL_DIR).toBe(path.join("C:\\repo", ".uv", "python"));
-    expect(env.UV_TOOL_DIR).toBe(path.join("C:\\repo", ".uv", "tools"));
-    expect(env.UV_TOOL_BIN_DIR).toBe(path.join("C:\\repo", ".uv", "tools", "bin"));
-    expect(env.UV_MANAGED_PYTHON).toBeUndefined();
-    expect(env.UV_PYTHON_PREFERENCE).toBe("only-managed");
-    expect(env.UV_PYTHON_NO_REGISTRY).toBe(process.platform === "win32" ? "true" : undefined);
+  it("preserves an existing unusable virtual environment instead of clearing it", async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-uv-test-"));
+    const marker = path.join(root, "keep.txt");
+    fs.writeFileSync(marker, "user data");
+    try {
+      await expect(
+        ensureUvVirtualEnvironment("uv-must-not-be-called", root, root, process.env)
+      ).rejects.toThrow("The virtual environment was preserved");
+      expect(fs.readFileSync(marker, "utf8")).toBe("user data");
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
   });
 
   it("builds uv commands for venv creation and requirements installation", () => {
-    expect(buildUvVenvArgs(".venv")).toEqual(["venv", ".venv", "--python", "3.11"]);
+    expect(buildUvVenvArgs(".venv")).toEqual(["venv", ".venv"]);
     expect(buildUvPipInstallArgs(path.join("C:\\repo", "functions", ".venv", "Scripts", "python.exe"), "requirements.txt")).toEqual([
       "pip",
       "install",
@@ -45,4 +74,11 @@ describe("python uv helpers", () => {
       "requirements.txt",
     ]);
   });
+
+  it("does not require a C compiler for PyYAML's optional codegen accelerator", () => {
+    expect(buildPythonCodegenInstallEnv({ UV_PYTHON: "3.15" })).toEqual({
+      UV_PYTHON: "3.15", PYYAML_FORCE_LIBYAML: "0",
+    });
+    expect(buildPythonCodegenInstallEnv({ PYYAML_FORCE_LIBYAML: "1" }).PYYAML_FORCE_LIBYAML).toBe("1");
+  });
 });

package/src/__tests__/python-venv.test.ts

@@ -0,0 +1,48 @@
+import { execFile } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import { ensureUvVirtualEnvironment, getVirtualEnvPythonPath } from "../utils/python-uv";
+
+let mockInterpreterError: Error | null = null;
+jest.mock("child_process", () => ({
+  execFile: jest.fn((
+    _command: string,
+    args: string[],
+    _options: object,
+    callback: (error: Error | null, stdout: string, stderr: string) => void
+  ) => callback(args[0] === "--version" ? mockInterpreterError : null, "Python 3.15.1\n", "")),
+}));
+jest.mock("fs", () => ({ existsSync: jest.fn() }));
+
+describe("uv virtual environment lifecycle", () => {
+  const cwd = path.resolve("python-fixture", "functions");
+  const venv = path.join(cwd, ".venv");
+  const env = { UV_PYTHON: "3.15", UV_PYTHON_DOWNLOADS: "never" };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockInterpreterError = null;
+  });
+
+  it("creates with normal uv selection, then checks that Python can actually execute", async () => {
+    jest.mocked(fs.existsSync).mockReturnValue(false);
+    await expect(ensureUvVirtualEnvironment("uv", venv, cwd, env)).resolves.toBe(getVirtualEnvPythonPath(venv));
+    expect(execFile).toHaveBeenNthCalledWith(1, "uv", ["venv", venv], { cwd, env }, expect.any(Function));
+    expect(execFile).toHaveBeenNthCalledWith(2, getVirtualEnvPythonPath(venv), ["--version"], { cwd, env }, expect.any(Function));
+  });
+
+  it("reuses an existing executable environment without changing its interpreter", async () => {
+    jest.mocked(fs.existsSync).mockReturnValue(true);
+    await ensureUvVirtualEnvironment("uv", venv, cwd, env);
+    expect(execFile).toHaveBeenCalledTimes(1);
+    expect(execFile).toHaveBeenCalledWith(getVirtualEnvPythonPath(venv), ["--version"], { cwd, env }, expect.any(Function));
+  });
+
+  it.each([true, false])("reports blocked Python after checking the environment (existing=%s)", async exists => {
+    jest.mocked(fs.existsSync).mockReturnValue(exists);
+    mockInterpreterError = new Error("Application control blocked this file (os error 4551)");
+    await expect(ensureUvVirtualEnvironment("uv", venv, cwd, env)).rejects.toThrow("os error 4551");
+    expect(jest.mocked(execFile).mock.calls.some(call => call[1]?.includes("--clear"))).toBe(false);
+    expect(execFile).toHaveBeenCalledTimes(exists ? 1 : 2);
+  });
+});

package/src/__tests__/react-dev.test.ts

@@ -0,0 +1,72 @@
+import ts from "typescript";
+import {
+  buildReactDevConfigSource,
+  buildReactDevWatchIgnoredSource,
+} from "../utils/react-dev";
+import { buildReactDevArgs } from "../cli/commands/dev";
+
+describe("React dev watch boundaries", () => {
+  it.each(["C:\\repo\\", "C:\\repo", "/repo/"])(
+    "ignores backend artifacts without excluding frontend or shared sources under %s",
+    root => {
+      const ignored: string[] = new Function("root", `return ${buildReactDevWatchIgnoredSource("root")}`)(root);
+      const normalized = root.replace(/\\/g, "/").replace(/\/$/, "");
+      expect(ignored).toEqual([
+        `${normalized}/functions/**`,
+        `${normalized}/bff/**`,
+        `${normalized}/.uv/**`,
+        `${normalized}/.swallowkit/**`,
+        `${normalized}/shared/dist/**`,
+      ]);
+      expect(ignored.some(value => value.includes("/src/") || value.includes("/shared/models/"))).toBe(false);
+    }
+  );
+
+  function loadWrapper(config: object) {
+    const loadConfigFromFile = jest.fn(async () => ({
+      config,
+      dependencies: ["/repo/vite.config.mts", "/repo/vite-settings.ts"],
+    }));
+    const mergeConfig = jest.fn((base: object, overrides: object) => ({ base, overrides }));
+    const result = { exports: {} as { default: (env: object) => Promise<unknown> } };
+    const source = ts.transpileModule(buildReactDevConfigSource(), {
+      compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 },
+    }).outputText;
+    new Function("require", "exports", source)(
+      () => ({ defineConfig: (value: unknown) => value, loadConfigFromFile, mergeConfig }),
+      result.exports
+    );
+    return { load: result.exports.default, loadConfigFromFile, mergeConfig };
+  }
+
+  it("loads the user's Vite config and merges rather than replacing their watch options", async () => {
+    const config = { plugins: ["user-plugin"], server: { watch: { ignored: ["**/custom/**"], usePolling: true } } };
+    const wrapper = loadWrapper(config);
+    const env = { command: "serve", mode: "development" };
+    await wrapper.load(env);
+    expect(wrapper.loadConfigFromFile).toHaveBeenCalledWith(env, undefined, process.cwd());
+    expect(wrapper.mergeConfig).toHaveBeenCalledWith(config, {
+      plugins: [expect.objectContaining({ name: "swallowkit-dev-watch-boundaries" })],
+      server: { watch: { ignored: expect.arrayContaining([expect.stringContaining("/functions/**")]) } },
+    });
+    const plugin = wrapper.mergeConfig.mock.calls[0][1] as {
+      plugins: Array<{ configResolved: (config: { configFileDependencies: string[] }) => void }>;
+    };
+    const resolved = { configFileDependencies: ["/repo/wrapper.mjs"] };
+    plugin.plugins[0].configResolved(resolved);
+    expect(resolved.configFileDependencies).toContain("/repo/vite.config.mts");
+  });
+
+  it("respects an explicitly disabled watcher", async () => {
+    const config = { server: { watch: null } };
+    const wrapper = loadWrapper(config);
+    await expect(wrapper.load({})).resolves.toBe(config);
+    expect(wrapper.mergeConfig).not.toHaveBeenCalled();
+  });
+
+  it("passes the override config to existing projects without editing their Vite config", () => {
+    expect(buildReactDevArgs("pnpm", "3100", "127.0.0.1", ".swallowkit/config.mjs")).toEqual([
+      "exec", "vite", "--port", "3100", "--host", "127.0.0.1", "--strictPort", "--config", ".swallowkit/config.mjs",
+    ]);
+  });
+});