api-foundry-query-engine 0.8.39__py3-none-any.whl

api_foundry_query_engine/dao/sql_custom_query_handler.py

@@ -0,0 +1,68 @@
+from typing import List, Dict
+import re
+
+from api_foundry_query_engine.dao.sql_query_handler import SQLQueryHandler
+from api_foundry_query_engine.utils.api_model import SchemaObjectProperty, PathOperation
+from api_foundry_query_engine.operation import Operation
+from api_foundry_query_engine.utils.app_exception import ApplicationException
+from api_foundry_query_engine.utils.logger import logger
+
+log = logger(__name__)
+
+
+class SQLCustomQueryHandler(SQLQueryHandler):
+    def __init__(
+        self, operation: Operation, path_operation: PathOperation, engine: str
+    ) -> None:
+        super().__init__(operation, engine)
+        self.path_operation = path_operation
+
+    @property
+    def sql(self) -> str:
+        if not hasattr(self, "_sql"):
+            self._compile()
+        return self._sql
+
+    @property
+    def placeholders(self) -> Dict[str, SchemaObjectProperty]:
+        if not hasattr(self, "_placeholders"):
+            self._compile()
+        return self._placeholders
+
+    @property
+    def select_list_columns(self) -> List[str]:
+        raise NotImplementedError()
+
+    @property
+    def selection_results(self) -> Dict:
+        if not hasattr(self, "_selection_results"):
+            self._selection_results = self.check_permissions(
+                "read", self.path_operation.permissions, self.path_operation.outputs
+            )
+            log.debug("selection_results: %s", self._selection_results)
+        return self._selection_results
+
+    def _compile(self):
+        placeholder_pattern = re.compile(r":(\w+)")
+        self._placeholders = dict()
+        result_sql = placeholder_pattern.sub(
+            self._get_placeholder_text, self.path_operation.sql
+        )
+        self._sql = re.sub(r"\s+", " ", result_sql).strip()
+
+    def _get_placeholder_text(self, match) -> str:
+        placeholder_name = match.group(1)
+        property = self.path_operation.inputs.get(placeholder_name)
+        if not property:
+            raise ApplicationException(
+                500,
+                f"Input parameter not defined for the placeholder: {placeholder_name}",
+            )
+
+        value = (
+            self.operation.query_params[placeholder_name]
+            if placeholder_name in self.operation.query_params
+            else property.default
+        )
+        self._placeholders.update(self.generate_placeholders(property, value))
+        return self.placeholder(property, placeholder_name)

api_foundry_query_engine/dao/sql_delete_query_handler.py

