botversion-sdk 2.1.0__tar.gz → 2.1.1__tar.gz

{botversion_sdk-2.1.0 → botversion_sdk-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: botversion-sdk
-Version: 2.1.0
+Version: 2.1.1
 Summary: BotVersion SDK — automatically discover and register your API endpoints
 Home-page: https://github.com/botversion/botversion-sdk-python
 Author: BotVersion

{botversion_sdk-2.1.0 → botversion_sdk-2.1.1}/botversion_sdk/interceptor.py

@@ -119,11 +119,75 @@ def body_structure_to_json_schema(body_structure):
     return {"type": "object", "properties": properties}
 
 
-def extract_trpc_get_input(path, query_string):
+def unwrap_trpc_json_envelope(obj):
+    """
+    Unwraps a single (non-batched) tRPC/superjson envelope:
+    { "json": {...realFields...} } -> {...realFields...}
+    """
+    if isinstance(obj, dict) and isinstance(obj.get("json"), dict):
+        return obj["json"]
+    return obj
+
+
+def split_batch_path(raw_path):
+    """
+    tRPC batches multiple procedure calls into one URL, e.g.
+      /api/trpc/me.get,getUserTopBanners,bookingUnconfirmedCount
+    tRPC is always mounted at a fixed base containing "/trpc/". Everything
+    after that marker is the comma-separated procedure list, and each
+    comma-separated piece is ALREADY a complete procedure path on its own
+    (it may itself contain "/" for nested routers) — it must never have
+    another procedure's prefix re-attached to it.
+    Returns a single-item list unchanged if the path isn't a batch.
+    """
+    marker = "/trpc/"
+    idx = raw_path.find(marker)
+    if idx == -1:
+        return [raw_path]
+
+    base = raw_path[: idx + len(marker)]
+    tail = raw_path[idx + len(marker):]
+
+    if "," not in tail:
+        return [raw_path]
+
+    procs = [p.strip() for p in tail.split(",") if p.strip()]
+    return [base + p for p in procs]
+
+
+def split_batch_body(body_obj):
+    """
+    Splits a batched tRPC request body/input — {"0": {...}, "1": {...}} —
+    into a list of individual bodies, in the same order as the batch keys,
+    which lines up with the order split_batch_path() returns procedure
+    names in. Each slot is unwrapped from its own {"json": {...}} envelope.
+    Returns a single-item list unchanged if the body isn't actually batched.
+    """
+    if not isinstance(body_obj, dict):
+        return [body_obj]
+
+    keys = list(body_obj.keys())
+    is_batch = len(keys) > 0 and all(k.isdigit() for k in keys)
+
+    if not is_batch:
+        return [body_obj]
+
+    ordered_keys = sorted(keys, key=lambda k: int(k))
+    slots = []
+    for k in ordered_keys:
+        entry = body_obj[k]
+        slots.append(
+            unwrap_trpc_json_envelope(entry) if isinstance(entry, dict) else entry
+        )
+    return slots
+
+
+def extract_trpc_get_input_raw(path, query_string):
     """
     tRPC GET requests send their input as a URL-encoded JSON query parameter
-    called 'input'. This function extracts and parses it.
-    Only activates for tRPC paths with an input param and empty body.
+    called 'input'. This returns the raw decoded dict as-is — still batched
+    if applicable — WITHOUT merging different procedures' fields together.
+    Splitting per-procedure happens later in report_endpoint().
     Safe for all non-tRPC endpoints — returns None if not applicable.
     """
     if "/trpc/" not in path:
@@ -142,41 +206,18 @@ def extract_trpc_get_input(path, query_string):
         if not isinstance(decoded, dict):
             return None
 
-        keys = list(decoded.keys())
-
-        # Format 1 — batched: { "0": { "json": {...} }, "1": { "json": {...} } }
-        is_batch = len(keys) > 0 and all(k.isdigit() for k in keys)
-        if is_batch:
-            merged = {}
-            for k in keys:
-                entry = decoded[k]
-                if isinstance(entry, dict):
-                    # Unwrap { json: {...} } envelope if present
-                    unwrapped = entry.get("json", entry) if isinstance(entry.get("json"), dict) else entry
-                    merged.update(unwrapped)
-            return merged if merged else None
-
-        # Format 2 — single with superjson: { "json": {...}, "meta": {...} }
-        if "json" in decoded and isinstance(decoded["json"], dict):
-            return decoded["json"]
-
-        # Format 3 — already unwrapped: { "group": {...}, "limit": 10 }
-        if "meta" not in decoded and "json" not in decoded:
-            return decoded
+        return decoded
 
     except Exception:
-        pass
-
-    return None
+        return None
 
 
-def report_endpoint(client, method, path, body_structure, options):
+def _report_single_endpoint(client, method, normalized_path, body_structure, options):
     """
-    Report a newly discovered endpoint to the platform.
+    Reports exactly one already-normalized, already-split endpoint.
     Uses body-key deduplication.
     """
-    normalized = normalize_path(path)
-    endpoint_key = f"{method}:{normalized}"
+    endpoint_key = f"{method}:{normalized_path}"
 
     body_fields = sorted(body_structure.keys()) if body_structure else []
     body_key = endpoint_key + ":" + ",".join(body_fields)
@@ -193,7 +234,7 @@ def report_endpoint(client, method, path, body_structure, options):
         try:
             client.update_endpoint({
                 "method": method,
-                "path": normalized,
+                "path": normalized_path,
                 "request_body": json_schema,
                 "detected_by": "runtime",
             })
@@ -204,6 +245,38 @@ def report_endpoint(client, method, path, body_structure, options):
     t.start()
 
 
+def report_endpoint(client, method, path, body_data, query_string, options):
+    """
+    Splits a (possibly batched) tRPC path into one clean endpoint per real
+    procedure — instead of one garbled, comma-joined path — with each
+    procedure's own body fields only, never mixed with another procedure's.
+    Falls back to reporting a single endpoint unchanged when the path
+    isn't a batch.
+
+    body_data — the raw parsed JSON body (or None/empty for GET requests).
+    query_string — the raw query string, used to recover tRPC GET input.
+    """
+    split_paths = [normalize_path(p) for p in split_batch_path(path)]
+
+    body_slots = None
+
+    # tRPC GET requests carry their input in the query string, not the body
+    if (not body_data) and query_string:
+        raw_input = extract_trpc_get_input_raw(path, query_string)
+        if raw_input is not None:
+            body_slots = split_batch_body(raw_input)
+
+    if body_slots is None:
+        body_slots = (
+            split_batch_body(body_data) if len(split_paths) > 1 else [body_data]
+        )
+
+    for i, single_path in enumerate(split_paths):
+        slot_body = body_slots[i] if i < len(body_slots) else None
+        body_structure = build_body_structure(slot_body)
+        _report_single_endpoint(client, method, single_path, body_structure, options)
+
+
 # ── FastAPI middleware ────────────────────────────────────────────────────────
 
 def attach_fastapi_interceptor(app, client, options):
@@ -250,18 +323,11 @@ def attach_fastapi_interceptor(app, client, options):
                                 return {"type": "http.request", "body": body_bytes}
                             request._receive = receive
                             body_data = _json.loads(body_bytes) if body_bytes else None
-                            body_structure = build_body_structure(body_data)
-                            # tRPC GET: input is in URL query param, not body
-                            if not body_structure:
-                                query_string = request.url.query
-                                trpc_body = extract_trpc_get_input(path, query_string)
-                                if trpc_body:
-                                    body_structure = build_body_structure(trpc_body)
                         except Exception:
-                            body_structure = None
+                            body_data = None
 
                         if response.status_code < 500:
-                            report_endpoint(client, method, path, body_structure, options)
+                            report_endpoint(client, method, path, body_data, request.url.query, options)
 
                 return response
 
@@ -303,16 +369,11 @@ def attach_flask_interceptor(app, client, options):
                 return
 
             try:
-                body_structure = build_body_structure(flask_request.get_json(silent=True))
-                # tRPC GET: input is in URL query param, not body
-                if not body_structure:
-                    trpc_body = extract_trpc_get_input(path, flask_request.query_string.decode("utf-8"))
-                    if trpc_body:
-                        body_structure = build_body_structure(trpc_body)
+                body_data = flask_request.get_json(silent=True)
             except Exception:
-                body_structure = None
+                body_data = None
 
-            report_endpoint(client, method, path, body_structure, options)
+            report_endpoint(client, method, path, body_data, flask_request.query_string.decode("utf-8"), options)
 
     except ImportError:
         pass
@@ -356,21 +417,16 @@ class BotVersionDjangoMiddleware:
             if not self.__class__._options.get("api_prefix") or path.startswith(self.__class__._options["api_prefix"]):
                 try:
                     body_data = json.loads(request.body) if request.body else None
-                    body_structure = build_body_structure(body_data)
-                    # tRPC GET: input is in URL query param, not body
-                    if not body_structure:
-                        trpc_body = extract_trpc_get_input(path, request.META.get("QUERY_STRING", ""))
-                        if trpc_body:
-                            body_structure = build_body_structure(trpc_body)
                 except Exception:
-                    body_structure = None
+                    body_data = None
 
                 if self.__class__._client:
                     report_endpoint(
                         self.__class__._client,
                         method,
                         path,
-                        body_structure,
+                        body_data,
+                        request.META.get("QUERY_STRING", ""),
                         self.__class__._options,
                     )
 
@@ -443,18 +499,11 @@ def attach_starlette_interceptor(app, client, options):
                         try:
                             body_bytes = await request.body()
                             body_data = _json.loads(body_bytes) if body_bytes else None
-                            body_structure = build_body_structure(body_data)
-                            # tRPC GET: input is in URL query param, not body
-                            if not body_structure:
-                                query_string = request.url.query
-                                trpc_body = extract_trpc_get_input(path, query_string)
-                                if trpc_body:
-                                    body_structure = build_body_structure(trpc_body)
                         except Exception:
-                            body_structure = None
+                            body_data = None
 
                         if response.status_code < 500:
-                            report_endpoint(client, method, path, body_structure, options)
+                            report_endpoint(client, method, path, body_data, request.url.query, options)
 
                 return response
 
@@ -496,16 +545,10 @@ def attach_sanic_interceptor(app, client, options):
 
             try:
                 body_data = request.json if request.body else None
-                body_structure = build_body_structure(body_data)
-                # tRPC GET: input is in URL query param, not body
-                if not body_structure:
-                    trpc_body = extract_trpc_get_input(path, request.query_string)
-                    if trpc_body:
-                        body_structure = build_body_structure(trpc_body)
             except Exception:
-                body_structure = None
+                body_data = None
 
-            report_endpoint(client, method, path, body_structure, options)
+            report_endpoint(client, method, path, body_data, request.query_string, options)
 
     except Exception:
         pass
@@ -551,19 +594,13 @@ def attach_falcon_interceptor(app, client, options):
                 try:
                     body_bytes = req.bounded_stream.read()
                     body_data = _json.loads(body_bytes) if body_bytes else None
-                    body_structure = build_body_structure(body_data)
-                    # tRPC GET: input is in URL query param, not body
-                    if not body_structure:
-                        trpc_body = extract_trpc_get_input(path, req.query_string)
-                        if trpc_body:
-                            body_structure = build_body_structure(trpc_body)
                     # Put body back so the actual handler can still read it
                     import io
                     req.bounded_stream = io.BytesIO(body_bytes)
                 except Exception:
-                    body_structure = None
+                    body_data = None
 
-                report_endpoint(client, method, path, body_structure, options)
+                report_endpoint(client, method, path, body_data, req.query_string, options)
 
         app.add_middleware(BotVersionFalconMiddleware())
 
@@ -617,16 +654,10 @@ def attach_bottle_interceptor(app, client, options):
 
             try:
                 body_data = bottle_request.json
-                body_structure = build_body_structure(body_data)
-                # tRPC GET: input is in URL query param, not body
-                if not body_structure:
-                    trpc_body = extract_trpc_get_input(path, bottle_request.query_string)
-                    if trpc_body:
-                        body_structure = build_body_structure(trpc_body)
             except Exception:
-                body_structure = None
+                body_data = None
 
-            report_endpoint(client, method, path, body_structure, options)
+            report_endpoint(client, method, path, body_data, bottle_request.query_string, options)
 
         # Install on the specific app instance, not globally
         app.add_hook("before_request", botversion_bottle_interceptor)
@@ -676,17 +707,11 @@ def attach_aiohttp_interceptor(app, client, options):
                     try:
                         body_bytes = await request.read()
                         body_data = _json.loads(body_bytes) if body_bytes else None
-                        body_structure = build_body_structure(body_data)
-                        # tRPC GET: input is in URL query param, not body
-                        if not body_structure:
-                            trpc_body = extract_trpc_get_input(path, request.rel_url.query_string)
-                            if trpc_body:
-                                body_structure = build_body_structure(trpc_body)
                     except Exception:
-                        body_structure = None
+                        body_data = None
 
                     if response.status < 500:
-                        report_endpoint(client, method, path, body_structure, options)
+                        report_endpoint(client, method, path, body_data, request.rel_url.query_string, options)
 
             return response
 
@@ -761,17 +786,11 @@ def attach_tornado_interceptor(app, client, options):
                         try:
                             body_bytes = self.request.body
                             body_data = _json.loads(body_bytes) if body_bytes else None
-                            body_structure = build_body_structure(body_data)
-                            # tRPC GET: input is in URL query param, not body
-                            if not body_structure:
-                                trpc_body = extract_trpc_get_input(path, self.request.query)
-                                if trpc_body:
-                                    body_structure = build_body_structure(trpc_body)
                         except Exception:
-                            body_structure = None
+                            body_data = None
 
                         if self.get_status() < 500:
-                            report_endpoint(client, method, path, body_structure, options)
+                            report_endpoint(client, method, path, body_data, self.request.query, options)
             except Exception:
                 pass
 
@@ -822,17 +841,11 @@ def botversion_pyramid_tween_factory(handler, registry):
                 if not _pyramid_options.get("api_prefix") or path.startswith(_pyramid_options["api_prefix"]):
                     try:
                         body_data = request.json_body if request.content_length else None
-                        body_structure = build_body_structure(body_data)
-                        # tRPC GET: input is in URL query param, not body
-                        if not body_structure:
-                            trpc_body = extract_trpc_get_input(path, request.query_string)
-                            if trpc_body:
-                                body_structure = build_body_structure(trpc_body)
                     except Exception:
-                        body_structure = None
+                        body_data = None
 
                     if response.status_int < 500:
-                        report_endpoint(_pyramid_client, method, path, body_structure, _pyramid_options)
+                        report_endpoint(_pyramid_client, method, path, body_data, request.query_string, _pyramid_options)
         except Exception:
             pass
 
@@ -897,20 +910,14 @@ def attach_cherrypy_interceptor(app, client, options):
             try:
                 body_bytes = request.body.read() if request.body else None
                 body_data = _json.loads(body_bytes) if body_bytes else None
-                body_structure = build_body_structure(body_data)
-                # tRPC GET: input is in URL query param, not body
-                if not body_structure:
-                    query_string = request.query_string if hasattr(request, "query_string") else ""
-                    trpc_body = extract_trpc_get_input(path, query_string)
-                    if trpc_body:
-                        body_structure = build_body_structure(trpc_body)
                 # Put body back so actual handler can still read it
                 import io
                 request.body = io.BytesIO(body_bytes or b"")
             except Exception:
-                body_structure = None
+                body_data = None
 
-            report_endpoint(client, method, path, body_structure, options)
+            query_string = request.query_string if hasattr(request, "query_string") else ""
+            report_endpoint(client, method, path, body_data, query_string, options)
 
         # Register as a CherryPy tool
         cherrypy.tools.botversion = cherrypy.Tool(

{botversion_sdk-2.1.0 → botversion_sdk-2.1.1}/botversion_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: botversion-sdk
-Version: 2.1.0
+Version: 2.1.1
 Summary: BotVersion SDK — automatically discover and register your API endpoints
 Home-page: https://github.com/botversion/botversion-sdk-python
 Author: BotVersion

{botversion_sdk-2.1.0 → botversion_sdk-2.1.1}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="botversion-sdk",
-    version="2.1.0",
+    version="2.1.1",
     description="BotVersion SDK — automatically discover and register your API endpoints",
     long_description=open("README.md").read() if __import__("os").path.exists("README.md") else "",
     long_description_content_type="text/markdown",