dex-connector-clickup 0.1.0__tar.gz

dex_connector_clickup-0.1.0/.gitignore

@@ -0,0 +1,16 @@
+.DS_Store
+__pycache__/
+*.py[cod]
+node_modules/
+dist/
+sdkpython/dist/dex_connectors_sdk-0.1.0-py3-none-any.whl
+/.bin/dexcli
+/.bin/dex-server-zd
+/sdkpython/.dexcli-data/
+site/.catalog.yaml
+coverage/
+*.out
+*.test
+go.work
+go.work.sum
+.idea/

dex_connector_clickup-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Super Durable
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dex_connector_clickup-0.1.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.5
+Name: dex-connector-clickup
+Version: 0.1.0
+Summary: ClickUp connector for Dex Flows
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: dex-connectors-sdk==0.1.0
+Requires-Dist: dex-python-sdk>=1.28.0
+Requires-Dist: httpx>=0.27
+Description-Content-Type: text/markdown
+
+# ClickUp Python connector
+
+The package implements the ClickUp `searchTasks`, `getTask`, `createTask`, `updateTask`, `updateTaskTags`, `addComment`, and `findMemberByEmail` operations for Dex Flows. The `taskEvent` webhook Trigger remains Go-only. Install `dex-connector-clickup==0.1.0` alongside a Dex Python application and load its named connection from Dex project configuration. The connection uses a ClickUp personal API token and resolves it before each provider request.
+
+The [getTask runnable example](examples/get_task/README.md) uses a static `clickup-workspace` connection and a real Dex Worker and Client. Its integration test exercises a retry and an unwired rejection branch against a local ClickUp stand-in. Run from this directory with `uv sync --locked`, then `uv run pytest tests/ examples/get_task/integration_test.py` while `dexcli dev` is running and `DEX_FLOW_SERVICE_ADDRESS` points to it.
+
+`createTask` and `addComment` store a Dex heartbeat checkpoint before an unkeyed write. If a retry sees the checkpoint, it reads back instead of sending the write again; an unconfirmable outcome selects `uncertain`. The provider has no idempotency-key support for these calls. The Python package currently has no live ClickUp authorization or API verification.
+
+`getTask` returns custom field JSON values only when Python can represent their numbers exactly. A value that would lose precision selects `invalidResponse` and identifies the field. `updateTaskTags` bounds its sequence of provider requests to 25 seconds; an incomplete sequence retries.

dex_connector_clickup-0.1.0/README.md

@@ -0,0 +1,9 @@
+# ClickUp Python connector
+
+The package implements the ClickUp `searchTasks`, `getTask`, `createTask`, `updateTask`, `updateTaskTags`, `addComment`, and `findMemberByEmail` operations for Dex Flows. The `taskEvent` webhook Trigger remains Go-only. Install `dex-connector-clickup==0.1.0` alongside a Dex Python application and load its named connection from Dex project configuration. The connection uses a ClickUp personal API token and resolves it before each provider request.
+
+The [getTask runnable example](examples/get_task/README.md) uses a static `clickup-workspace` connection and a real Dex Worker and Client. Its integration test exercises a retry and an unwired rejection branch against a local ClickUp stand-in. Run from this directory with `uv sync --locked`, then `uv run pytest tests/ examples/get_task/integration_test.py` while `dexcli dev` is running and `DEX_FLOW_SERVICE_ADDRESS` points to it.
+
+`createTask` and `addComment` store a Dex heartbeat checkpoint before an unkeyed write. If a retry sees the checkpoint, it reads back instead of sending the write again; an unconfirmable outcome selects `uncertain`. The provider has no idempotency-key support for these calls. The Python package currently has no live ClickUp authorization or API verification.
+
+`getTask` returns custom field JSON values only when Python can represent their numbers exactly. A value that would lose precision selects `invalidResponse` and identifies the field. `updateTaskTags` bounds its sequence of provider requests to 25 seconds; an incomplete sequence retries.

dex_connector_clickup-0.1.0/examples/get_task/README.md