@@ -0,0 +1,146 @@
+from api_foundry_query_engine.dao.sql_query_handler import SQLSchemaQueryHandler
+from api_foundry_query_engine.operation import Operation
+from api_foundry_query_engine.utils.app_exception import ApplicationException
+from api_foundry_query_engine.utils.api_model import SchemaObject
+from api_foundry_query_engine.utils.logger import logger
+
+log = logger(__name__)
+
+
+class SQLDeleteSchemaQueryHandler(SQLSchemaQueryHandler):
+    def __init__(
+        self, operation: Operation, schema_object: SchemaObject, engine: str
+    ) -> None:
+        super().__init__(operation, schema_object, engine)
+
+    def check_permission(self) -> bool:
+        """
+        Checks the user's permissions for the specified permission type.
+
+        Args:
+            permission_type (str): The type of permission to check ("read" or "write").
+            properties (List[str], optional): Specific properties to check. If None,
+                all schema properties are checked.
+
+        Returns:
+            List[str]: A list of properties the user is permitted to access.
+        """
+        # if permissions are not defined then no restrictions are applied
+        if not self.schema_object.permissions:
+            return True
+
+        # Use the proper provider-action-role structure
+        provider_permissions = self.schema_object.permissions.get("default", {})
+        delete_permissions = provider_permissions.get("delete", {})
+
+        for role in self.operation.roles:
+            role_permissions = delete_permissions.get(role)
+            log.info("role: %s, role_permissions: %s", role, role_permissions)
+
+            # If no permissions found for role, check wildcard "*"
+            if role_permissions is None:
+                role_permissions = delete_permissions.get("*")
+                log.info("Fallback to wildcard role '*': %s", role_permissions)
+                if role_permissions is None:
+                    continue
+
+            # Handle both boolean and object permission formats
+            if isinstance(role_permissions, bool):
+                allowed = role_permissions
+            else:
+                # For complex permission objects, existence means allowed
+                allowed = True
+
+            if allowed:
+                return True
+
+        return False
+
+    def _has_soft_delete_fields(self) -> bool:
+        """Check if schema object supports soft delete."""
+        return self.schema_object.has_soft_delete_support()
+
+    def _get_soft_delete_update_values(self) -> str:
+        """Generate SET clause for soft delete operation."""
+        self.store_placeholders = {}
+        columns = []
+
+        # Process soft delete properties
+        soft_delete_props = self.schema_object.get_soft_delete_properties()
+
+        for _, prop in soft_delete_props.items():
+            strategy = prop.get_soft_delete_strategy()
+            config = prop.get_soft_delete_config()
+            column_name = prop.column_name
+
+            if strategy == "null_check":
+                # Set timestamp fields to CURRENT_TIMESTAMP
+                if prop.api_type in ["date-time", "datetime"]:
+                    columns.append(f"{column_name} = CURRENT_TIMESTAMP")
+                else:
+                    columns.append(f"{column_name} = 'deleted'")
+            elif strategy == "boolean_flag":
+                inactive_value = not config.get("active_value", True)
+                value_str = str(inactive_value).lower()
+                columns.append(f"{column_name} = {value_str}")
+            elif strategy == "exclude_values":
+                delete_value = config.get("delete_value")
+                if delete_value:
+                    if isinstance(delete_value, str):
+                        columns.append(f"{column_name} = '{delete_value}'")
+                    else:
+                        columns.append(f"{column_name} = {delete_value}")
+
+        # Process audit fields
+        audit_props = self.schema_object.get_soft_delete_audit_properties()
+        claims = self.operation.claims or {}
+
+        for _, prop in audit_props.items():
+            config = prop.get_soft_delete_config()
+            action = config.get("action", "")
+
+            if action == "delete" and "sub" in claims:
+                placeholder_key = f"audit_{prop.api_name}"
+                columns.append(f"{prop.column_name} = %({placeholder_key})s")
+                self.store_placeholders[placeholder_key] = claims["sub"]
+
+        return " SET " + ", ".join(columns) if columns else ""
+
+    @property
+    def sql(self) -> str:
+        if not self.check_permission():
+            raise ApplicationException(
+                403, f"Subject is not allowed to delete {self.schema_object.api_name}"
+            )
+
+        concurrency_property = self.schema_object.concurrency_property
+        if concurrency_property:
+            if not self.operation.query_params.get(concurrency_property.api_name):
+                raise ApplicationException(
+                    400,
+                    "Missing required concurrency management property.  "
+                    + f"schema_object: {self.schema_object.api_name}, "
+                    + f"property: {concurrency_property.api_name}",
+                )
+            if self.operation.store_params.get(concurrency_property.api_name):
+                raise ApplicationException(
+                    400,
+                    "For updating concurrency managed schema objects the current "
+                    + "version may not be supplied as a storage parameter.  "
+                    + f"schema_object: {self.schema_object.api_name}, "
+                    + f"property: {concurrency_property.api_name}",
+                )
+
+        # Use soft delete if supported, otherwise hard delete
+        if self._has_soft_delete_fields():
+            update_clause = self._get_soft_delete_update_values()
+            return (
+                f"UPDATE {self.table_expression}{update_clause}"
+                + f"{self.search_condition} RETURNING {self.select_list}"
+            )
+        else:
+            # Fall back to hard delete for tables without soft delete support
+            return (
+                f"DELETE FROM {self.table_expression}{self.search_condition} "
+                + f"RETURNING {self.select_list}"
+            )

