pypproxy 0.1.0__py3-none-any.whl

pypproxy/exporter/importer.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+import base64
+import json
+import logging
+from datetime import UTC, datetime
+from pathlib import Path
+
+from pypproxy.store.models import Entry
+from pypproxy.store.store import Store
+
+logger = logging.getLogger(__name__)
+
+
+def import_har(data: str | bytes, store: Store) -> int:
+    """Import entries from a HAR file string/bytes. Returns count imported."""
+    if isinstance(data, bytes):
+        data = data.decode("utf-8", errors="replace")
+
+    har = json.loads(data)
+    entries = har.get("log", har).get("entries", [])
+    count = 0
+
+    for item in entries:
+        try:
+            entry = _har_entry_to_entry(item)
+            store.add(entry)
+            count += 1
+        except Exception as e:
+            logger.debug("Skipping HAR entry: %s", e)
+
+    return count
+
+
+def import_json(data: str | bytes, store: Store) -> int:
+    """Import entries from a paxy JSON export. Returns count imported."""
+    if isinstance(data, bytes):
+        data = data.decode("utf-8", errors="replace")
+
+    parsed = json.loads(data)
+    items = parsed.get("entries", []) if isinstance(parsed, dict) else parsed
+
+    count = 0
+    for item in items:
+        try:
+            entry = _json_to_entry(item)
+            store.add(entry)
+            count += 1
+        except Exception as e:
+            logger.debug("Skipping entry: %s", e)
+
+    return count
+
+
+def import_file(path: str, store: Store) -> int:
+    """Auto-detect format from file extension and import."""
+    p = Path(path)
+    data = p.read_bytes()
+    if p.suffix.lower() == ".har":
+        return import_har(data, store)
+    # Try HAR first, then paxy JSON
+    try:
+        parsed = json.loads(data)
+        if "log" in parsed and "entries" in parsed.get("log", {}):
+            return import_har(data, store)
+        return import_json(data, store)
+    except Exception as e:
+        raise ValueError(f"Cannot parse {path}: {e}") from e
+
+
+def _har_entry_to_entry(item: dict) -> Entry:
+    req = item.get("request", {})
+    resp = item.get("response", {})
+
+    # Parse URL
+    url = req.get("url", "")
+    scheme, _, rest = url.partition("://")
+    host, _, path_q = rest.partition("/")
+    path, _, query = ("/" + path_q).partition("?")
+    query = query or ""
+
+    # Request headers
+    req_headers: dict[str, list[str]] = {}
+    for h in req.get("headers", []):
+        req_headers.setdefault(h["name"].lower(), []).append(h["value"])
+
+    # Request body
+    req_body = b""
+    if post_data := req.get("postData", {}):
+        text = post_data.get("text", "")
+        req_body = text.encode() if text else b""
+
+    # Response headers
+    resp_headers: dict[str, list[str]] = {}
+    for h in resp.get("headers", []):
+        resp_headers.setdefault(h["name"].lower(), []).append(h["value"])
+
+    # Response body
+    resp_body = b""
+    content = resp.get("content", {})
+    if text := content.get("text", ""):
+        if content.get("encoding") == "base64":
+            resp_body = base64.b64decode(text)
+        else:
+            resp_body = text.encode("utf-8", errors="replace")
+
+    # Timestamp
+    started = item.get("startedDateTime", "")
+    try:
+        created_at = datetime.fromisoformat(started.replace("Z", "+00:00"))
+    except Exception:
+        created_at = datetime.now(UTC)
+
+    return Entry(
+        method=req.get("method", "GET"),
+        scheme=scheme or "https",
+        host=host,
+        path=path or "/",
+        query=query,
+        req_headers=req_headers,
+        req_body=req_body,
+        status_code=resp.get("status", 0),
+        resp_headers=resp_headers,
+        resp_body=resp_body,
+        duration_ms=int(item.get("time", 0)),
+        protocol="https" if scheme == "https" else "http",
+        created_at=created_at,
+    )
+
+
+def _json_to_entry(item: dict) -> Entry:
+    req_body = b""
+    if rb := item.get("req_body", ""):
+        try:
+            req_body = base64.b64decode(rb)
+        except Exception:
+            req_body = rb.encode()
+
+    resp_body = b""
+    if rsb := item.get("resp_body", ""):
+        try:
+            resp_body = base64.b64decode(rsb)
+        except Exception:
+            resp_body = rsb.encode()
+
+    created_at = datetime.now(UTC)
+    if ts := item.get("created_at", ""):
+        import contextlib
+
+        with contextlib.suppress(Exception):
+            created_at = datetime.fromisoformat(ts)
+
+    return Entry(
+        method=item.get("method", "GET"),
+        scheme=item.get("scheme", "https"),
+        host=item.get("host", ""),
+        path=item.get("path", "/"),
+        query=item.get("query", ""),
+        req_headers=item.get("req_headers", {}),
+        req_body=req_body,
+        status_code=item.get("status_code", 0),
+        resp_headers=item.get("resp_headers", {}),
+        resp_body=resp_body,
+        duration_ms=item.get("duration_ms", 0),
+        protocol=item.get("protocol", "https"),
+        tags=item.get("tags", []),
+        modified=item.get("modified", False),
+        created_at=created_at,
+    )

