fw-nodes-postgres 0.0.1a1__py3-none-any.whl

fw_nodes_postgres/__init__.py

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

fw_nodes_postgres/credentials.py

@@ -0,0 +1,23 @@
+"""Shared credential schema for PostgreSQL nodes."""
+
+from typing import ClassVar
+
+from pydantic import BaseModel, Field
+
+
+class PostgresCredentialSchema(BaseModel):
+    """Credential schema for PostgreSQL database connections.
+
+    Shared across all PostgreSQL nodes in this package.
+    """
+
+    credential_name: ClassVar[str] = "PostgreSQL"
+    credential_description: ClassVar[str] = "PostgreSQL database connection details"
+    credential_icon: ClassVar[str | None] = "database"
+
+    host: str = Field(..., description="Database host (e.g., localhost or db.example.com)")
+    port: int = Field(default=5432, description="Database port")
+    database: str = Field(..., description="Database name")
+    user: str = Field(..., description="Database user")
+    password: str = Field(..., description="Database password")
+    ssl: bool = Field(default=False, description="Use SSL/TLS connection")

fw_nodes_postgres/nodes/delete.py

@@ -0,0 +1,113 @@
+"""Structured DELETE node for PostgreSQL."""
+
+from typing import Any
+
+from flowire_sdk import BaseNode, BaseNodeOutput, InputField, NodeExecutionContext, NodeMetadata
+from flowire_sdk.node_base import FieldOption
+from pydantic import BaseModel, Field
+
+from fw_nodes_postgres.credentials import PostgresCredentialSchema
+from fw_nodes_postgres.utils.db import (
+    WhereCondition,
+    build_where_clause,
+    execute_query,
+    pg_field_options,
+    qualify_table,
+    sanitize_identifier,
+    serialize_rows,
+)
+
+
+class DeleteInput(BaseModel):
+    credential_id: str = InputField(..., description="PostgreSQL credential")
+    schema: str | None = InputField(
+        default=None,
+        description="PostgreSQL schema (defaults to search_path, usually 'public')",
+        dynamic_options=["credential_id"],
+    )
+    table: str = InputField(
+        ...,
+        description="Table to delete from",
+        dynamic_options=["credential_id", "schema"],
+    )
+    where: list[WhereCondition] = InputField(
+        ...,
+        min_length=1,
+        description="WHERE conditions (at least one required to prevent accidental full-table deletes)",
+    )
+    returning: list[str] = InputField(
+        default_factory=list,
+        description="Columns to return from deleted rows",
+    )
+    timeout: int = InputField(default=30, ge=1, le=300, description="Query timeout in seconds")
+
+
+class DeleteOutput(BaseNodeOutput):
+    rows: list[dict[str, Any]] = Field(..., description="Returned rows (if RETURNING was specified)")
+    affected_count: int = Field(..., description="Number of rows deleted")
+    success: bool = Field(..., description="Whether the delete executed successfully")
+    raw_sql: str = Field(..., description="The generated SQL query (with $N placeholders)")
+
+
+class DeleteNode(BaseNode):
+    """Delete rows from a PostgreSQL table."""
+
+    input_schema = DeleteInput
+    output_schema = DeleteOutput
+    credential_schema = PostgresCredentialSchema
+
+    metadata = NodeMetadata(
+        name="Postgres Delete",
+        description="Delete rows from a PostgreSQL table",
+        category="database",
+        icon="database",
+        color="#336791",
+    )
+
+    async def get_field_options(
+        self,
+        field_name: str,
+        credential_data: dict[str, Any] | None = None,
+        field_values: dict[str, Any] | None = None,
+    ) -> list[FieldOption]:
+        return await pg_field_options(field_name, credential_data, field_values)
+
+    async def execute_logic(
+        self,
+        validated_inputs: dict[str, Any],
+        context: NodeExecutionContext,
+    ) -> DeleteOutput:
+        credential_data = await context.resolve_credential(
+            credential_id=validated_inputs["credential_id"],
+            credential_type=self.get_credential_type(),
+        )
+        context.register_secret(credential_data["password"])
+
+        query, params = _build_delete_query(validated_inputs)
+        timeout = validated_inputs.get("timeout", 30)
+
+        rows, row_count = await execute_query(credential_data, query, params, timeout=timeout)
+        return DeleteOutput(
+            rows=serialize_rows(rows),
+            affected_count=row_count,
+            success=True,
+            raw_sql=query,
+        )
+
+
+def _build_delete_query(inputs: dict[str, Any]) -> tuple[str, list[Any]]:
+    """Build a parameterized DELETE query from structured inputs."""
+    table = qualify_table(inputs["table"], inputs.get("schema"))
+
+    # WHERE clause (required)
+    where_sql, params, _ = build_where_clause(inputs["where"])
+
+    query = f"DELETE FROM {table} {where_sql}"
+
+    # RETURNING
+    returning = inputs.get("returning") or []
+    if returning:
+        ret_str = ", ".join(sanitize_identifier(c) for c in returning)
+        query += f" RETURNING {ret_str}"
+
+    return query, params

