feat: Add functionality to expand compact flow format #10785

ogabrielluiz · 2025-11-28T19:37:47Z

Introduce an endpoint to expand a compact flow format into a full flow format, along with unit tests to ensure the functionality works as intended. This enhancement allows for better integration with AI-generated flows.

Summary by CodeRabbit

New Features
- Added new API endpoint to expand compact AI-generated flow representations into complete, usable flow format.
- System now validates component availability and handles errors gracefully during flow expansion.
Tests
- Added comprehensive unit and integration tests for flow expansion functionality, including error handling and endpoint validation scenarios.

_{✏️ Tip: You can customize this high-level summary in your review settings.}

coderabbitai · 2025-11-28T19:38:05Z

Important

Review skipped

Auto incremental reviews are disabled on this repository.

Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Walkthrough

This change introduces a new API endpoint (POST /flows/expand/) that expands compact AI-generated flow representations into full Langflow-compatible flows. It includes a new processing module with data models, utility functions for node and edge expansion, and comprehensive unit/integration tests.

Changes

Cohort / File(s)	Summary
API Endpoint `src/backend/base/langflow/api/v1/flows.py`	Adds POST /flows/expand/ endpoint that accepts compact flow data, validates user authentication, loads component cache, and calls expand_compact_flow to produce expanded flow representation. Includes error handling for ValueError (400) and other exceptions (500).
Core Expansion Logic `src/backend/base/langflow/processing/expand_flow.py`	New module defining CompactNode, CompactEdge, and CompactFlowData models. Provides utility functions to flatten components, expand nodes (merging user values with templates), encode handles, and expand edges (computing source/target handle metadata). Main expand_compact_flow function orchestrates full flow expansion.
Test Coverage `src/backend/tests/unit/test_expand_flow.py`	Unit and integration tests covering component flattening, node expansion (simple/edited/with-values scenarios), edge expansion with handle encoding, full flow expansion, and endpoint authentication/error handling. Uses synthetic component dataset to validate expansion paths.

Sequence Diagram

sequenceDiagram
    participant Client
    participant API as API Endpoint<br/>/flows/expand/
    participant Auth as Authentication
    participant Cache as Component Cache
    participant Expand as expand_compact_flow
    participant Response

    Client->>API: POST compact_data
    API->>Auth: get_current_active_user
    Auth-->>API: authenticated user
    
    API->>Cache: get_and_cache_all_types_dict
    alt Cache needs load
        Cache-->>Cache: load all component types
    end
    Cache-->>API: all_types_dict
    
    API->>Expand: expand_compact_flow(compact_data, all_types_dict)
    
    Expand->>Expand: _get_flat_components (flatten templates)
    Expand->>Expand: _expand_node (for each node)<br/>merge values & templates
    Expand->>Expand: _expand_edge (for each edge)<br/>encode handles
    
    alt Success
        Expand-->>API: expanded flow dict
        API-->>Response: 200 OK {nodes, edges}
    else ValueError (invalid component)
        Expand-->>API: ValueError
        API-->>Response: 400 Bad Request
    else Other Error
        API-->>Response: 500 Internal Server Error
    end
    
    Response-->>Client: response

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~45 minutes

expand_flow.py: Contains multiple interdependent functions with handle encoding logic, component template resolution, and nested data structure manipulation requiring careful validation
Edge expansion logic: Complex sourceHandle/targetHandle formatting with JSON encoding and special character handling warrants close inspection
Error handling paths: Multiple validation scenarios (unknown components, missing nodes/edges) need thorough tracing
API integration: Endpoint handler coordinates cache initialization and expansion orchestration—verify dependency injection and error status codes are correct

Pre-merge checks and finishing touches

Important

Pre-merge checks failed

Please resolve all errors before merging. Addressing warnings is optional.

❌ Failed checks (1 error, 3 warnings)

Check name	Status	Explanation	Resolution
Test Coverage For New Implementations	❌ Error	Four async test methods in TestExpandFlowEndpoint class are missing required @pytest.mark.asyncio decorator, preventing pytest-asyncio from executing them.	Add @pytest.mark.asyncio decorator to test_expand_flow_endpoint_requires_auth, test_expand_flow_endpoint_success, test_expand_flow_endpoint_invalid_component, and test_expand_flow_endpoint_invalid_edge methods.
Docstring Coverage	⚠️ Warning	Docstring coverage is 50.00% which is insufficient. The required threshold is 80.00%.	You can run `@coderabbitai generate docstrings` to improve docstring coverage.
Test Quality And Coverage	⚠️ Warning	Async test methods in TestExpandFlowEndpoint class are missing @pytest.mark.asyncio decorators required for proper pytest-asyncio integration.	Add @pytest.mark.asyncio decorator to all four async test methods (test_expand_flow_endpoint_requires_auth, test_expand_flow_endpoint_success, test_expand_flow_endpoint_invalid_component, test_expand_flow_endpoint_invalid_edge) and verify pytest-asyncio configuration.
Test File Naming And Structure	⚠️ Warning	Test file test_expand_flow.py has 4 async test methods missing @pytest.mark.asyncio decorators required for proper execution.	Add @pytest.mark.asyncio decorator to all async test methods in TestExpandFlowEndpoint class to enable proper pytest async test execution.