@@ -0,0 +1,5 @@
+# Read a ClickUp task
+
+The Flow uses the static `clickup-workspace` connection and the `getTask` Query. Create that connection in Dex Web using the ClickUp personal API token described in the [connector guide](../../../README.md). From the `python/` directory, run `uv sync --locked`, start `uv run python -m examples.get_task.worker`, then run `uv run python -m examples.get_task.start clickup-task-1 examples/get_task/input.example.json` against the same Dex stack. Set `DEX_FLOW_SERVICE_ADDRESS` when Dex runs on a nondefault port.
+
+The example stores the returned task in a Dex Attribute. An unwired optional branch fails the Flow. The integration test runs the same Flow through a real Dex Worker and Client with an inert local provider stand-in; it does not verify live ClickUp authorization.

dex_connector_clickup-0.1.0/examples/get_task/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Runnable ClickUp task read example."""

dex_connector_clickup-0.1.0/examples/get_task/flow.py

@@ -0,0 +1,70 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Read one ClickUp task through a typed Dex Flow."""
+
+from dataclasses import dataclass, field
+
+import dex
+from dex_connectors.sdk import QueryResult
+
+from dex_connectors.clickup import Connection, GetTaskInput, Task, new_get_task_step
+
+CONNECTION_NAME = "clickup-workspace"
+FLOW_TYPE = "ClickUpGetTaskPython"
+TASK_RESULT = dex.Attribute("clickup-get-task-result", Task)
+
+
+@dataclass(frozen=True, slots=True)
+class GetTaskRequest:
+    """Task ID selected for one Flow run."""
+
+    task_id: str = field(metadata={"dex_json_name": "taskId"})
+
+    def to_operation_input(self) -> GetTaskInput:
+        """Name the ClickUp task to read."""
+        return GetTaskInput(task_id=self.task_id)
+
+
+# dex:group group-id:clickup-task group-label:"ClickUp task"
+# dex:explanation text:"Store the task returned by ClickUp and complete the Flow."
+class CompleteTaskRead(dex.Step[QueryResult[Task]]):
+    """Persist the provider task result."""
+
+    def execute(self, context: dex.Context, input: QueryResult[Task]) -> dex.StepDecision:
+        """Complete after saving the task for external reads."""
+        TASK_RESULT.set(context, input.value)
+        return dex.graceful_complete(input.value)
+
+
+class GetTaskFlow(dex.Flow[GetTaskRequest]):
+    """Read one task through the static ClickUp connection."""
+
+    def __init__(self, connection: Connection) -> None:
+        if connection.reference.name != CONNECTION_NAME:
+            raise ValueError("getTask requires the static ClickUp connection")
+        self.complete = CompleteTaskRead()
+        self.read = new_get_task_step(
+            step_type="ReadClickUpTask",
+            step_input_type=GetTaskRequest,
+            annotations={
+                "groupId": "clickup-task",
+                "groupLabel": "ClickUp task",
+                "explanation": "Read one ClickUp task with its custom fields.",
+            },
+            connection=connection,
+            connection_name=CONNECTION_NAME,
+            map_to_operation_input=GetTaskRequest.to_operation_input,
+            found=self.complete,
+        )
+
+    def get_flow_type(self) -> str:
+        """Return the stable Flow identity."""
+        return FLOW_TYPE
+
+    def get_steps(self) -> dex.StepList[GetTaskRequest]:
+        """Register the provider Step and completion Step."""
+        return dex.StepList.start_step(self.read).other_steps(self.complete)
+
+    def get_persistence_schema(self) -> dex.PersistenceSchema:
+        """Register the retained task Attribute."""
+        return dex.PersistenceSchema.of(TASK_RESULT)

dex_connector_clickup-0.1.0/examples/get_task/input.example.json

@@ -0,0 +1 @@
+{"taskId":"86b2x4k7q"}

dex_connector_clickup-0.1.0/examples/get_task/integration_test.py