fw_nodes_postgres/nodes/insert.py

@@ -0,0 +1,146 @@
+"""Structured INSERT node for PostgreSQL."""
+
+from typing import Any
+
+from flowire_sdk import BaseNode, BaseNodeOutput, InputField, NodeExecutionContext, NodeMetadata
+from flowire_sdk.node_base import FieldOption
+from pydantic import BaseModel, Field
+
+from fw_nodes_postgres.credentials import PostgresCredentialSchema
+from fw_nodes_postgres.utils.db import (
+    execute_query,
+    pg_field_options,
+    qualify_table,
+    sanitize_identifier,
+    serialize_rows,
+)
+
+
+class InsertInput(BaseModel):
+    credential_id: str = InputField(..., description="PostgreSQL credential")
+    schema: str | None = InputField(
+        default=None,
+        description="PostgreSQL schema (defaults to search_path, usually 'public')",
+        dynamic_options=["credential_id"],
+    )
+    table: str = InputField(
+        ...,
+        description="Table to insert into",
+        dynamic_options=["credential_id", "schema"],
+    )
+    data: dict[str, Any] | list[dict[str, Any]] = InputField(
+        ...,
+        description="Row data as key-value pairs, or a list of rows for bulk insert",
+    )
+    returning: list[str] = InputField(
+        default_factory=list,
+        description="Columns to return from inserted rows (e.g., ['id', 'created_at'])",
+    )
+    timeout: int = InputField(default=30, ge=1, le=300, description="Query timeout in seconds")
+
+
+class InsertOutput(BaseNodeOutput):
+    rows: list[dict[str, Any]] = Field(..., description="Returned rows (if RETURNING was specified)")
+    affected_count: int = Field(..., description="Number of rows inserted")
+    success: bool = Field(..., description="Whether the insert executed successfully")
+    raw_sql: str = Field(..., description="The generated SQL query (with $N placeholders)")
+
+
+class InsertNode(BaseNode):
+    """Insert rows into a PostgreSQL table."""
+
+    input_schema = InsertInput
+    output_schema = InsertOutput
+    credential_schema = PostgresCredentialSchema
+
+    metadata = NodeMetadata(
+        name="Postgres Insert",
+        description="Insert rows into a PostgreSQL table",
+        category="database",
+        icon="database",
+        color="#336791",
+    )
+
+    async def get_field_options(
+        self,
+        field_name: str,
+        credential_data: dict[str, Any] | None = None,
+        field_values: dict[str, Any] | None = None,
+    ) -> list[FieldOption]:
+        return await pg_field_options(field_name, credential_data, field_values)
+
+    async def execute_logic(
+        self,
+        validated_inputs: dict[str, Any],
+        context: NodeExecutionContext,
+    ) -> InsertOutput:
+        credential_data = await context.resolve_credential(
+            credential_id=validated_inputs["credential_id"],
+            credential_type=self.get_credential_type(),
+        )
+        context.register_secret(credential_data["password"])
+
+        query, params = _build_insert_query(validated_inputs)
+        timeout = validated_inputs.get("timeout", 30)
+
+        rows, row_count = await execute_query(credential_data, query, params, timeout=timeout)
+        return InsertOutput(
+            rows=serialize_rows(rows),
+            affected_count=row_count,
+            success=True,
+            raw_sql=query,
+        )
+
+
+def _build_insert_query(inputs: dict[str, Any]) -> tuple[str, list[Any]]:
+    """Build a parameterized INSERT query from structured inputs."""
+    table = qualify_table(inputs["table"], inputs.get("schema"))
+    data = inputs["data"]
+
+    # Normalize to list of rows
+    rows_data = data if isinstance(data, list) else [data]
+    if not rows_data:
+        raise ValueError("No data provided for insert")
+
+    # Use column order from the first row
+    columns = list(rows_data[0].keys())
+    if not columns:
+        raise ValueError("No columns provided for insert")
+
+    # Validate all rows have the same columns
+    expected = set(columns)
+    for i, row in enumerate(rows_data[1:], start=2):
+        actual = set(row.keys())
+        if actual != expected:
+            missing = expected - actual
+            extra = actual - expected
+            parts = []
+            if missing:
+                parts.append(f"missing {missing}")
+            if extra:
+                parts.append(f"unexpected {extra}")
+            raise ValueError(f"Row {i} has inconsistent columns: {', '.join(parts)}")
+
+    col_str = ", ".join(sanitize_identifier(c) for c in columns)
+
+    params: list[Any] = []
+    value_groups: list[str] = []
+    param_idx = 1
+
+    for row in rows_data:
+        placeholders = []
+        for col in columns:
+            placeholders.append(f"${param_idx}")
+            params.append(row.get(col))
+            param_idx += 1
+        value_groups.append(f"({', '.join(placeholders)})")
+
+    query = f"INSERT INTO {table} ({col_str}) VALUES {', '.join(value_groups)}"
+
+    # RETURNING
+    returning = inputs.get("returning") or []
+    if returning:
+        ret_str = ", ".join(sanitize_identifier(c) for c in returning)
+        query += f" RETURNING {ret_str}"
+
+    return query, params

