tw-framework 0.5.2__tar.gz → 0.6.2__tar.gz

{tw_framework-0.5.2 → tw_framework-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tw-framework
-Version: 0.5.2
+Version: 0.6.2
 Summary: TW framework CLI with create, dev, build, and deploy commands
 Author-email: KANISHK KUMAR <mlkraj290@gmail.com>
 Maintainer-email: Kanishk Kumar <mlkraj290@gmail.com>

{tw_framework-0.5.2 → tw_framework-0.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tw-framework"
-version = "0.5.2"
+version = "0.6.2"
 description = "TW framework CLI with create, dev, build, and deploy commands"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -26,8 +26,8 @@ dev = [
 [project.scripts]
 tw = "tw_framework.cli:main"
 
-[tool.setuptools]
-packages = ["tw_framework", "tw_framework.adapters"]
+[tool.setuptools.packages.find]
+include = ["tw_framework*"]
 
 [tool.setuptools.package-data]
 tw_framework = ["*.js"]

tw_framework-0.6.2/tests/test_component_classifier.py

@@ -0,0 +1,90 @@
+"""Tests for the component classifier."""
+import pytest
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from tw_framework.component_classifier import (
+    ComponentClassifier, ComponentClassification, STATIC,
+    CLIENT, SERVER,
+)
+
+
+class TestComponentClassification:
+    def test_static_component(self):
+        c = ComponentClassifier()
+        source = """div { class "card" } {
+  h1 { "Hello World" }
+  p { "This is static content" }
+}"""
+        result = c.classify("Card", source)
+        assert result.classification == STATIC
+        assert result.needs_client_js is False
+
+    def test_client_component_with_state(self):
+        c = ComponentClassifier()
+        source = 'state { count 0 }\nbutton { on:click "count++" } { "{count}" }'
+        result = c.classify("Counter", source)
+        assert result.classification == CLIENT
+        assert result.needs_client_js is True
+        assert result.needs_state is True
+
+    def test_client_component_with_events(self):
+        c = ComponentClassifier()
+        source = 'button { on:click "submit" } { "Submit" }'
+        result = c.classify("SubmitButton", source)
+        assert result.classification == CLIENT
+        assert result.needs_client_js is True
+
+    def test_client_component_with_bind(self):
+        c = ComponentClassifier()
+        source = 'input { bind:value "name" }'
+        result = c.classify("Input", source)
+        assert result.classification == CLIENT
+
+    def test_client_component_with_tw_state_import(self):
+        c = ComponentClassifier()
+        source = 'import { store } from "tw/state"'
+        result = c.classify("StateComp", source)
+        assert result.classification == CLIENT
+        assert result.needs_state is True
+
+    def test_client_component_with_tw_router_import(self):
+        c = ComponentClassifier()
+        source = 'import { Link } from "tw/router"'
+        result = c.classify("NavLink", source)
+        assert result.classification == CLIENT
+        assert result.needs_router is True
+
+    def test_client_component_with_tw_realtime_import(self):
+        c = ComponentClassifier()
+        source = 'import { socket } from "tw/realtime"'
+        result = c.classify("LiveCounter", source)
+        assert result.classification == CLIENT
+        assert result.needs_realtime is True
+
+    def test_explicit_static(self):
+        c = ComponentClassifier()
+        source = 'static true\nbutton { on:click "x" } { "Click" }'
+        result = c.classify("ForcedStatic", source)
+        assert result.classification == STATIC
+        assert result.needs_client_js is False
+
+    def test_explicit_client(self):
+        c = ComponentClassifier()
+        source = 'client true\nh1 { "Hello" }'
+        result = c.classify("ForcedClient", source)
+        assert result.classification == CLIENT
+        assert result.needs_client_js is True
+
+    def test_classify_page(self):
+        c = ComponentClassifier()
+        source = """page { title "Home" }
+state { count 0 }
+div {
+  button { on:click "count++" } { "Count: {count}" }
+}"""
+        result = c.classify_page(source)
+        assert result.classification == CLIENT
+        assert result.needs_state is True

tw_framework-0.6.2/tests/test_error_boundaries.py

@@ -0,0 +1,75 @@
+"""Tests for error boundaries."""
+import pytest
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from tw_framework.error_boundaries import (
+    ErrorInfo, render_error_page, render_404, render_500,
+    render_error_from_exception, render_loading, get_error_boundary_js,
+)
+
+
+class TestErrorPages:
+    def test_render_404(self):
+        html = render_404("/nonexistent")
+        assert "404" in html
+        assert "Not Found" in html
+
+    def test_render_500(self):
+        html = render_500("Something broke")
+        assert "500" in html
+        assert "Server Error" in html
+
+    def test_render_404_production_safe(self):
+        html = render_404("/path", is_dev=False)
+        assert "does not exist" in html
+        assert "Stack Trace" not in html
+
+    def test_render_error_with_dev_details(self):
+        error = ErrorInfo(
+            code=500,
+            title="Test Error",
+            message="Something went wrong",
+            stack="Error: at line 1\n    at test()",
+            is_dev=True,
+        )
+        html = render_error_page(error)
+        assert "Stack Trace" in html
+        assert "Error: at line 1" in html
+
+    def test_render_error_production_no_stack(self):
+        error = ErrorInfo(
+            code=500,
+            title="Test Error",
+            message="Internal error",
+            stack="secret stack trace",
+            is_dev=False,
+        )
+        html = render_error_page(error)
+        assert "secret stack trace" not in html
+
+    def test_render_error_from_exception(self):
+        try:
+            raise ValueError("Test error")
+        except ValueError as e:
+            html = render_error_from_exception(e, is_dev=True)
+            assert "ValueError" in html
+            assert "Test error" in html
+
+    def test_render_loading(self):
+        html = render_loading()
+        assert "tw-loading" in html
+
+    def test_get_error_boundary_js(self):
+        js = get_error_boundary_js()
+        assert "__tw.errorBoundary" in js
+        assert "catch" in js
+
+
+class TestErrorInfo:
+    def test_error_info_defaults(self):
+        info = ErrorInfo()
+        assert info.code == 500
+        assert info.is_dev is False

tw_framework-0.6.2/tests/test_js_interop.py

@@ -0,0 +1,68 @@
+"""Tests for JS/NPM interop."""
+import pytest
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from tw_framework.js_interop import JSInterop, NPMPackage
+from tw_framework.module_boundaries import CLIENT, SERVER
+
+
+class TestNPMPackageResolution:
+    def test_client_safe_package(self):
+        interop = JSInterop()
+        pkg = interop.resolve_npm_package("chart.js")
+        assert pkg is not None
+        assert pkg.boundary == CLIENT
+
+    def test_server_only_package(self):
+        interop = JSInterop()
+        pkg = interop.resolve_npm_package("express")
+        assert pkg is not None
+        assert pkg.boundary == SERVER
+
+    def test_unknown_package_defaults_to_client(self):
+        interop = JSInterop()
+        pkg = interop.resolve_npm_package("some-unknown-lib")
+        assert pkg is not None
+        assert pkg.boundary == CLIENT
+
+    def test_scoped_package_resolution(self):
+        interop = JSInterop()
+        pkg = interop.resolve_npm_package("@tiptap/core")
+        assert pkg is not None
+        assert pkg.boundary == CLIENT
+
+
+class TestDynamicImportDetection:
+    def test_detect_dynamic_import(self):
+        interop = JSInterop()
+        source = 'const mod = import("chart.js")'
+        results = interop.detect_dynamic_imports(source)
+        assert len(results) == 1
+        assert results[0]["path"] == "chart.js"
+        assert results[0]["dynamic"] is True
+
+    def test_no_dynamic_import(self):
+        interop = JSInterop()
+        source = 'import Chart from "chart.js"'
+        results = interop.detect_dynamic_imports(source)
+        assert len(results) == 0
+
+
+class TestServerIsolation:
+    def test_server_package_in_client_context_is_error(self):
+        interop = JSInterop()
+        from tw_framework.module_boundaries import ImportInfo
+        imports = [ImportInfo(path="express", context="client", line=1, file="test.tw")]
+        errors = interop.validate_server_isolation(imports)
+        assert len(errors) == 1
+        assert errors[0]["code"] == "TW3000"
+
+    def test_client_package_in_client_context_is_ok(self):
+        interop = JSInterop()
+        from tw_framework.module_boundaries import ImportInfo
+        imports = [ImportInfo(path="chart.js", context="client", line=1, file="test.tw")]
+        errors = interop.validate_server_isolation(imports)
+        assert len(errors) == 0

tw_framework-0.6.2/tests/test_module_boundaries.py

@@ -0,0 +1,164 @@
+"""Tests for the module boundary system."""
+import pytest
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from tw_framework.module_boundaries import (
+    ImportClassifier, ImportInfo, BoundaryViolation,
+    SERVER, CLIENT, SHARED,
+    ALL_TW_PACKAGES, TW_PACKAGE_BOUNDARIES,
+    is_tw_package, get_package_boundary,
+)
+
+
+class TestImportClassification:
+    def test_tw_state_is_client(self):
+        c = ImportClassifier()
+        assert c.classify_import("tw/state") == CLIENT
+
+    def test_tw_router_is_client(self):
+        c = ImportClassifier()
+        assert c.classify_import("tw/router") == CLIENT
+
+    def test_tw_form_is_client(self):
+        c = ImportClassifier()
+        assert c.classify_import("tw/form") == CLIENT
+
+    def test_tw_realtime_is_client(self):
+        c = ImportClassifier()
+        assert c.classify_import("tw/realtime") == CLIENT
+
+    def test_tw_auth_is_shared(self):
+        c = ImportClassifier()
+        assert c.classify_import("tw/auth") == SHARED
+
+    def test_tw_fetch_is_shared(self):
+        c = ImportClassifier()
+        assert c.classify_import("tw/fetch") == SHARED
+
+    def test_tw_image_is_shared(self):
+        c = ImportClassifier()
+        assert c.classify_import("tw/image") == SHARED
+
+    def test_tw_server_is_server(self):
+        c = ImportClassifier()
+        assert c.classify_import("tw/server") == SERVER
+
+    def test_npm_package_is_client(self):
+        c = ImportClassifier()
+        assert c.classify_import("chart.js") == CLIENT
+
+    def test_scoped_npm_is_client(self):
+        c = ImportClassifier()
+        assert c.classify_import("@tiptap/core") == CLIENT
+
+    def test_twm_file_is_server(self):
+        c = ImportClassifier()
+        assert c.classify_import("api.twm") == SERVER
+
+    def test_lib_import_is_server(self):
+        c = ImportClassifier()
+        assert c.classify_import("@lib/database") == SERVER
+
+    def test_tw_component_is_shared(self):
+        c = ImportClassifier()
+        assert c.classify_import("Button") == SHARED
+
+
+class TestBoundaryValidation:
+    def test_client_importing_server_is_error(self):
+        c = ImportClassifier()
+        imports = [ImportInfo(path="tw/server", context="client", line=1, file="test.tw")]
+        violations = c.validate_imports(imports)
+        assert len(violations) == 1
+        assert violations[0].code == "TW2000"
+
+    def test_server_importing_client_is_error(self):
+        c = ImportClassifier()
+        imports = [ImportInfo(path="tw/state", context="server", line=1, file="test.tw")]
+        violations = c.validate_imports(imports)
+        assert len(violations) == 1
+        assert violations[0].code == "TW2001"
+
+    def test_valid_imports_no_violations(self):
+        c = ImportClassifier()
+        imports = [
+            ImportInfo(path="tw/state", context="client", line=1, file="test.tw"),
+            ImportInfo(path="tw/server", context="server", line=2, file="test.tw"),
+        ]
+        violations = c.validate_imports(imports)
+        assert len(violations) == 0
+
+    def test_get_client_imports_filters_correctly(self):
+        c = ImportClassifier()
+        imports = [
+            ImportInfo(path="tw/state", context="client", line=1),
+            ImportInfo(path="tw/server", context="server", line=2),
+            ImportInfo(path="tw/fetch", context="client", line=3),
+        ]
+        client_imports = c.get_client_imports(imports)
+        paths = [imp.path for imp in client_imports]
+        assert "tw/state" in paths
+        assert "tw/fetch" in paths
+        assert "tw/server" not in paths
+
+
+class TestSourceScanning:
+    def test_scan_simple_import(self):
+        c = ImportClassifier()
+        source = 'import "Button"'
+        imports = c.scan_source_imports(source, "test.tw")
+        assert len(imports) == 1
+        assert imports[0].path == "Button"
+
+    def test_scan_named_import(self):
+        c = ImportClassifier()
+        source = 'import { store } from "tw/state"'
+        imports = c.scan_source_imports(source, "test.tw")
+        assert len(imports) == 1
+        assert imports[0].path == "tw/state"
+
+    def test_scan_default_import(self):
+        c = ImportClassifier()
+        source = 'import Chart from "chart.js"'
+        imports = c.scan_source_imports(source, "test.tw")
+        assert len(imports) == 1
+        assert imports[0].path == "chart.js"
+
+    def test_scan_multiple_imports(self):
+        c = ImportClassifier()
+        source = """import "Button"
+import { store } from "tw/state"
+import Chart from "chart.js"
+"""
+        imports = c.scan_source_imports(source, "test.tw")
+        assert len(imports) == 3
+
+    def test_is_tw_package(self):
+        assert is_tw_package("tw/state") is True
+        assert is_tw_package("tw/router") is True
+        assert is_tw_package("chart.js") is False
+
+    def test_get_package_boundary(self):
+        assert get_package_boundary("tw/state") == CLIENT
+        assert get_package_boundary("tw/auth") == SHARED
+        assert get_package_boundary("tw/server") == SERVER
+
+
+class TestModuleSourceClassification:
+    def test_server_api_detected(self):
+        c = ImportClassifier()
+        source = "const fs = require('fs')"
+        assert c.classify_module_source(source) == SERVER
+
+    def test_client_api_detected(self):
+        c = ImportClassifier()
+        source = "document.getElementById('app')"
+        assert c.classify_module_source(source) == CLIENT
+
+    def test_pure_module_is_shared(self):
+        c = ImportClassifier()
+        source = "function add(a, b) { return a + b; }"
+        assert c.classify_module_source(source) == SHARED

tw_framework-0.6.2/tests/test_runtime_loader.py

@@ -0,0 +1,96 @@
+"""Tests for the runtime loader."""
+import pytest
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from tw_framework.runtime_loader import PageCapability, RuntimeLoader
+
+
+class TestPageCapability:
+    def test_default_is_zero_js(self):
+        cap = PageCapability()
+        assert cap.is_zero_js is True
+
+    def test_needs_state_disables_zero_js(self):
+        cap = PageCapability(needs_state=True)
+        assert cap.is_zero_js is False
+
+    def test_needs_router_disables_zero_js(self):
+        cap = PageCapability(needs_router=True)
+        assert cap.is_zero_js is False
+
+    def test_needs_npm_packages_disables_zero_js(self):
+        cap = PageCapability(needs_npm_packages=["chart.js"])
+        assert cap.is_zero_js is False
+
+
+class TestRuntimeLoader:
+    def test_analyze_static_page(self):
+        loader = RuntimeLoader()
+        cap = loader.analyze_page_capabilities(
+            source="<h1>Hello</h1>",
+            page_ast=None,
+        )
+        assert cap.is_zero_js is True
+
+    def test_analyze_state_page(self):
+        loader = RuntimeLoader()
+        cap = loader.analyze_page_capabilities(
+            source="state { count 0 }",
+            page_ast=None,
+        )
+        assert cap.is_zero_js is False
+        assert cap.needs_state is True
+
+    def test_analyze_router_page(self):
+        loader = RuntimeLoader()
+        cap = loader.analyze_page_capabilities(
+            source='Link { href "/dashboard" } { "Dashboard" }',
+            page_ast=None,
+        )
+        assert cap.needs_router is True
+
+    def test_analyze_realtime_page(self):
+        loader = RuntimeLoader()
+        cap = loader.analyze_page_capabilities(
+            source="socket('/api/events')",
+            page_ast=None,
+        )
+        assert cap.needs_realtime is True
+
+    def test_analyze_form_page(self):
+        loader = RuntimeLoader()
+        cap = loader.analyze_page_capabilities(
+            source='Form { action "/api/contact" } { }',
+            page_ast=None,
+        )
+        assert cap.needs_forms is True
+
+    def test_generate_runtime_tags_zero_js(self):
+        loader = RuntimeLoader()
+        cap = PageCapability()
+        tags = loader.generate_runtime_tags(cap)
+        assert tags == ""
+
+    def test_generate_runtime_tags_with_state(self):
+        loader = RuntimeLoader()
+        cap = PageCapability(needs_state=True)
+        tags = loader.generate_runtime_tags(cap)
+        assert "state" in tags
+        assert "base" in tags
+
+    def test_get_required_runtimes_zero_js(self):
+        loader = RuntimeLoader()
+        cap = PageCapability()
+        runtimes = loader.get_required_runtimes(cap)
+        assert len(runtimes) == 0
+
+    def test_get_required_runtimes_interactive(self):
+        loader = RuntimeLoader()
+        cap = PageCapability(needs_state=True, needs_router=True)
+        runtimes = loader.get_required_runtimes(cap)
+        assert "base" in runtimes
+        assert "state" in runtimes
+        assert "router" in runtimes

tw_framework-0.6.2/tests/test_server_actions.py

@@ -0,0 +1,119 @@
+"""Tests for server actions."""
+import pytest
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from tw_framework.server_actions import (
+    ActionRegistry, ServerAction, handle_action_request,
+    get_action_registry, register_action,
+)
+
+
+class TestActionRegistry:
+    def test_register_action(self):
+        registry = ActionRegistry()
+        registry.register("test_action", lambda args, session=None: {"ok": True})
+        assert "test_action" in registry.list_actions()
+
+    def test_get_action(self):
+        registry = ActionRegistry()
+        registry.register("test_action", lambda args, session=None: {"ok": True})
+        action = registry.get("test_action")
+        assert action is not None
+        assert action.name == "test_action"
+
+    def test_get_unknown_action(self):
+        registry = ActionRegistry()
+        assert registry.get("nonexistent") is None
+
+    def test_execute_action(self):
+        registry = ActionRegistry()
+        registry.register(
+            "create_post",
+            lambda args, session=None: {"id": 1, "title": args.get("title")},
+            require_auth=False,
+            require_csrf=False,
+        )
+        result = registry.execute("create_post", {"title": "Hello"}, session=None, csrf_token="")
+        assert result["ok"] is True
+        assert result["data"]["title"] == "Hello"
+
+    def test_execute_unknown_action(self):
+        registry = ActionRegistry()
+        result = registry.execute("unknown", {}, session=None, csrf_token="")
+        assert result["ok"] is False
+        assert result["status"] == 404
+
+    def test_execute_requires_auth(self):
+        registry = ActionRegistry()
+        registry.register("secret", lambda args, session=None: "data", require_auth=True, require_csrf=False)
+        result = registry.execute("secret", {}, session=None, csrf_token="")
+        assert result["ok"] is False
+        assert result["status"] == 401
+
+    def test_execute_requires_csrf(self):
+        registry = ActionRegistry()
+        registry.register("protected", lambda args, session=None: "data", require_auth=False, require_csrf=True)
+        result = registry.execute("protected", {}, session=None, csrf_token="")
+        assert result["ok"] is False
+        assert result["status"] == 403
+
+    def test_validate_args(self):
+        registry = ActionRegistry()
+        registry.register(
+            "create_user",
+            lambda args, session=None: {"created": True},
+            schema={"name": {"required": True, "type": "string"}},
+            require_auth=False,
+            require_csrf=False,
+        )
+        result = registry.execute("create_user", {}, session=None, csrf_token="")
+        assert result["ok"] is False
+        assert "Missing required field" in result["error"]
+
+    def test_validate_args_type(self):
+        registry = ActionRegistry()
+        registry.register(
+            "set_age",
+            lambda args, session=None: {"ok": True},
+            schema={"age": {"required": True, "type": "number"}},
+            require_auth=False,
+            require_csrf=False,
+        )
+        result = registry.execute("set_age", {"age": "not-a-number"}, session=None, csrf_token="")
+        assert result["ok"] is False
+        assert "must be a number" in result["error"]
+
+
+class TestHandleActionRequest:
+    def test_missing_action_name(self):
+        result = handle_action_request({"args": {}}, {})
+        assert result["status"] == 400
+
+    def test_unknown_action(self):
+        result = handle_action_request(
+            {"action": "unknown", "args": {}, "csrf": "token"},
+            {},
+        )
+        import json
+        data = json.loads(result["body"])
+        assert data["ok"] is False
+
+
+class TestActionRegistration:
+    def teardown_method(self):
+        """Clean up global registry."""
+        registry = get_action_registry()
+        registry._actions.clear()
+
+    def test_global_register(self):
+        register_action(
+            "global_test",
+            lambda args, session=None: {"ok": True},
+            require_auth=False,
+            require_csrf=False,
+        )
+        registry = get_action_registry()
+        assert "global_test" in registry.list_actions()