Flowfile 0.3.9__py3-none-any.whl → 0.4.0__py3-none-any.whl

flowfile_core/flowfile/node_designer/data_types.py

@@ -0,0 +1,146 @@
+# types.py - Public API for type specifications
+"""
+Public type system for column selection and data type specification.
+
+Usage:
+    from flowfile_core.types import Types
+
+    # Use type groups
+    ColumnSelector(data_types=Types.Numeric)
+    ColumnSelector(data_types=Types.String)
+
+    # Use specific types
+    ColumnSelector(data_types=Types.Int64)
+    ColumnSelector(data_types=Types.Float)
+
+    # Mix and match
+    ColumnSelector(data_types=[Types.Numeric, Types.String])
+"""
+
+from enum import Enum
+from typing import List, Union
+import polars as pl
+
+
+class TypeGroup(str, Enum):
+    """High-level type groups for column selection."""
+    Numeric = "Numeric"
+    String = "String"
+    Date = "Date"
+    Boolean = "Boolean"
+    Binary = "Binary"
+    Complex = "Complex"
+    All = "ALL"
+
+    def __str__(self) -> str:
+        return self.value
+
+    def __repr__(self) -> str:
+        return f"Types.{self.name}"
+
+
+class DataType(str, Enum):
+    """Specific data types for fine-grained control."""
+    # Numeric types
+    Int8 = "Int8"
+    Int16 = "Int16"
+    Int32 = "Int32"
+    Int64 = "Int64"
+    UInt8 = "UInt8"
+    UInt16 = "UInt16"
+    UInt32 = "UInt32"
+    UInt64 = "UInt64"
+    Float32 = "Float32"
+    Float64 = "Float64"
+    Decimal = "Decimal"
+
+    # String types
+    String = "String"
+    Categorical = "Categorical"
+
+    # Date types
+    Date = "Date"
+    Datetime = "Datetime"
+    Time = "Time"
+    Duration = "Duration"
+
+    # Other types
+    Boolean = "Boolean"
+    Binary = "Binary"
+    List = "List"
+    Struct = "Struct"
+    Array = "Array"
+
+    def __str__(self) -> str:
+        return self.value
+
+    def __repr__(self) -> str:
+        return f"Types.{self.name}"
+
+
+class Types:
+    """
+    Main entry point for type specifications.
+
+    Examples:
+        Types.Numeric     # All numeric columns
+        Types.String      # All string columns
+        Types.Int64       # 64-bit integers only
+        Types.Float       # Alias for Float64
+        Types.All         # All column types
+    """
+
+    # Type groups (most common use case)
+    Numeric = TypeGroup.Numeric
+    String = TypeGroup.String
+    Date = TypeGroup.Date
+    Boolean = TypeGroup.Boolean
+    Binary = TypeGroup.Binary
+    Complex = TypeGroup.Complex
+    All = TypeGroup.All
+
+    # Specific numeric types
+    Int = DataType.Int64  # Default integer
+    Int8 = DataType.Int8
+    Int16 = DataType.Int16
+    Int32 = DataType.Int32
+    Int64 = DataType.Int64
+    UInt8 = DataType.UInt8
+    UInt16 = DataType.UInt16
+    UInt32 = DataType.UInt32
+    UInt64 = DataType.UInt64
+
+    Float = DataType.Float64  # Default float
+    Float32 = DataType.Float32
+    Float64 = DataType.Float64
+    Decimal = DataType.Decimal
+
+    # String types
+    Str = DataType.String
+    Text = DataType.String  # Alias
+    Categorical = DataType.Categorical
+    Cat = DataType.Categorical  # Short alias
+
+    # Date/time types
+    Date = DataType.Date
+    Datetime = DataType.Datetime
+    Time = DataType.Time
+    Duration = DataType.Duration
+
+    # Other types
+    Bool = DataType.Boolean
+    Bytes = DataType.Binary
+    List = DataType.List
+    Struct = DataType.Struct
+    Array = DataType.Array
+
+
+# Type alias for better type hints
+TypeSpec = Union[
+    TypeGroup,
+    DataType,
+    str,
+    List[Union[TypeGroup, DataType, str, type[pl.DataType], pl.DataType]],
+    type[pl.DataType],
+    pl.DataType
+]