fw_nodes_postgres/nodes/raw_query.py

@@ -0,0 +1,79 @@
+"""Raw SQL query node for executing arbitrary SQL against PostgreSQL."""
+
+from typing import Any
+
+from flowire_sdk import BaseNode, BaseNodeOutput, CodeEditorContract, InputField, NodeExecutionContext, NodeMetadata
+from pydantic import BaseModel, Field
+
+from fw_nodes_postgres.credentials import PostgresCredentialSchema
+from fw_nodes_postgres.utils.db import execute_query, serialize_rows
+
+SQL_DEFAULT = "SELECT * FROM my_table\nWHERE id = $1\nLIMIT 100;"
+
+
+class RawQueryInput(BaseModel):
+    credential_id: str = InputField(..., description="PostgreSQL credential")
+    query: str = InputField(
+        default=SQL_DEFAULT,
+        description="SQL query to execute. Use $1, $2, etc. for parameterized values.",
+        code=True,
+    )
+    params: list[Any] = InputField(
+        default_factory=list,
+        description="Query parameters (matched to $1, $2, etc. in the query)",
+    )
+    timeout: int = InputField(default=30, ge=1, le=300, description="Query timeout in seconds")
+
+
+class RawQueryOutput(BaseNodeOutput):
+    rows: list[dict[str, Any]] = Field(..., description="Query result rows (empty for non-SELECT queries)")
+    row_count: int = Field(..., description="Number of rows returned or affected")
+    success: bool = Field(..., description="Whether the query executed successfully")
+    raw_sql: str = Field(..., description="The SQL query that was executed")
+
+
+class RawQueryNode(BaseNode):
+    """Execute raw SQL queries against a PostgreSQL database."""
+
+    input_schema = RawQueryInput
+    output_schema = RawQueryOutput
+    credential_schema = PostgresCredentialSchema
+
+    metadata = NodeMetadata(
+        name="Postgres Raw Query",
+        description="Execute raw SQL queries against PostgreSQL",
+        category="database",
+        icon="database",
+        color="#336791",
+        display_component="code",
+        code_editor=CodeEditorContract(
+            code_field="query",
+            language_field=None,
+            code_format="code",
+            language_defaults={"sql": SQL_DEFAULT},
+            language_options=["sql"],
+        ),
+    )
+
+    async def execute_logic(
+        self,
+        validated_inputs: dict[str, Any],
+        context: NodeExecutionContext,
+    ) -> RawQueryOutput:
+        credential_data = await context.resolve_credential(
+            credential_id=validated_inputs["credential_id"],
+            credential_type=self.get_credential_type(),
+        )
+        context.register_secret(credential_data["password"])
+
+        query = validated_inputs["query"]
+        params = validated_inputs.get("params") or []
+        timeout = validated_inputs.get("timeout", 30)
+
+        rows, row_count = await execute_query(credential_data, query, params, timeout=timeout)
+        return RawQueryOutput(
+            rows=serialize_rows(rows),
+            row_count=row_count,
+            success=True,
+            raw_sql=query,
+        )

fw_nodes_postgres/nodes/select.py

