Flowfile 0.3.5__py3-none-any.whl → 0.3.7__py3-none-any.whl

flowfile_core/flowfile/flow_node/models.py

@@ -1,15 +1,32 @@
 
 import pyarrow as pa
 from typing import List, Union, Callable, Optional, Literal
+from dataclasses import dataclass
+
+# Forward declaration for type hints to avoid circular imports
+if False:
+    from flowfile_core.flowfile.flow_node.flow_node import FlowNode
 
 from flowfile_core.flowfile.flow_data_engine.flow_file_column.main import FlowfileColumn
 from flowfile_core.flowfile.flow_data_engine.flow_data_engine import FlowDataEngine
 from flowfile_core.schemas import schemas
-from dataclasses import dataclass
 
 
 @dataclass
 class NodeStepPromise:
+    """
+    A lightweight, temporary representation of a node during the initial
+    graph construction phase, before full `FlowNode` objects are created.
+
+    Attributes:
+        node_id: The unique identifier for the node.
+        name: The display name of the node.
+        is_start: A boolean indicating if this is a starting node with no inputs.
+        leads_to_id: A list of node IDs that this node connects to.
+        left_input: The ID of the node connected to the left input port.
+        right_input: The ID of the node connected to the right input port.
+        depends_on: A list of node IDs that this node depends on for main inputs.
+    """
     node_id: Union[str, int]
     name: str
     is_start: bool
@@ -20,13 +37,79 @@ class NodeStepPromise:
 
 
 class NodeStepStats:
+    """
+    Tracks the execution status and statistics of a `FlowNode`.
+    """
     error: str = None
-    has_run: bool = False
+    _has_run_with_current_setup: bool = False
+    has_completed_last_run: bool = False
     active: bool = True
     is_canceled: bool = False
 
+    def __init__(self, error: str = None,
+                 has_run_with_current_setup: bool = False,
+                 has_completed_last_run: bool = False,
+                 active: bool = True,
+                 is_canceled: bool = False):
+        """
+        Initializes the node's statistics.
+
+        :param error: Any error message from the last run.
+        :param has_run_with_current_setup: Flag indicating if the node has run successfully with its current configuration.
+        :param has_completed_last_run: Flag indicating if the last triggered run finished (successfully or not).
+        :param active: Flag indicating if the node is active in the flow.
+        :param is_canceled: Flag indicating if the last run was canceled.
+        """
+        self.error = error
+        self._has_run_with_current_setup = has_run_with_current_setup
+        self.has_completed_last_run = has_completed_last_run
+        self.active = active
+        self.is_canceled = is_canceled
+
+    def __repr__(self) -> str:
+        """
+        Provides a string representation of the node's stats.
+        :return: A string detailing the current stats.
+        """
+        return (f"NodeStepStats(error={self.error}, has_run_with_current_setup={self.has_run_with_current_setup}, "
+                f"has_completed_last_run={self.has_completed_last_run}, "
+                f"active={self.active}, is_canceled={self.is_canceled})")
+
+    @property
+    def has_run_with_current_setup(self) -> bool:
+        """
+        Checks if the node has run successfully with its current settings and inputs.
+        This is the primary flag for caching.
+        :return: True if the node is considered up-to-date, False otherwise.
+        """
+        return self._has_run_with_current_setup
+
+    @has_run_with_current_setup.setter
+    def has_run_with_current_setup(self, value: bool):
+        """
+        Sets the run status of the node.
+        If set to True, it implies the last run was completed successfully.
+        :param value: The new boolean status.
+        """
+        if value:
+            self._has_run_with_current_setup = True
+            self.has_completed_last_run = True
+        else:
+            self._has_run_with_current_setup = False
+
 
 class NodeStepSettings:
