fw-nodes-postgres 0.0.1a1__tar.gz

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

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

fw_nodes_postgres-0.0.1a1/.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+.venv/
+*.egg

fw_nodes_postgres-0.0.1a1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,11 @@
+# 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/fw_nodes_postgres/__init__.py

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

fw_nodes_postgres-0.0.1a1/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-0.0.1a1/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-0.0.1a1/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-0.0.1a1/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-0.0.1a1/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