✅ Passed checks (3 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title accurately summarizes the main change: adding functionality to expand compact flow formats, which is the core feature introduced across the new endpoint and processing module.
Excessive Mock Usage Warning	✅ Passed	Test file uses appropriate mocks only for external dependencies (AsyncClient, auth headers) while testing real core logic functions directly with synthetic test data fixtures.

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

coderabbitai

Actionable comments posted: 1

🧹 Nitpick comments (1)

src/backend/tests/unit/test_expand_flow.py (1)
554-565: Consider strengthening the success test assertion.

The test accepts both 200 OK and 400 Bad Request as valid outcomes, which weakens the test's ability to catch regressions. Consider either:

Mocking component_cache.all_types_dict with SAMPLE_COMPONENTS to ensure deterministic behavior

Adding a docstring explaining why both statuses are acceptable

Example approach with mocking:
@pytest.mark.asyncio
async def test_expand_flow_endpoint_success(self, client: AsyncClient, logged_in_headers, monkeypatch):
    """Test successful flow expansion with mocked components."""
    from lfx.interface.components import component_cache
    monkeypatch.setattr(component_cache, "all_types_dict", SAMPLE_COMPONENTS)
    
    compact_data = {
        "nodes": [{"id": "1", "type": "ChatInput"}],
        "edges": [],
    }
    
    response = await client.post("api/v1/flows/expand/", json=compact_data, headers=logged_in_headers)
    assert response.status_code == status.HTTP_200_OK

📜 Review details

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 271c7ff and 9c2893c.

📒 Files selected for processing (3)

src/backend/base/langflow/api/v1/flows.py (2 hunks)
src/backend/base/langflow/processing/expand_flow.py (1 hunks)
src/backend/tests/unit/test_expand_flow.py (1 hunks)

🧰 Additional context used

📓 Path-based instructions (5)

src/backend/**/*.py

📄 CodeRabbit inference engine (.cursor/rules/backend_development.mdc)

src/backend/**/*.py: Use FastAPI async patterns with await for async operations in component execution methods
Use asyncio.create_task() for background tasks and implement proper cleanup with try/except for asyncio.CancelledError
Use queue.put_nowait() for non-blocking queue operations and asyncio.wait_for() with timeouts for controlled get operations

Files:

src/backend/base/langflow/api/v1/flows.py
src/backend/tests/unit/test_expand_flow.py
src/backend/base/langflow/processing/expand_flow.py

src/backend/base/langflow/api/**/*.py

📄 CodeRabbit inference engine (.cursor/rules/backend_development.mdc)

Backend API endpoints should be organized by version (v1/, v2/) under src/backend/base/langflow/api/ with specific modules for features (chat.py, flows.py, users.py, etc.)

Files:

src/backend/base/langflow/api/v1/flows.py

src/backend/tests/**/*.py

📄 CodeRabbit inference engine (.cursor/rules/testing.mdc)

src/backend/tests/**/*.py: Place backend unit tests in src/backend/tests/ directory, component tests in src/backend/tests/unit/components/ organized by component subdirectory, and integration tests accessible via make integration_tests
Use same filename as component with appropriate test prefix/suffix (e.g., my_component.py → test_my_component.py)
Use the client fixture (FastAPI Test Client) defined in src/backend/tests/conftest.py for API tests; it provides an async httpx.AsyncClient with automatic in-memory SQLite database and mocked environment variables. Skip client creation by marking test with @pytest.mark.noclient
Inherit from the correct ComponentTestBase family class located in src/backend/tests/base.py based on API access needs: ComponentTestBase (no API), ComponentTestBaseWithClient (needs API), or ComponentTestBaseWithoutClient (pure logic). Provide three required fixtures: component_class, default_kwargs, and file_names_mapping
Create comprehensive unit tests for all new backend components. If unit tests are incomplete, create a corresponding Markdown file documenting manual testing steps and expected outcomes
Test both sync and async code paths, mock external dependencies appropriately, test error handling and edge cases, validate input/output behavior, and test component initialization and configuration
Use @pytest.mark.asyncio decorator for async component tests and ensure async methods are properly awaited
Test background tasks using asyncio.create_task() and verify completion with asyncio.wait_for() with appropriate timeout constraints
Test queue operations using non-blocking queue.put_nowait() and asyncio.wait_for(queue.get(), timeout=...) to verify queue processing without blocking
Use @pytest.mark.no_blockbuster marker to skip the blockbuster plugin in specific tests
For database tests that may fail in batch runs, run them sequentially using uv run pytest src/backend/tests/unit/test_database.py r...

Files:

src/backend/tests/unit/test_expand_flow.py

**/{test_*.py,*.test.ts,*.test.tsx}

📄 CodeRabbit inference engine (Custom checks)

Check that test files follow the project's naming conventions (test_*.py for backend, *.test.ts for frontend)

Files:

src/backend/tests/unit/test_expand_flow.py

**/test_*.py

📄 CodeRabbit inference engine (Custom checks)

**/test_*.py: Backend tests should follow pytest structure with proper test_*.py naming
For async functions, ensure proper async testing patterns are used with pytest for backend

Files:

src/backend/tests/unit/test_expand_flow.py

🧠 Learnings (13)

📓 Common learnings

Learnt from: ogabrielluiz
Repo: langflow-ai/langflow PR: 0
File: :0-0
Timestamp: 2025-06-26T19:43:18.260Z
Learning: In langflow custom components, the `module_name` parameter is now propagated through template building functions to add module metadata and code hashes to frontend nodes for better component tracking and debugging.

📚 Learning: 2025-11-24T19:46:09.104Z

Learnt from: CR
Repo: langflow-ai/langflow PR: 0
File: .cursor/rules/backend_development.mdc:0-0
Timestamp: 2025-11-24T19:46:09.104Z
Learning: Applies to src/backend/base/langflow/api/**/*.py : Backend API endpoints should be organized by version (v1/, v2/) under `src/backend/base/langflow/api/` with specific modules for features (chat.py, flows.py, users.py, etc.)

Applied to files:

src/backend/base/langflow/api/v1/flows.py