flowfile_core/flowfile/node_designer/ui_components.py

@@ -0,0 +1,277 @@
+# ui_components.py - Updated ColumnSelector
+
+from typing import List, Optional, Any, Literal, Union, Type, Tuple, Dict
+
+from pydantic import Field, BaseModel, computed_field
+
+from flowfile_core.flowfile.node_designer._type_registry import normalize_type_spec
+# Public API import
+from flowfile_core.flowfile.node_designer.data_types import DataType, TypeSpec
+
+InputType = Literal["text", "number", "secret", "array", "date", "boolean"]
+
+
+def normalize_input_to_data_types(
+    v: Any
+) -> Union[Literal["ALL"], List[DataType]]:
+    """
+    Normalizes a wide variety of inputs to either 'ALL' or a sorted list of DataType enums.
+    This function is used as a Pydantic BeforeValidator.
+
+    Args:
+        v: The input value to normalize. Can be a string, a list of strings,
+           a DataType, a TypeGroup, or a list of those.
+
+    Returns:
+        Either the string "ALL" or a sorted list of unique DataType enums.
+    """
+    if v == "ALL":
+        return "ALL"
+    if isinstance(v, list) and all(isinstance(item, DataType) for item in v):
+        return v
+
+    normalized_set = normalize_type_spec(v)
+
+    if normalized_set == set(DataType):
+        return "ALL"
+
+    return sorted(list(normalized_set), key=lambda x: x.value)
+
+
+class FlowfileInComponent(BaseModel):
+    """
+    Base class for all UI components in the node settings panel.
+
+    This class provides the common attributes and methods that all UI components share.
+    It's not meant to be used directly, but rather to be inherited by specific
+    component classes.
+    """
+    component_type: str = Field(..., description="Type of the UI component")
+    value: Any = None
+    label: Optional[str] = None
+    input_type: InputType
+
+    def set_value(self, value: Any):
+        """
+        Sets the value of the component, received from the frontend.
+
+        This method is used internally by the framework to populate the component's
+        value when a user interacts with the UI.
+
+        Args:
+            value: The new value for the component.
+
+        Returns:
+            The component instance with the updated value.
+        """
+        self.value = value
+        return self
+
+
+class IncomingColumns:
+    """
+    A marker class used in `SingleSelect` and `MultiSelect` components.
+
+    When `options` is set to this class, the component will be dynamically
+    populated with the column names from the node's input dataframe.
+    This allows users to select from the available columns at runtime.
+
+    Example:
+        class MyNodeSettings(NodeSettings):
+            column_to_process = SingleSelect(
+                label="Select a column",
+                options=IncomingColumns
+            )
+    """
+    pass
+
+
+class ColumnSelector(FlowfileInComponent):
+    """
+    A UI component that allows users to select one or more columns from the
+    input dataframe, with an optional filter based on column data types.
+
+    This is particularly useful when a node operation should only be applied
+    to columns of a specific type (e.g., numeric, string, date).
+    """
+    component_type: Literal["ColumnSelector"] = "ColumnSelector"
+    required: bool = False
+    multiple: bool = False
+    input_type: InputType = "text"
+
+    # Normalized output: either "ALL" or list of DataType enums
+    data_type_filter_input: TypeSpec = Field(
+        default="ALL",
+        alias="data_types",
+        repr=False,
+        exclude=True
+    )
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    @computed_field
+    @property
+    def data_types_filter(self) -> Union[Literal["ALL"], List[DataType]]:
+        """
+        A computed field that normalizes the `data_type_filter_input` into a
+        standardized format for the frontend.
+        """
+        return normalize_input_to_data_types(self.data_type_filter_input)
+
+    def model_dump(self, **kwargs) -> dict:
+        """
+        Overrides the default `model_dump` to ensure `data_types` is in the
+        correct format for the frontend.
+        """
+        data = super().model_dump(**kwargs)
+        if 'data_types_filter' in data and data['data_types_filter'] != "ALL":
+            data['data_types'] = sorted([dt.value for dt in data['data_types_filter']])
+        return data
+
+
+class TextInput(FlowfileInComponent):
+    """A standard text input field for capturing string values."""
+    component_type: Literal["TextInput"] = "TextInput"
+    default: Optional[str] = ""
+    placeholder: Optional[str] = ""
+    input_type: InputType = "text"
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        if self.value is None and self.default is not None:
+            self.value = self.default
+
+
+class NumericInput(FlowfileInComponent):
+    """A numeric input field with optional minimum and maximum value validation."""
+    component_type: Literal["NumericInput"] = "NumericInput"
+    default: Optional[float] = None
+    min_value: Optional[float] = None
+    max_value: Optional[float] = None
+    input_type: InputType = "number"
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        if self.value is None and self.default is not None:
+            self.value = self.default
+
+
+class ToggleSwitch(FlowfileInComponent):
+    """A boolean toggle switch, typically used for enabling or disabling a feature."""
+    component_type: Literal["ToggleSwitch"] = "ToggleSwitch"
+    default: bool = False
+    description: Optional[str] = None
+    input_type: InputType = "boolean"
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        if self.value is None:
+            self.value = self.default
+
+    def __bool__(self):
+        """Allows the component instance to be evaluated as a boolean."""
+        return bool(self.value)
+
+
+class SingleSelect(FlowfileInComponent):
+    """
+    A dropdown menu for selecting a single option from a list.
+
+    The options can be a static list of strings or tuples, or they can be
+    dynamically populated from the input dataframe's columns by using the
+    `IncomingColumns` marker.
+    """
+    component_type: Literal["SingleSelect"] = "SingleSelect"
+    options: Union[List[Union[str, Tuple[str, Any]]], Type[IncomingColumns]]
+    default: Optional[Any] = None
+    input_type: InputType = "text"
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        if self.value is None and self.default is not None:
+            self.value = self.default
+
+
+class MultiSelect(FlowfileInComponent):
+    """
+    A multi-select dropdown for choosing multiple options from a list.
+
+    Like `SingleSelect`, the options can be static or dynamically populated
+    from the input columns using the `IncomingColumns` marker.
+    """
+    component_type: Literal["MultiSelect"] = "MultiSelect"
+    options: Union[List[Union[str, Tuple[str, Any]]], Type[IncomingColumns]]
+    default: List[Any] = Field(default_factory=list)
+    input_type: InputType = "array"
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        if self.value is None:
+            self.value = self.default if self.default else []
+
+
+class Section(BaseModel):
+    """
+    A container for grouping related UI components in the node settings panel.
+
+    Sections help organize the UI by grouping components under a common title
+    and description. Components can be added as keyword arguments during
+    initialization or afterward.
+
+    Example:
+        main_section = Section(
+            title="Main Settings",
+            description="Configure the primary behavior of the node.",
+            my_text_input=TextInput(label="Enter a value")
+        )
+    """
+    title: Optional[str] = None
+    description: Optional[str] = None
+    hidden: bool = False
+
+    class Config:
+        extra = 'allow'
+        arbitrary_types_allowed = True
+
+    def __init__(self, **data):
+        """
+        Initialize a Section with components as keyword arguments.
+        """
+        super().__init__(**data)
+
+    def __call__(self, **kwargs) -> 'Section':
+        """
+        Allows adding components to the section after initialization.
+
+        This makes it possible to build up a section dynamically.
+        """
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+        return self
+
+    def get_components(self) -> Dict[str, FlowfileInComponent]:
+        """
+        Get all FlowfileInComponent instances from the section.
+
+        This method collects all the UI components that have been added to the
+        section, whether as defined fields or as extra fields.
+
+        Returns:
+            A dictionary mapping component names to their instances.
+        """
+        components = {}
+
+        # Get from extra fields
+        for key, value in getattr(self, '__pydantic_extra__', {}).items():
+            if isinstance(value, FlowfileInComponent):
+                components[key] = value
+
+        # Get from defined fields (excluding metadata)
+        for field_name in self.model_fields:
+            if field_name not in {'title', 'description', 'hidden'}:
+                value = getattr(self, field_name, None)
+                if isinstance(value, FlowfileInComponent):
+                    components[field_name] = value
+
+        return components

