api-foundry-query-engine 0.8.10__tar.gz → 0.8.11__tar.gz

{api_foundry_query_engine-0.8.10 → api_foundry_query_engine-0.8.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: api-foundry-query-engine
-Version: 0.8.10
+Version: 0.8.11
 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
@@ -12,3 +12,9 @@ Requires-Python: >=3.9
 Requires-Dist: boto3
 Requires-Dist: pyhumps
 Requires-Dist: pyyaml
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: fixture-foundry>=0.1.0; extra == 'dev'
+Requires-Dist: isort>=5.12.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'

{api_foundry_query_engine-0.8.10 → api_foundry_query_engine-0.8.11}/api_foundry_query_engine/adapters/gateway_adapter.py

@@ -70,6 +70,7 @@ class GatewayAdapter(Adapter):
             metadata_params=metadata_params,
             roles=roles,
             subject=subject,
+            claims=claims,
         )
 
     def _convert_parameters(self, parameters):

{api_foundry_query_engine-0.8.10 → api_foundry_query_engine-0.8.11}/api_foundry_query_engine/dao/sql_select_query_handler.py

@@ -1,17 +1,60 @@
-from api_foundry_query_engine.dao.sql_query_handler import SQLSchemaQueryHandler
-from api_foundry_query_engine.operation import Operation
+import re
+from typing import Match
+from api_foundry_query_engine.dao.sql_query_handler import (
+    SQLSchemaQueryHandler,
+)
 from api_foundry_query_engine.utils.app_exception import ApplicationException
-from api_foundry_query_engine.utils.api_model import SchemaObject, SchemaObjectProperty
-from api_foundry_query_engine.utils.logger import logger
-
-log = logger(__name__)
+from api_foundry_query_engine.utils.api_model import SchemaObjectProperty
 
 
 class SQLSelectSchemaQueryHandler(SQLSchemaQueryHandler):
-    def __init__(
-        self, operation: Operation, schema_object: SchemaObject, engine: str
-    ) -> None:
+    def _template_where(self, expr: str) -> str:
+        if not expr:
+            return expr
+
+        def _quote(val: object) -> str:
+            if val is None:
+                return "NULL"
+            if isinstance(val, (int, float)):
+                return str(val)
+            s = str(val).replace("'", "''")
+            return f"'{s}'"
+
+        def _replace(m: Match[str]) -> str:
+            key = m.group(1)
+            claims = self.operation.claims or {}
+            return _quote(claims.get(key))
+
+        return re.sub(r"\$\{claims\.([A-Za-z0-9_]+)\}", _replace, expr)
+
+    def _row_where_clause(self) -> str:
+        perms = getattr(self.schema_object, "permissions", None) or {}
+        # provider-first default
+        if "default" in perms:
+            provider = perms.get("default", {}) or {}
+            read_map = provider.get("read", {}) or {}
+        else:
+            # legacy role-first -> synthesize read map
+            read_map = {}
+            for role, role_perms in perms.items():
+                if isinstance(role_perms, dict):
+                    read_map[role] = role_perms.get("read")
+
+        filters = []
+        for role in self.operation.roles or []:
+            rule = read_map.get(role)
+            if isinstance(rule, dict):
+                where = rule.get("where")
+                if isinstance(where, str) and where.strip():
+                    filters.append(self._template_where(where))
+        if not filters:
+            return ""
+        return "(" + ") OR (".join(filters) + ")"
+
+    def __init__(self, operation, schema_object, engine: str) -> None:
         super().__init__(operation, schema_object, engine)
+        # Lazy cache for selection results
+        self._selection_results = None
 
     @property
     def sql(self) -> str:
@@ -63,38 +106,39 @@ class SQLSelectSchemaQueryHandler(SQLSchemaQueryHandler):
                             + " does not have property "
                             + parts[1],
                         )
-                    property = relation.child_schema_object.properties[parts[1]]
+                    prop = relation.child_schema_object.properties[parts[1]]
                     prefix = self.prefix_map[parts[0]]
                 else:
-                    property = self.schema_object.properties[parts[0]]
-                    if self.schema_object.api_name is None:
-                        raise ApplicationException(
-                            500,
-                            "schema_object.api_name is None, cannot use as key in prefix_map",
-                        )
-                    prefix = self.prefix_map[self.schema_object.api_name]
-            except KeyError:
+                    prop = self.schema_object.properties[parts[0]]
+                    prefix = self.prefix_map[str(self.schema_object.api_name)]
+            except KeyError as exc:
                 raise ApplicationException(
                     500,
-                    "Invalid query parameter, property not found. "
-                    + "schema object: "
-                    + str(self.schema_object.api_name)
-                    + ", property: "
-                    + name,
-                )
-
-            assignment, holders = self.search_value_assignment(property, value, prefix)
+                    (
+                        "Invalid query parameter, property not found. "
+                        + "schema object: "
+                        + str(self.schema_object.api_name)
+                        + ", property: "
+                        + name
+                    ),
+                ) from exc
+
+            assignment, holders = self.search_value_assignment(prop, value, prefix)
             self.active_prefixes.add(prefix)
             conditions.append(assignment)
             self.search_placeholders.update(holders)
+        # append row-level filters if present
+        row_filter = self._row_where_clause()
+        if row_filter:
+            conditions.append(f"({row_filter})")
 
-        return f" WHERE {' AND '.join(conditions)}" if len(conditions) > 0 else ""
+        return (" WHERE " + " AND ".join(conditions)) if conditions else ""
 
     @property
     def table_expression(self) -> str:
         joins = []
         parent_prefix = self.prefix_map[str(self.schema_object.api_name)]