pypproxy/graphql/detector.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import json
+import re
+
+from pypproxy.store.models import Entry
+
+
+def is_graphql(entry: Entry) -> bool:
+    """Return True if the entry looks like a GraphQL request."""
+    ct = entry.req_headers.get("content-type", [""])[0].lower()
+    if "graphql" in ct:
+        return True
+
+    # POST with JSON body containing 'query' key
+    if entry.method == "POST" and entry.req_body:
+        try:
+            body = json.loads(entry.req_body)
+            if isinstance(body, dict) and "query" in body:
+                q = body["query"].strip()
+                if q.startswith(("{", "query", "mutation", "subscription", "fragment")):
+                    return True
+        except Exception:
+            pass
+
+    # GET with 'query' parameter
+    if entry.method == "GET" and entry.query and "query=" in entry.query:
+        return True
+
+    # common GraphQL paths
+    return bool(re.search(r"/graphql", entry.path, re.IGNORECASE))
+
+
+def parse_operation(body: bytes) -> dict:
+    """Parse a GraphQL request body. Returns dict with query/variables/operationName."""
+    try:
+        data = json.loads(body)
+        if isinstance(data, dict):
+            return {
+                "query": data.get("query", ""),
+                "variables": data.get("variables", {}),
+                "operationName": data.get("operationName", ""),
+            }
+    except Exception:
+        pass
+    return {"query": body.decode("utf-8", errors="replace"), "variables": {}, "operationName": ""}
+
+
+def extract_operation_type(query: str) -> str:
+    """Return 'query', 'mutation', 'subscription', or 'unknown'."""
+    q = query.strip().lower()
+    if q.startswith("mutation"):
+        return "mutation"
+    if q.startswith("subscription"):
+        return "subscription"
+    if q.startswith("query") or q.startswith("{"):
+        return "query"
+    return "unknown"
+
+
+def extract_operation_name(query: str) -> str:
+    """Extract the operation name from a GraphQL query string."""
+    m = re.search(r"(?:query|mutation|subscription)\s+(\w+)", query)
+    if m:
+        return m.group(1)
+    return ""
+
+
+def extract_field_names(query: str) -> list[str]:
+    """Extract top-level field names from a GraphQL query (heuristic)."""
+    # Remove strings, comments, and directives to avoid false positives
+    clean = re.sub(r'"[^"]*"', '""', query)
+    clean = re.sub(r"#[^\n]*", "", clean)
+    # Find word tokens after '{' that look like field names
+    fields = re.findall(r"[{,]\s*(\w+)\s*[({:\s]", clean)
+    return list(dict.fromkeys(fields))  # dedupe preserving order