api_foundry_query_engine/dao/sql_insert_query_handler.py

@@ -0,0 +1,187 @@
+from typing import Optional
+from api_foundry_query_engine.dao.sql_query_handler import SQLSchemaQueryHandler
+from api_foundry_query_engine.operation import Operation
+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__)
+
+
+class SQLInsertSchemaQueryHandler(SQLSchemaQueryHandler):
+    key_property: Optional[SchemaObjectProperty]
+
+    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:
+            if self.key_property.key_type == "auto":
+                if operation.store_params.get(self.key_property.column_name):
+                    raise ApplicationException(
+                        400,
+                        "Primary key values cannot be inserted when key type"
+                        + f" is auto. schema_object: {schema_object.api_name}",
+                    )
+            elif self.key_property.key_type == "required":
+                if not operation.store_params.get(self.key_property.column_name):
+                    raise ApplicationException(
+                        400,
+                        "Primary key values must be provided when key type is"
+                        + 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
+        ):
+            raise ApplicationException(
+                400,
+                "Versioned properties can not be supplied a store parameters. "
+                + f"schema_object: {schema_object.api_name}, "
+                + f"property: {self.concurrency_property.api_name}",
+            )
+
+    @property
+    def sql(self) -> str:
+        self.concurrency_property = self.schema_object.concurrency_property
+        # Get columns to return - use read permissions if available,
+        # otherwise fall back to primary key
+        returning_clause = self._get_returning_clause()
+        
+        if not self.concurrency_property:
+            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(
+                400,
+                "When inserting schema objects with a version property "
+                + "the a version must not be supplied as a storage parameter."
+                + 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
+        )
+
+    def _get_returning_clause(self) -> str:
+        """
+        Get RETURNING clause with fallback to primary key
+        if no read permissions.
+        """
+        try:
+            select_list = self.select_list
+            if select_list:
+                return f"RETURNING {select_list}"
+        except ApplicationException:
+            # If read permissions filter everything,
+            # return at least the primary key
+            pass
+        
+        # Fallback to primary key
+        pk_property = self.schema_object.primary_key
+        if pk_property:
+            return f"RETURNING {pk_property.column_name}"
+        
+        # Last resort - return nothing
+        # (should never happen with properly defined schemas)
+        return ""
+
+    @property
+    def insert_values(self) -> str:
+        self.store_placeholders = {}
+        placeholders = []
+        columns = []
+
+        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
+        }
+        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:
+                raise ApplicationException(
+                    403,
+                    f"Property '{property_name}' is auto-injected and "
+                    + "cannot be set manually",
+                )
+
+        for name, value in self.operation.store_params.items():
+            parts = name.split(".")
+
+            if len(parts) > 1:
+                raise ApplicationException(
+                    400,
+                    "Properties can not be set on associated objects " + name,
+                )
+
+            property = allowed_properties.get(parts[0], None)
+            if property is None:
+                if parts[0] not in self.schema_object.properties:
+                    raise ApplicationException(400, f"Invalid property: {name}")
+                else:
+                    raise ApplicationException(
+                        403,
+                        f"Subject is not allowed to create with property: {parts[0]}",
+                    )
+
+            columns.append(property.column_name)
+            if property.api_name is None:
+                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)
+
+        # 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}'",
+                    )
+
+        if self.key_property:
+            if self.key_property.key_type == "sequence":
+                columns.append(self.key_property.column_name)
+                placeholders.append(f"nextval('{self.key_property.sequence_name}')")
+
+        if self.concurrency_property:
+            columns.append(self.concurrency_property.column_name)
+            if self.concurrency_property.column_type == "integer":
+                placeholders.append("1")
+            else:
+                placeholders.append(
+                    self.concurrency_generator(self.concurrency_property)
+                )
+
+        return f" ( {', '.join(columns)} ) VALUES ( {', '.join(placeholders)})"