flowfile_core/flowfile/schema_callbacks.py

@@ -61,21 +61,25 @@ def calculate_fuzzy_match_schema(fm_input: transform_schema.FuzzyMatchInput,
                                           join_inputs=fm_input.left_select)
     _order_join_inputs_based_on_col_order(col_order=[col.column_name for col in right_schema],
                                           join_inputs=fm_input.right_select)
+    for column in fm_input.left_select.renames:
+        if column.join_key:
+            column.keep = True
+    for column in fm_input.right_select.renames:
+        if column.join_key:
+            column.keep = True
     left_schema_dict, right_schema_dict = ({ls.name: ls for ls in left_schema}, {rs.name: rs for rs in right_schema})
     fm_input.auto_rename()
-
     right_renames = {column.old_name: column.new_name for column in fm_input.right_select.renames}
     new_join_mapping = rename_fuzzy_right_mapping(fm_input.join_mapping, right_renames)
-
     output_schema = []
     for column in fm_input.left_select.renames:
         column_schema = left_schema_dict.get(column.old_name)
-        if column_schema and column.keep:
+        if column_schema and (column.keep or column.join_key):
             output_schema.append(FlowfileColumn.from_input(column.new_name, column_schema.data_type,
                                                            example_values=column_schema.example_values))
     for column in fm_input.right_select.renames:
         column_schema = right_schema_dict.get(column.old_name)
