jac-client 0.2.11__py3-none-any.whl → 0.2.13__py3-none-any.whl

jac_client/plugin/utils/client_deps.jac

@@ -0,0 +1,14 @@
+"""Client dependency checker utility for jac-client.
+
+Provides a function to check if required npm dependencies are configured
+and prompt the user to install defaults if missing.
+"""
+
+"""Check if client npm dependencies are configured, prompt to install if missing.
+
+Takes a JacClientConfig instance, checks if dependencies and devDependencies
+are both empty, and if so prompts the user to install default jac-client deps.
+
+Returns True if deps are configured (or were just installed), False if user declined.
+"""
+def ensure_client_deps(config_loader: object) -> bool;

jac_client/plugin/utils/impl/client_deps.impl.jac

@@ -0,0 +1,73 @@
+"""Implementation of client dependency checker utility."""
+
+"""Check if client npm dependencies are configured, prompt to install if missing."""
+impl ensure_client_deps(config_loader: object) -> bool {
+    package_config = config_loader.get_package_config();
+    dependencies = package_config.get('dependencies', {});
+    dev_dependencies = package_config.get('devDependencies', {});
+    # If either deps or devDeps has entries, assume configured
+    if dependencies or dev_dependencies {
+        return True;
+    }
+    # No deps configured — prompt the user
+    return prompt_install_client_deps(config_loader);
+}
+
+"""Prompt user to install default jac-client npm dependencies."""
+def prompt_install_client_deps(config_loader: object) -> bool {
+    import sys;
+    print("\n  ⚠ Client dependencies are not configured.", file=sys.stderr);
+    print(
+        "  jac-client requires npm packages (react, vite, etc.) to build client pages.",
+        file=sys.stderr
+    );
+    print("  These will be added to your jac.toml file.\n", file=sys.stderr);
+    try {
+        response = input("  Install default client dependencies now? [Y/n]: ").strip().lower();
+    } except (EOFError, KeyboardInterrupt) {
+        print("", file=sys.stderr);
+        return False;
+    }
+    if response and response not in ('y', 'yes', '') {
+        print(
+            "\n  To configure manually, add [dependencies.npm] to your jac.toml.",
+            file=sys.stderr
+        );
+        print(
+            "  Or create a new project with: jac create --use client\n",
+            file=sys.stderr
+        );
+        return False;
+    }
+    # Default runtime dependencies
+    default_deps: dict[str, str] = {
+        'react': '^18.2.0',
+        'react-dom': '^18.2.0',
+        'react-router-dom': '^6.22.0',
+        'react-error-boundary': '^5.0.0'
+    };
+    # Default build infrastructure dependencies
+    default_dev_deps: dict[str, str] = {
+        'vite': '^6.4.1',
+        '@vitejs/plugin-react': '^4.2.1',
+        'typescript': '^5.3.3',
+        '@types/react': '^18.2.0',
+        '@types/react-dom': '^18.2.0'
+    };
+    print("\n  ⏳ Adding default client dependencies to jac.toml...", flush=True);
+    try {
+        for (name, version) in default_deps.items() {
+            config_loader.add_dependency(name, version, is_dev=False);
+        }
+        for (name, version) in default_dev_deps.items() {
+            config_loader.add_dependency(name, version, is_dev=True);
+        }
+        config_loader.save();
+        config_loader.invalidate();
+        print("  ✔ Default client dependencies added to jac.toml\n", flush=True);
+        return True;
+    } except Exception as e {
+        print(f"  ✖ Failed to add dependencies: {e}", file=sys.stderr);
+        return False;
+    }
+}

jac_client/templates/client.jacpack

@@ -33,10 +33,6 @@
     "assets",
     ".jac/client"
   ],
-  "gitignore_entries": [
-    "# Ignore all build artifacts in .jac directory",
-    "*"
-  ],
   "root_gitignore_entries": [
     "# Jac project",
     "packages/",

jac_client/templates/fullstack.jacpack

@@ -36,10 +36,6 @@
     ".jac",
     "assets"
   ],