@@ -0,0 +1,151 @@
+"""Structured SELECT node for PostgreSQL."""
+
+from enum import StrEnum
+from typing import Any
+
+from flowire_sdk import BaseNode, BaseNodeOutput, InputField, NodeExecutionContext, NodeMetadata
+from flowire_sdk.node_base import FieldOption
+from pydantic import BaseModel, Field
+
+from fw_nodes_postgres.credentials import PostgresCredentialSchema
+from fw_nodes_postgres.utils.db import (
+    WhereCondition,
+    build_where_clause,
+    execute_query,
+    pg_field_options,
+    qualify_table,
+    sanitize_identifier,
+    serialize_rows,
+)
+
+
+class SortDirection(StrEnum):
+    ASC = "ASC"
+    DESC = "DESC"
+
+
+class SortClause(BaseModel):
+    column: str = InputField(..., description="Column to sort by")
+    direction: SortDirection = InputField(default=SortDirection.ASC, description="Sort direction")
+
+
+class SelectInput(BaseModel):
+    credential_id: str = InputField(..., description="PostgreSQL credential")
+    schema: str | None = InputField(
+        default=None,
+        description="PostgreSQL schema (defaults to search_path, usually 'public')",
+        dynamic_options=["credential_id"],
+    )
+    table: str = InputField(
+        ...,
+        description="Table name to query",
+        dynamic_options=["credential_id", "schema"],
+    )
+    columns: list[str] = InputField(
+        default_factory=lambda: ["*"],
+        description="Columns to select (defaults to all)",
+    )
+    where: list[WhereCondition] = InputField(
+        default_factory=list,
+        description="WHERE conditions (combined with AND)",
+    )
+    order_by: list[SortClause] = InputField(default_factory=list, description="ORDER BY clauses")
+    limit: int | None = InputField(default=None, ge=1, description="Maximum rows to return")
+    offset: int | None = InputField(default=None, ge=0, description="Number of rows to skip")
+    timeout: int = InputField(default=30, ge=1, le=300, description="Query timeout in seconds")
+
+
+class SelectOutput(BaseNodeOutput):
+    rows: list[dict[str, Any]] = Field(..., description="Query result rows")
+    row_count: int = Field(..., description="Number of rows returned")
+    success: bool = Field(..., description="Whether the query executed successfully")
+    raw_sql: str = Field(..., description="The generated SQL query (with $N placeholders)")
+
+
+class SelectNode(BaseNode):
+    """Query rows from a PostgreSQL table with a structured interface."""
+
+    input_schema = SelectInput
+    output_schema = SelectOutput
+    credential_schema = PostgresCredentialSchema
+
+    metadata = NodeMetadata(
+        name="Postgres Select",
+        description="Query rows from a PostgreSQL table",
+        category="database",
+        icon="database",
+        color="#336791",
+    )
+
+    async def get_field_options(
+        self,
+        field_name: str,
+        credential_data: dict[str, Any] | None = None,
+        field_values: dict[str, Any] | None = None,
+    ) -> list[FieldOption]:
+        return await pg_field_options(field_name, credential_data, field_values)
+
+    async def execute_logic(
+        self,
+        validated_inputs: dict[str, Any],
+        context: NodeExecutionContext,
+    ) -> SelectOutput:
+        credential_data = await context.resolve_credential(
+            credential_id=validated_inputs["credential_id"],
+            credential_type=self.get_credential_type(),
+        )
+        context.register_secret(credential_data["password"])
+
+        query, params = _build_select_query(validated_inputs)
+        timeout = validated_inputs.get("timeout", 30)
+
+        rows, row_count = await execute_query(credential_data, query, params, timeout=timeout)
+        return SelectOutput(
+            rows=serialize_rows(rows),
+            row_count=row_count,
+            success=True,
+            raw_sql=query,
+        )
+
+
+def _build_select_query(inputs: dict[str, Any]) -> tuple[str, list[Any]]:
+    """Build a parameterized SELECT query from structured inputs."""
+    table = qualify_table(inputs["table"], inputs.get("schema"))
+    columns = inputs.get("columns") or ["*"]
+    col_str = ", ".join(sanitize_identifier(c) if c != "*" else "*" for c in columns)
+
+    parts = [f"SELECT {col_str} FROM {table}"]
+    params: list[Any] = []
+    param_idx = 1
+
+    # WHERE
+    where_conditions = inputs.get("where") or []
+    if where_conditions:
+        where_sql, where_params, param_idx = build_where_clause(where_conditions, param_idx)
+        parts.append(where_sql)
+        params.extend(where_params)
+
+    # ORDER BY
+    order_by = inputs.get("order_by") or []
+    if order_by:
+        order_parts = []
+        for clause in order_by:
+            col = sanitize_identifier(clause["column"])
+            direction = clause.get("direction", "ASC").upper()
+            if direction not in ("ASC", "DESC"):
+                direction = "ASC"
+            order_parts.append(f"{col} {direction}")
+        parts.append("ORDER BY " + ", ".join(order_parts))
+
+    # LIMIT / OFFSET
+    if inputs.get("limit") is not None:
+        parts.append(f"LIMIT ${param_idx}")
+        params.append(inputs["limit"])
+        param_idx += 1
+
+    if inputs.get("offset") is not None:
+        parts.append(f"OFFSET ${param_idx}")
+        params.append(inputs["offset"])
+        param_idx += 1
+
+    return " ".join(parts), params