pypproxy/graphql/introspection.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+INTROSPECTION_QUERY = """
+query IntrospectionQuery {
+  __schema {
+    queryType { name }
+    mutationType { name }
+    subscriptionType { name }
+    types {
+      ...FullType
+    }
+    directives {
+      name
+      description
+      locations
+      args { ...InputValue }
+    }
+  }
+}
+
+fragment FullType on __Type {
+  kind
+  name
+  description
+  fields(includeDeprecated: true) {
+    name
+    description
+    args { ...InputValue }
+    type { ...TypeRef }
+    isDeprecated
+    deprecationReason
+  }
+  inputFields { ...InputValue }
+  interfaces { ...TypeRef }
+  enumValues(includeDeprecated: true) {
+    name
+    description
+    isDeprecated
+    deprecationReason
+  }
+  possibleTypes { ...TypeRef }
+}
+
+fragment InputValue on __InputValue {
+  name
+  description
+  type { ...TypeRef }
+  defaultValue
+}
+
+fragment TypeRef on __Type {
+  kind
+  name
+  ofType {
+    kind
+    name
+    ofType {
+      kind
+      name
+      ofType {
+        kind
+        name
+        ofType { kind name ofType { kind name ofType { kind name ofType { kind name } } } }
+      }
+    }
+  }
+}
+"""
+
+
+@dataclass
+class GraphQLField:
+    name: str
+    description: str
+    type_name: str
+    args: list[str] = field(default_factory=list)
+    is_deprecated: bool = False
+
+
+@dataclass
+class GraphQLType:
+    name: str
+    kind: str
+    description: str
+    fields: list[GraphQLField] = field(default_factory=list)
+
+
+@dataclass
+class GraphQLSchema:
+    query_type: str = ""
+    mutation_type: str = ""
+    subscription_type: str = ""
+    types: list[GraphQLType] = field(default_factory=list)
+    raw: dict = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return {
+            "query_type": self.query_type,
+            "mutation_type": self.mutation_type,
+            "subscription_type": self.subscription_type,
+            "types": [
+                {
+                    "name": t.name,
+                    "kind": t.kind,
+                    "description": t.description,
+                    "fields": [
+                        {
+                            "name": f.name,
+                            "description": f.description,
+                            "type": f.type_name,
+                            "args": f.args,
+                            "is_deprecated": f.is_deprecated,
+                        }
+                        for f in t.fields
+                    ],
+                }
+                for t in self.types
+                if not t.name.startswith("__")  # exclude built-in types
+            ],
+        }
+
+    def get_type(self, name: str) -> GraphQLType | None:
+        for t in self.types:
+            if t.name == name:
+                return t
+        return None
+
+    def root_fields(self) -> list[GraphQLField]:
+        """Return fields of the Query root type."""
+        t = self.get_type(self.query_type or "Query")
+        return t.fields if t else []
+
+    def mutation_fields(self) -> list[GraphQLField]:
+        t = self.get_type(self.mutation_type or "Mutation")
+        return t.fields if t else []
+
+
+async def fetch_schema(
+    url: str,
+    headers: dict[str, str] | None = None,
+    timeout: int = 15,
+) -> GraphQLSchema | None:
+    """Send an introspection query and parse the schema."""
+    req_headers = {"content-type": "application/json"}
+    if headers:
+        req_headers.update(headers)
+
+    try:
+        async with httpx.AsyncClient(verify=False, timeout=timeout, http2=True) as client:
+            resp = await client.post(
+                url,
+                json={"query": INTROSPECTION_QUERY},
+                headers=req_headers,
+            )
+        data = resp.json()
+    except Exception as e:
+        logger.warning("Introspection failed for %s: %s", url, e)
+        return None
+
+    if "errors" in data and not data.get("data"):
+        logger.warning("Introspection returned errors: %s", data["errors"])
+        return None
+
+    schema_data = data.get("data", {}).get("__schema", {})
+    if not schema_data:
+        return None
+
+    return _parse_schema(schema_data, data)
+
+
+def _parse_schema(schema_data: dict, raw: dict) -> GraphQLSchema:
+    schema = GraphQLSchema(
+        query_type=(schema_data.get("queryType") or {}).get("name", ""),
+        mutation_type=(schema_data.get("mutationType") or {}).get("name", ""),
+        subscription_type=(schema_data.get("subscriptionType") or {}).get("name", ""),
+        raw=raw,
+    )
+
+    for type_data in schema_data.get("types", []):
+        gql_type = GraphQLType(
+            name=type_data.get("name", ""),
+            kind=type_data.get("kind", ""),
+            description=type_data.get("description", "") or "",
+        )
+        for field_data in type_data.get("fields") or []:
+            gql_field = GraphQLField(
+                name=field_data.get("name", ""),
+                description=field_data.get("description", "") or "",
+                type_name=_type_ref_to_str(field_data.get("type", {})),
+                args=[a.get("name", "") for a in field_data.get("args", [])],
+                is_deprecated=field_data.get("isDeprecated", False),
+            )
+            gql_type.fields.append(gql_field)
+        schema.types.append(gql_type)
+
+    return schema
+
+
+def _type_ref_to_str(type_ref: dict) -> str:
+    if not type_ref:
+        return ""
+    kind = type_ref.get("kind", "")
+    name = type_ref.get("name", "")
+    of_type = type_ref.get("ofType")
+
+    if kind == "NON_NULL":
+        return f"{_type_ref_to_str(of_type)}!"
+    if kind == "LIST":
+        return f"[{_type_ref_to_str(of_type)}]"
+    return name or ""