-  "gitignore_entries": [
-    "# Ignore all build artifacts in .jac directory",
-    "*"
-  ],
   "root_gitignore_entries": [
     "# Jac build artifacts",
     ".jac/",

jac_client/tests/test_cli.py

@@ -1,9 +1,11 @@
 """Test create-jac-app command."""
 
+import contextlib
 import os
 import tempfile
 import tomllib
 from subprocess import PIPE, Popen, run
+from unittest.mock import patch
 
 
 def test_create_jac_app() -> None:
@@ -920,3 +922,143 @@ def test_create_cl_and_run_no_root_files() -> None:
 
         finally:
             os.chdir(original_cwd)
+
+
+def test_vite_build_prompts_for_missing_client_deps() -> None:
+    """Test that ViteBundler.build() prompts to install deps when jac.toml is missing.
+
+    Exercises the same code path as `jac start` → server.start() → ensure_bundle()
+    → ViteBundler.build(), which checks for npm deps before building.
+    """
+    import json
+    from pathlib import Path
+
+    from jac_client.plugin.src.vite_bundler import ViteBundler
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        project_dir = Path(temp_dir)
+        config_file = project_dir / "jac.toml"
+
+        # No jac.toml — ViteBundler.build() should prompt via ensure_client_deps
+        bundler = ViteBundler(project_dir)
+
+        # Mock input to accept, and mock bun/vite so we don't need real installs.
+        # We only care that ensure_client_deps wrote jac.toml before reaching bun.
+        with (
+            patch("builtins.input", return_value="Y"),
+            patch(
+                "jac_client.plugin.utils.bun_installer.ensure_bun_available",
+                return_value=True,
+            ),
+            patch("subprocess.run") as mock_subprocess,
+        ):
+            # bun install returns success, vite build returns failure
+            # (we don't have real vite — that's fine, we're testing the dep prompt)
+            mock_subprocess.side_effect = [
+                type("Result", (), {"returncode": 0})(),  # bun install
+                type("Result", (), {"returncode": 1})(),  # vite build
+            ]
+            with contextlib.suppress(Exception):
+                bundler.build()  # vite build failure is expected
+
+        # The key assertion: jac.toml was created with default client deps
+        assert config_file.exists(), (
+            "jac.toml should have been created after accepting the prompt"
+        )
+
+        with open(config_file, "rb") as f:
+            data = tomllib.load(f)
+
+        npm_deps = data.get("dependencies", {}).get("npm", {})
+        assert "react" in npm_deps, "react should be in dependencies.npm"
+        assert "react-dom" in npm_deps, "react-dom should be in dependencies.npm"
+
+        npm_dev = npm_deps.get("dev", {})
+        assert "vite" in npm_dev, "vite should be in dev dependencies"
+        assert "@vitejs/plugin-react" in npm_dev, (
+            "@vitejs/plugin-react should be in dev deps"
+        )
+
+        # Verify the generated package.json also picked up the deps
+        package_json = project_dir / ".jac" / "client" / "configs" / "package.json"
+        assert package_json.exists(), "package.json should have been generated"
+
+        with open(package_json) as f:
+            pkg = json.load(f)
+
+        assert pkg["dependencies"].get("react"), "package.json should have react"
+        assert pkg["devDependencies"].get("vite"), "package.json should have vite"
+
+
+def test_start_dev_with_client_does_initial_compilation() -> None:
+    """Test that `jac start --dev` with client enabled performs initial compilation."""
+    import time
+
+    test_project_name = "test-start-dev-client"
+    with tempfile.TemporaryDirectory() as temp_dir:
+        original_cwd = os.getcwd()
+        try:
+            os.chdir(temp_dir)
+            # Create a client project
+            process = Popen(
+                ["jac", "create", "--use", "client", test_project_name],
+                stdin=PIPE,
+                stdout=PIPE,
+                stderr=PIPE,
+                text=True,
+            )
+            stdout, stderr = process.communicate()
+            assert process.returncode == 0
+            # Change to project directory
+            os.chdir(test_project_name)
+            # Install dependencies
+            install_process = Popen(
+                ["jac", "install", "--dev"],
+                stdout=PIPE,
+                stderr=PIPE,
+                text=True,
+            )
+            install_stdout, install_stderr = install_process.communicate()
+            assert install_process.returncode == 0, (
+                f"jac install --dev failed: {install_stderr}"
+            )
+            # Run jac start --dev main.jac
+            process = Popen(
+                ["jac", "start", "--dev", "main.jac"],
+                stdout=PIPE,
+                stderr=PIPE,
+                text=True,
+            )
+            # Wait for the initial compilation message or timeout
+            start_time = time.time()
+            output = ""
+            found_message = False
+            while time.time() - start_time < 30:  # 30 seconds timeout
+                if process.poll() is not None:
+                    break
+                if process.stdout is None:
+                    break
+                line = process.stdout.readline()
+                if not line:
+                    time.sleep(0.1)
+                    continue
+                output += line
+                if "Initial client compilation completed" in output:
+                    found_message = True
+                    break
+            # Terminate the process
+            process.terminate()
+            try:
+                process.wait(timeout=5)
+            except Exception:
+                process.kill()
+            # Close pipes
+            if process.stdout:
+                process.stdout.close()
+            if process.stderr:
+                process.stderr.close()
+            assert found_message, (
+                f"Expected 'Initial client compilation completed' in output, but got: {output}"
+            )
+        finally:
+            os.chdir(original_cwd)