-        if column_schema and column.keep:
+        if column_schema and (column.keep or column.join_key):
             output_schema.append(FlowfileColumn.from_input(column.new_name, column_schema.data_type,
                                                            example_values=column_schema.example_values))
     set_name_in_fuzzy_mappings(new_join_mapping)

flowfile_core/flowfile/setting_generator/settings.py

@@ -56,7 +56,6 @@ def cross_join(node_data: "NodeData") -> NodeData:
         ji = transform_schema.CrossJoinInput(left_select=node_data.main_input.columns,
                                              right_select=node_data.right_input.columns)
         ji.auto_rename()
-        print(ji)
         node_data.setting_input = input_schema.NodeCrossJoin(flow_id=node_data.flow_id,
                                                              node_id=node_data.node_id,
                                                              cross_join_input=ji)

flowfile_core/main.py

@@ -7,6 +7,8 @@ import uvicorn
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
+from shared.storage_config import storage
+
 from flowfile_core import ServerRun
 from flowfile_core.configs.settings import (SERVER_HOST, SERVER_PORT, WORKER_HOST, WORKER_PORT, WORKER_URL,)
 
@@ -16,15 +18,16 @@ from flowfile_core.routes.routes import router
 from flowfile_core.routes.public import router as public_router
 from flowfile_core.routes.logs import router as logs_router
 from flowfile_core.routes.cloud_connections import router as cloud_connections_router
+from flowfile_core.routes.user_defined_components import router as user_defined_components_router
 
 from flowfile_core.configs.flow_logger import clear_all_flow_logs
+storage.cleanup_directories()
 
 os.environ["FLOWFILE_MODE"] = "electron"
 
 should_exit = False
 server_instance = None
 
