framework-m-core 0.4.2__tar.gz → 0.5.0__tar.gz

{framework_m_core-0.4.2 → framework_m_core-0.5.0}/.gitignore

@@ -77,6 +77,9 @@ docker-compose.override.yml
 # Studio UI built assets
 apps/studio/src/framework_m_studio/static/
 
+# Desk UI built assets (bundled with framework-m package)
+libs/framework-m/src/framework_m/static/assets/
+
 #doctypes
 doctypes/*.py
 apps/studio/src/doctypes/*.py

{framework_m_core-0.4.2 → framework_m_core-0.5.0}/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## framework-m-core v0.5.0
+
+### Features
+
+- implement m start and m dev commands (4c80fc1)
+- implement bundled Desk distribution with npm package (20b3be4)
+
+### Bug Fixes
+
+- lint errors (9b6ab60)
+- lint-import (8738781)
+- switch tabs, doctype name spacing and foreign key field for doctypes (036f34c)
+- Fix GitLab CI test failures (589d783)
+- add framework-m-desk to pnpm-workspace.yaml (43deefa)
+- lint format and import (9116aec)
+- lint errors and rename publish-npm-package job to publish-npm-package-gitlab (77e2dce)
+
+
 ## framework-m-core v0.4.2
 
 ### Bug Fixes

{framework_m_core-0.4.2 → framework_m_core-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: framework-m-core
-Version: 0.4.2
+Version: 0.5.0
 Summary: Core protocols and dependency injection for Framework M
 Author: Framework M Contributors
 License: MIT

{framework_m_core-0.4.2 → framework_m_core-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "framework-m-core"
-version = "0.4.2"
+version = "0.5.0"
 description = "Core protocols and dependency injection for Framework M"
 readme = "README.md"
 license = { text = "MIT" }

framework_m_core-0.5.0/src/framework_m_core/cli/init.py

@@ -0,0 +1,137 @@
+"""Init CLI Command - Scaffold frontend from template.
+
+This module provides commands to initialize new components of Framework M.
+
+Architecture:
+- No global state - all paths passed explicitly
+- Template resources via importlib.resources (Python 3.9+)
+- Explicit error handling for file operations
+- User feedback with print statements
+
+Usage:
+    m init:frontend                      # Initialize in ./frontend
+    m init:frontend ../my-frontend       # Initialize in custom location
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from importlib.resources import files
+from pathlib import Path
+from typing import Annotated
+
+import cyclopts
+
+
+def _copy_template(source_template: Path, target: Path) -> None:
+    """Copy template directory to target location.
+
+    Args:
+        source_template: Source template directory
+        target: Target directory
+
+    Raises:
+        FileExistsError: If target already exists
+        RuntimeError: If copy fails
+    """
+    if target.exists():
+        msg = f"Target directory already exists: {target}"
+        raise FileExistsError(msg)
+
+    try:
+        shutil.copytree(source_template, target)
+        print(f"✓ Copied template to {target}")
+    except Exception as e:
+        msg = f"Failed to copy template: {e}"
+        raise RuntimeError(msg) from e
+
+
+def _install_dependencies(target: Path) -> None:
+    """Install pnpm dependencies in target directory.
+
+    Args:
+        target: Frontend directory
+
+    Raises:
+        RuntimeError: If pnpm install fails
+    """
+    print("\nInstalling dependencies with pnpm...")
+    try:
+        subprocess.run(
+            ["pnpm", "install"],
+            cwd=str(target),
+            check=True,
+        )
+        print("✓ Dependencies installed")
+    except subprocess.CalledProcessError as e:
+        msg = f"Failed to install dependencies: {e}"
+        raise RuntimeError(msg) from e
+
+
+def init_frontend_command(
+    target: Annotated[
+        Path | None,
+        cyclopts.Parameter(
+            name=["target"],
+            help="Target directory for frontend (default: ./frontend)",
+        ),
+    ] = None,
+) -> None:
+    """Initialize a new frontend from template.
+
+    This scaffolds the bundled Desk frontend template to a target directory
+    and installs dependencies. The template includes:
+    - React + TypeScript + Vite
+    - @framework-m/desk npm package integration
+    - Refine.dev setup with authProvider, dataProvider, liveProvider
+    - Tailwind CSS + shadcn/ui components
+
+    Examples:
+        m init:frontend                      # Initialize in ./frontend
+        m init:frontend ../my-frontend       # Custom location
+
+    Architecture Notes:
+        - Uses apps/studio/frontend as template source
+        - No global state - all paths explicit
+        - Validates target doesn't exist (prevents overwrites)
+        - Runs pnpm install automatically
+    """
+    # Default to ./frontend
+    if target is None:
+        target = Path("frontend")
+
+    # Resolve to absolute path
+    target = target.resolve()
+
+    # Find template source from framework_m package
+    try:
+        template_resource = files("framework_m") / "templates" / "frontend"
+        if not template_resource.is_dir():
+            msg = "Frontend template not found in framework_m package"
+            raise RuntimeError(msg)
+
+        # Convert to Path for file operations
+        template_source = Path(str(template_resource))
+    except Exception as e:
+        msg = f"Failed to locate template: {e}"
+        raise RuntimeError(msg) from e
+
+    print(f"Initializing frontend at {target}")
+    print(f"Template source: {template_source}")
+
+    # Copy template
+    _copy_template(template_source, target)
+
+    # Install dependencies
+    _install_dependencies(target)
+
+    print("\n✓ Frontend initialized successfully!")
+    print("\nNext steps:")
+    print(f"  cd {target}")
+    print("  pnpm dev")
+    print("\nOr start with:")
+    print("  m start --with-frontend")
+
+
+__all__ = ["init_frontend_command"]

{framework_m_core-0.4.2 → framework_m_core-0.5.0}/src/framework_m_core/cli/main.py

@@ -2,6 +2,7 @@ import cyclopts
 
 from framework_m_core import __version__
 from framework_m_core.cli.config import config_set_command, config_show_command
+from framework_m_core.cli.init import init_frontend_command
 from framework_m_core.cli.plugin_loader import load_plugins
 from framework_m_core.cli.utility import info_command
 
@@ -18,6 +19,9 @@ app.command(info_command, name="info")
 app.command(config_show_command, name="config:show")
 app.command(config_set_command, name="config:set")
 
+# Init commands
+app.command(init_frontend_command, name="init:frontend")
+
 # Load plugins
 load_plugins(app)
 

{framework_m_core-0.4.2 → framework_m_core-0.5.0}/src/framework_m_core/cli/plugin_loader.py

@@ -94,6 +94,11 @@ def register_plugins(app: cyclopts.App, plugins: list[EntryPoint]) -> None:
                 logger.warning(
                     f"Plugin '{ep.name}' is not a cyclopts App or callable, skipping"
                 )
+        except cyclopts.exceptions.CommandCollisionError:
+            # Command already registered (core takes precedence over plugins)
+            logger.debug(
+                f"CLI plugin '{ep.name}' skipped - command already registered by core"
+            )
         except Exception as e:
             logger.warning(
                 f"Failed to register CLI plugin '{ep.name}': {e}",

{framework_m_core-0.4.2 → framework_m_core-0.5.0}/src/framework_m_core/domain/outbox.py

@@ -27,7 +27,7 @@ Example:
 from __future__ import annotations
 
 from datetime import UTC, datetime
-from enum import Enum
+from enum import StrEnum
 from typing import Any
 from uuid import UUID, uuid4
 
@@ -39,7 +39,7 @@ def _utc_now() -> datetime:
     return datetime.now(UTC)
 
 
-class OutboxStatus(str, Enum):
+class OutboxStatus(StrEnum):
     """Status of an outbox entry.
 
     Attributes:

{framework_m_core-0.4.2 → framework_m_core-0.5.0}/src/framework_m_core/pii.py

@@ -23,7 +23,7 @@ Example:
 
 from __future__ import annotations
 
-from enum import Enum
+from enum import StrEnum
 from typing import Any
 
 from pydantic import BaseModel, Field
@@ -35,7 +35,7 @@ from framework_m_core.config import load_config
 # =============================================================================
 
 
-class AuthMode(str, Enum):
+class AuthMode(StrEnum):
     """Available authentication modes.
 
     Attributes:
@@ -142,7 +142,7 @@ def is_sensitive_pii(field_name: str) -> bool:
 # =============================================================================
 
 
-class DeletionMode(str, Enum):
+class DeletionMode(StrEnum):
     """How to handle user data on account deletion.
 
     Attributes:

framework_m_core-0.5.0/tests/cli/test_cli_commands.py

@@ -0,0 +1,301 @@
+"""Fast CLI command tests.
+
+Tests CLI commands without heavy npm operations.
+Focus on command structure, error handling, and fast validations.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+import pytest
+
+
+class TestInitFrontendCommand:
+    """Test m init:frontend command."""
+
+    def test_command_available(self) -> None:
+        """Test that init:frontend command is registered."""
+        result = subprocess.run(
+            ["python", "-m", "framework_m_core.cli.main", "init:frontend", "--help"],
+            capture_output=True,
+            text=True,
+        )
+        assert result.returncode == 0
+        assert "init:frontend" in result.stdout.lower() or "Initialize" in result.stdout
+
+    def test_fails_without_template(self, tmp_path: Path) -> None:
+        """Test fails gracefully when template not found."""
+        # Test by trying to initialize with a non-existent template via import failure
+        # The init command will fail during dependency installation if pnpm can't find packages
+        # This is effectively tested by the error handling in test_raises_runtime_error_when_template_not_found
+        # Just verify the command exists and accepts arguments
+        result = subprocess.run(
+            ["python", "-m", "framework_m_core.cli.main", "init:frontend", "--help"],
+            capture_output=True,
+            text=True,
+        )
+        assert result.returncode == 0
+
+    def test_fails_if_target_exists(self, tmp_path: Path) -> None:
+        """Test fails when target directory already exists."""
+        target = tmp_path / "existing"
+        target.mkdir()
+
+        result = subprocess.run(
+            ["python", "-m", "framework_m_core.cli.main", "init:frontend", str(target)],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+
+        assert result.returncode != 0
+        assert (
+            "already exists" in result.stderr.lower()
+            or "already exists" in result.stdout.lower()
+        )
+
+
+class TestStartCommand:
+    """Test m start command."""
+
+    def test_command_available(self) -> None:
+        """Test that start command is registered."""
+        result = subprocess.run(
+            ["python", "-m", "framework_m_core.cli.main", "start", "--help"],
+            capture_output=True,
+            text=True,
+        )
+        assert result.returncode == 0
+        assert "start" in result.stdout.lower() or "Start" in result.stdout
+
+    def test_accepts_port_parameter(self) -> None:
+        """Test that --port parameter is accepted."""
+        result = subprocess.run(
+            ["python", "-m", "framework_m_core.cli.main", "start", "--help"],
+            capture_output=True,
+            text=True,
+        )
+        assert "--port" in result.stdout.lower()
+
+    def test_accepts_with_frontend_parameter(self) -> None:
+        """Test that --with-frontend parameter is accepted."""
+        result = subprocess.run(
+            ["python", "-m", "framework_m_core.cli.main", "start", "--help"],
+            capture_output=True,
+            text=True,
+        )
+        assert "--with-frontend" in result.stdout.lower()
+
+
+class TestCLIStructure:
+    """Test overall CLI structure."""
+
+    def test_main_cli_runs(self) -> None:
+        """Test that main CLI runs without errors."""
+        result = subprocess.run(
+            ["python", "-m", "framework_m_core.cli.main", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        assert result.returncode == 0
+        assert "framework" in result.stdout.lower() or "usage" in result.stdout.lower()
+
+    def test_all_commands_listed(self) -> None:
+        """Test that key commands are listed in help."""
+        result = subprocess.run(
+            ["python", "-m", "framework_m_core.cli.main", "--help"],
+            capture_output=True,
+            text=True,
+        )
+
+        # Should list major commands
+        help_text = result.stdout.lower()
+        assert "start" in help_text
+        assert "init" in help_text or "frontend" in help_text
+
+
+@pytest.mark.skipif(
+    not Path("frontend").exists(),
+    reason="Frontend template not available",
+)
+class TestTemplateStructure:
+    """Test frontend template structure (fast validation)."""
+
+    def test_template_has_package_json(self) -> None:
+        """Test template has package.json."""
+        template = Path("frontend")
+        assert (template / "package.json").exists()
+
+    def test_template_has_vite_config(self) -> None:
+        """Test template has vite.config.ts."""
+        template = Path("frontend")
+        assert (template / "vite.config.ts").exists()
+
+    def test_template_has_tsconfig(self) -> None:
+        """Test template has tsconfig.json."""
+        template = Path("frontend")
+        assert (template / "tsconfig.json").exists()
+
+    def test_template_has_src_directory(self) -> None:
+        """Test template has src directory with essential files."""
+        template = Path("frontend")
+        assert (template / "src").exists()
+        assert (template / "src" / "App.tsx").exists()
+        assert (template / "src" / "index.tsx").exists()
+
+    def test_template_has_npmrc(self) -> None:
+        """Test template has .npmrc for pnpm configuration."""
+        template = Path("frontend")
+        assert (template / ".npmrc").exists()
+
+    def test_package_json_has_required_deps(self) -> None:
+        """Test package.json has required dependencies."""
+        template = Path("frontend")
+        package_json = template / "package.json"
+        content = package_json.read_text()
+
+        # Should have Refine and React
+        assert "@refinedev/core" in content
+        assert "react" in content
+        assert "vite" in content
+
+
+@pytest.mark.skipif(
+    not Path("libs/framework-m-desk").exists(),
+    reason="@framework-m/desk package not available",
+)
+class TestDeskPackageStructure:
+    """Test @framework-m/desk package structure (fast validation)."""
+
+    def test_package_has_package_json(self) -> None:
+        """Test package has package.json."""
+        package = Path("libs/framework-m-desk")
+        assert (package / "package.json").exists()
+
+    def test_package_has_src_directory(self) -> None:
+        """Test package has src directory."""
+        package = Path("libs/framework-m-desk")
+        assert (package / "src").exists()
+        assert (package / "src" / "index.ts").exists()
+
+    def test_package_exports_providers(self) -> None:
+        """Test index.ts exports required providers."""
+        package = Path("libs/framework-m-desk")
+        index_file = package / "src" / "index.ts"
+        content = index_file.read_text()
+
+        expected_exports = [
+            "frameworkMDataProvider",
+            "authProvider",
+            "liveProvider",
+            "API_URL",
+        ]
+
+        for export in expected_exports:
+            assert export in content, f"Missing export: {export}"
+
+    def test_package_json_has_correct_config(self) -> None:
+        """Test package.json has correct configuration."""
+        package = Path("libs/framework-m-desk")
+        package_json = package / "package.json"
+        content = package_json.read_text()
+
+        assert "@framework-m/desk" in content
+        assert "dist/index.js" in content
+        assert "peerDependencies" in content
+
+
+class TestFrontendBuildConfig:
+    """Test frontend build configuration (no actual build)."""
+
+    @pytest.mark.skipif(
+        not Path("frontend").exists(),
+        reason="Frontend template not available",
+    )
+    def test_vite_config_exists_and_valid(self) -> None:
+        """Test vite config file exists and has basic structure."""
+        vite_config = Path("frontend/vite.config.ts")
+        assert vite_config.exists()
+
+        content = vite_config.read_text()
+        assert "defineConfig" in content
+        assert "plugins" in content
+
+    @pytest.mark.skipif(
+        not Path("frontend").exists(),
+        reason="Frontend template not available",
+    )
+    def test_tsconfig_exists_and_valid(self) -> None:
+        """Test TypeScript config exists and has basic structure."""
+        tsconfig = Path("frontend/tsconfig.json")
+        assert tsconfig.exists()
+
+        content = tsconfig.read_text()
+        assert "compilerOptions" in content
+
+    @pytest.mark.skipif(
+        not Path("frontend").exists(),
+        reason="Frontend template not available",
+    )
+    def test_npmrc_has_peer_dependency_config(self) -> None:
+        """Test .npmrc has peer dependency configuration."""
+        npmrc = Path("frontend/.npmrc")
+        if npmrc.exists():
+            content = npmrc.read_text()
+            # Should have peer dependency settings for compatibility
+            assert (
+                "legacy-peer-deps" in content.lower()
+                or "strict-peer-dependencies" in content.lower()
+            )
+
+
+class TestPackageJsonOverrides:
+    """Test package.json configuration."""
+
+    def test_root_package_json_exists_and_valid(self) -> None:
+        """Test root package.json exists and has valid monorepo config."""
+        package_json = Path("package.json")
+        if package_json.exists():
+            content = package_json.read_text()
+            import json
+
+            data = json.loads(content)
+            # Should be a monorepo with pnpm workspace
+            assert data.get("private") is True
+            # Overrides are optional - only needed if dependency conflicts exist
+            # Just verify the file is valid JSON and has basic monorepo structure
+
+
+class TestAutoFormTypescriptFix:
+    """Test AutoForm TypeScript fixes."""
+
+    @pytest.mark.skipif(
+        not Path("frontend/src/components/form/AutoForm.tsx").exists(),
+        reason="AutoForm component not available",
+    )
+    def test_autoform_has_validator_type_cast(self) -> None:
+        """Test AutoForm has ValidatorType cast to fix type error."""
+        autoform = Path("frontend/src/components/form/AutoForm.tsx")
+        content = autoform.read_text()
+
+        # Should import ValidatorType
+        assert "ValidatorType" in content
+
+        # Should have type cast
+        assert "as ValidatorType" in content
+
+    @pytest.mark.skipif(
+        not Path("frontend/src/components/form/AutoForm.tsx").exists(),
+        reason="AutoForm component not available",
+    )
+    def test_autoform_imports_rjsf_correctly(self) -> None:
+        """Test AutoForm imports from @rjsf packages."""
+        autoform = Path("frontend/src/components/form/AutoForm.tsx")
+        content = autoform.read_text()
+
+        assert "@rjsf/core" in content
+        assert "@rjsf/utils" in content
+        assert "@rjsf/validator-ajv8" in content