api-foundry-query-engine 0.8.62__tar.gz → 0.8.64__tar.gz

{api_foundry_query_engine-0.8.62 → api_foundry_query_engine-0.8.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: api-foundry-query-engine
-Version: 0.8.62
+Version: 0.8.64
 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.64/api_foundry_query_engine/__init__.py

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

{api_foundry_query_engine-0.8.62 → api_foundry_query_engine-0.8.64}/api_foundry_query_engine/adapters/gateway_adapter.py

@@ -43,9 +43,7 @@ class GatewayAdapter(Adapter):
             parts = [p for p in resource.split("/") if p]
             # Skip common API prefixes like "api", "v1", "v2", etc.
             api_prefixes = {"api", "v1", "v2", "v3"}
-            literal_parts = [
-                p for p in parts if p not in api_prefixes and not p.startswith("{")
-            ]
+            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

{api_foundry_query_engine-0.8.62 → api_foundry_query_engine-0.8.64}/api_foundry_query_engine/dao/sql_insert_query_handler.py

@@ -1,3 +1,4 @@
+import json
 from typing import Dict, Optional
 from api_foundry_query_engine.dao.sql_query_handler import SQLSchemaQueryHandler
 from api_foundry_query_engine.operation import Operation
@@ -11,9 +12,7 @@ log = logger(__name__)
 class SQLInsertSchemaQueryHandler(SQLSchemaQueryHandler):
     key_property: Optional[SchemaObjectProperty]
 
-    def __init__(
-        self, operation: Operation, schema_object: SchemaObject, engine: str
-    ) -> None:
+    def __init__(self, operation: Operation, schema_object: SchemaObject, engine: str) -> None:
         super().__init__(operation, schema_object, engine)
         self.key_property = schema_object.primary_key
         if self.key_property:
@@ -32,9 +31,7 @@ class SQLInsertSchemaQueryHandler(SQLSchemaQueryHandler):
                         + f" required. schema_object: {schema_object.api_name}",
                     )
         self.concurrency_property = schema_object.concurrency_property
-        if self.concurrency_property and operation.store_params.get(
-            self.concurrency_property.api_name
-        ):
+        if self.concurrency_property and operation.store_params.get(self.concurrency_property.api_name):
             raise ApplicationException(
                 400,
                 "Versioned properties can not be supplied a store parameters. "
@@ -61,7 +58,9 @@ class SQLInsertSchemaQueryHandler(SQLSchemaQueryHandler):
                 self.schema_object.properties,
             )
             # Combine both (union of read and write)
-            self._insert_selection_results = {**read_props, **write_props}
+            combined = {**read_props, **write_props}
+            filters = self.operation.metadata_params.get("_properties", ".*").split()
+            self._insert_selection_results = self.filter_and_prefix_keys(filters, combined)
         return self._insert_selection_results
 
     @property
@@ -72,10 +71,7 @@ class SQLInsertSchemaQueryHandler(SQLSchemaQueryHandler):
         returning_clause = self._get_returning_clause()
 
         if not self.concurrency_property:
-            return (
-                f"INSERT INTO {self.table_expression}{self.insert_values} "
-                + returning_clause
-            )
+            return f"INSERT INTO {self.table_expression}{self.insert_values} " + returning_clause
 
         if self.operation.store_params.get(self.concurrency_property.api_name):
             raise ApplicationException(
@@ -85,10 +81,7 @@ class SQLInsertSchemaQueryHandler(SQLSchemaQueryHandler):
                 + f"  schema_object: {self.schema_object.api_name}, "
                 + f"property: {self.concurrency_property.api_name}",
             )