-        for name, relation in self.schema_object.relations.items():
+        for _, relation in self.schema_object.relations.items():
             child_prefix = self.prefix_map[str(relation.api_name)]
             if child_prefix in self.active_prefixes:
                 joins.append(
@@ -121,7 +165,7 @@ class SQLSelectSchemaQueryHandler(SQLSchemaQueryHandler):
 
     @property
     def selection_results(self) -> dict:
-        if not hasattr(self, "_selection_results"):
+        if self._selection_results is None:
             self._selection_results = {}
             if "count" in self.operation.metadata_params:
                 self._selection_results = {
@@ -163,10 +207,14 @@ class SQLSelectSchemaQueryHandler(SQLSchemaQueryHandler):
                 # Filter and prefix keys for the current entity
                 # and regular expressions
                 allowed_properties = self.check_permissions(
-                    "read", schema_object.permissions, schema_object.properties
+                    "read",
+                    schema_object.permissions,
+                    schema_object.properties,
                 )
                 filtered_keys = self.filter_and_prefix_keys(
-                    reg_exs, allowed_properties, self.prefix_map[relation]
+                    reg_exs,
+                    allowed_properties,
+                    self.prefix_map[relation],
                 )
 
                 # Extend the result map with the filtered keys
@@ -175,15 +223,18 @@ class SQLSelectSchemaQueryHandler(SQLSchemaQueryHandler):
             if len(self._selection_results) == 0:
                 raise ApplicationException(
                     402,
-                    "After applying permissions there are no properties returned in response",
+                    (
+                        "After applying permissions there are no properties "
+                        "returned in response"
+                    ),
                 )
         return self._selection_results
 
-    def get_regex_map(self, filter_str: str) -> dict[str, list]:
+    def get_regex_map(self, filter_str: str) -> dict:
         result = {}
 
-        for filter in filter_str.split():
-            parts = filter.split(":")
+        for flt in filter_str.split():
+            parts = flt.split(":")
             entity = parts[0] if len(parts) > 1 else self.schema_object.api_name
             expression = parts[-1]
 
@@ -200,17 +251,17 @@ class SQLSelectSchemaQueryHandler(SQLSchemaQueryHandler):
     def marshal_record(self, record) -> dict:
         object_set = {}
         for name, value in record.items():
-            property = self.selection_results[name]
+            prop = self.selection_results[name]
             parts = name.split(".")
             component = (
                 parts[0]
                 if len(parts) > 1
                 else self.prefix_map[str(self.schema_object.api_name)]
             )
-            object = object_set.get(component, {})
-            if not object:
-                object_set[component] = object
-            object[property.api_name] = property.convert_to_api_value(value)
+            obj = object_set.get(component, {})
+            if not obj:
+                object_set[component] = obj
+            obj[prop.api_name] = prop.convert_to_api_value(value)
 
         result = object_set[self.prefix_map[str(self.schema_object.api_name)]]
         for name, prefix in self.prefix_map.items():
@@ -243,13 +294,13 @@ class SQLSelectSchemaQueryHandler(SQLSchemaQueryHandler):
             field_parts = field_name.split(".")
             if len(field_parts) == 1:
                 prefix = self.prefix_map[str(self.schema_object.api_name)]
-                property = self.schema_object.properties.get(field_parts[0])
-                if not property:
+                prop = self.schema_object.properties.get(field_parts[0])
+                if not prop:
                     raise ApplicationException(
                         400,
                         f"Invalid order by property, schema object: {self.schema_object.api_name} does not have a property: {field_parts[0]}",  # noqa E501
                     )
-                column = property.column_name
+                column = prop.column_name
             else:
                 # Extract the schema object for the current entity
                 relation_property = self.schema_object.relations.get(field_parts[0])
@@ -272,13 +323,13 @@ class SQLSelectSchemaQueryHandler(SQLSchemaQueryHandler):
                     schema_object = self.schema_object
 
                 prefix = self.prefix_map[field_parts[0]]
-                property = schema_object.properties.get(field_parts[1])
-                if not property:
+                prop = schema_object.properties.get(field_parts[1])
+                if not prop:
                     raise ApplicationException(
                         400,
                         f"Invalid order by property, schema object: {schema_object.api_name} does not have a property: {field_parts[1]}",  # noqa E501
                     )
-                column = property.column_name
+                column = prop.column_name
                 self.active_prefixes.add(prefix)
                 use_prefixes = True
 

api_foundry_query_engine-0.8.11/api_foundry_query_engine/operation.py

@@ -0,0 +1,81 @@
+from typing import Any, Dict, Optional
+
+
+class Operation:
+    """
+    Represents an action to be performed on an entity.
+
+    The `Operation` class encapsulates the details required
+    to execute an operation on a given entity, including
+    query parameters for selecting records, parameters for
+    storing or updating values, metadata for operational
+    instructions, and roles defining the contexts in which
+    the operation can be performed.
+
+    Attributes:
+        entity (str): The name of the resource or object being
+            targeted (e.g., "User", "Order").
+        action (str): The type of action being performed
+            (e.g., "create", "read", "update", "delete").
+        query_params (dict): Parameters used to filter or select
+            the records affected by the operation.
+        store_params (dict): Parameters that define the values to
+            be stored or updated for the selected records.
+        metadata_params (dict): Additional instructions for the
+            operation, such as sorting or pagination.
+        roles (dict): Defines the roles under which the operation
+            is allowed to be performed.
+    """
+
+    def __init__(
+        self,
+        *,
+        entity: str,
+        action: str,
+        query_params: Optional[Dict[str, Any]] = None,
+        store_params: Optional[Dict[str, Any]] = None,
+        metadata_params: Optional[Dict[str, Any]] = None,
+        roles: Optional[Dict[str, Any]] = None,
+        subject: Optional[str] = None,
+        claims: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initializes the Operation instance.
+
+        Args:
+            entity (str): The name of the entity to perform the operation on.
+            action (str): The action to perform on the entity.
+            query_params (dict, optional): Parameters for selecting
+                affected records (default: {}).
+            store_params (dict, optional): Parameters defining new or
+                updated values (default: {}).
+            metadata_params (dict, optional): Metadata for the
+                operation, such as sorting or pagination (default: {}).
+            roles (dict, optional): Defines the roles allowed to
+                perform the operation (default: {}).
+        """
+        # The target entity for the operation (e.g., "User", "Order").
+        self.entity = entity
+
+        # The type of action to perform (e.g., "create",
+        # "read", "update", "delete").
+        self.action = action
+
+        # Query parameters to filter or identify the affected records.
+        self.query_params = query_params or {}
+
+        # Parameters defining the values to be stored or updated
+        # for the operation.
+        self.store_params = store_params or {}
+
+        # Metadata for operational instructions like sorting,
+        # limiting, or offsetting results.
+        self.metadata_params = metadata_params or {}
+
+        # Roles defining the context in which the operation is allowed.
+        self.roles = roles or {}
+
+        self.subject = subject
+        # Full set of claims (when available). Used for row-level filters
+        # like where: "id = ${claims.sub}".
+        self.claims = claims or ({"sub": subject} if subject is not None else {})

{api_foundry_query_engine-0.8.10 → api_foundry_query_engine-0.8.11}/api_foundry_query_engine/utils/api_model.py

@@ -155,7 +155,9 @@ 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()

{api_foundry_query_engine-0.8.10 → api_foundry_query_engine-0.8.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "api-foundry-query-engine"
-version = "0.8.10"
+version = "0.8.11"
 authors = [
     { name="Daniel Repik", email="danrepik@icloud.com" },
 ]
@@ -19,6 +19,14 @@ dependencies = [
     "pyyaml",
     "pyhumps",
 ]
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0.0",
+    "black>=23.0.0",
+    "isort>=5.12.0",
+    "fixture_foundry>=0.1.0"
+]
 
 [project.urls]
 "Documentation" = "https://github.com/DanRepik/api-foundry"
@@ -30,6 +38,15 @@ include = ["api_foundry_query_engine"]
 [tool.hatch.build.targets.wheel]
 include = ["api_foundry_query_engine"]
 
+[tool.hatch.envs.dev]
+dependencies = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0.0",
+    "black>=23.0.0",
+    "isort>=5.12.0",
+    "fixture_foundry>=0.1.0",
+    ]
+
 [project.scripts]
 
 [tool.pytest.ini_options]

api_foundry_query_engine-0.8.10/api_foundry_query_engine/operation.py

@@ -1,59 +0,0 @@
-class Operation:
-    """
-    Represents an action to be performed on an entity.
-
-    The `Operation` class encapsulates the details required to execute an operation
-    on a given entity, including query parameters for selecting records, parameters
-    for storing or updating values, metadata for operational instructions, and
-    roles defining the contexts in which the operation can be performed.
-
-    Attributes:
-        entity (str): The name of the resource or object being targeted (e.g., "User", "Order").
-        action (str): The type of action being performed (e.g., "create", "read", "update", "delete").
-        query_params (dict): Parameters used to filter or select the records affected by the operation.
-        store_params (dict): Parameters that define the values to be stored or updated for the selected records.
-        metadata_params (dict): Additional instructions for the operation, such as sorting or pagination.
-        roles (dict): Defines the roles under which the operation is allowed to be performed.
-    """
-
-    def __init__(
-        self,
-        *,
-        entity: str,
-        action: str,
-        query_params: dict = {},
-        store_params: dict = {},
-        metadata_params: dict = {},
-        roles: dict = {},
-        subject: str = None,
-    ):
-        """
-        Initializes the Operation instance.
-
-        Args:
-            entity (str): The name of the entity to perform the operation on.
-            action (str): The action to perform on the entity.
-            query_params (dict, optional): Parameters for selecting affected records (default: {}).
-            store_params (dict, optional): Parameters defining new or updated values (default: {}).
-            metadata_params (dict, optional): Metadata for the operation, such as sorting or pagination (default: {}).
-            roles (dict, optional): Defines the roles allowed to perform the operation (default: {}).
-        """
-        # The target entity for the operation (e.g., "User", "Order").
-        self.entity = entity
-
-        # The type of action to perform (e.g., "create", "read", "update", "delete").
-        self.action = action
-
-        # Query parameters to filter or identify the affected records.
-        self.query_params = query_params
-
-        # Parameters defining the values to be stored or updated for the operation.
-        self.store_params = store_params
-
-        # Metadata for operational instructions like sorting, limiting, or offsetting results.
-        self.metadata_params = metadata_params
-
-        # Roles defining the context in which the operation is allowed.
-        self.roles = roles
-
-        self.subject = subject