+    """
+    Holds the configuration settings that control a node's execution behavior.
+
+    Attributes:
+        cache_results: If True, the node will cache its results to avoid re-computation.
+        renew_schema: If True, the schema will be re-evaluated on changes.
+        streamable: If True, the node can process data in a streaming fashion.
+        setup_errors: If True, indicates a non-blocking error occurred during setup.
+        breaking_setup_errors: If True, indicates an error occurred that prevents execution.
+        execute_location: The preferred location for execution ('auto', 'local', 'remote').
+    """
     cache_results: bool = False
     renew_schema: bool = True
     streamable: bool = True
@@ -36,20 +119,40 @@ class NodeStepSettings:
 
 
 class NodeStepInputs:
+    """
+    Manages the input connections for a `FlowNode`.
+
+    Attributes:
+        left_input: The `FlowNode` connected to the left input port.
+        right_input: The `FlowNode` connected to the right input port.
+        main_inputs: A list of `FlowNode` objects connected to the main input port(s).
+    """
     left_input: "FlowNode" = None
     right_input: "FlowNode" = None
     main_inputs: List["FlowNode"] = None
 
     @property
-    def input_ids(self) -> List[int]:
+    def input_ids(self) -> List[int] | None:
+        """
+        Gets the IDs of all connected input nodes.
+        :return: A list of integer node IDs.
+        """
         if self.main_inputs is not None:
             return [node_input.node_information.id for node_input in self.get_all_inputs()]
 
     def get_all_inputs(self) -> List["FlowNode"]:
+        """
+        Retrieves a single list containing all input nodes (main, left, and right).
+        :return: A list of all connected `FlowNode` objects.
+        """
         main_inputs = self.main_inputs or []
         return [v for v in main_inputs + [self.left_input, self.right_input] if v is not None]
 
     def __repr__(self) -> str:
+        """
+        Provides a string representation of the node's inputs.
+        :return: A string detailing the connected inputs.
+        """
         left_repr = f"Left Input: {self.left_input}" if self.left_input else "Left Input: None"
         right_repr = f"Right Input: {self.right_input}" if self.right_input else "Right Input: None"
         main_inputs_repr = f"Main Inputs: {self.main_inputs}" if self.main_inputs else "Main Inputs: None"
@@ -57,27 +160,46 @@ class NodeStepInputs:
 
     def validate_if_input_connection_exists(self, node_input_id: int,
                                             connection_name: Literal['main', 'left', 'right']) -> bool:
-        if connection_name == 'main':
-            return any((node_input.node_information.id == node_input_id for node_input in self.main_inputs))
-        if connection_name == 'left':
+        """
+        Checks if a connection from a specific node ID exists on a given port.
+
+        :param node_input_id: The ID of the source node to check for.
+        :param connection_name: The name of the input port ('main', 'left', 'right').
+        :return: True if the connection exists, False otherwise.
+        """
+        if connection_name == 'main' and self.main_inputs:
+            return any(node_input.node_information.id == node_input_id for node_input in self.main_inputs)
+        if connection_name == 'left' and self.left_input:
             return self.left_input.node_information.id == node_input_id
         if connection_name == 'right':
             return self.right_input.node_information.id == node_input_id
 
 
 class NodeSchemaInformation:
-    result_schema: Optional[List[FlowfileColumn]] = []  # resulting schema of the function
-    predicted_schema: Optional[List[FlowfileColumn]] = []  # predicted resulting schema of the function
-    input_columns: List[str] = []  # columns that are needed for the function
-    drop_columns: List[str] = []  # columns that will not be available after the function
-    output_columns: List[FlowfileColumn] = []  # columns that will be added with the function
+    """
+    Stores all schema-related information for a `FlowNode`.
+
+    Attributes:
+        result_schema: The actual output schema after a successful execution.
+        predicted_schema: The predicted output schema, calculated without full execution.
+        input_columns: A list of column names the node requires from its inputs.
+        drop_columns: A list of column names that will be dropped by the node.
+        output_columns: A list of `FlowfileColumn` objects that will be added by the node.
+    """
+    result_schema: Optional[List[FlowfileColumn]] = None
+    predicted_schema: Optional[List[FlowfileColumn]] = None
+    input_columns: List[str] = []
+    drop_columns: List[str] = []
+    output_columns: List[FlowfileColumn] = []
 
 
 class NodeResults:
-    _resulting_data: Optional[FlowDataEngine] = None  # after successful execution this will contain the Flowfile
-    example_data: Optional[
-        FlowDataEngine] = None  # after success this will contain a sample of the data (to provide frontend data)
-    example_data_path: Optional[str] = None  # Path to the arrow table file
+    """
+    Stores the outputs of a `FlowNode`'s execution, including data, errors, and metadata.
+    """
+    _resulting_data: Optional[FlowDataEngine] = None
+    example_data: Optional[FlowDataEngine] = None
+    example_data_path: Optional[str] = None
     example_data_generator: Optional[Callable[[], pa.Table]] = None
     run_time: int = -1
     errors: Optional[str] = None
@@ -93,19 +215,31 @@ class NodeResults:
         self.example_data_generator = None
         self.analysis_data_generator = None
 
-    def get_example_data(self) -> pa.Table | None:
+    def get_example_data(self) -> Optional[pa.Table]:
+        """
+        Executes the generator to fetch a sample of the resulting data.
+        :return: A PyArrow Table containing a sample of the data, or None.
+        """
         if self.example_data_generator:
             return self.example_data_generator()
 
     @property
-    def resulting_data(self) -> FlowDataEngine:
+    def resulting_data(self) -> Optional[FlowDataEngine]:
+        """
+        Gets the full resulting data from the node's execution.
+        :return: A `FlowDataEngine` instance containing the result, or None.
+        """
         return self._resulting_data
 
     @resulting_data.setter
-    def resulting_data(self, d: FlowDataEngine):
+    def resulting_data(self, d: Optional[FlowDataEngine]):
+        """
+        Sets the resulting data.
+        :param d: The `FlowDataEngine` instance to store.
+        """
         self._resulting_data = d
 
     def reset(self):
+        """Resets all result attributes to their default, empty state."""
         self._resulting_data = None
-        self.run_time = -1
-
+        self.run_time = -1

flowfile_core/flowfile/flow_node/schema_callback.py

@@ -14,6 +14,7 @@ class SingleExecutionFuture(Generic[T]):
     func: Callable[[], T]
     on_error: Optional[Callable[[Exception], Any]]
     result_value: Optional[T]