-
 @asynccontextmanager
 async def shutdown_handler(app: FastAPI):
     """Handles the graceful startup and shutdown of the FastAPI application.
@@ -77,6 +80,7 @@ app.include_router(logs_router, tags=["logs"])
 app.include_router(auth_router, prefix="/auth", tags=["auth"])
 app.include_router(secrets_router, prefix="/secrets", tags=["secrets"])
 app.include_router(cloud_connections_router, prefix="/cloud_connections", tags=["cloud_connections"])
+app.include_router(user_defined_components_router, prefix="/user_defined_components", tags=["user_defined_components"])
 
 
 @app.post("/shutdown")

flowfile_core/routes/routes.py

@@ -12,49 +12,49 @@ import logging
 import os
 from pathlib import Path
 from typing import List, Dict, Any, Optional
-from sqlalchemy.orm import Session
 
 from fastapi import APIRouter, File, UploadFile, BackgroundTasks, HTTPException, status, Body, Depends
 from fastapi.responses import JSONResponse, Response
 # External dependencies
 from polars_expr_transformer.function_overview import get_all_expressions, get_expression_overview
+from sqlalchemy.orm import Session
 
+from flowfile_core import flow_file_handler
 # Core modules
 from flowfile_core.auth.jwt import get_current_active_user
 from flowfile_core.configs import logger
-from flowfile_core.configs.node_store import nodes
-from flowfile_core.configs.settings import IS_RUNNING_IN_DOCKER
+from flowfile_core.configs.node_store import nodes_list, check_if_has_default_setting
+from flowfile_core.database.connection import get_db
 # File handling
 from flowfile_core.fileExplorer.funcs import (
-    FileExplorer,
+    SecureFileExplorer,
     FileInfo,
     get_files_from_directory
 )
-from flowfile_core.flowfile.flow_graph import add_connection, delete_connection
-from flowfile_core.flowfile.code_generator.code_generator import export_flow_to_polars
 from flowfile_core.flowfile.analytics.analytics_processor import AnalyticsProcessor
+from flowfile_core.flowfile.code_generator.code_generator import export_flow_to_polars
+from flowfile_core.flowfile.database_connection_manager.db_connections import (store_database_connection,
+                                                                               get_database_connection,
+                                                                               delete_database_connection,
+                                                                               get_all_database_connections_interface)
 from flowfile_core.flowfile.extensions import get_instant_func_results
-# Flow handling
-
+from flowfile_core.flowfile.flow_graph import add_connection, delete_connection
 from flowfile_core.flowfile.sources.external_sources.sql_source.sql_source import create_sql_source_from_db_settings
 from flowfile_core.run_lock import get_flow_run_lock
-# Schema and models
 from flowfile_core.schemas import input_schema, schemas, output_model
 from flowfile_core.utils import excel_file_manager
-from flowfile_core.utils.fileManager import create_dir, remove_paths
+from flowfile_core.utils.fileManager import create_dir
 from flowfile_core.utils.utils import camel_case_to_snake_case
-from flowfile_core import flow_file_handler
-from flowfile_core.flowfile.database_connection_manager.db_connections import (store_database_connection,
-                                                                               get_database_connection,
-                                                                               delete_database_connection,
-                                                                               get_all_database_connections_interface)
-from flowfile_core.database.connection import get_db
+from shared.storage_config import storage
 
 
 router = APIRouter(dependencies=[Depends(get_current_active_user)])
 
 # Initialize services
-file_explorer = FileExplorer('/app/shared' if IS_RUNNING_IN_DOCKER else None)
+file_explorer = SecureFileExplorer(
+    start_path=storage.user_data_directory,
+    sandbox_root=storage.user_data_directory
+)
 
 
 def get_node_model(setting_name_ref: str):
@@ -148,7 +148,7 @@ async def get_directory_contents(directory: str, file_types: List[str] = None,
     Returns:
         A list of `FileInfo` objects representing the directory's contents.
     """
-    directory_explorer = FileExplorer(directory)
+    directory_explorer = SecureFileExplorer(directory, storage.user_data_directory)
     try:
         return directory_explorer.list_contents(show_hidden=include_hidden, file_types=file_types)
     except Exception as e:
@@ -198,6 +198,24 @@ async def get_active_flow_file_sessions() -> List[schemas.FlowSettings]:
     return [flf.flow_settings for flf in flow_file_handler.flowfile_flows]
 
 