@@ -0,0 +1,106 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Exercise ClickUp getTask through a real Dex Worker and Client."""
+
+import asyncio
+import json
+import os
+import tempfile
+from datetime import timedelta
+from pathlib import Path
+from uuid import uuid4
+
+import dex
+import httpx
+import pytest
+from dex_connectors.sdk.projectconfig import load_from_environment
+
+from dex_connectors.clickup import Task, new_project_connection
+
+from .flow import CONNECTION_NAME, GetTaskFlow, GetTaskRequest
+
+
+@pytest.mark.asyncio
+async def test_get_task_retries_and_fails_unwired_rejection_in_real_dex(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Cover Worker registration, a rate-limited retry, and an optional branch."""
+    server_address = os.environ["DEX_FLOW_SERVICE_ADDRESS"]
+    requests: list[httpx.Request] = []
+
+    def answer(request: httpx.Request) -> httpx.Response:
+        requests.append(request)
+        if request.url.path.endswith("/rejected"):
+            return httpx.Response(403, json={"ECODE": "ACCESS_001"})
+        if len(requests) == 1:
+            return httpx.Response(429, headers={"Retry-After": "1"})
+        return httpx.Response(
+            200,
+            json={
+                "id": "86b2x4k7q",
+                "name": "Escalation: Fix login",
+                "status": {"status": "open", "type": "open"},
+                "assignees": [],
+                "tags": [],
+            },
+        )
+
+    with tempfile.TemporaryDirectory(prefix="clickup-python-dex-") as directory:
+        connections_path = Path(directory) / "connections.json"
+        connections_path.write_text(
+            json.dumps(
+                {
+                    "schemaVersion": "connectors.dex.dev/local-connections/v1alpha1",
+                    "connections": [
+                        {
+                            "connectorId": "clickup",
+                            "connectionName": CONNECTION_NAME,
+                            "modulePath": "github.com/superdurable/dex-connectors-library/connectors/clickup",
+                            "provider": "clickup",
+                            "configuration": {},
+                            "credentials": {"api_token": "pk_inert_test_token"},
+                        }
+                    ],
+                    "triggerBindings": [],
+                }
+            )
+        )
+        connections_path.chmod(0o600)
+        monkeypatch.setenv("DEX_CONNECTOR_CONFIG_FILE", str(connections_path))
+        project = await load_from_environment({"DEX_CONNECTOR_CONFIG_FILE": str(connections_path)})
+        async with httpx.AsyncClient(transport=httpx.MockTransport(answer)) as provider_http_client:
+            connection = new_project_connection(project, CONNECTION_NAME, provider_http_client)
+            flow = GetTaskFlow(connection)
+            registry = dex.Registry([flow], allow_async_handlers=True)
+            cache = dex.open_blob_cache(dex.BlobCacheConfig(str(Path(directory) / "blobs"), 1 << 24))
+            try:
+                worker = dex.AsyncWorker(registry, cache, dex.WorkerOptions(server_address=server_address))
+                worker_task = asyncio.create_task(worker.start())
+                try:
+                    await worker.wait_pull_registered(timeout=15)
+                    async with dex.AsyncClient(
+                        registry, cache, dex.ClientOptions(server_address=server_address)
+                    ) as dex_client:
+                        successful_flow_id = f"clickup-python-get-{uuid4().hex}"
+                        await dex_client.start_flow(flow, successful_flow_id, GetTaskRequest("86b2x4k7q"))
+                        success = await asyncio.wait_for(
+                            dex_client.wait_for_flow(successful_flow_id, timedelta(seconds=20)), 30
+                        )
+                        assert success.status == dex.FlowStatus.COMPLETED, success.error_message
+                        assert success.single_output(Task).id == "86b2x4k7q"
+                        assert len(requests) == 2
+
+                        rejected_flow_id = f"clickup-python-get-{uuid4().hex}"
+                        await dex_client.start_flow(flow, rejected_flow_id, GetTaskRequest("rejected"))
+                        rejected = await asyncio.wait_for(
+                            dex_client.wait_for_flow(rejected_flow_id, timedelta(seconds=20)), 30
+                        )
+                        assert rejected.status == dex.FlowStatus.FAILED
+                        assert "providerRejected" in (rejected.error_message or "")
+                finally:
+                    await worker.stop()
+                    await worker_task
+            finally:
+                cache.close()
+                await connection.aclose()
+                await project.close()

dex_connector_clickup-0.1.0/examples/get_task/start.py

