fw-nodes-github 0.0.1a1__tar.gz

fw_nodes_github-0.0.1a1/.forgejo/workflows/tag-release.yml

@@ -0,0 +1,41 @@
+name: Tag & Publish
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  tag-and-publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: Public-Mirrors/actions_checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Extract version from pyproject.toml
+        id: version
+        run: |
+          VERSION=$(grep '^version' pyproject.toml | head -1 | sed 's/.*"\(.*\)".*/\1/')
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+          echo "Detected version: $VERSION"
+
+      - name: Check if tag already exists
+        run: |
+          if git rev-parse "v${{ steps.version.outputs.version }}" >/dev/null 2>&1; then
+            echo "::error::Tag v${{ steps.version.outputs.version }} already exists. Bump the version in pyproject.toml before pushing to main."
+            exit 1
+          fi
+
+      - name: Create and push tag
+        run: |
+          git tag "v${{ steps.version.outputs.version }}"
+          git push origin "v${{ steps.version.outputs.version }}"
+
+      - name: Install uv
+        run: curl -LsSf https://astral.sh/uv/install.sh | sh
+
+      - name: Build and publish
+        run: |
+          uv build
+          uv publish --token ${{ secrets.PYPI_API_TOKEN }}

fw_nodes_github-0.0.1a1/.gitignore

@@ -0,0 +1,41 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+
+# Environment files
+.env
+.env.local
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+coverage.xml
+
+# Build artifacts
+dist/
+build/
+*.egg-info/
+.eggs/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# uv
+uv.lock