fw_nodes_postgres/nodes/update.py

@@ -0,0 +1,129 @@
+"""Structured UPDATE node for PostgreSQL."""
+
+from typing import Any
+
+from flowire_sdk import BaseNode, BaseNodeOutput, InputField, NodeExecutionContext, NodeMetadata
+from flowire_sdk.node_base import FieldOption
+from pydantic import BaseModel, Field
+
+from fw_nodes_postgres.credentials import PostgresCredentialSchema
+from fw_nodes_postgres.utils.db import (
+    WhereCondition,
+    build_where_clause,
+    execute_query,
+    pg_field_options,
+    qualify_table,
+    sanitize_identifier,
+    serialize_rows,
+)
+
+
+class UpdateInput(BaseModel):
+    credential_id: str = InputField(..., description="PostgreSQL credential")
+    schema: str | None = InputField(
+        default=None,
+        description="PostgreSQL schema (defaults to search_path, usually 'public')",
+        dynamic_options=["credential_id"],
+    )
+    table: str = InputField(
+        ...,
+        description="Table to update",
+        dynamic_options=["credential_id", "schema"],
+    )
+    data: dict[str, Any] = InputField(..., description="Column values to set (key-value pairs)")
+    where: list[WhereCondition] = InputField(
+        ...,
+        min_length=1,
+        description="WHERE conditions (at least one required to prevent accidental full-table updates)",
+    )
+    returning: list[str] = InputField(
+        default_factory=list,
+        description="Columns to return from updated rows",
+    )
+    timeout: int = InputField(default=30, ge=1, le=300, description="Query timeout in seconds")
+
+
+class UpdateOutput(BaseNodeOutput):
+    rows: list[dict[str, Any]] = Field(..., description="Returned rows (if RETURNING was specified)")
+    affected_count: int = Field(..., description="Number of rows updated")
+    success: bool = Field(..., description="Whether the update executed successfully")
+    raw_sql: str = Field(..., description="The generated SQL query (with $N placeholders)")
+
+
+class UpdateNode(BaseNode):
+    """Update rows in a PostgreSQL table."""
+
+    input_schema = UpdateInput
+    output_schema = UpdateOutput
+    credential_schema = PostgresCredentialSchema
+
+    metadata = NodeMetadata(
+        name="Postgres Update",
+        description="Update rows in a PostgreSQL table",
+        category="database",
+        icon="database",
+        color="#336791",
+    )
+
+    async def get_field_options(
+        self,
+        field_name: str,
+        credential_data: dict[str, Any] | None = None,
+        field_values: dict[str, Any] | None = None,
+    ) -> list[FieldOption]:
+        return await pg_field_options(field_name, credential_data, field_values)
+
+    async def execute_logic(
+        self,
+        validated_inputs: dict[str, Any],
+        context: NodeExecutionContext,
+    ) -> UpdateOutput:
+        credential_data = await context.resolve_credential(
+            credential_id=validated_inputs["credential_id"],
+            credential_type=self.get_credential_type(),
+        )
+        context.register_secret(credential_data["password"])
+
+        query, params = _build_update_query(validated_inputs)
+        timeout = validated_inputs.get("timeout", 30)
+
+        rows, row_count = await execute_query(credential_data, query, params, timeout=timeout)
+        return UpdateOutput(
+            rows=serialize_rows(rows),
+            affected_count=row_count,
+            success=True,
+            raw_sql=query,
+        )
+
+
+def _build_update_query(inputs: dict[str, Any]) -> tuple[str, list[Any]]:
+    """Build a parameterized UPDATE query from structured inputs."""
+    table = qualify_table(inputs["table"], inputs.get("schema"))
+    data = inputs["data"]
+
+    if not data:
+        raise ValueError("No data provided for update")
+
+    params: list[Any] = []
+    param_idx = 1
+
+    # SET clause
+    set_parts = []
+    for col, val in data.items():
+        set_parts.append(f"{sanitize_identifier(col)} = ${param_idx}")
+        params.append(val)
+        param_idx += 1
+
+    # WHERE clause (required)
+    where_sql, where_params, param_idx = build_where_clause(inputs["where"], param_idx)
+    params.extend(where_params)
+
+    query = f"UPDATE {table} SET {', '.join(set_parts)} {where_sql}"
+
+    # RETURNING
+    returning = inputs.get("returning") or []
+    if returning:
+        ret_str = ", ".join(sanitize_identifier(c) for c in returning)
+        query += f" RETURNING {ret_str}"
+
+    return query, params

