api-foundry-query-engine 0.8.12__tar.gz → 0.8.30__tar.gz

{api_foundry_query_engine-0.8.12 → api_foundry_query_engine-0.8.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: api-foundry-query-engine
-Version: 0.8.12
+Version: 0.8.30
 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.12 → api_foundry_query_engine-0.8.30}/api_foundry_query_engine/adapters/gateway_adapter.py

@@ -67,10 +67,36 @@ class GatewayAdapter(Adapter):
 
         authorizer_info = event.get("requestContext", {}).get("authorizer", {})
         claims = authorizer_info.get("claims", {})
-        roles = claims.get("roles", [])
-        groups = claims.get("groups", [])
+
+        # Decode JSON-encoded arrays from OAuth context
+        roles_raw = claims.get("roles", [])
+        if isinstance(roles_raw, str):
+            try:
+                roles = json.loads(roles_raw)
+            except (json.JSONDecodeError, TypeError):
+                roles = []
+        else:
+            roles = roles_raw if isinstance(roles_raw, list) else []
+
+        groups_raw = claims.get("groups", [])
+        if isinstance(groups_raw, str):
+            try:
+                groups = json.loads(groups_raw)
+            except (json.JSONDecodeError, TypeError):
+                groups = []
+        else:
+            groups = groups_raw if isinstance(groups_raw, list) else []
+
+        permissions_raw = claims.get("permissions", [])
+        if isinstance(permissions_raw, str):
+            try:
+                permissions = json.loads(permissions_raw)
+            except (json.JSONDecodeError, TypeError):
+                permissions = []
+        else:
+            permissions = permissions_raw if isinstance(permissions_raw, list) else []
+
         subject = claims.get("sub")
-        permissions = claims.get("permissions", [])
         scope_str = claims.get("scope")
 
         # Enforce OAuth scopes (simulating API Gateway authorizer behavior)

{api_foundry_query_engine-0.8.12 → api_foundry_query_engine-0.8.30}/api_foundry_query_engine/dao/sql_query_handler.py

@@ -193,20 +193,43 @@ class SQLQueryHandler:
             log.info(f"role: {role}, role_permissions: {role_permissions}")
             if len(role_permissions) == 0:
                 continue
+
+            # Extract permission patterns for this role
+            read_perm = role_permissions.get("read", "")
+            write_perm = role_permissions.get("write", "")
+            read_pattern = self._extract_permission_pattern(read_perm)
+            write_pattern = self._extract_permission_pattern(write_perm)
+
             for prop_name, property in properties.items():
                 log.info(f"prop_name: {prop_name}, property: {property}")
-                if permission_type == "read" and re.match(
-                    role_permissions.get("read", ""), prop_name
-                ):
+                if permission_type == "read" and re.match(read_pattern, prop_name):
                     allowed_properties[prop_name] = property
-                if permission_type == "write" and re.match(
-                    role_permissions.get("write", ""), prop_name
-                ):
+                if permission_type == "write" and re.match(write_pattern, prop_name):
                     allowed_properties[prop_name] = property
 
         log.info(f"allowed_properties: {allowed_properties}")
         return allowed_properties
 
+    def _extract_permission_pattern(self, permission_rule) -> str:
+        """Extract the regex pattern from a permission rule.
+
+        Args:
+            permission_rule: Can be a string (regex) or dict with
+                'properties'/'fields' key
+
+        Returns:
+            str: The regex pattern to match property names
+        """
+        if isinstance(permission_rule, str):
+            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", ""
+            )
+        else:
+            return ""
+
     @property
     def selection_results(self) -> Dict:
         raise NotImplementedError()

{api_foundry_query_engine-0.8.12 → api_foundry_query_engine-0.8.30}/api_foundry_query_engine/dao/sql_select_query_handler.py

@@ -33,20 +33,34 @@ class SQLSelectSchemaQueryHandler(SQLSchemaQueryHandler):
         if "default" in perms:
             provider = perms.get("default", {}) or {}
             read_map = provider.get("read", {}) or {}
+            role_permissions = perms.get("default", {})
         else:
             # legacy role-first -> synthesize read map
             read_map = {}
+            role_permissions = perms
             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 []:
+            # Check for role-level WHERE clause (hybrid approach)
+            role_where = None
+            if isinstance(role_permissions.get(role), dict):
+                role_where = role_permissions[role].get("where")
+
+            # Check for operation-level WHERE clause
+            operation_where = None
             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))
+                operation_where = rule.get("where")
+
+            # Operation-level takes precedence, fallback to role-level
+            where_clause = operation_where if operation_where else role_where
+
+            if isinstance(where_clause, str) and where_clause.strip():
+                filters.append(self._template_where(where_clause))
+
         if not filters:
             return ""
         return "(" + ") OR (".join(filters) + ")"

{api_foundry_query_engine-0.8.12 → api_foundry_query_engine-0.8.30}/api_foundry_query_engine/operation.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 
 class Operation:
@@ -35,10 +35,10 @@ class Operation:
         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,
+        roles: Optional[List[str]] = None,
         scope: Optional[Dict[str, Any]] = None,