fw_nodes_github-0.0.1a1/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: fw-nodes-github
+Version: 0.0.1a1
+Summary: GitHub nodes for Flowire workflow automation
+License-Expression: MIT
+Requires-Python: >=3.13
+Requires-Dist: flowire-sdk>=0.0.1a1
+Requires-Dist: httpx>=0.26.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# fw-nodes-github
+
+GitHub nodes for [Flowire](https://github.com/flowire) workflow automation.
+
+## Nodes
+
+- **GitHub Get Repo** — Get details about a GitHub repository by URL or owner/repo
+
+## Installation
+
+```bash
+uv pip install fw-nodes-github
+```
+
+Enable in your Flowire backend `.env`:
+
+```
+INSTALLED_NODE_PACKAGES=fw-nodes-core,fw-nodes-github
+```

fw_nodes_github-0.0.1a1/README.md

@@ -0,0 +1,19 @@
+# fw-nodes-github
+
+GitHub nodes for [Flowire](https://github.com/flowire) workflow automation.
+
+## Nodes
+
+- **GitHub Get Repo** — Get details about a GitHub repository by URL or owner/repo
+
+## Installation
+
+```bash
+uv pip install fw-nodes-github
+```
+
+Enable in your Flowire backend `.env`:
+
+```
+INSTALLED_NODE_PACKAGES=fw-nodes-core,fw-nodes-github
+```

fw_nodes_github-0.0.1a1/fw_nodes_github/__init__.py

@@ -0,0 +1 @@
+"""GitHub nodes for Flowire workflow automation."""

fw_nodes_github-0.0.1a1/fw_nodes_github/credentials.py

@@ -0,0 +1,21 @@
+"""Shared credential schemas for GitHub nodes."""
+
+from typing import ClassVar
+
+from pydantic import BaseModel, Field
+
+
+class GitHubCredentialSchema(BaseModel):
+    """Credential schema for GitHub API authentication.
+
+    Shared across all GitHub nodes in this package.
+    """
+
+    credential_name: ClassVar[str] = "GitHub"
+    credential_description: ClassVar[str] = "GitHub personal access token for API authentication"
+    credential_icon: ClassVar[str | None] = "github"
+
+    personal_access_token: str = Field(
+        ...,
+        description="Personal access token (Settings → Developer settings → Personal access tokens)",
+    )

fw_nodes_github-0.0.1a1/fw_nodes_github/nodes/__init__.py

@@ -0,0 +1,5 @@
+"""Node implementations for GitHub integration.
+
+Nodes in this package are auto-discovered via entry points.
+No manual imports or registration needed.
+"""

fw_nodes_github-0.0.1a1/fw_nodes_github/nodes/get_repo.py

@@ -0,0 +1,158 @@
+"""Get details about a GitHub repository."""
+
+import re
+from typing import Any
+
+import httpx
+from flowire_sdk import BaseNode, BaseNodeOutput, InputField, NodeExecutionContext, NodeMetadata
+from pydantic import BaseModel, Field
+
+from fw_nodes_github.credentials import GitHubCredentialSchema
+
+GITHUB_API_BASE = "https://api.github.com"
+
+# Matches: https://github.com/owner/repo, https://github.com/owner/repo.git, owner/repo
+GITHUB_REPO_PATTERN = re.compile(r"(?:https?://github\.com/)?([a-zA-Z0-9\-_.]+)/([a-zA-Z0-9\-_.]+?)(?:\.git)?/?$")
+
+
+def parse_repo_identifier(repo_input: str) -> tuple[str, str]:
+    """Parse a GitHub repo identifier into (owner, repo).
+
+    Accepts:
+        - "owner/repo"
+        - "https://github.com/owner/repo"
+        - "https://github.com/owner/repo.git"
+    """
+    repo_input = repo_input.strip()
+    match = GITHUB_REPO_PATTERN.match(repo_input)
+    if not match:
+        raise ValueError(
+            f"Invalid GitHub repository: '{repo_input}'. Use 'owner/repo' or 'https://github.com/owner/repo'."
+        )
+    return match.group(1), match.group(2)
+
+
+class GetRepoInput(BaseModel):
+    credential_id: str | None = InputField(
+        default=None,
+        description="Optional GitHub credential for private repos or higher rate limits",
+    )
+    repository: str = InputField(
+        ...,
+        description="GitHub repository — either 'owner/repo' or a full GitHub URL",
+    )
+
+
+class GetRepoOutput(BaseNodeOutput):
+    owner: str = Field(..., description="Repository owner (user or organization)")
+    name: str = Field(..., description="Repository name")
+    full_name: str = Field(..., description="Full name (owner/repo)")
+    description: str = Field(..., description="Repository description")
+    html_url: str = Field(..., description="URL to view the repository on GitHub")
+    clone_url: str = Field(..., description="HTTPS clone URL")
+    ssh_url: str = Field(..., description="SSH clone URL")
+    language: str = Field(..., description="Primary programming language")
+    default_branch: str = Field(..., description="Default branch name")
+    stargazers_count: int = Field(..., description="Number of stars")
+    forks_count: int = Field(..., description="Number of forks")
+    open_issues_count: int = Field(..., description="Number of open issues")
+    watchers_count: int = Field(..., description="Number of watchers")
+    is_fork: bool = Field(..., description="Whether the repository is a fork")
+    is_archived: bool = Field(..., description="Whether the repository is archived")
+    is_private: bool = Field(..., description="Whether the repository is private")
+    created_at: str = Field(..., description="Repository creation date (ISO 8601)")
+    updated_at: str = Field(..., description="Last update date (ISO 8601)")
+    pushed_at: str = Field(..., description="Last push date (ISO 8601)")
+    license_name: str = Field(..., description="License name (empty if none)")
+    topics: list[str] = Field(..., description="Repository topics/tags")
+    size_kb: int = Field(..., description="Repository size in KB")
+
+
+class GitHubGetRepoNode(BaseNode):
+    """Get details about a GitHub repository."""
+
+    input_schema = GetRepoInput
+    output_schema = GetRepoOutput
+    credential_schema = GitHubCredentialSchema
+
+    metadata = NodeMetadata(
+        name="GitHub Get Repo",
+        description="Get details about a GitHub repository by URL or owner/repo",
+        category="github",
+        icon="github",
+        color="#24292e",
+    )
+
+    async def execute_logic(
+        self,
+        validated_inputs: dict[str, Any],
+        context: NodeExecutionContext,
+    ) -> GetRepoOutput:
+        owner, repo = parse_repo_identifier(validated_inputs["repository"])
+
+        headers: dict[str, str] = {
+            "Accept": "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28",
+        }
+
+        credential_id = validated_inputs.get("credential_id")
+        if credential_id:
+            credential_data = await context.resolve_credential(
+                credential_id=credential_id,
+                credential_type=self.get_credential_type(),
+            )
+            token = credential_data["personal_access_token"]
+            context.register_secret(token)
+            headers["Authorization"] = f"Bearer {token}"
+
+        async with httpx.AsyncClient() as client:
+            response = await client.get(
+                f"{GITHUB_API_BASE}/repos/{owner}/{repo}",
+                headers=headers,
+                timeout=30,
+            )
+
+        if response.status_code == 404:
+            raise RuntimeError(
+                f"Repository '{owner}/{repo}' not found. It may not exist or you may need credentials for private repos."
+            )
+        if response.status_code == 403:
+            raise RuntimeError(
+                f"GitHub API rate limit exceeded or access denied for '{owner}/{repo}'. "
+                "Add a GitHub credential for higher rate limits."
+            )
+        if response.status_code != 200:
+            try:
+                error_detail = response.json().get("message", response.text)
+            except Exception:
+                error_detail = response.text
+            raise RuntimeError(f"GitHub API error ({response.status_code}): {error_detail}")
+
+        data = response.json()
+
+        license_info = data.get("license") or {}
+
+        return GetRepoOutput(
+            owner=data["owner"]["login"],
+            name=data["name"],
+            full_name=data["full_name"],
+            description=data.get("description") or "",
+            html_url=data["html_url"],
+            clone_url=data["clone_url"],
+            ssh_url=data["ssh_url"],
+            language=data.get("language") or "",
+            default_branch=data["default_branch"],
+            stargazers_count=data["stargazers_count"],
+            forks_count=data["forks_count"],
+            open_issues_count=data["open_issues_count"],
+            watchers_count=data["watchers_count"],
+            is_fork=data["fork"],
+            is_archived=data["archived"],
+            is_private=data["private"],
+            created_at=data["created_at"],
+            updated_at=data["updated_at"],
+            pushed_at=data.get("pushed_at") or "",
+            license_name=license_info.get("name") or "",
+            topics=data.get("topics") or [],
+            size_kb=data.get("size", 0),
+        )

fw_nodes_github-0.0.1a1/justfile

@@ -0,0 +1,53 @@
+# Flowire GitHub Nodes development commands
+
+# Default recipe - show available commands
+default:
+    @just --list
+
+# Install dependencies (including dev)
+install:
+    uv sync --all-extras
+
+# Run linter
+lint:
+    uv run ruff check .
+
+# Run linter and fix auto-fixable issues
+lint-fix:
+    uv run ruff check --fix .
+
+# Format code
+format:
+    uv run ruff format .
+
+# Check formatting without making changes
+format-check:
+    uv run ruff format --check .
+
+# Run all checks (lint + format check)
+check: lint format-check
+
+# Run tests
+test:
+    uv run pytest
+
+# Run tests with verbose output
+test-verbose:
+    uv run pytest -v
+
+# Run tests with coverage
+test-cov:
+    uv run pytest --cov=fw_nodes_github --cov-report=term-missing
+
+# Build the package
+build:
+    uv build
+
+# Publish to PyPI (requires UV_PUBLISH_TOKEN env var)
+publish: build
+    uv publish
+
+# Clean build artifacts
+clean:
+    rm -rf dist/ build/ *.egg-info/ .pytest_cache/ .ruff_cache/ .coverage htmlcov/
+    find . -type d -name __pycache__ -exec rm -rf {} + 2>/dev/null || true

fw_nodes_github-0.0.1a1/pyproject.toml

@@ -0,0 +1,54 @@
+[project]
+name = "fw-nodes-github"
+version = "0.0.1a1"
+description = "GitHub nodes for Flowire workflow automation"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.13"
+dependencies = [
+    "flowire-sdk>=0.0.1a1",
+    "httpx>=0.26.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "ruff>=0.4.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fw_nodes_github"]
+
+[project.entry-points."flowire.nodes"]
+github_get_repo = "fw_nodes_github.nodes.get_repo:GitHubGetRepoNode"
+
+[tool.ruff]
+target-version = "py313"
+line-length = 120
+
+[tool.ruff.lint]
+select = [
+    "E",      # pycodestyle errors
+    "W",      # pycodestyle warnings
+    "F",      # pyflakes
+    "I",      # isort
+    "B",      # flake8-bugbear
+    "C4",     # flake8-comprehensions
+    "UP",     # pyupgrade
+]
+ignore = [
+    "E501",   # line too long (handled by formatter)
+    "B008",   # do not perform function calls in argument defaults
+]
+
+[tool.ruff.lint.isort]
+known-first-party = ["fw_nodes_github"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

fw_nodes_github-0.0.1a1/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for fw-nodes-github."""

fw_nodes_github-0.0.1a1/tests/conftest.py

@@ -0,0 +1,107 @@
+"""Shared test fixtures for fw-nodes-github tests."""
+
+from typing import Any
+from uuid import uuid4
+
+import pytest
+from flowire_sdk import NodeExecutionContext
+
+
+class MockExecutionContext(NodeExecutionContext):
+    """Mock execution context for testing nodes."""
+
+    def __init__(
+        self,
+        workflow_id: str | None = None,
+        execution_id: str | None = None,
+        node_id: str | None = None,
+        project_id: str | None = None,
+        user_id: str | None = None,
+        node_results: dict[str, dict[str, Any]] | None = None,
+        project_variables: dict[str, Any] | None = None,
+        credentials: dict[str, dict] | None = None,
+        binary_store: dict[str, bytes] | None = None,
+    ):
+        self.workflow_id = workflow_id or str(uuid4())
+        self.execution_id = execution_id or str(uuid4())
+        self.node_id = node_id or "test_node"
+        self.project_id = project_id or str(uuid4())
+        self.user_id = user_id or str(uuid4())
+        self.node_results = node_results or {}
+        self._secrets: set[str] = set()
+        self._project_variables = project_variables or {}
+        self._credentials = credentials or {}
+        self._binary_store: dict[str, bytes] = binary_store or {}
+
+    async def resolve_credential(self, credential_id: str, credential_type: str) -> dict:
+        if credential_id in self._credentials:
+            return self._credentials[credential_id]
+        raise ValueError(f"Credential {credential_id} not found")
+
+    async def resolve_credential_by_id(self, credential_id: str) -> dict:
+        if credential_id in self._credentials:
+            return self._credentials[credential_id]
+        raise ValueError(f"Credential {credential_id} not found")
+
+    async def resolve_project_variable(self, key: str) -> Any:
+        if key in self._project_variables:
+            return self._project_variables[key]
+        raise ValueError(f"Project variable {key} not found")
+
+    async def resolve_project_variable_by_id(self, variable_id: str) -> Any:
+        if variable_id in self._project_variables:
+            return self._project_variables[variable_id]
+        raise ValueError(f"Project variable {variable_id} not found")
+
+    def register_secret(self, value: str) -> None:
+        if value:
+            self._secrets.add(value)
+
+    def get_secrets(self) -> set:
+        return self._secrets
+
+    def store_binary(
+        self,
+        data: bytes,
+        filename: str,
+        content_type: str = "application/octet-stream",
+        metadata: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        uri = f"storage://test/{self.project_id}/{filename}"
+        self._binary_store[uri] = data
+        return {
+            "_type": "storage_reference",
+            "uri": uri,
+            "metadata": {"content_type": content_type, **(metadata or {})},
+        }
+
+    def retrieve_binary(self, reference: dict[str, Any]) -> bytes:
+        uri = reference.get("uri", "")
+        if uri not in self._binary_store:
+            raise ValueError(f"Storage reference not found: {uri}")
+        return self._binary_store[uri]
+
+    def publish_webhook_error(self, error: str, status_code: int = 400) -> None:
+        pass
+
+    def publish_immediate_response(
+        self,
+        status_code: int = 200,
+        body: Any = None,
+        content_type: str = "application/json",
+        headers: dict[str, str] | None = None,
+    ) -> None:
+        pass
+
+
+@pytest.fixture
+def mock_context():
+    """Create a MockExecutionContext for testing."""
+    return MockExecutionContext(
+        workflow_id="wf_123",
+        execution_id="exec_456",
+        node_id="node_789",
+        project_id="proj_abc",
+        user_id="user_xyz",
+        node_results={},
+    )

fw_nodes_github-0.0.1a1/tests/test_get_repo.py

@@ -0,0 +1,184 @@
+"""Tests for GitHubGetRepoNode."""
+
+from unittest.mock import AsyncMock, patch
+
+import httpx
+import pytest
+
+from fw_nodes_github.nodes.get_repo import GitHubGetRepoNode, parse_repo_identifier
+
+SAMPLE_REPO_RESPONSE = {
+    "id": 1234,
+    "name": "my-repo",
+    "full_name": "octocat/my-repo",
+    "owner": {"login": "octocat"},
+    "description": "A test repository",
+    "html_url": "https://github.com/octocat/my-repo",
+    "clone_url": "https://github.com/octocat/my-repo.git",
+    "ssh_url": "git@github.com:octocat/my-repo.git",
+    "language": "Python",
+    "default_branch": "main",
+    "stargazers_count": 42,
+    "forks_count": 10,
+    "open_issues_count": 5,
+    "watchers_count": 42,
+    "fork": False,
+    "archived": False,
+    "private": False,
+    "created_at": "2024-01-01T00:00:00Z",
+    "updated_at": "2024-06-15T12:00:00Z",
+    "pushed_at": "2024-06-15T11:00:00Z",
+    "license": {"name": "MIT License"},
+    "topics": ["python", "automation"],
+    "size": 1024,
+}
+
+
+def _mock_response(status_code: int = 200, json_data: dict | None = None, text: str = "") -> httpx.Response:
+    response = httpx.Response(
+        status_code=status_code,
+        json=json_data if json_data is not None else SAMPLE_REPO_RESPONSE,
+        request=httpx.Request("GET", "https://api.github.com/repos/octocat/my-repo"),
+    )
+    return response
+
+
+@pytest.fixture
+def node():
+    return GitHubGetRepoNode()
+
+
+# --- parse_repo_identifier tests ---
+
+
+class TestParseRepoIdentifier:
+    def test_owner_repo(self):
+        assert parse_repo_identifier("octocat/my-repo") == ("octocat", "my-repo")
+
+    def test_full_url(self):
+        assert parse_repo_identifier("https://github.com/octocat/my-repo") == ("octocat", "my-repo")
+
+    def test_full_url_with_git_suffix(self):
+        assert parse_repo_identifier("https://github.com/octocat/my-repo.git") == ("octocat", "my-repo")
+
+    def test_full_url_trailing_slash(self):
+        assert parse_repo_identifier("https://github.com/octocat/my-repo/") == ("octocat", "my-repo")
+
+    def test_http_url(self):
+        assert parse_repo_identifier("http://github.com/octocat/my-repo") == ("octocat", "my-repo")
+
+    def test_with_whitespace(self):
+        assert parse_repo_identifier("  octocat/my-repo  ") == ("octocat", "my-repo")
+
+    def test_dots_and_underscores(self):
+        assert parse_repo_identifier("my.org/my_repo.js") == ("my.org", "my_repo.js")
+
+    def test_invalid_empty(self):
+        with pytest.raises(ValueError, match="Invalid GitHub repository"):
+            parse_repo_identifier("")
+
+    def test_invalid_no_slash(self):
+        with pytest.raises(ValueError, match="Invalid GitHub repository"):
+            parse_repo_identifier("just-a-name")
+
+    def test_invalid_too_many_segments(self):
+        with pytest.raises(ValueError, match="Invalid GitHub repository"):
+            parse_repo_identifier("https://github.com/a/b/c/d")
+
+
+# --- Node execution tests ---
+
+
+class TestGitHubGetRepoNode:
+    async def test_success_with_owner_repo(self, node, mock_context):
+        with patch("fw_nodes_github.nodes.get_repo.httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.get = AsyncMock(return_value=_mock_response())
+            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+            mock_client.__aexit__ = AsyncMock(return_value=False)
+            mock_client_cls.return_value = mock_client
+
+            result = await node.execute({"repository": "octocat/my-repo"}, mock_context)
+
+        assert result.full_name == "octocat/my-repo"
+        assert result.owner == "octocat"
+        assert result.name == "my-repo"
+        assert result.stargazers_count == 42
+        assert result.language == "Python"
+        assert result.topics == ["python", "automation"]
+        assert result.license_name == "MIT License"
+
+    async def test_success_with_full_url(self, node, mock_context):
+        with patch("fw_nodes_github.nodes.get_repo.httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.get = AsyncMock(return_value=_mock_response())
+            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+            mock_client.__aexit__ = AsyncMock(return_value=False)
+            mock_client_cls.return_value = mock_client
+
+            result = await node.execute({"repository": "https://github.com/octocat/my-repo"}, mock_context)
+
+        assert result.full_name == "octocat/my-repo"
+
+    async def test_with_credential(self, node, mock_context):
+        mock_context._credentials["cred_1"] = {"personal_access_token": "ghp_test123"}
+
+        with patch("fw_nodes_github.nodes.get_repo.httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.get = AsyncMock(return_value=_mock_response())
+            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+            mock_client.__aexit__ = AsyncMock(return_value=False)
+            mock_client_cls.return_value = mock_client
+
+            result = await node.execute({"repository": "octocat/my-repo", "credential_id": "cred_1"}, mock_context)
+
+        assert result.full_name == "octocat/my-repo"
+        # Verify auth header was sent
+        call_kwargs = mock_client.get.call_args
+        assert call_kwargs.kwargs["headers"]["Authorization"] == "Bearer ghp_test123"
+        # Verify secret was registered
+        assert "ghp_test123" in mock_context.get_secrets()
+
+    async def test_repo_not_found(self, node, mock_context):
+        with patch("fw_nodes_github.nodes.get_repo.httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.get = AsyncMock(
+                return_value=_mock_response(status_code=404, json_data={"message": "Not Found"})
+            )
+            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+            mock_client.__aexit__ = AsyncMock(return_value=False)
+            mock_client_cls.return_value = mock_client
+
+            with pytest.raises(RuntimeError, match="not found"):
+                await node.execute({"repository": "octocat/nonexistent"}, mock_context)
+
+    async def test_rate_limit(self, node, mock_context):
+        with patch("fw_nodes_github.nodes.get_repo.httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.get = AsyncMock(
+                return_value=_mock_response(status_code=403, json_data={"message": "rate limit exceeded"})
+            )
+            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+            mock_client.__aexit__ = AsyncMock(return_value=False)
+            mock_client_cls.return_value = mock_client
+
+            with pytest.raises(RuntimeError, match="rate limit"):
+                await node.execute({"repository": "octocat/my-repo"}, mock_context)
+
+    async def test_null_optional_fields(self, node, mock_context):
+        """Repo with null language, no license, no topics."""
+        data = {**SAMPLE_REPO_RESPONSE, "language": None, "license": None, "topics": None, "pushed_at": None}
+
+        with patch("fw_nodes_github.nodes.get_repo.httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.get = AsyncMock(return_value=_mock_response(json_data=data))
+            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+            mock_client.__aexit__ = AsyncMock(return_value=False)
+            mock_client_cls.return_value = mock_client
+
+            result = await node.execute({"repository": "octocat/my-repo"}, mock_context)
+
+        assert result.language == ""
+        assert result.license_name == ""
+        assert result.topics == []
+        assert result.pushed_at == ""