@@ -0,0 +1,60 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Start one ClickUp task-read Flow."""
+
+import argparse
+import asyncio
+import os
+import tempfile
+from pathlib import Path
+
+import dex
+from dex_connectors.sdk.projectconfig import load_from_environment
+
+from dex_connectors.clickup import new_project_connection
+
+from .flow import CONNECTION_NAME, GetTaskFlow, GetTaskRequest
+
+
+async def start_task_read(flow_id: str, input_file: Path) -> str:
+    """Decode one safe task ID and start its Flow."""
+    with input_file.open("rb") as source:
+        encoded = source.read(65_537)
+    if len(encoded) > 65_536:
+        raise ValueError("ClickUp input exceeds 65536 bytes")
+    input_value = (
+        dex.CodecRegistry()
+        .resolve(GetTaskRequest)
+        .decode(dex.Value(dex.WireKind.JSON, encoded.decode("utf-8")))
+    )
+    project = await load_from_environment()
+    connection = new_project_connection(project, CONNECTION_NAME)
+    try:
+        flow = GetTaskFlow(connection)
+        registry = dex.Registry([flow], allow_async_handlers=True)
+        with tempfile.TemporaryDirectory(prefix="clickup-python-start-blobs-") as cache_directory:
+            cache = dex.open_blob_cache(dex.BlobCacheConfig(cache_directory, 1 << 24))
+            try:
+                server_address = os.environ.get("DEX_FLOW_SERVICE_ADDRESS", "localhost:8801")
+                async with dex.AsyncClient(
+                    registry, cache, dex.ClientOptions(server_address=server_address)
+                ) as client:
+                    return await client.start_flow(flow, flow_id, input_value)
+            finally:
+                cache.close()
+    finally:
+        await connection.aclose()
+        await project.close()
+
+
+def main() -> None:
+    """Take a unique Flow ID and JSON input path."""
+    parser = argparse.ArgumentParser(description="Start a ClickUp task read")
+    parser.add_argument("flow_id")
+    parser.add_argument("input_file", type=Path)
+    arguments = parser.parse_args()
+    print(asyncio.run(start_task_read(arguments.flow_id, arguments.input_file)))
+
+
+if __name__ == "__main__":
+    main()

dex_connector_clickup-0.1.0/examples/get_task/worker.py

@@ -0,0 +1,51 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Worker entrypoint for the ClickUp getTask example."""
+
+import asyncio
+import os
+import tempfile
+from pathlib import Path
+
+import dex
+from dex_connectors.sdk.projectconfig import load_from_environment
+
+from dex_connectors.clickup import new_project_connection
+
+from .flow import CONNECTION_NAME, GetTaskFlow
+
+
+async def run_worker() -> None:
+    """Load the named connection and serve task reads."""
+    project = await load_from_environment()
+    connection = None
+    cache = None
+    try:
+        connection = new_project_connection(project, CONNECTION_NAME)
+        registry = dex.Registry([GetTaskFlow(connection)], allow_async_handlers=True)
+        cache_directory = os.environ.get(
+            "DEX_BLOB_CACHE_DIR", str(Path(tempfile.gettempdir()) / "dex-clickup-get-task-blobs")
+        )
+        cache = dex.open_blob_cache(dex.BlobCacheConfig(cache_directory, 1 << 30))
+        worker = dex.AsyncWorker(
+            registry,
+            cache,
+            dex.WorkerOptions(server_address=os.environ.get("DEX_FLOW_SERVICE_ADDRESS", "localhost:8801")),
+        )
+        async with worker:
+            await worker.start()
+    finally:
+        if connection is not None:
+            await connection.aclose()
+        if cache is not None:
+            cache.close()
+        await project.close()
+
+
+def main() -> None:
+    """Run until the Worker stops."""
+    asyncio.run(run_worker())
+
+
+if __name__ == "__main__":
+    main()