pypproxy/graphql/modifier.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import json
+import re
+from typing import Any
+
+
+def set_variable(body: bytes, var_name: str, new_value: Any) -> bytes:
+    """Replace a variable value in a GraphQL request body."""
+    try:
+        data = json.loads(body)
+        if isinstance(data, dict) and "variables" in data and isinstance(data["variables"], dict):
+            data["variables"][var_name] = new_value
+            return json.dumps(data).encode()
+    except Exception:
+        pass
+    return body
+
+
+def replace_field_alias(body: bytes, field: str, alias: str) -> bytes:
+    """Add an alias to a field in the query string."""
+    try:
+        data = json.loads(body)
+        if "query" in data:
+            data["query"] = re.sub(
+                rf"\b{re.escape(field)}\b",
+                f"{alias}: {field}",
+                data["query"],
+                count=1,
+            )
+            return json.dumps(data).encode()
+    except Exception:
+        pass
+    return body
+
+
+def inject_field(body: bytes, type_name: str, extra_fields: list[str]) -> bytes:
+    """
+    Inject extra fields into the selection set of a named type in the query.
+    E.g. inject_field(body, "User", ["__typename", "id"]) adds those fields
+    after the opening brace of User { ...
+    """
+    try:
+        data = json.loads(body)
+        if "query" in data:
+            extra = " ".join(extra_fields)
+            # insert after the type name's opening brace
+            data["query"] = re.sub(
+                rf"\b{re.escape(type_name)}\s*{{",
+                f"{type_name} {{ {extra} ",
+                data["query"],
+                count=1,
+            )
+            return json.dumps(data).encode()
+    except Exception:
+        pass
+    return body
+
+
+def strip_operation_name(body: bytes) -> bytes:
+    """Remove operationName to test anonymous query handling."""
+    try:
+        data = json.loads(body)
+        if isinstance(data, dict):
+            data.pop("operationName", None)
+            return json.dumps(data).encode()
+    except Exception:
+        pass
+    return body
+
+
+def add_introspection_field(body: bytes) -> bytes:
+    """Inject __typename into every selection set as a probe."""
+    try:
+        data = json.loads(body)
+        if "query" in data:
+            data["query"] = re.sub(r"{\s*", "{ __typename ", data["query"])
+            return json.dumps(data).encode()
+    except Exception:
+        pass
+    return body
+
+
+def build_query(fields: list[str], type_name: str = "") -> bytes:
+    """Build a simple GraphQL query for the given field list."""
+    selection = "\n  ".join(fields)
+    query = f"{{ {selection} }}"
+    return json.dumps({"query": query}).encode()
+
+
+def build_mutation(mutation_name: str, args: dict, return_fields: list[str]) -> bytes:
+    """Build a GraphQL mutation."""
+    arg_str = ", ".join(
+        f'{k}: "{v}"' if isinstance(v, str) else f"{k}: {v}" for k, v in args.items()
+    )
+    return_str = " ".join(return_fields)
+    query = f"mutation {{ {mutation_name}({arg_str}) {{ {return_str} }} }}"
+    return json.dumps({"query": query}).encode()

pypproxy/graphql/schema_store.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import threading
+
+from .introspection import GraphQLSchema
+
+
+class SchemaStore:
+    """Per-host schema cache."""
+
+    def __init__(self) -> None:
+        self._schemas: dict[str, GraphQLSchema] = {}
+        self._lock = threading.Lock()
+
+    def set(self, host: str, schema: GraphQLSchema) -> None:
+        with self._lock:
+            self._schemas[host] = schema
+
+    def get(self, host: str) -> GraphQLSchema | None:
+        with self._lock:
+            return self._schemas.get(host)
+
+    def list_hosts(self) -> list[str]:
+        with self._lock:
+            return list(self._schemas.keys())
+
+    def delete(self, host: str) -> None:
+        with self._lock:
+            self._schemas.pop(host, None)
+
+    def all(self) -> dict[str, GraphQLSchema]:
+        with self._lock:
+            return dict(self._schemas)