+    has_run_at_least_once: bool = False  # Indicates if the function has been run at least once
 
     def __init__(
         self,
@@ -26,6 +27,7 @@ class SingleExecutionFuture(Generic[T]):
         self.func = func
         self.on_error = on_error
         self.result_value = None
+        self.has_run_at_least_once = False
 
     def start(self) -> None:
         """Start the function execution if not already started."""
@@ -35,8 +37,7 @@ class SingleExecutionFuture(Generic[T]):
 
     def cleanup(self) -> None:
         """Clean up resources by clearing the future and shutting down the executor."""
-        # if self.future:
-        #     self.future = None
+        self.has_run_at_least_once = True
         self.executor.shutdown(wait=False)
 
     def __call__(self) -> Optional[T]:

flowfile_core/flowfile/handler.py

@@ -1,8 +1,3 @@
-import time
-import random
-import uuid
-import socket
-import hashlib
 
 from dataclasses import dataclass
 from typing import Dict, List
@@ -12,33 +7,7 @@ from pathlib import Path
 from flowfile_core.flowfile.manage.open_flowfile import open_flow
 from flowfile_core.flowfile.flow_graph import FlowGraph
 from flowfile_core.schemas.schemas import FlowSettings
-from flowfile_core.configs import logger
-
-
-def create_unique_id() -> int:
-    """
-    Create a unique id for the flowfile with increased randomness while maintaining 32-bit compatibility
-    Returns:
-        int: unique id within 32 bits (4 bytes)
-    """
-    # Get various entropy sources
-    time_ms = int(time.time() * 1000)
-    pid = os.getpid()
-    random_bytes = random.getrandbits(32)
-    mac_addr = uuid.getnode()  # MAC address as integer
-    hostname = socket.gethostname()
-
-    # Combine all sources into a string
-    seed = f"{time_ms}-{pid}-{random_bytes}-{mac_addr}-{hostname}-{uuid.uuid4()}"
-
-    # Create a hash of all entropy sources
-    hash_obj = hashlib.md5(seed.encode())
-    hash_int = int(hash_obj.hexdigest(), 16)
-
-    # Ensure the result fits within 32 bits (4 bytes)
-    unique_id = hash_int & 0xFFFFFFFF
-
-    return unique_id
+from flowfile_core.flowfile.utils import create_unique_id
 
 
 @dataclass
@@ -71,7 +40,7 @@ class FlowfileHandler:
             raise 'flow already registered'
         else:
             name = flow_settings.name if flow_settings.name else flow_settings.flow_id
-            self._flows[flow_settings.flow_id] = FlowGraph(name=name, flow_id=flow_settings.flow_id, flow_settings=flow_settings)
+            self._flows[flow_settings.flow_id] = FlowGraph(name=name, flow_settings=flow_settings)
         return self.get_flow(flow_settings.flow_id)
 
     def get_flow(self, flow_id: int) -> FlowGraph | None:

flowfile_core/flowfile/manage/open_flowfile.py

@@ -70,8 +70,7 @@ def open_flow(flow_path: Path) -> FlowGraph:
     flow_storage_obj.flow_name = str(flow_path.stem)
     ensure_compatibility(flow_storage_obj, str(flow_path))
     ingestion_order = determine_insertion_order(flow_storage_obj)
-    new_flow = FlowGraph(flow_id=flow_storage_obj.flow_id, name=flow_storage_obj.flow_name,
-                        flow_settings=flow_storage_obj.flow_settings)
+    new_flow = FlowGraph(name=flow_storage_obj.flow_name, flow_settings=flow_storage_obj.flow_settings)
     for node_id in ingestion_order:
         node_info: schemas.NodeInformation = flow_storage_obj.data[node_id]
         node_promise = input_schema.NodePromise(flow_id=new_flow.flow_id, node_id=node_info.id,

flowfile_core/flowfile/sources/external_sources/__init__.py

@@ -1,3 +1 @@
 from flowfile_core.flowfile.sources.external_sources import custom_external_sources
-# from flowfile.sources.external_sources.custom_external_sources.external_source import check_for_key_vault_existence
-# from flowfile.sources.external_sources.airbyte_sources.airbyte import AirbyteSource

flowfile_core/flowfile/sources/external_sources/factory.py

@@ -1,22 +1,19 @@
 from flowfile_core.flowfile.sources.external_sources.custom_external_sources.external_source import CustomExternalSource
-from flowfile_core.flowfile.sources.external_sources.airbyte_sources.airbyte import AirbyteSource
 
 
-def data_source_factory(source_type: str, **kwargs) -> CustomExternalSource | AirbyteSource:
+def data_source_factory(source_type: str, **kwargs) -> CustomExternalSource:
     """
-    Factory function to generate either CustomExternalSource or AirbyteSource.
+    Factory function to generate either CustomExternalSource .
 
     Args:
-        source_type (str): The type of source to create ("custom" or "airbyte").
+        source_type (str): The type of source to create ("custom").
         **kwargs: The keyword arguments required for the specific source type.
 
     Returns:
-        Union[CustomExternalSource, AirbyteSource]: An instance of the selected data source type.
+        Union[CustomExternalSource]: An instance of the selected data source type.
     """
     if source_type == "custom":
         return CustomExternalSource(**kwargs)
-    elif source_type == "airbyte":
-        return AirbyteSource(**kwargs)
     else:
         raise ValueError(f"Unknown source type: {source_type}")
 

flowfile_core/flowfile/util/calculate_layout.py

@@ -4,7 +4,6 @@ from collections import defaultdict, deque
 from typing import List, Dict, Set, Tuple, TYPE_CHECKING
 
 if TYPE_CHECKING:
-    # Make sure this import path is correct for your project structure
     from flowfile_core.flowfile.flow_graph import FlowGraph
 
 
@@ -64,7 +63,6 @@ def calculate_layered_layout(
                 if child_node.node_id in node_ids:
                     if child_node.node_id not in adj[node.node_id]:
                         adj[node.node_id].append(child_node.node_id)
-                    # Assuming primary method works or in_degree is handled elsewhere
                     in_degree[child_node.node_id] += 1
 
     stages: Dict[int, List[int]] = defaultdict(list)

flowfile_core/flowfile/utils.py

@@ -1,15 +1,15 @@
 import os
-import hashlib
 import json
-import polars as pl
 import shutil
 
-from datetime import datetime, date, time
+import datetime
 from typing import List
 from decimal import Decimal
-
-from flowfile_core.flowfile.flow_data_engine.utils import standardize_col_dtype
-from flowfile_core.schemas import input_schema
+import time
+import random
+import uuid
+import socket
+import hashlib
 
 
 def generate_sha256_hash(data: bytes):
@@ -30,11 +30,11 @@ def snake_case_to_camel_case(text: str) -> str:
 
 
 def json_default(val):
-    if isinstance(val, datetime):
+    if isinstance(val, datetime.datetime):
         return val.isoformat(timespec='microseconds')
-    elif isinstance(val, date):
+    elif isinstance(val, datetime.date):
         return val.isoformat()
-    elif isinstance(val, time):
+    elif isinstance(val, datetime.time):
         return val.isoformat()
     elif hasattr(val, '__dict__'):
         return val.__dict__
@@ -61,7 +61,7 @@ def get_hash(val):
     if hasattr(val, 'overridden_hash') and val.overridden_hash():
         val = hash(val)
     elif hasattr(val, '__dict__'):
-        val = {k: v for k, v in val.__dict__.items() if k not in {'pos_x', 'pos_y'}}
+        val = {k: v for k, v in val.__dict__.items() if k not in {'pos_x', 'pos_y', 'description'}}
     elif hasattr(val, 'json'):
         pass
     return generate_sha256_hash(json_dumps(val).encode('utf-8'))
@@ -119,19 +119,28 @@ def batch_generator(input_list: List, batch_size: int = 10000):
             run = False
 
 
-def _handle_raw_data(node_manual_input: input_schema.NodeManualInput):
-    """Ensure compatibility with the new typed raw data and the old dict form data type"""
-    if (not (hasattr(node_manual_input, "raw_data_format") and node_manual_input.raw_data_format)
-            and (hasattr(node_manual_input, 'raw_data') and node_manual_input.raw_data)):
-        values = [standardize_col_dtype([vv for vv in c]) for c in zip(*(r.values()
-                                                                         for r in node_manual_input.raw_data))]
-        data_types = (pl.DataType.from_python(type(next((v for v in column_values), None))) for column_values in values)
-        _columns = [input_schema.MinimalFieldInfo(name=c, data_type=str(next(data_types))) for c in
-                    node_manual_input.raw_data[0].keys()]
-
-        node_manual_input.raw_data_format = input_schema.RawData(columns=_columns, data=values)
-    elif ((hasattr(node_manual_input, "raw_data_format") and node_manual_input.raw_data_format)
-          and not (hasattr(node_manual_input, 'raw_data') and node_manual_input.raw_data)):
-        node_manual_input.raw_data = [{c.name: node_manual_input.raw_data_format.data[ci][ri] for ci, c in
-                                       enumerate(node_manual_input.raw_data_format.columns)}
-                                      for ri in range(len(node_manual_input.raw_data_format.data[0]))]
+def create_unique_id() -> int:
+    """
+    Create a unique id for the flowfile with increased randomness while maintaining 32-bit compatibility
+    Returns:
+        int: unique id within 32 bits (4 bytes)
+    """
+    # Get various entropy sources
+    time_ms = int(time.time() * 1000)
+    pid = os.getpid()
+    random_bytes = random.getrandbits(32)
+    mac_addr = uuid.getnode()  # MAC address as integer
+    hostname = socket.gethostname()
+
+    # Combine all sources into a string
+    seed = f"{time_ms}-{pid}-{random_bytes}-{mac_addr}-{hostname}-{uuid.uuid4()}"
+
+    # Create a hash of all entropy sources
+
+    hash_obj = hashlib.sha256(seed.encode())
+    hash_int = int(hash_obj.hexdigest(), 16)
+
+    # Ensure the result fits within 32 bits (4 bytes)
+    unique_id = hash_int & 0xFFFFFFFF
+
+    return unique_id

flowfile_core/main.py

@@ -8,14 +8,14 @@ from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
 from flowfile_core import ServerRun
-from flowfile_core.configs.settings import (SERVER_HOST, SERVER_PORT, WORKER_HOST, WORKER_PORT, WORKER_URL,
-                                            OFFLOAD_TO_WORKER)
+from flowfile_core.configs.settings import (SERVER_HOST, SERVER_PORT, WORKER_HOST, WORKER_PORT, WORKER_URL,)
 
 from flowfile_core.routes.auth import router as auth_router
 from flowfile_core.routes.secrets import router as secrets_router
 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.configs.flow_logger import clear_all_flow_logs
 
@@ -27,7 +27,11 @@ server_instance = None
 
 @asynccontextmanager
 async def shutdown_handler(app: FastAPI):
-    """Handle graceful shutdown of the application."""
+    """Handles the graceful startup and shutdown of the FastAPI application.
+
+    This context manager ensures that resources, such as log files, are cleaned
+    up properly when the application is terminated.
+    """
     print('Starting core application...')
     try:
         yield
@@ -72,35 +76,51 @@ app.include_router(router)
 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.post("/shutdown")
 async def shutdown():
-    """Endpoint to handle graceful shutdown"""
-    ServerRun.exit = True
-    print(f"ServerRun.exit = {ServerRun.exit}")
-    if server_instance:
-        # Schedule the shutdown
-        await asyncio.create_task(trigger_shutdown())
-    return {"message": "Shutting down"}
+    """An API endpoint to gracefully shut down the server.
+
+    This endpoint sets a flag that the Uvicorn server checks, allowing it
+    to terminate cleanly. A background task is used to trigger the shutdown
+    after the HTTP response has been sent.
+    """
+    # Use a background task to trigger the shutdown after the response is sent
+    background_tasks = ServerRun()
+    background_tasks.add_task(trigger_shutdown)
+    return {"message": "Server is shutting down"}
 
 
 async def trigger_shutdown():
-    """Trigger the actual shutdown after responding to the client"""
-    await asyncio.sleep(1)  # Give time for the response to be sent
+    """(Internal) Triggers the actual server shutdown.
+
+    Waits for a moment to allow the `/shutdown` response to be sent before
+    telling the Uvicorn server instance to exit.
+    """
+    await asyncio.sleep(1)
     if server_instance:
         server_instance.should_exit = True
 
 
 def signal_handler(signum, frame):
-    """Handle shutdown signals"""
+    """Handles OS signals like SIGINT (Ctrl+C) and SIGTERM for graceful shutdown."""
     print(f"Received signal {signum}")
     if server_instance:
         server_instance.should_exit = True
 
 
 def run(host: str = None, port: int = None):
-    """Run the FastAPI app with graceful shutdown"""
+    """Runs the FastAPI application using Uvicorn.
+
+    This function configures and starts the Uvicorn server, setting up
+    signal handlers to ensure a graceful shutdown.
+
+    Args:
+        host: The host to bind the server to. Defaults to `SERVER_HOST` from settings.
+        port: The port to bind the server to. Defaults to `SERVER_PORT` from settings.
+    """
     global server_instance
 
     # Use values from settings if not explicitly provided
@@ -133,7 +153,7 @@ def run(host: str = None, port: int = None):
         print("Received interrupt signal, shutting down...")
     finally:
         server_instance = None
-        print("Core server shutdown complete")
+        print("Server has shut down.")
 
 
 if __name__ == "__main__":

flowfile_core/routes/cloud_connections.py

@@ -0,0 +1,77 @@
+from typing import List
+
+from fastapi import HTTPException, Depends, APIRouter
+from sqlalchemy.orm import Session
+
+# Core modules
+from flowfile_core.auth.jwt import get_current_active_user
+from flowfile_core.configs import logger
+from flowfile_core.database.connection import get_db
+from flowfile_core.flowfile.database_connection_manager.db_connections import (store_cloud_connection,
+                                                                               get_cloud_connection_schema,
+                                                                               get_all_cloud_connections_interface,
+                                                                               delete_cloud_connection)
+# Schema and models
+from flowfile_core.schemas.cloud_storage_schemas import FullCloudStorageConnection, FullCloudStorageConnectionInterface
+
+# External dependencies
+# File handling
+router = APIRouter()
+
+
+@router.post("/cloud_connection", tags=['cloud_connections'])
+def create_cloud_storage_connection(input_connection: FullCloudStorageConnection,
+                                    current_user=Depends(get_current_active_user),
+                                    db: Session = Depends(get_db)
+                                    ):
+    """
+    Create a new cloud storage connection.
+    Parameters
+        input_connection: FullCloudStorageConnection schema containing connection details
+        current_user: User obtained from Depends(get_current_active_user)
+        db: Session obtained from Depends(get_db)
+    Returns
+        Dict with a success message
+    """
+    logger.info(f'Create cloud connection {input_connection.connection_name}')
+    try:
+        store_cloud_connection(db, input_connection, current_user.id)
+    except ValueError:
+        raise HTTPException(422, 'Connection name already exists')
+    except Exception as e:
+        logger.error(e)
+        raise HTTPException(422, str(e))
+    return {"message": "Cloud connection created successfully"}
+
+
+@router.delete('/cloud_connection', tags=['cloud_connections'])
+def delete_cloud_connection_with_connection_name(connection_name: str,
+                                                 current_user=Depends(get_current_active_user),
+                                                 db: Session = Depends(get_db)
+                                                 ):
+    """
+    Delete a cloud connection.
+    """
+    logger.info(f'Deleting cloud connection {connection_name}')
+    cloud_storage_connection = get_cloud_connection_schema(db, connection_name, current_user.id)
+    if cloud_storage_connection is None:
+        raise HTTPException(404, 'Cloud connection connection not found')
+    delete_cloud_connection(db, connection_name, current_user.id)
+    return {"message": "Cloud connection deleted successfully"}
+
+
+@router.get('/cloud_connections', tags=['cloud_connection'],
+            response_model=List[FullCloudStorageConnectionInterface])
+def get_cloud_connections(
+        db: Session = Depends(get_db),
+        current_user=Depends(get_current_active_user)) -> List[FullCloudStorageConnectionInterface]:
+    """
+    Get all cloud storage connections for the current user.
+    Parameters
+        db: Session obtained from Depends(get_db)
+        current_user: User obtained from Depends(get_current_active_user)
+
+    Returns
+        List[FullCloudStorageConnectionInterface]
+    """
+    return get_all_cloud_connections_interface(db, current_user.id)