-        return (
-            f"INSERT INTO {self.table_expression}{self.insert_values}"
-            + returning_clause
-        )
+        return f"INSERT INTO {self.table_expression}{self.insert_values} " + returning_clause
 
     def _get_returning_clause(self) -> str:
         """
@@ -121,22 +114,18 @@ class SQLInsertSchemaQueryHandler(SQLSchemaQueryHandler):
         allowed_property_names = self.check_permissions(
             "write", self.schema_object.permissions, self.schema_object.properties
         )
-        allowed_properties = {
-            k: v
-            for k, v in self.schema_object.properties.items()
-            if k in allowed_property_names
-        }
+        allowed_properties = {k: v for k, v in self.schema_object.properties.items() if k in allowed_property_names}
         log.info("allowed properties: %s", allowed_properties)
 
-        import json
-
-        # First, validate that user is not trying to set injected properties
         for property_name, property in self.schema_object.properties.items():
-            if property.inject_value and property_name in self.operation.store_params:
+            inject_value = getattr(property, "inject_value", None)
+            inject_on = getattr(property, "inject_on", None) or []
+            if not inject_value or "create" not in inject_on:
+                continue
+            if property_name in self.operation.store_params:
                 raise ApplicationException(
                     403,
-                    f"Property '{property_name}' is auto-injected and "
-                    + "cannot be set manually",
+                    f"Property '{property_name}' is auto-injected and cannot be set manually",
                 )
 
         for name, value in self.operation.store_params.items():
@@ -160,36 +149,33 @@ class SQLInsertSchemaQueryHandler(SQLSchemaQueryHandler):
 
             columns.append(property.column_name)
             if property.api_name is None:
-                raise ApplicationException(
-                    400, f"Property '{name}' does not have a valid api_name."
-                )
+                raise ApplicationException(400, f"Property '{name}' does not have a valid api_name.")
             placeholders.append(self.placeholder(property, property.api_name))
             # Serialize embedded objects to JSON
             if property.api_type == "object":
                 self.store_placeholders[property.api_name] = json.dumps(value)
             else:
-                self.store_placeholders[
-                    property.api_name
-                ] = property.convert_to_db_value(value)
+                self.store_placeholders[property.api_name] = property.convert_to_db_value(value)
 
-        # Inject values from claims/timestamps/etc for properties with
-        # x-af-inject-value on CREATE
         for property_name, property in self.schema_object.properties.items():
-            if property.inject_value and "create" in property.inject_on:
-                injected_value = self.extract_injected_value(property.inject_value)
-                if injected_value is not None:
-                    placeholder_key = f"__inject_{property_name}"
-                    columns.append(property.column_name)
-                    placeholders.append(self.placeholder(property, placeholder_key))
-                    self.store_placeholders[
-                        placeholder_key
-                    ] = property.convert_to_db_value(injected_value)
-                elif property.required:
-                    raise ApplicationException(
-                        400,
-                        f"Required injected property '{property_name}' "
-                        + f"could not be populated from '{property.inject_value}'",
-                    )
+            inject_value = getattr(property, "inject_value", None)
+            inject_on = getattr(property, "inject_on", None) or []
+            if not inject_value or "create" not in inject_on:
+                continue
+            if property_name in self.store_placeholders:
+                continue
+
+            # Preserve legacy placeholder names for writable injected fields
+            # while using the API name for non-writable injected fields.
+            placeholder_name = (
+                f"__inject_{property_name}"
+                if property_name in allowed_properties
+                else (str(property.api_name) if property.api_name is not None else property_name)
+            )
+            injected_value = self.extract_injected_value(str(inject_value))
+            columns.append(property.column_name)
+            placeholders.append(self.placeholder(property, placeholder_name))
+            self.store_placeholders[placeholder_name] = property.convert_to_db_value(injected_value)
 
         if self.key_property:
             if self.key_property.key_type == "sequence":
@@ -201,8 +187,6 @@ class SQLInsertSchemaQueryHandler(SQLSchemaQueryHandler):
             if self.concurrency_property.column_type == "integer":
                 placeholders.append("1")
             else:
-                placeholders.append(
-                    self.concurrency_generator(self.concurrency_property)
-                )
+                placeholders.append(self.concurrency_generator(self.concurrency_property))
 
         return f" ( {', '.join(columns)} ) VALUES ( {', '.join(placeholders)})"

{api_foundry_query_engine-0.8.62 → api_foundry_query_engine-0.8.64}/api_foundry_query_engine/dao/sql_query_handler.py

@@ -1,4 +1,6 @@
 import re
+import os
+import uuid
 from typing import Optional, List, Dict
 from datetime import datetime, date
 
@@ -108,9 +110,7 @@ class SQLQueryHandler:
     operation: Operation
     engine: str
 
-    def __init__(
-        self, operation: Operation, engine: str
-    ):  # , schema_object: SchemaObject):
+    def __init__(self, operation: Operation, engine: str):  # , schema_object: SchemaObject):
         self.operation = operation
         self.engine = engine
         self.__select_list_columns = None
@@ -180,9 +180,7 @@ class SQLQueryHandler:
             List[str]: A list of properties the user is permitted to access.
         """
         # if permissions are not defined then no restrictions are applied