-        groups: Optional[Dict[str, Any]] = None,
-        permissions: Optional[Dict[str, Any]] = None,
+        groups: Optional[List[str]] = None,
+        permissions: Optional[List[str]] = None,
         subject: Optional[str] = None,
         claims: Optional[Dict[str, Any]] = None,
     ):

{api_foundry_query_engine-0.8.12 → api_foundry_query_engine-0.8.30}/api_foundry_query_engine/utils/api_model.py

@@ -49,38 +49,117 @@ class SchemaObjectProperty:
     def convert_to_db_value(self, value: str) -> Optional[Any]:
         if value is None:
             return None
-        conversion_mapping = {
-            "string": lambda x: x,
-            "number": float,
-            "float": float,
-            "integer": int,
-            "boolean": lambda x: x.lower() == "true",
-            "date": lambda x: datetime.strptime(x, "%Y-%m-%d").date() if x else None,
-            "date-time": lambda x: datetime.fromisoformat(x) if x else None,
-            "time": lambda x: datetime.strptime(x, "%H:%M:%S").time() if x else None,
-        }
-        conversion_func = conversion_mapping.get(
-            self.column_type if self.column_type is not None else "string", lambda x: x
-        )
-        return conversion_func(value)
+
+        column_type = self.column_type if self.column_type is not None else "string"
+
+        # Handle string types
+        if column_type in ["string", "varchar", "char", "text", "uuid"]:
+            return value
+
+        # Handle numeric types - float/double/numeric variations
+        elif column_type in ["number", "float", "double", "numeric", "decimal", "real"]:
+            return float(value)
+
+        # Handle boolean types - can map to boolean or integer columns
+        elif column_type == "boolean":
+            return value.lower() == "true"
+        elif (
+            column_type in ["int", "integer", "smallint", "bigint"]
+            and hasattr(self, "api_type")
+            and self.api_type == "boolean"
+        ):
+            # Boolean API type mapping to integer column type
+            return 1 if value.lower() == "true" else 0
+
+        # Handle integer types (after boolean check to avoid conflicts)
+        elif column_type in [
+            "integer",
+            "int",
+            "bigint",
+            "smallint",
+            "serial",
+            "bigserial",
+        ]:
+            return int(value)
+
+        # Handle date types
+        elif column_type == "date":
+            return datetime.strptime(value, "%Y-%m-%d").date() if value else None
+
+        # Handle datetime types - various column type names
+        elif column_type in ["date-time", "datetime", "timestamp", "timestamptz"]:
+            return datetime.fromisoformat(value) if value else None
+
+        # Handle time types
+        elif column_type in ["time", "timetz"]:
+            return datetime.strptime(value, "%H:%M:%S").time() if value else None
+
+        # Default to string conversion for unknown types
+        else:
+            return value
 
     def convert_to_api_value(self, value) -> Optional[Any]:
         if value is None:
             return None
-        conversion_mapping = {
-            "string": lambda x: x,
-            "number": float,
-            "float": float,
-            "integer": int,
-            "boolean": str,
-            "date": lambda x: x.date().isoformat() if x else None,
-            "date-time": lambda x: x.isoformat() if x else None,
-            "time": lambda x: x.time().isoformat() if x else None,
-        }
-        conversion_func = conversion_mapping.get(
-            self.api_type if self.api_type is not None else "string", lambda x: x
-        )
-        return conversion_func(value)
+
+        api_type = self.api_type if self.api_type is not None else "string"
+
+        # Handle string types (including UUID which is represented as string in API)
+        if api_type in ["string", "uuid"]:
+            return str(value) if value is not None else None
+
+        # Handle integer type
+        elif api_type == "integer":
+            return int(value) if value is not None else None
+
+        # Handle number and float types
+        elif api_type in ["number", "float"]:
+            return float(value) if value is not None else None
+
+        # Handle boolean type - convert any value to string representation
+        elif api_type == "boolean":
+            if isinstance(value, bool):
+                return str(value)
+            elif isinstance(value, int):
+                # Handle boolean stored as integer (0/1)
+                return "true" if value != 0 else "false"
+            elif isinstance(value, str):
+                return value.lower() in ["true", "1", "yes", "on"]
+            else:
+                return str(bool(value))
+
+        # Handle date type
+        elif api_type == "date":
+            if hasattr(value, "date"):
+                # If it's a datetime, extract the date part
+                return value.date().isoformat()
+            elif hasattr(value, "isoformat"):
+                # If it's already a date
+                return value.isoformat()
+            else:
+                return str(value)
+
+        # Handle datetime type
+        elif api_type == "date-time":
+            if hasattr(value, "isoformat"):
+                return value.isoformat()
+            else:
+                return str(value)
+
+        # Handle time type
+        elif api_type == "time":
+            if hasattr(value, "time"):
+                # If it's a datetime, extract the time part
+                return value.time().isoformat()
+            elif hasattr(value, "isoformat"):
+                # If it's already a time
+                return value.isoformat()
+            else:
+                return str(value)
+
+        # Default to string conversion for unknown types
+        else:
+            return str(value) if value is not None else None
 
 
 class SchemaObjectAssociation:

{api_foundry_query_engine-0.8.12 → api_foundry_query_engine-0.8.30}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "api-foundry-query-engine"
-version = "0.8.12"
+version = "0.8.30"
 authors = [
     { name="Daniel Repik", email="danrepik@icloud.com" },
 ]