api-foundry-query-engine 0.8.58__tar.gz → 0.8.60__tar.gz

{api_foundry_query_engine-0.8.58 → api_foundry_query_engine-0.8.60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: api-foundry-query-engine
-Version: 0.8.58
+Version: 0.8.60
 Summary: The AWS lambda service handler use by the `api_foundry` project is a powerful tool designed to automate the deployment of REST APIs on AWS using Lambda services to access and interact with relational databases (RDBMS). This project leverages the OpenAPI specification to define and manage the APIs
 Project-URL: Documentation, https://github.com/DanRepik/api-foundry
 Project-URL: Source, https://github.com/DanRepik/api-foundry

api_foundry_query_engine-0.8.60/api_foundry_query_engine/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.8.60"

{api_foundry_query_engine-0.8.58 → api_foundry_query_engine-0.8.60}/api_foundry_query_engine/adapters/gateway_adapter.py

@@ -39,12 +39,12 @@ class GatewayAdapter(Adapter):
         - tuple: Tuple containing data, query and metadata parameters.
         """
         resource = event.get("resource")
-        if resource is not None and "/" in resource:
+        if resource:
             parts = [p for p in resource.split("/") if p]  # Remove empty strings
             # Skip common API prefixes like "api", "v1", "v2", etc.
             api_prefixes = {"api", "v1", "v2", "v3"}
-            filtered_parts = [p for p in parts if p not in api_prefixes and not p.startswith("{")]
-            entity = filtered_parts[0] if filtered_parts else None
+            literal_parts = [p for p in parts if p not in api_prefixes and not p.startswith("{")]
+            entity = "_".join(literal_parts) if literal_parts else None
         else:
             entity = None
 
@@ -99,7 +99,16 @@ class GatewayAdapter(Adapter):
 
         event_params = {}
 
-        path_parameters = self._convert_parameters(event.get("pathParameters"))
+        raw_path = event.get("path") or ""
+        path_parameters = event.get("pathParameters") or {}
+        if "proxy" in path_parameters and not raw_path:
+            raw_path = f"/{path_parameters['proxy']}"
+        extracted_path_params = self._extract_path_params(resource, raw_path)
+        for key, value in extracted_path_params.items():
+            if key not in path_parameters or path_parameters.get(key) in (None, "", "None"):
+                path_parameters[key] = value
+
+        path_parameters = self._convert_parameters(path_parameters)
         if path_parameters is not None:
             event_params.update(path_parameters)
 
@@ -107,6 +116,8 @@ class GatewayAdapter(Adapter):
         if query_string_parameters is not None:
             event_params.update(query_string_parameters)
         query_params, metadata_params = self.split_params(event_params)
+        log.info("Unmarshalled query parameters: %s", query_params)
+        log.info("Unmarshalled metadata parameters: %s", metadata_params)
 
         store_params = {}
         body = event.get("body")
@@ -146,6 +157,22 @@ class GatewayAdapter(Adapter):
                     result[parameter] = value
         return result
 
+    def _extract_path_params(self, resource: Optional[str], path: str) -> Dict[str, str]:
+        if not resource or not path:
+            return {}
+
+        resource_parts = [p for p in resource.split("/") if p]
+        path_parts = [p for p in path.split("/") if p]
+        params: Dict[str, str] = {}
+
+        for template, actual in zip(resource_parts, path_parts):
+            if template.startswith("{") and template.endswith("}"):
+                key = template[1:-1]
+                if key:
+                    params[key] = actual
+
+        return params
+
     def split_params(self, parameters: Dict[str, Any]) -> Tuple[Dict[str, Any], Dict[str, Any]]:
         """
         Split a dictionary into two dictionaries based on keys.

{api_foundry_query_engine-0.8.58 → api_foundry_query_engine-0.8.60}/api_foundry_query_engine/utils/claims_check.py

@@ -403,17 +403,27 @@ def _extract_entity_from_path(event: Dict[str, Any]) -> Optional[str]:
     # Remove leading slash and split by slash
     path_parts = path.lstrip("/").split("/")
 
-    # Find the first non-parameter part (entity is typically first)
+    # Find literal path parts (ignoring params and common prefixes)
     # For paths like "/comment/123" or "/comment/123/version/1"
-    # Skip common API prefixes like "api", "v1", etc.
     api_prefixes = {"api", "v1", "v2", "v3"}
+    literal_parts = []
     for part in path_parts:
-        if part and not part.startswith("{") and part not in api_prefixes:
-            # Skip numeric IDs and known path keywords
-            if not part.isdigit() and part not in {"version", "batch"}:
-                return part
+        if not part or part.startswith("{"):
+            continue
+        if part in api_prefixes:
+            continue
+        # Skip numeric IDs and known path keywords
+        if part.isdigit() or part in {"version", "batch"}:
+            continue
+        literal_parts.append(part)
+
+    if not literal_parts:
+        return None
+
+    if len(literal_parts) == 1:
+        return literal_parts[0]
 
-    return None
+    return "_".join(literal_parts)
 
 
 def _scope_matches(user_scopes: list, required_scope: str, operation: str, entity: str) -> bool:

api_foundry_query_engine-0.8.58/api_foundry_query_engine/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.8.58"