fw_nodes_postgres/utils/db.py

@@ -0,0 +1,255 @@
+"""Shared database utilities for PostgreSQL nodes."""
+
+from decimal import Decimal
+from typing import Any
+
+import asyncpg
+from flowire_sdk import InputField
+from flowire_sdk.node_base import FieldOption
+from pydantic import BaseModel
+
+
+class WhereCondition(BaseModel):
+    column: str = InputField(..., description="Column name")
+    operator: str = InputField(
+        default="=",
+        description="Comparison operator (=, !=, <, >, <=, >=, LIKE, ILIKE, IN, IS NULL, IS NOT NULL)",
+    )
+    value: Any = InputField(default=None, description="Comparison value (ignored for IS NULL / IS NOT NULL)")
+
+
+_ALLOWED_OPERATORS = frozenset({"=", "!=", "<>", "<", ">", "<=", ">=", "LIKE", "ILIKE"})
+
+
+def sanitize_identifier(name: str) -> str:
+    """Quote a SQL identifier to prevent injection."""
+    cleaned = name.replace('"', '""')
+    return f'"{cleaned}"'
+
+
+def qualify_table(table: str, schema: str | None = None) -> str:
+    """Return a fully-qualified, quoted table reference (e.g. "myschema"."mytable")."""
+    qualified = sanitize_identifier(table)
+    if schema:
+        qualified = f"{sanitize_identifier(schema)}.{qualified}"
+    return qualified
+
+
+def build_where_clause(
+    conditions: list[dict[str, Any]],
+    param_idx: int = 1,
+) -> tuple[str, list[Any], int]:
+    """Build a parameterized WHERE clause from a list of conditions.
+
+    Returns (clause_sql, params, next_param_idx).
+    clause_sql includes the 'WHERE' keyword.
+    """
+    clauses: list[str] = []
+    params: list[Any] = []
+
+    for cond in conditions:
+        col = sanitize_identifier(cond["column"])
+        op = cond.get("operator", "=").upper().strip()
+
+        if op in ("IS NULL", "IS NOT NULL"):
+            clauses.append(f"{col} {op}")
+        elif op == "IN":
+            values = cond["value"] if isinstance(cond["value"], list) else [cond["value"]]
+            placeholders = ", ".join(f"${param_idx + i}" for i in range(len(values)))
+            clauses.append(f"{col} IN ({placeholders})")
+            params.extend(values)
+            param_idx += len(values)
+        else:
+            if op not in _ALLOWED_OPERATORS:
+                raise ValueError(f"Unsupported operator: {op}")
+            clauses.append(f"{col} {op} ${param_idx}")
+            params.append(cond["value"])
+            param_idx += 1
+
+    return "WHERE " + " AND ".join(clauses), params, param_idx
+
+
+async def execute_query(
+    credential_data: dict[str, Any],
+    query: str,
+    params: list[Any] | None = None,
+    *,
+    timeout: float = 30.0,
+) -> tuple[list[dict[str, Any]], int]:
+    """Execute a query and return (rows, row_count).
+
+    For SELECT queries, rows contains the result set and row_count is len(rows).
+    For INSERT/UPDATE/DELETE, rows is empty and row_count is the affected row count.
+    Returns with RETURNING clauses return the rows and len(rows) as row_count.
+    """
+    ssl_config: str | bool = "require" if credential_data.get("ssl") else False
+
+    try:
+        conn: asyncpg.Connection = await asyncpg.connect(
+            host=credential_data["host"],
+            port=credential_data.get("port", 5432),
+            database=credential_data["database"],
+            user=credential_data["user"],
+            password=credential_data["password"],
+            ssl=ssl_config,
+            timeout=timeout,
+        )
+    except OSError as e:
+        raise ConnectionError(
+            f"Cannot connect to PostgreSQL at {credential_data['host']}:{credential_data.get('port', 5432)}: {e}"
+        ) from e
+    except asyncpg.InvalidPasswordError as e:
+        raise ConnectionError("Authentication failed: invalid username or password") from e
+    except asyncpg.InvalidCatalogNameError as e:
+        raise ConnectionError(f"Database '{credential_data['database']}' does not exist") from e
+    except TimeoutError as e:
+        raise TimeoutError(
+            f"Connection timed out after {timeout}s to {credential_data['host']}:{credential_data.get('port', 5432)}"
+        ) from e
+    except asyncpg.PostgresError as e:
+        raise ConnectionError(f"PostgreSQL connection error: {e}") from e
+
+    try:
+        async with conn.transaction():
+            stmt = await conn.prepare(query, timeout=timeout)
+            if stmt.get_attributes():
+                records = await stmt.fetch(*(params or []), timeout=timeout)
+                rows = [dict(r) for r in records]
+                return rows, len(rows)
+            else:
+                result = await conn.execute(query, *(params or []), timeout=timeout)
+                row_count = _parse_command_tag(result)
+                return [], row_count
+    except asyncpg.PostgresSyntaxError as e:
+        raise ValueError(f"SQL syntax error: {e}") from e
+    except asyncpg.UndefinedTableError as e:
+        raise ValueError(f"Table not found: {e}") from e
+    except asyncpg.UndefinedColumnError as e:
+        raise ValueError(f"Column not found: {e}") from e
+    except asyncpg.DataError as e:
+        raise ValueError(f"Data error: {e}") from e
+    except TimeoutError as e:
+        raise TimeoutError(f"Query timed out after {timeout}s") from e
+    except asyncpg.PostgresError as e:
+        raise RuntimeError(f"PostgreSQL error: {e}") from e
+    finally:
+        await conn.close()
+
+
+def _parse_command_tag(tag: str) -> int:
+    """Parse asyncpg command tag like 'DELETE 3' into affected row count."""
+    parts = tag.split()
+    if len(parts) >= 2 and parts[-1].isdigit():
+        return int(parts[-1])
+    return 0
+
+
+def _serialize_value(value: Any) -> Any:
+    """Convert asyncpg types to JSON-serializable Python types.
+
+    Preserves native JSON types (int, float, bool) and converts
+    Decimal to int/float so downstream nodes get usable numbers.
+    """
+    if value is None:
+        return None
+    if isinstance(value, bool):
+        # Check bool before int since bool is a subclass of int
+        return value
+    if isinstance(value, (int, float)):
+        return value
+    if isinstance(value, str):
+        return value
+    if isinstance(value, Decimal):
+        # Preserve as int when there's no fractional part
+        if value == value.to_integral_value():
+            return int(value)
+        return float(value)
+    if isinstance(value, (list, tuple)):
+        return [_serialize_value(v) for v in value]
+    if isinstance(value, dict):
+        return {k: _serialize_value(v) for k, v in value.items()}
+    # datetime, date, time, UUID, etc.
+    return str(value)
+
+
+def serialize_rows(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Serialize all values in rows to JSON-safe types."""
+    return [{k: _serialize_value(v) for k, v in row.items()} for row in rows]
+
+
+# ---------------------------------------------------------------------------
+# Dynamic field options helpers
+# ---------------------------------------------------------------------------
+
+# Schemas to hide from the dropdown (PostgreSQL internals)
+_HIDDEN_SCHEMAS = frozenset({"pg_catalog", "pg_toast", "information_schema"})
+
+
+async def _connect(credential_data: dict[str, Any]) -> asyncpg.Connection:
+    """Open a short-lived connection for metadata queries."""
+    ssl_config: str | bool = "require" if credential_data.get("ssl") else False
+    return await asyncpg.connect(
+        host=credential_data["host"],
+        port=credential_data.get("port", 5432),
+        database=credential_data["database"],
+        user=credential_data["user"],
+        password=credential_data["password"],
+        ssl=ssl_config,
+        timeout=10,
+    )
+
+
+async def fetch_schemas(credential_data: dict[str, Any]) -> list[FieldOption]:
+    """List user-visible schemas from the connected database."""
+    conn = await _connect(credential_data)
+    try:
+        rows = await conn.fetch("SELECT schema_name FROM information_schema.schemata ORDER BY schema_name")
+        return [
+            FieldOption(id=r["schema_name"], name=r["schema_name"])
+            for r in rows
+            if r["schema_name"] not in _HIDDEN_SCHEMAS
+        ]
+    finally:
+        await conn.close()
+
+
+async def fetch_tables(
+    credential_data: dict[str, Any],
+    schema: str | None = None,
+) -> list[FieldOption]:
+    """List tables (and views) in a schema. Defaults to 'public'."""
+    schema = schema or "public"
+    conn = await _connect(credential_data)
+    try:
+        rows = await conn.fetch(
+            "SELECT table_name, table_type FROM information_schema.tables WHERE table_schema = $1 ORDER BY table_name",
+            schema,
+        )
+        return [
+            FieldOption(
+                id=r["table_name"],
+                name=r["table_name"],
+                description="view" if r["table_type"] == "VIEW" else None,
+            )
+            for r in rows
+        ]
+    finally:
+        await conn.close()
+
+
+async def pg_field_options(
+    field_name: str,
+    credential_data: dict[str, Any] | None,
+    field_values: dict[str, Any] | None = None,
+) -> list[FieldOption]:
+    """Shared get_field_options implementation for all PostgreSQL CRUD nodes."""
+    if credential_data is None:
+        return []
+
+    if field_name == "schema":
+        return await fetch_schemas(credential_data)
+    elif field_name == "table":
+        schema = (field_values or {}).get("schema")
+        return await fetch_tables(credential_data, schema)
+
+    return []

fw_nodes_postgres-0.0.1a1.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: fw-nodes-postgres
+Version: 0.0.1a1
+Summary: PostgreSQL database nodes for Flowire workflow automation
+License-Expression: MIT
+Requires-Python: >=3.13
+Requires-Dist: asyncpg>=0.30.0
+Requires-Dist: flowire-sdk>=0.0.1a1
+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-postgres
+
+PostgreSQL database nodes for Flowire workflow automation.
+
+## Nodes
+
+- **Postgres Raw Query** — Execute raw SQL with a code editor and parameterized values
+- **Postgres Select** — Structured query builder for SELECT operations
+- **Postgres Insert** — Insert single or bulk rows
+- **Postgres Update** — Update rows with required WHERE conditions
+- **Postgres Delete** — Delete rows with required WHERE conditions

fw_nodes_postgres-0.0.1a1.dist-info/RECORD

@@ -0,0 +1,14 @@
+fw_nodes_postgres/__init__.py,sha256=CxCjSWye6NI41h2VKl8C3v7YEnVIPmIMDwgDQ16FHbg,56
+fw_nodes_postgres/credentials.py,sha256=nXo-NgL_fxBeCmXoz5I5KiFftS5o07LUs2sdYNOnQ0E,897
+fw_nodes_postgres/nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fw_nodes_postgres/nodes/delete.py,sha256=5hOhnomDhb_ORz0OaKxV_OQjglBc_qjbK1QjbPNIilU,3810
+fw_nodes_postgres/nodes/insert.py,sha256=BLk6_po7uKyTc86QCWFsfbMSYwREQw5Fd6NfuA7pf24,4999
+fw_nodes_postgres/nodes/raw_query.py,sha256=8sgjqxzgRVaostkqAqnDXK5yZiim1rmrG3Ocq_SStHo,2895
+fw_nodes_postgres/nodes/select.py,sha256=wz96sjtibOwLV13lWQveLcojTQIxCLHWH06UXE5nVm4,5243
+fw_nodes_postgres/nodes/update.py,sha256=HJ-TqQxmFpFYMb0rnyMB7j83GPfDzKCqPhg69VI225U,4315
+fw_nodes_postgres/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fw_nodes_postgres/utils/db.py,sha256=xyEJnsnBxdOR6--CZwKQ1BzvtqkcubG5xembAWJXZ44,9296
+fw_nodes_postgres-0.0.1a1.dist-info/METADATA,sha256=W2ec0PPy86ByimJm608UxK2F7oweiQVzkOYu_bouOTw,892
+fw_nodes_postgres-0.0.1a1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+fw_nodes_postgres-0.0.1a1.dist-info/entry_points.txt,sha256=USDmzbO4r6dVAurrfEXPJUXK_0kcEhcLV-K8R6dBPNY,294
+fw_nodes_postgres-0.0.1a1.dist-info/RECORD,,

fw_nodes_postgres-0.0.1a1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

fw_nodes_postgres-0.0.1a1.dist-info/entry_points.txt

@@ -0,0 +1,6 @@
+[flowire.nodes]
+pg_delete = fw_nodes_postgres.nodes.delete:DeleteNode
+pg_insert = fw_nodes_postgres.nodes.insert:InsertNode
+pg_raw_query = fw_nodes_postgres.nodes.raw_query:RawQueryNode
+pg_select = fw_nodes_postgres.nodes.select:SelectNode
+pg_update = fw_nodes_postgres.nodes.update:UpdateNode