-        log.info(
-            f"checking permissions permission_type: {permission_type}, permissions: {permissions}"
-        )
+        log.info(f"checking permissions permission_type: {permission_type}, permissions: {permissions}")
         if not permissions:
             return properties
 
@@ -223,9 +221,7 @@ class SQLQueryHandler:
 
             if regex_pattern:
                 # Use efficient regex dictionary filtering
-                role_allowed = self._filter_properties_by_regex(
-                    properties, regex_pattern
-                )
+                role_allowed = self._filter_properties_by_regex(properties, regex_pattern)
                 log.info(
                     "role: %s, pattern: %s, matched: %s",
                     role,
@@ -284,9 +280,7 @@ class SQLQueryHandler:
 
             for action, rule in actions.items():
                 # Normalize action names: create/update -> write
-                normalized_action = (
-                    "write" if action in ("create", "update") else action
-                )
+                normalized_action = "write" if action in ("create", "update") else action
 
                 if normalized_action in normalized["default"]:
                     normalized["default"][normalized_action][role] = rule
@@ -330,9 +324,7 @@ class SQLQueryHandler:
             return permission_rule
         elif isinstance(permission_rule, dict):
             # Support both 'properties' (preferred) and 'fields' (legacy)
-            return permission_rule.get("properties") or permission_rule.get(
-                "fields", ""
-            )
+            return permission_rule.get("properties") or permission_rule.get("fields", "")
         else:
             return ""
 
@@ -340,9 +332,7 @@ class SQLQueryHandler:
     def selection_results(self) -> Dict:
         raise NotImplementedError()
 
-    def generate_sql_condition(
-        self, property: SchemaObjectProperty, value, prefix: Optional[str] = None
-    ) -> str:
+    def generate_sql_condition(self, property: SchemaObjectProperty, value, prefix: Optional[str] = None) -> str:
         operand = "="
         if isinstance(value, str):
             parts = value.split("::", 1)
@@ -354,9 +344,7 @@ class SQLQueryHandler:
             value_str = str(value)
 
         column = f"{prefix}.{property.column_name}" if prefix else property.column_name
-        placeholder_name = (
-            f"{prefix}_{property.api_name}" if prefix else property.api_name
-        )
+        placeholder_name = f"{prefix}_{property.api_name}" if prefix else property.api_name
 
         if operand in ["between", "not-between"]:
             value_set = value_str.split(",")
@@ -364,17 +352,14 @@ class SQLQueryHandler:
         elif operand in ["in", "not-in"]:
             value_set = value_str.split(",")
             assignments = [
-                self.placeholder(property, f"{placeholder_name}_{index}")
-                for index, _ in enumerate(value_set)
+                self.placeholder(property, f"{placeholder_name}_{index}") for index, _ in enumerate(value_set)
             ]
             sql = f"{column} {'NOT ' if operand == 'not-in' else ''}IN ({', '.join(assignments)})"  # noqa E501
         else:
             sql = f"{column} {operand} {self.placeholder(property, str(placeholder_name))}"
         return sql
 
-    def generate_placeholders(
-        self, property: SchemaObjectProperty, value, prefix: Optional[str] = None
-    ) -> dict:
+    def generate_placeholders(self, property: SchemaObjectProperty, value, prefix: Optional[str] = None) -> dict:
         operand = "="
 
         if isinstance(value, str):
@@ -386,9 +371,7 @@ class SQLQueryHandler:
         else:
             value_str = str(value)
 
-        placeholder_name = (
-            f"{prefix}_{property.api_name}" if prefix else property.api_name
-        )
+        placeholder_name = f"{prefix}_{property.api_name}" if prefix else property.api_name
         placeholders = {}
 
         if operand in ["between", "not-between"]:
@@ -428,9 +411,6 @@ class SQLQueryHandler:
         Raises:
             ApplicationException: If source format is invalid
         """
-        import os
-        import uuid
-
         if inject_value_source.startswith("claim:"):
             claim_key = inject_value_source[6:]
             return self.operation.claims.get(claim_key)
@@ -444,17 +424,13 @@ class SQLQueryHandler:
             env_key = inject_value_source[4:]
             return os.environ.get(env_key)
         else:
-            raise ApplicationException(
-                400, f"Unknown inject value source: {inject_value_source}"
-            )
+            raise ApplicationException(400, f"Unknown inject value source: {inject_value_source}")
 
 
 class SQLSchemaQueryHandler(SQLQueryHandler):
     schema_object: SchemaObject
 
-    def __init__(
-        self, operation: Operation, schema_object: SchemaObject, engine: str
-    ) -> None:
+    def __init__(self, operation: Operation, schema_object: SchemaObject, engine: str) -> None:
         super().__init__(operation, engine)
         self.schema_object = schema_object
         self.single_table = self.__single_table()
@@ -483,10 +459,7 @@ class SQLSchemaQueryHandler(SQLQueryHandler):
                 entity_lower = entity.lower()
                 for i in range(1, len(entity_lower) + 1):
                     substring = entity_lower[:i]
-                    if (
-                        substring not in self._prefix_map.values()
-                        and substring not in SQL_RESERVED_WORDS
-                    ):
+                    if substring not in self._prefix_map.values() and substring not in SQL_RESERVED_WORDS:
                         self._prefix_map[entity] = substring
                         break
         return self._prefix_map
@@ -526,9 +499,7 @@ class SQLSchemaQueryHandler(SQLQueryHandler):
             allowed_properties = self.check_permissions(
                 "read", self.schema_object.permissions, self.schema_object.properties
             )
-            self.__selection_results = self.filter_and_prefix_keys(
-                filters, allowed_properties
-            )
+            self.__selection_results = self.filter_and_prefix_keys(filters, allowed_properties)
         return self.__selection_results
 
     def _has_soft_delete_conflicts(self) -> Dict[str, bool]:
@@ -617,8 +588,7 @@ class SQLSchemaQueryHandler(SQLQueryHandler):
                 if excluded_values:
                     # Format values for SQL IN clause
                     formatted_values = ", ".join(
-                        f"'{val}'" if isinstance(val, str) else str(val)
-                        for val in excluded_values
+                        f"'{val}'" if isinstance(val, str) else str(val) for val in excluded_values
                     )
                     conditions.append(f"{column_name} NOT IN ({formatted_values})")
 
@@ -636,20 +606,14 @@ class SQLSchemaQueryHandler(SQLQueryHandler):
 
         for name, value in self.operation.query_params.items():
             if "." in name:
-                raise ApplicationException(
-                    400, "Selection on relations is not supported"
-                )
+                raise ApplicationException(400, "Selection on relations is not supported")
             property = self.schema_object.properties.get(name)
             if not property:
-                raise ApplicationException(
-                    500, f"Search condition column not found {name}"
-                )
+                raise ApplicationException(500, f"Search condition column not found {name}")
             if (
                 self.operation.action != "read"
                 and isinstance(value, str)
-                and re.match(
-                    r"^(lt|le|eq|ne|gt|ge|in|not-in|between|not-between)::(.+)$", value
-                )
+                and re.match(r"^(lt|le|eq|ne|gt|ge|in|not-in|between|not-between)::(.+)$", value)
                 and self.schema_object.concurrency_property
             ):
                 raise ApplicationException(
@@ -665,9 +629,7 @@ class SQLSchemaQueryHandler(SQLQueryHandler):
             self.search_placeholders.update(holders)
         return f" WHERE {' AND '.join(conditions)}" if conditions else ""
 
-    def filter_and_prefix_keys(
-        self, regex_list: List[str], properties: dict, prefix: Optional[str] = None
-    ) -> dict:
+    def filter_and_prefix_keys(self, regex_list: List[str], properties: dict, prefix: Optional[str] = None) -> dict:
         """
         Accepts a prefix string, list of regular expressions, and a dictionary.
         Returns a new dictionary containing items whose keys match any of the

{api_foundry_query_engine-0.8.62 → api_foundry_query_engine-0.8.64}/api_foundry_query_engine/dao/sql_subselect_query_handler.py

@@ -51,16 +51,11 @@ class SQLSubselectSchemaQueryHandler(SQLSelectSchemaQueryHandler):
         if len(self.select_list_columns) == 1:  # then it only contains the key
             return None
 
-        # Get the parent table alias to avoid ambiguous column references
-        parent_alias = self.parent_generator.prefix_map[
-            str(self.parent_generator.schema_object.api_name)
-        ]
-
         sql = (
             f"SELECT {self.select_list} "
             + f"FROM {self.relation.child_schema_object.qualified_name} "
             + f"WHERE {self.relation.child_property} "
-            + f"IN ( SELECT {parent_alias}.{self.relation.parent_property} "
+            + f"IN ( SELECT {self.relation.parent_property} "
             + f"FROM {self.parent_generator.table_expression}"
             + f"{self.parent_generator.search_condition} "
             #            + f"{order_by} {limit} {offset})"

{api_foundry_query_engine-0.8.62 → api_foundry_query_engine-0.8.64}/api_foundry_query_engine/dao/sql_update_query_handler.py

@@ -1,3 +1,4 @@
+import json
 import re
 from typing import Match
 from api_foundry_query_engine.dao.sql_query_handler import SQLSchemaQueryHandler
@@ -7,9 +8,7 @@ from api_foundry_query_engine.utils.api_model import SchemaObject
 
 
 class SQLUpdateSchemaQueryHandler(SQLSchemaQueryHandler):
-    def __init__(
-        self, operation: Operation, schema_object: SchemaObject, engine: str
-    ) -> None:
+    def __init__(self, operation: Operation, schema_object: SchemaObject, engine: str) -> None:
         super().__init__(operation, schema_object, engine)
 
     def _template_where(self, expr: str) -> str:
@@ -106,24 +105,20 @@ class SQLUpdateSchemaQueryHandler(SQLSchemaQueryHandler):
         allowed_property_names = self.check_permissions(
             "write", self.schema_object.permissions, self.schema_object.properties
         )
-        allowed_properties = {
-            k: v
-            for k, v in self.schema_object.properties.items()
-            if k in allowed_property_names
-        }
+        allowed_properties = {k: v for k, v in self.schema_object.properties.items() if k in allowed_property_names}
         self.store_placeholders = {}
         columns = []
         invalid_columns = []
 
-        import json
-
-        # First, validate that user is not trying to set injected properties
         for property_name, property in self.schema_object.properties.items():
-            if property.inject_value and property_name in self.operation.store_params:
+            inject_value = getattr(property, "inject_value", None)
+            inject_on = getattr(property, "inject_on", None) or []
+            if not inject_value:
+                continue
+            if property_name in self.operation.store_params:
                 raise ApplicationException(
                     403,
-                    f"Property '{property_name}' is auto-injected and "
-                    + "cannot be set manually",
+                    f"Property '{property_name}' is auto-injected and cannot be set manually",
                 )
 
         for name, value in self.operation.store_params.items():
@@ -132,9 +127,7 @@ class SQLUpdateSchemaQueryHandler(SQLSchemaQueryHandler):
                 invalid_columns.append(name)
                 continue
 
-            placeholder = (
-                str(property.api_name) if property.api_name is not None else name
-            )
+            placeholder = str(property.api_name) if property.api_name is not None else name
             column_name = property.column_name
 
             columns.append(f"{column_name} = {self.placeholder(property, placeholder)}")
@@ -142,36 +135,28 @@ class SQLUpdateSchemaQueryHandler(SQLSchemaQueryHandler):
             if property.api_type == "object":
                 self.store_placeholders[placeholder] = json.dumps(value)
             else:
-                self.store_placeholders[placeholder] = property.convert_to_db_value(
-                    value
-                )
+                self.store_placeholders[placeholder] = property.convert_to_db_value(value)
 
-        # Inject values from claims/timestamps/etc for properties with
-        # x-af-inject-value on UPDATE
         for property_name, property in self.schema_object.properties.items():
-            if property.inject_value and "update" in property.inject_on:
-                injected_value = self.extract_injected_value(property.inject_value)
-                if injected_value is not None:
-                    placeholder_key = f"__inject_{property_name}"
-                    column_name = property.column_name
-                    columns.append(
-                        f"{column_name} = {self.placeholder(property, placeholder_key)}"
-                    )
-                    self.store_placeholders[
-                        placeholder_key
-                    ] = property.convert_to_db_value(injected_value)
-                elif property.required:
-                    raise ApplicationException(
-                        400,
-                        f"Required injected property '{property_name}' "
-                        + f"could not be populated from '{property.inject_value}'",
-                    )
+            inject_value = getattr(property, "inject_value", None)
+            inject_on = getattr(property, "inject_on", None) or []
+            if not inject_value or "update" not in inject_on:
+                continue
+
+            placeholder = (
+                f"__inject_{property_name}"
+                if property_name in allowed_properties
+                else (str(property.api_name) if property.api_name is not None else property_name)
+            )
+            columns.append(f"{property.column_name} = {self.placeholder(property, placeholder)}")
+            self.store_placeholders[placeholder] = property.convert_to_db_value(
+                self.extract_injected_value(str(inject_value))
+            )
 
         if invalid_columns:
             raise ApplicationException(
                 403,
-                f"Subject does not have permission to update properties: "
-                f"{invalid_columns}",
+                f"Subject does not have permission to update properties: " f"{invalid_columns}",
             )
         return f" SET {', '.join(columns)}"
 

{api_foundry_query_engine-0.8.62 → api_foundry_query_engine-0.8.64}/api_foundry_query_engine/operation.py

@@ -40,6 +40,7 @@ class Operation:
         store_params: Optional[Dict[str, Any]] = None,
         metadata_params: Optional[Dict[str, Any]] = None,
         claims: Optional[Dict[str, Any]] = None,
+        roles: Optional[List[str]] = None,
     ):
         """
         Initializes the Operation instance.
@@ -76,6 +77,8 @@ class Operation:
 
         # Roles defining the context in which the operation is allowed.
         self.claims = claims or {}
+        if roles is not None and "roles" not in self.claims:
+            self.claims["roles"] = roles
 
         # Log the operation for debugging and audit purposes
         logger.info(

{api_foundry_query_engine-0.8.62 → api_foundry_query_engine-0.8.64}/api_foundry_query_engine/utils/api_model.py

@@ -207,9 +207,7 @@ class SchemaObjectAssociation:
             raise ValueError(f"Primary key not defined for schema '{self.schema_name}'")
         column_name = getattr(child_schema.primary_key, "column_name", None)
         if column_name is None:
-            raise ValueError(
-                f"Primary key property does not have 'column_name' for schema '{self.schema_name}'"
-            )
+            raise ValueError(f"Primary key property does not have 'column_name' for schema '{self.schema_name}'")
         return column_name
 
     @property
@@ -220,14 +218,10 @@ class SchemaObjectAssociation:
         if not parent_schema_obj:
             raise ValueError(f"SchemaObject '{self.parent_schema}' not found")
         if not parent_schema_obj.primary_key:
-            raise ValueError(
-                f"Primary key not defined for schema '{self.parent_schema}'"
-            )
+            raise ValueError(f"Primary key not defined for schema '{self.parent_schema}'")
         column_name = getattr(parent_schema_obj.primary_key, "column_name", None)
         if column_name is None:
-            raise ValueError(
-                f"Primary key property does not have 'column_name' for schema '{self.parent_schema}'"
-            )
+            raise ValueError(f"Primary key property does not have 'column_name' for schema '{self.parent_schema}'")
         return column_name
 
     def __repr__(self):
@@ -255,23 +249,16 @@ class SchemaObject:
         self.database: str = str(data.get("database"))
         self.schema: Optional[str] = data.get("schema")
         self.table_name: str = str(data.get("table_name"))
-        self.qualified_name: str = (
-            f"{self.schema}.{self.table_name}" if self.schema else self.table_name
-        )
+        self.qualified_name: str = f"{self.schema}.{self.table_name}" if self.schema else self.table_name
         self.properties: Dict[str, SchemaObjectProperty] = {
-            name: SchemaObjectProperty(prop_data)
-            for name, prop_data in data.get("properties", {}).items()
+            name: SchemaObjectProperty(prop_data) for name, prop_data in data.get("properties", {}).items()
         }
         self.relations = {
-            name: SchemaObjectAssociation(
-                self.api_name if self.api_name is not None else "", assoc_data
-            )
+            name: SchemaObjectAssociation(self.api_name if self.api_name is not None else "", assoc_data)
             for name, assoc_data in data.get("relations", {}).items()
         }
         self.concurrency_property = (
-            self.properties[str(data.get("concurrency_property"))]
-            if data.get("concurrency_property")
-            else None
+            self.properties[str(data.get("concurrency_property"))] if data.get("concurrency_property") else None
         )
         self._primary_key: str = str(data.get("primary_key"))
         self.permissions = data.get("permissions")
@@ -293,8 +280,7 @@ class SchemaObject:
             name: prop
             for name, prop in self.properties.items()
             if prop.is_soft_delete_field()
-            and prop.get_soft_delete_strategy()
-            in ["null_check", "boolean_flag", "exclude_values"]
+            and prop.get_soft_delete_strategy() in ["null_check", "boolean_flag", "exclude_values"]
         }
 
     def get_soft_delete_audit_properties(
@@ -304,8 +290,7 @@ class SchemaObject:
         return {
             name: prop
             for name, prop in self.properties.items()
-            if prop.is_soft_delete_field()
-            and prop.get_soft_delete_strategy() == "audit_field"
+            if prop.is_soft_delete_field() and prop.get_soft_delete_strategy() == "audit_field"
         }
 
     def get_soft_delete_strategies(self) -> List[str]:
@@ -326,12 +311,10 @@ class PathOperation:
         self.sql: str = data["sql"]
         self.database: str = data["database"]
         self.inputs: Dict[str, SchemaObjectProperty] = {
-            name: SchemaObjectProperty(input_data)
-            for name, input_data in data.get("inputs", {}).items()
+            name: SchemaObjectProperty(input_data) for name, input_data in data.get("inputs", {}).items()
         }
         self.outputs: Dict[str, SchemaObjectProperty] = {
-            name: SchemaObjectProperty(output_data)
-            for name, output_data in data.get("outputs", {}).items()
+            name: SchemaObjectProperty(output_data) for name, output_data in data.get("outputs", {}).items()
         }
         self.permissions = data.get("security")
 
@@ -345,12 +328,10 @@ class APIModel:
     def __init__(self, config: Dict[str, Any]):
         log.info("building api_model")
         self.schema_objects = {
-            name: SchemaObject(schema_data)
-            for name, schema_data in config.get("schema_objects", {}).items()
+            name: SchemaObject(schema_data) for name, schema_data in config.get("schema_objects", {}).items()
         }
         self.path_operations = {
-            name: PathOperation(path_data)
-            for name, path_data in config.get("path_operations", {}).items()
+            name: PathOperation(path_data) for name, path_data in config.get("path_operations", {}).items()
         }
 
     def get_path_operation(self, path: str, method: str) -> Optional[PathOperation]:
@@ -373,8 +354,6 @@ def set_api_model(engine_config: Mapping[str, str]):
             api_model = APIModel(yaml.safe_load(engine_config["API_SPEC"]))
         else:
             log.info("Loading API model from file")
-            with open(
-                os.environ.get("API_SPEC", "/var/task/api_spec.yaml"), "r"
-            ) as file:
+            with open(os.environ.get("API_SPEC", "/var/task/api_spec.yaml"), "r") as file:
                 api_model = APIModel(yaml.safe_load(file))
         log.info("Loaded API model: %s", api_model)

{api_foundry_query_engine-0.8.62 → api_foundry_query_engine-0.8.64}/api_foundry_query_engine/utils/claims_check.py

@@ -420,10 +420,9 @@ def _extract_entity_from_path(event: Dict[str, Any]) -> Optional[str]:
     if not literal_parts:
         return None
 
-    if len(literal_parts) == 1:
-        return literal_parts[0]
-
-    return "_".join(literal_parts)
+    # For API paths with prefixes (e.g. "/chinook-api/album"),
+    # the entity is the most specific trailing literal segment.
+    return literal_parts[-1]
 
 
 def _scope_matches(user_scopes: list, required_scope: str, operation: str, entity: str) -> bool:

api_foundry_query_engine-0.8.62/api_foundry_query_engine/__init__.py

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