+@router.post("/node/trigger_fetch_data", tags=['editor'])
+async def trigger_fetch_node_data(flow_id: int, node_id: int, background_tasks: BackgroundTasks):
+    """Fetches and refreshes the data for a specific node."""
+    flow = flow_file_handler.get_flow(flow_id)
+    lock = get_flow_run_lock(flow_id)
+    async with lock:
+        if flow.flow_settings.is_running:
+            raise HTTPException(422, 'Flow is already running')
+        try:
+            flow.validate_if_node_can_be_fetched(node_id)
+        except Exception as e:
+            raise HTTPException(422, str(e))
+        background_tasks.add_task(flow.trigger_fetch_node, node_id)
+    return JSONResponse(content={"message": "Data started",
+                                 "flow_id": flow_id,
+                                 "node_id": node_id}, status_code=status.HTTP_200_OK)
+
+
 @router.post('/flow/run/', tags=['editor'])
 async def run_flow(flow_id: int, background_tasks: BackgroundTasks) -> JSONResponse:
     """Executes a flow in a background task.
@@ -228,6 +246,16 @@ def cancel_flow(flow_id: int):
     flow.cancel()
 
 
+@router.post("/flow/apply_standard_layout/", tags=["editor"])
+def apply_standard_layout(flow_id: int):
+    flow = flow_file_handler.get_flow(flow_id)
+    if not flow:
+        raise HTTPException(status_code=404, detail="Flow not found")
+    if flow.flow_settings.is_running:
+        raise HTTPException(422, "Flow is running")
+    flow.apply_layout()
+
+
 @router.get('/flow/run_status/', tags=['editor'],
             response_model=output_model.RunInformation)
 def get_run_status(flow_id: int, response: Response):
@@ -238,10 +266,12 @@ def get_run_status(flow_id: int, response: Response):
     flow = flow_file_handler.get_flow(flow_id)
     if not flow:
         raise HTTPException(status_code=404, detail="Flow not found")
+    if flow.latest_run_info is None:
+        raise HTTPException(status_code=404, detail="No run information available")
     if flow.flow_settings.is_running:
         response.status_code = status.HTTP_202_ACCEPTED
-        return flow.get_run_info()
-    response.status_code = status.HTTP_200_OK
+    else:
+        response.status_code = status.HTTP_200_OK
     return flow.get_run_info()
 
 
@@ -324,7 +354,7 @@ def add_node(flow_id: int, node_id: int, node_type: str, pos_x: int = 0, pos_y:
         logger.info("Adding node")
         flow.add_node_promise(node_promise)
 
-    if nodes.check_if_has_default_setting(node_type):
+    if check_if_has_default_setting(node_type):
         logger.info(f'Found standard settings for {node_type}, trying to upload them')
         setting_name_ref = 'node' + node_type.replace('_', '')
         node_model = get_node_model(setting_name_ref)
@@ -439,11 +469,24 @@ def get_generated_code(flow_id: int) -> str:
 
 
 @router.post('/editor/create_flow/', tags=['editor'])
-def create_flow(flow_path: str):
+def create_flow(flow_path: str = None, name: str = None):
     """Creates a new, empty flow file at the specified path and registers a session for it."""
-    flow_path = Path(flow_path)
-    logger.info('Creating flow')
-    return flow_file_handler.add_flow(name=flow_path.stem, flow_path=str(flow_path))
+    if flow_path is not None and name is None:
+        name = Path(flow_path).stem
+    elif flow_path is not None and name is not None:
+        if name not in flow_path and flow_path.endswith(".flowfile"):
+            raise HTTPException(422, 'The name must be part of the flow path when a full path is provided')
+        elif name in flow_path and not flow_path.endswith(".flowfile"):
+            flow_path = str(Path(flow_path) / (name + ".flowfile"))
+        elif name not in flow_path and name.endswith(".flowfile"):
+            flow_path = str(Path(flow_path) / name)
+        elif name not in flow_path and not name.endswith(".flowfile"):
+            flow_path = str(Path(flow_path) / (name + ".flowfile"))
+    if flow_path is not None:
+        flow_path_ref = Path(flow_path)
+        if not flow_path_ref.parent.exists():
+            raise HTTPException(422, 'The directory does not exist')
+    return flow_file_handler.add_flow(name=name, flow_path=flow_path)
 
 
 @router.post('/editor/close_flow/', tags=['editor'])
@@ -471,6 +514,7 @@ def add_generic_settings(input_data: Dict[str, Any], node_type: str, current_use
     add_func = getattr(flow, 'add_' + node_type)
     parsed_input = None
     setting_name_ref = 'node' + node_type.replace('_', '')
+
     if add_func is None:
         raise HTTPException(404, 'could not find the function')
     try:
@@ -496,10 +540,11 @@ def get_list_of_saved_flows(path: str):
     except:
         return []
 
-@router.get('/node_list', response_model=List[nodes.NodeTemplate])
-def get_node_list() -> List[nodes.NodeTemplate]:
+
+@router.get('/node_list', response_model=List[schemas.NodeTemplate])
+def get_node_list() -> List[schemas.NodeTemplate]:
     """Retrieves the list of all available node types and their templates."""
-    return nodes.nodes_list
+    return nodes_list
 
 
 @router.get('/node', response_model=output_model.NodeData, tags=['editor'])