synapsedx-sdk 0.3.0.dev20261012__py3-none-any.whl

synapsedx_sdk/__init__.py

@@ -0,0 +1,277 @@
+# Copyright 2026 SynapseDX Contributors
+# Licensed under the Apache License, Version 2.0 (the "License");
+"""synapsedx Python SDK — gateway + IAM + workflow client."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import quote, urlencode
+
+import requests
+
+
+class SynapseDXError(Exception):
+    """Mọi lỗi SDK đều là SynapseDXError (network hoặc HTTP)."""
+
+
+__all__ = ["SynapseDXClient", "SynapseDXError"]
+
+
+@dataclass
+class SynapseDXClient:
+    base_url: str
+    token: str | None = None
+    api_key: str | None = None
+    timeout: int = 15
+
+    def __post_init__(self) -> None:
+        self.base_url = self.base_url.rstrip("/")
+
+    def _headers(self) -> dict[str, str]:
+        h = {"Content-Type": "application/json"}
+        if self.token:
+            h["Authorization"] = f"Bearer {self.token}"
+        if self.api_key:
+            h["X-API-Key"] = self.api_key
+        return h
+
+    def set_token(self, token: str) -> None:
+        """Set/replace the Bearer JWT (mirrors JS setToken / Go SetToken)."""
+        self.token = token
+
+    def set_api_key(self, api_key: str) -> None:
+        """Set/replace the X-API-Key (mirrors JS setApiKey / Go SetAPIKey)."""
+        self.api_key = api_key
+
+    def _req(self, method: str, path: str, body: Any | None = None) -> Any:
+        try:
+            r = requests.request(
+                method,
+                self.base_url + path,
+                json=body,
+                headers=self._headers(),
+                timeout=self.timeout,
+            )
+        except Exception as e:  # network, DNS, timeout...
+            raise SynapseDXError(f"synapsedx network {path}: {e}") from e
+        try:
+            r.raise_for_status()
+        except Exception as e:
+            raise SynapseDXError(
+                f"synapsedx {r.status_code} {path}: {r.text[:500]}"
+            ) from e
+        return r.json() if r.text else None
+
+    # ---- auth ----
+    def login(self, email: str, org_slug: str = "acme") -> dict:
+        return self._req(
+            "POST", "/v1/auth/login", {"email": email, "orgSlug": org_slug}
+        )
+
+    def refresh(self, refresh_token: str) -> dict:
+        return self._req("POST", "/v1/auth/refresh", {"refreshToken": refresh_token})
+
+    def logout(self, refresh_token: str) -> dict:
+        return self._req("POST", "/v1/auth/logout", {"refreshToken": refresh_token})
+
+    def logout_all(self, refresh_token: str) -> dict:
+        return self._req("POST", "/v1/auth/logout-all", {"refreshToken": refresh_token})
+
+    def verify(self) -> dict:
+        return self._req("GET", "/v1/auth/verify")
+
+    def me(self) -> dict:
+        return self._req("GET", "/v1/auth/me")
+
+    # ---- orgs ----
+    def list_orgs(self) -> list:
+        return self._req("GET", "/v1/orgs")
+
+    def create_org(self, slug: str, display_name: str) -> dict:
+        return self._req(
+            "POST", "/v1/orgs", {"slug": slug, "displayName": display_name}
+        )
+
+    def create_account(self, org_id: str, slug: str, display_name: str) -> dict:
+        return self._req(
+            "POST",
+            f"/v1/orgs/{quote(org_id, safe='')}/accounts",
+            {"slug": slug, "displayName": display_name},
+        )
+
+    def list_accounts(self, org_id: str) -> list:
+        return self._req("GET", f"/v1/orgs/{quote(org_id, safe='')}/accounts")
+
+    def create_user(
+        self, org_id: str, email: str, display_name: str | None = None
+    ) -> dict:
+        return self._req(
+            "POST",
+            f"/v1/orgs/{quote(org_id, safe='')}/users",
+            {"email": email, "displayName": display_name},
+        )
+
+    def list_users(self, org_id: str) -> list:
+        return self._req("GET", f"/v1/orgs/{quote(org_id, safe='')}/users")
+
+    def user_policies(self, user_id: str) -> list:
+        """Effective policy documents of a user (debug helper for authorize)."""
+        return self._req("GET", f"/v1/users/{quote(user_id, safe='')}/policies")
+
+    # ---- iam ----
+    def authorize(
+        self, user_id: str, action: str, resource: str, context: dict | None = None
+    ) -> dict:
+        return self._req(
+            "POST",
+            "/v1/authorize",
+            {
+                "userId": user_id,
+                "action": action,
+                "resource": resource,
+                "context": context,
+            },
+        )
+
+    def attach_policy(self, role_id: str, policy_id: str) -> dict:
+        return self._req(
+            "POST",
+            f"/v1/roles/{quote(role_id, safe='')}/attach",
+            {"policyId": policy_id},
+        )
+
+    def assign_role(self, user_id: str, role_id: str) -> dict:
+        return self._req(
+            "POST", f"/v1/users/{quote(user_id, safe='')}/assign", {"roleId": role_id}
+        )
+
+    def simulate(
+        self, documents: list, action: str, resource: str, context: dict | None = None
+    ) -> dict:
+        return self._req(
+            "POST",
+            "/v1/authorize/dry-run",
+            {
+                "documents": documents,
+                "action": action,
+                "resource": resource,
+                "context": context,
+            },
+        )
+
+    def list_audit(self, limit: int = 50, actor: str | None = None) -> list:
+        params: dict[str, Any] = {"limit": limit}
+        if actor:
+            params["actor"] = actor
+        return self._req("GET", f"/v1/audit?{urlencode(params)}")
+
+    def create_api_key(
+        self, account_id: str, name: str = "default", scopes: list | None = None
+    ) -> dict:
+        return self._req(
+            "POST",
+            f"/v1/accounts/{quote(account_id, safe='')}/keys",
+            {"name": name, "scopes": scopes or ["*"]},
+        )
+
+    def revoke_api_key(self, key_id: str) -> dict:
+        return self._req("DELETE", f"/v1/keys/{quote(key_id, safe='')}")
+
+    def verify_api_key(self, api_key: str) -> dict:
+        """Check a raw API key via the internal verify endpoint."""
+        return self._req("POST", "/v1/keys/verify", {"apiKey": api_key})
+
+    def create_service_account(
+        self, account_id: str, slug: str, description: str = ""
+    ) -> dict:
+        return self._req(
+            "POST",
+            f"/v1/accounts/{quote(account_id, safe='')}/service-accounts",
+            {"slug": slug, "description": description},
+        )
+
+    def list_service_accounts(self, account_id: str) -> list:
+        return self._req(
+            "GET", f"/v1/accounts/{quote(account_id, safe='')}/service-accounts"
+        )
+
+    def list_roles(self, account_id: str) -> list:
+        return self._req("GET", f"/v1/accounts/{quote(account_id, safe='')}/roles")
+
+    def create_role(self, account_id: str, slug: str, description: str = "") -> dict:
+        return self._req(
+            "POST",
+            f"/v1/accounts/{quote(account_id, safe='')}/roles",
+            {"slug": slug, "description": description},
+        )
+
+    def delete_role(self, role_id: str) -> dict:
+        return self._req("DELETE", f"/v1/roles/{quote(role_id, safe='')}")
+
+    def list_policies(self, account_id: str) -> list:
+        return self._req("GET", f"/v1/accounts/{quote(account_id, safe='')}/policies")
+
+    def create_policy(
+        self, account_id: str, slug: str, document: dict, description: str = ""
+    ) -> dict:
+        return self._req(
+            "POST",
+            f"/v1/accounts/{quote(account_id, safe='')}/policies",
+            {"slug": slug, "document": document, "description": description},
+        )
+
+    def delete_policy(self, policy_id: str) -> dict:
+        return self._req("DELETE", f"/v1/policies/{quote(policy_id, safe='')}")
+
+    def service_account_token(self, sa_id: str, scopes: list | None = None) -> dict:
+        return self._req(
+            "POST",
+            f"/v1/service-accounts/{quote(sa_id, safe='')}/token",
+            {"scopes": scopes or ["*"]},
+        )
+
+    # ---- workflows ----
+    def list_templates(self) -> Any:
+        return self._req("GET", "/v1/templates")
+
+    def get_template(self, name: str) -> Any:
+        """Fetch a single built-in template definition by name."""
+        return self._req("GET", f"/v1/templates/{quote(name, safe='')}")
+
+    def get_workflow(self, wf_id: str) -> Any:
+        return self._req("GET", f"/v1/workflows/{quote(wf_id, safe='')}")
+
+    def activate_workflow(self, wf_id: str) -> Any:
+        return self._req("POST", f"/v1/workflows/{quote(wf_id, safe='')}/activate")
+
+    def deactivate_workflow(self, wf_id: str) -> Any:
+        return self._req("POST", f"/v1/workflows/{quote(wf_id, safe='')}/deactivate")
+
+    def execute_workflow(self, wf_id: str, payload: dict | None = None) -> Any:
+        """Trigger a manual execution (proxied to the engine)."""
+        return self._req(
+            "POST", f"/v1/workflows/{quote(wf_id, safe='')}/execute", payload or {}
+        )
+
+    def list_workflows(self) -> Any:
+        return self._req("GET", "/v1/workflows")
+
+    def create_workflow_from_template(
+        self, template: str, name: str | None = None
+    ) -> Any:
+        return self._req("POST", "/v1/workflows", {"template": template, "name": name})
+
+    def create_workflow(self, name: str, definition: dict) -> Any:
+        """Create a workflow from a raw n8n definition."""
+        return self._req(
+            "POST", "/v1/workflows", {"name": name, "definition": definition}
+        )
+
+    def list_executions(self, query: str = "") -> Any:
+        """Proxy the engine execution list (e.g. query='limit=20')."""
+        q = query if not query or query.startswith("?") else f"?{query}"
+        return self._req("GET", f"/v1/executions{q}")
+
+    def get_execution(self, exec_id: str) -> Any:
+        return self._req("GET", f"/v1/executions/{quote(exec_id, safe='')}")

synapsedx_sdk/example.py

@@ -0,0 +1,12 @@
+"""Smoke example for synapsedx-sdk."""
+
+import os
+
+from synapsedx_sdk import SynapseDXClient
+
+base = os.environ.get("SYNAPSEDX_BASE_URL", "http://localhost:8080")
+c = SynapseDXClient(base)
+login = c.login("demo@acme.local")
+print("login:", login["user"]["email"])
+c.token = login["accessToken"]
+print(c.list_orgs())

synapsedx_sdk/test_client.py

@@ -0,0 +1,118 @@
+"""Offline SDK tests — stdlib echo server, no platform needed."""
+
+import json
+import threading
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+from synapsedx_sdk import SynapseDXClient, SynapseDXError
+
+_seen: dict = {}
+
+
+class Echo(BaseHTTPRequestHandler):
+    def _send(self):
+        _seen["auth"] = self.headers.get("Authorization")
+        _seen["key"] = self.headers.get("X-API-Key")
+        _seen["path"] = self.path
+        _seen["method"] = self.command
+        # List endpoints return arrays like the real API.
+        is_list = self.command == "GET" and (
+            self.path == "/v1/orgs"
+            or self.path.startswith("/v1/executions")
+            or self.path in ("/v1/templates", "/v1/workflows", "/v1/audit")
+            or self.path.endswith(
+                ("/accounts", "/users", "/roles", "/policies", "/service-accounts")
+            )
+        )
+        payload = b"[]" if is_list else json.dumps({"ok": True}).encode()
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(payload)))
+        self.end_headers()
+        self.wfile.write(payload)
+
+    do_GET = _send
+    do_POST = _send
+    do_DELETE = _send
+
+    def log_message(self, *a):  # silent
+        pass
+
+
+def _server():
+    srv = HTTPServer(("127.0.0.1", 0), Echo)
+    threading.Thread(target=srv.serve_forever, daemon=True).start()
+    return srv
+
+
+def test_trim_and_headers():
+    srv = _server()
+    try:
+        base = f"http://127.0.0.1:{srv.server_port}"
+        c = SynapseDXClient(base + "/")
+        assert c.base_url == base
+        c.token = "t1"
+        c.list_orgs()
+        assert _seen["auth"] == "Bearer t1", _seen
+        assert _seen["path"] == "/v1/orgs"
+        c2 = SynapseDXClient(base, api_key="k1")
+        c2.list_templates()
+        assert _seen["key"] == "k1", _seen
+    finally:
+        srv.shutdown()
+
+
+def test_network_error_wrapped():
+    c = SynapseDXClient("http://127.0.0.1:1", timeout=2)
+    try:
+        c.list_orgs()
+    except SynapseDXError as e:
+        assert "synapsedx" in str(e)
+        return
+    raise AssertionError("expected SynapseDXError")
+
+
+def test_import():
+    from synapsedx_sdk import SynapseDXClient
+
+    c = SynapseDXClient("http://localhost:8080")
+    assert c.base_url == "http://localhost:8080"
+
+
+def test_full_coverage_paths():
+    srv = _server()
+    try:
+        base = f"http://127.0.0.1:{srv.server_port}"
+        c = SynapseDXClient(base)
+        c.login("a@b.c")
+        assert _seen["path"] == "/v1/auth/login"
+        c.refresh("rt")
+        assert _seen["path"] == "/v1/auth/refresh"
+        c.list_accounts("org1")
+        assert _seen["path"] == "/v1/orgs/org1/accounts"
+        c.user_policies("u1")
+        assert _seen["path"] == "/v1/users/u1/policies"
+        c.get_template("webhook-to-log")
+        assert _seen["path"] == "/v1/templates/webhook-to-log"
+        c.get_workflow("a/b")
+        assert _seen["path"] == "/v1/workflows/a%2Fb"
+        c.deactivate_workflow("w1")
+        assert _seen["path"] == "/v1/workflows/w1/deactivate"
+        c.execute_workflow("w1", {})
+        assert _seen["path"] == "/v1/workflows/w1/execute"
+        c.list_executions("limit=5")
+        assert _seen["path"] == "/v1/executions?limit=5"
+        c.get_execution("e1")
+        assert _seen["path"] == "/v1/executions/e1"
+        c.verify_api_key("k")
+        assert _seen["path"] == "/v1/keys/verify"
+        c.list_audit(actor="u@x")
+        assert "actor=u%40x" in _seen["path"], _seen
+        c.set_token("t")
+        c.set_api_key("k")
+        assert c.token == "t" and c.api_key == "k"
+        doc = {"Statement": [{"Effect": "Allow", "Action": "*", "Resource": "*"}]}
+        c.create_workflow("n", doc)
+        assert _seen["path"] == "/v1/workflows"
+    finally:
+        srv.shutdown()

synapsedx_sdk-0.3.0.dev20261012.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: synapsedx-sdk
+Version: 0.3.0.dev20261012
+Summary: synapsedx SDK for Python (Apache-2.0)
+License: Apache-2.0
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+
+# synapsedx SDK for Python
+Apache-2.0. See root LICENSE. Part of [SynapseDX](../../README.md) Tier-1 PaaS.
+
+```bash
+pip install synapsedx-sdk
+```
+
+```python
+from synapsedx_sdk import SynapseDXClient
+
+c = SynapseDXClient("http://localhost:8080")
+login = c.login("demo@acme.local")
+c.set_token(login["accessToken"])
+
+c.create_org("acme-2", "ACME 2")
+c.authorize(login["user"]["id"], "workflow:Execute", "*")
+c.create_workflow_from_template("webhook-to-log", "demo")
+```
+
+Auth: `SynapseDXClient(base_url, token=..., api_key=...)`, or `set_token(jwt)` /
+`set_api_key(key)` after login. `timeout` configurable (default 15s).
+See `synapsedx_sdk/example.py` and [docs/api.md](../../docs/api.md).
+
+## Full method coverage (mirrors `docs/api.md`)
+
+- Auth: `login`, `refresh`, `logout`, `logout_all`, `verify`, `me`
+- Orgs/accounts/users: `list_orgs`, `create_org`, `list_accounts`, `create_account`,
+  `list_users`, `create_user`, `user_policies`
+- IAM: `create_role`, `list_roles`, `delete_role`, `create_policy`, `list_policies`,
+  `delete_policy`, `attach_policy`, `assign_role`, `authorize`, `simulate`,
+  `list_audit`, `create_api_key`, `revoke_api_key`, `verify_api_key`,
+  `create_service_account`, `list_service_accounts`, `service_account_token`
+- Workflows: `list_workflows`, `get_workflow`, `create_workflow_from_template`,
+  `create_workflow`, `activate_workflow`, `deactivate_workflow`, `execute_workflow`,
+  `list_templates`, `get_template`, `list_executions`, `get_execution`

synapsedx_sdk-0.3.0.dev20261012.dist-info/RECORD

@@ -0,0 +1,7 @@
+synapsedx_sdk/__init__.py,sha256=lZG9AAZA1to5e0LNxFT-7okKBc6t9o84U-OF-lb_ss4,9783
+synapsedx_sdk/example.py,sha256=NRC5baEUwQfnfEqa4IINUp0lXtvAPFNQike6r8X9j8E,316
+synapsedx_sdk/test_client.py,sha256=YuCi8FJfa3qg_NvRuUC71scZk8GDbu25Nt9wr68D0vU,3855
+synapsedx_sdk-0.3.0.dev20261012.dist-info/METADATA,sha256=prssFAEonMEb24WEWEFPP_LgqzfThYcDYmNuwpbY4yc,1806
+synapsedx_sdk-0.3.0.dev20261012.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+synapsedx_sdk-0.3.0.dev20261012.dist-info/top_level.txt,sha256=Z-344B3E557x3g82iRDzss7X6LX6vGohdsO1S1bo3Iw,14
+synapsedx_sdk-0.3.0.dev20261012.dist-info/RECORD,,

synapsedx_sdk-0.3.0.dev20261012.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

synapsedx_sdk-0.3.0.dev20261012.dist-info/top_level.txt

@@ -0,0 +1 @@
+synapsedx_sdk