dex_connector_clickup-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dex-connector-clickup"
+version = "0.1.0"
+description = "ClickUp connector for Dex Flows"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+dependencies = ["dex-connectors-sdk==0.1.0", "dex-python-sdk>=1.28.0", "httpx>=0.27"]
+
+[dependency-groups]
+dev = ["pytest>=8", "pytest-asyncio>=0.24", "mypy>=1.13", "ruff>=0.7", "pyyaml>=6"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dex_connectors"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = [".", "src"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+mypy_path = "src"
+explicit_package_bases = true
+
+[tool.ruff]
+target-version = "py311"
+line-length = 110
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]

dex_connector_clickup-0.1.0/src/dex_connectors/clickup/__init__.py

@@ -0,0 +1,71 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Dex-native ClickUp task operations."""
+
+from .client import Client as Client
+from .client import Config as Config
+from .client import Credentials as Credentials
+from .connection import Connection as Connection
+from .connection import new_connection as new_connection
+from .connection import new_connection_with_operations as new_connection_with_operations
+from .connection import new_project_connection as new_project_connection
+from .models import AddCommentInput as AddCommentInput
+from .models import AddCommentOutput as AddCommentOutput
+from .models import CreateTaskInput as CreateTaskInput
+from .models import CreateTaskOutput as CreateTaskOutput
+from .models import CustomFieldInput as CustomFieldInput
+from .models import CustomFieldValue as CustomFieldValue
+from .models import FindMemberByEmailInput as FindMemberByEmailInput
+from .models import GetTaskInput as GetTaskInput
+from .models import Member as Member
+from .models import SearchTasksInput as SearchTasksInput
+from .models import SearchTasksOutput as SearchTasksOutput
+from .models import Task as Task
+from .models import TaskStatus as TaskStatus
+from .models import UpdateTaskInput as UpdateTaskInput
+from .models import UpdateTaskOutput as UpdateTaskOutput
+from .models import UpdateTaskTagsInput as UpdateTaskTagsInput
+from .models import UpdateTaskTagsOutput as UpdateTaskTagsOutput
+from .models import User as User
+from .steps import new_add_comment_step as new_add_comment_step
+from .steps import new_create_task_step as new_create_task_step
+from .steps import new_find_member_by_email_step as new_find_member_by_email_step
+from .steps import new_get_task_step as new_get_task_step
+from .steps import new_search_tasks_step as new_search_tasks_step
+from .steps import new_update_task_step as new_update_task_step
+from .steps import new_update_task_tags_step as new_update_task_tags_step
+
+__all__ = [
+    "AddCommentInput",
+    "AddCommentOutput",
+    "Client",
+    "Config",
+    "Connection",
+    "CreateTaskInput",
+    "CreateTaskOutput",
+    "Credentials",
+    "CustomFieldInput",
+    "CustomFieldValue",
+    "FindMemberByEmailInput",
+    "GetTaskInput",
+    "Member",
+    "SearchTasksInput",
+    "SearchTasksOutput",
+    "Task",
+    "TaskStatus",
+    "UpdateTaskInput",
+    "UpdateTaskOutput",
+    "UpdateTaskTagsInput",
+    "UpdateTaskTagsOutput",
+    "User",
+    "new_add_comment_step",
+    "new_connection",
+    "new_connection_with_operations",
+    "new_create_task_step",
+    "new_find_member_by_email_step",
+    "new_get_task_step",
+    "new_project_connection",
+    "new_search_tasks_step",
+    "new_update_task_step",
+    "new_update_task_tags_step",
+]

dex_connector_clickup-0.1.0/src/dex_connectors/clickup/_generated/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT

dex_connector_clickup-0.1.0/src/dex_connectors/clickup/_generated/config.py

@@ -0,0 +1,25 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+# ruff: noqa
+
+from dataclasses import dataclass
+
+from dex_connectors.sdk import SecretString
+
+
+@dataclass(frozen=True, slots=True)
+class Config:
+
+    max_response_bytes: int = 4194304
+    webhook_max_body_bytes: int = 1048576
+
+setattr(Config, '__module__', 'dex_connectors.clickup.client')
+
+
+@dataclass(frozen=True, slots=True)
+class Credentials:
+
+    api_token: SecretString
+    webhook_secret: SecretString
+
+setattr(Credentials, '__module__', 'dex_connectors.clickup.client')