api-foundry-query-engine 0.8.32__tar.gz → 0.8.34__tar.gz

{api_foundry_query_engine-0.8.32 → api_foundry_query_engine-0.8.34}/PKG-INFO

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

@@ -46,26 +46,7 @@ class GatewayAdapter(Adapter):
         method = str(event.get("httpMethod", "")).upper()
         action = actions_map.get(method, "read")
 
-        event_params = {}
-
-        path_parameters = self._convert_parameters(event.get("pathParameters"))
-        if path_parameters is not None:
-            event_params.update(path_parameters)
-
-        queryStringParameters = self._convert_parameters(
-            event.get("queryStringParameters")
-        )
-        if queryStringParameters is not None:
-            event_params.update(queryStringParameters)
-
-        query_params, metadata_params = self.split_params(event_params)
-
-        store_params = {}
-        body = event.get("body")
-        if body is not None and len(body) > 0:
-            store_params = json.loads(body)
-
-        # Extract JWT claims from API Gateway event
+        # Extract JWT claims early for batch operations
         claims = event.get("requestContext", {}).get("authorizer", {})
 
         # Handle different authorizer types
@@ -89,6 +70,37 @@ class GatewayAdapter(Adapter):
         else:
             # Non-dict authorizer context
             claims = {}
+
+        # Handle batch requests
+        if entity == "batch" and method == "POST":
+            body = event.get("body")
+            if body:
+                batch_request = json.loads(body)
+                return Operation(
+                    entity="batch",
+                    action="create",
+                    store_params=batch_request,
+                    claims=claims,
+                )
+
+        event_params = {}
+
+        path_parameters = self._convert_parameters(event.get("pathParameters"))
+        if path_parameters is not None:
+            event_params.update(path_parameters)
+
+        queryStringParameters = self._convert_parameters(
+            event.get("queryStringParameters")
+        )
+        if queryStringParameters is not None:
+            event_params.update(queryStringParameters)
+
+        query_params, metadata_params = self.split_params(event_params)
+
+        store_params = {}
+        body = event.get("body")
+        if body is not None and len(body) > 0:
+            store_params = json.loads(body)
         scope_str = claims.get("scope")
 
         # Enforce OAuth scopes (simulating API Gateway authorizer behavior)

{api_foundry_query_engine-0.8.32 → api_foundry_query_engine-0.8.34}/api_foundry_query_engine/connectors/postgres_connection.py

@@ -42,13 +42,25 @@ class PostgresCursor(Cursor):
             return result
         except IntegrityError as err:
             # Handle integrity constraint violation (e.g., duplicate key)
-            raise Exception(409, err.pgerror)
+            from api_foundry_query_engine.utils.app_exception import (
+                ApplicationException,
+            )
+
+            raise ApplicationException(409, err.pgerror)
         except ProgrammingError as err:
             # Handle programming errors (e.g., syntax error in SQL)
-            raise Exception(400, err.pgerror)
+            from api_foundry_query_engine.utils.app_exception import (
+                ApplicationException,
+            )
+
+            raise ApplicationException(400, err.pgerror)
         except Error as err:
             # Handle other database errors
-            raise Exception(500, err.pgerror)
+            from api_foundry_query_engine.utils.app_exception import (
+                ApplicationException,
+            )
+
+            raise ApplicationException(500, err.pgerror)
 
     def close(self):
         self.__cursor.close()
@@ -68,6 +80,9 @@ class PostgresConnection(Connection):
     def commit(self):
         self.__connection.commit()
 
+    def rollback(self):
+        self.__connection.rollback()
+
     def get_connection(self):
         """
         Get a connection to the PostgreSQL database.

api_foundry_query_engine-0.8.34/api_foundry_query_engine/dao/batch_operation_handler.py

@@ -0,0 +1,295 @@
+"""
+Batch Operation Handler
+
+Orchestrates execution of multiple operations with dependency resolution,
+reference substitution, and transaction management.
+"""
+
+from typing import Dict, Any, List, Optional
+from api_foundry_query_engine.operation import Operation
+from api_foundry_query_engine.dao.operation_dao import OperationDAO
+from api_foundry_query_engine.utils.dependency_resolver import DependencyResolver
+from api_foundry_query_engine.utils.reference_resolver import ReferenceResolver
+from api_foundry_query_engine.utils.app_exception import ApplicationException
+from api_foundry_query_engine.utils.logger import logger
+
+log = logger(__name__)
+
+
+class BatchOperationHandler:
+    """Handles execution of batch operations with dependencies."""
+
+    def __init__(self, batch_request: Dict[str, Any], connection, engine: str):
+        """
+        Initialize the batch operation handler.
+
+        Args:
+            batch_request: Batch request with 'operations' and 'options'
+            connection: Database connection for executing operations
+            engine: Database engine type (postgres, mysql, etc.)
+        """
+        self.operations = batch_request.get("operations", [])
+        self.options = batch_request.get("options", {})
+        self.connection = connection
+        self.engine = engine
+        self.results: Dict[str, Dict[str, Any]] = {}
+        self.failed_operations: List[str] = []
+
+        # Validate batch request
+        self._validate_batch_request()
+
+        # Resolve execution order
+        self.resolver = DependencyResolver(self.operations)
+        self.execution_order = self.resolver.get_execution_order()
+
+    def _validate_batch_request(self):
+        """Validate the batch request structure."""
+        if not self.operations:
+            raise ApplicationException(
+                400, "Batch request must contain at least one operation"
+            )
+
+        if len(self.operations) > 100:
+            raise ApplicationException(
+                400,
+                f"Batch size exceeds maximum (100). "
+                f"Requested: {len(self.operations)}",
+            )
+
+        # Auto-generate IDs for operations that don't have them
+        seen_ids = set()
+        for i, op in enumerate(self.operations):
+            # Auto-generate ID if not provided
+            if "id" not in op or not op["id"]:
+                op["id"] = f"op_{i}"
+
+            # Check for duplicate IDs
+            if op["id"] in seen_ids:
+                raise ApplicationException(
+                    400,
+                    f"Duplicate operation ID '{op['id']}' found",
+                )
+            seen_ids.add(op["id"])
+
+            # Validate required fields
+            if "entity" not in op:
+                raise ApplicationException(
+                    400,
+                    f"Operation '{op['id']}' missing required field 'entity'",
+                )
+            if "action" not in op:
+                raise ApplicationException(
+                    400,
+                    f"Operation '{op['id']}' missing required field 'action'",
+                )
+            if op["action"] not in ["create", "read", "update", "delete"]:
+                raise ApplicationException(
+                    400,
+                    f"Operation '{op['id']}' has invalid action " f"'{op['action']}'",
+                )
+
+    def execute(self) -> Dict[str, Any]:
+        """
+        Execute all operations in dependency order.
+
+        Returns:
+            Dictionary with 'success', 'results', and optionally 'errors'
+
+        Raises:
+            ApplicationException: On validation or execution errors
+        """
+        atomic = self.options.get("atomic", True)
+        continue_on_error = self.options.get("continueOnError", False)
+
+        log.info(
+            "Executing batch with %d operations (atomic=%s, continue=%s)",
+            len(self.operations),
+            atomic,
+            continue_on_error,
+        )
+
+        try:
+            for op_id in self.execution_order:
+                # Check if we should skip this operation
+                if self._should_skip_operation(op_id):
+                    self.results[op_id] = {
+                        "status": "skipped",
+                        "reason": "Dependency failed",
+                    }
+                    continue
+
+                # Execute the operation
+                try:
+                    result = self._execute_operation(op_id)
+                    # Unwrap single-item lists for easier reference access
+                    # e.g., $ref:op_0.invoice_id instead of $ref:op_0.0.invoice_id
+                    if isinstance(result, list) and len(result) == 1:
+                        result = result[0]
+                    self.results[op_id] = {"status": "completed", "data": result}
+                    log.info("Operation '%s' completed successfully", op_id)
+
+                except ApplicationException as e:
+                    log.error("Operation '%s' failed: %s", op_id, e.message)
+                    self.results[op_id] = {
+                        "status": "failed",
+                        "error": e.message,
+                        "statusCode": e.status_code,
+                    }
+                    self.failed_operations.append(op_id)
+
+                    # Rollback the failed transaction
+                    # In non-atomic mode, this allows next operation to proceed
+                    if not atomic:
+                        self.connection.rollback()
+                        log.info("Failed operation rolled back (non-atomic mode)")
+
+                    # Stop on error if not continuing
+                    if not continue_on_error:
+                        if atomic:
+                            self.connection.rollback()
+                            log.info("Transaction rolled back")
+                        raise ApplicationException(
+                            400,
+                            f"Batch failed at operation '{op_id}': {e.message}",
+                        ) from e
+
+                # Commit each operation if not atomic and it succeeded
+                if not atomic and op_id not in self.failed_operations:
+                    self.connection.commit()
+                    log.info("Operation '%s' committed (non-atomic mode)", op_id)
+
+            # Commit transaction if atomic and all succeeded
+            if atomic and not self.failed_operations:
+                self.connection.commit()
+                log.info("Batch transaction committed successfully")
+            elif atomic and self.failed_operations and continue_on_error:
+                self.connection.rollback()
+                log.info("Batch had failures, transaction rolled back")
+
+            # Build response
+            success = len(self.failed_operations) == 0
+            response = {"success": success, "results": self.results}
+
+            if self.failed_operations:
+                response["failedOperations"] = self.failed_operations
+
+            return response
+
+        except Exception as e:
+            # Rollback on any unexpected error
+            if atomic:
+                self.connection.rollback()
+                log.error("Batch failed, transaction rolled back")
+            raise e
+
+    def _should_skip_operation(self, op_id: str) -> bool:
+        """
+        Determine if operation should be skipped due to failed dependencies.
+
+        Args:
+            op_id: Operation ID to check
+
+        Returns:
+            True if operation should be skipped
+        """
+        op = next(o for o in self.operations if o["id"] == op_id)
+        depends_on = op.get("depends_on", [])
+
+        for dep_id in depends_on:
+            if dep_id in self.failed_operations:
+                log.info(
+                    "Skipping operation '%s' due to failed dependency '%s'",
+                    op_id,
+                    dep_id,
+                )
+                return True
+            if dep_id not in self.results:
+                log.warning(
+                    "Operation '%s' depends on '%s' which hasn't executed yet",
+                    op_id,
+                    dep_id,
+                )
+                return True
+            if self.results[dep_id].get("status") != "completed":
+                log.info(
+                    "Skipping operation '%s' due to incomplete dependency '%s'",
+                    op_id,
+                    dep_id,
+                )
+                return True
+
+        return False
+
+    def _execute_operation(self, op_id: str) -> Any:
+        """
+        Execute a single operation.
+
+        Args:
+            op_id: Operation ID to execute
+
+        Returns:
+            Operation result data
+
+        Raises:
+            ApplicationException: On execution error
+        """
+        # Get operation definition
+        op_def = next(o for o in self.operations if o["id"] == op_id)
+
+        # Resolve references in parameters
+        ref_resolver = ReferenceResolver(self.results)
+        query_params = ref_resolver.resolve_parameters(
+            op_def.get("query_params", {}), op_id
+        )
+        store_params = ref_resolver.resolve_parameters(
+            op_def.get("store_params", {}), op_id
+        )
+        metadata_params = ref_resolver.resolve_parameters(
+            op_def.get("metadata_params", {}), op_id
+        )
+
+        # Get claims from operation or use empty dict
+        claims = op_def.get("claims", {})
+
+        # Create Operation object
+        operation = Operation(
+            entity=op_def["entity"],
+            action=op_def["action"],
+            query_params=query_params,
+            store_params=store_params,
+            metadata_params=metadata_params,
+            claims=claims,
+        )
+
+        log.debug(
+            "Executing operation '%s': %s %s",
+            op_id,
+            operation.action,
+            operation.entity,
+        )
+
+        # Execute through OperationDAO
+        dao = OperationDAO(operation, self.engine)
+        result = dao.execute(self.connection)
+
+        return result
+
+    def get_operation_summary(self) -> Dict[str, int]:
+        """
+        Get summary statistics of batch execution.
+
+        Returns:
+            Dictionary with counts of completed, failed, skipped operations
+        """
+        summary = {"total": len(self.operations), "completed": 0, "failed": 0}
+
+        for op_result in self.results.values():
+            status = op_result.get("status")
+            if status == "completed":
+                summary["completed"] += 1
+            elif status == "failed":
+                summary["failed"] += 1
+            elif status == "skipped":
+                summary["skipped"] = summary.get("skipped", 0) + 1
+
+        return summary

{api_foundry_query_engine-0.8.32 → api_foundry_query_engine-0.8.34}/api_foundry_query_engine/dao/operation_dao.py

@@ -16,6 +16,9 @@ from api_foundry_query_engine.dao.sql_subselect_query_handler import (
 from api_foundry_query_engine.dao.sql_update_query_handler import (
     SQLUpdateSchemaQueryHandler,
 )
+from api_foundry_query_engine.dao.sql_restore_query_handler import (
+    SQLRestoreSchemaQueryHandler,
+)
 from api_foundry_query_engine.utils.app_exception import ApplicationException
 from api_foundry_query_engine.dao.dao import DAO
 from api_foundry_query_engine.connectors.connection import Cursor
@@ -80,6 +83,10 @@ class OperationDAO(DAO):
                 self._query_handler = SQLDeleteSchemaQueryHandler(
                     self.operation, schema_object, self.engine
                 )
+            elif self.operation.action == "restore":
+                self._query_handler = SQLRestoreSchemaQueryHandler(
+                    self.operation, schema_object, self.engine
+                )
             else:
                 raise ApplicationException(
                     400, f"Invalid operation action: {self.operation.action}"
@@ -101,6 +108,21 @@ class OperationDAO(DAO):
 
         # Use self.operation if operation is not provided
         op = operation if operation is not None else self.operation
+
+        # Check if this is a batch operation
+        if op.entity == "batch" and op.action == "create":
+            from api_foundry_query_engine.dao.batch_operation_handler import (
+                BatchOperationHandler,
+            )
+
+            # Extract batch request from store_params
+            batch_request = op.store_params
+
+            # Execute batch
+            handler = BatchOperationHandler(batch_request, connector, self.engine)
+            return handler.execute()
+
+        # Standard operation handling
         # Assume connector has a 'cursor()' method to get a Cursor
         cursor = connector.cursor()
 
@@ -110,7 +132,7 @@ class OperationDAO(DAO):
             if op.metadata_params.get("count", False):
                 return result[0]
             self.__fetch_many(result, cursor)
-        elif op.action in ["update", "delete"] and len(result) == 0:
+        elif op.action in ["update", "delete", "restore"] and len(result) == 0:
             raise ApplicationException(400, "No records were modified")
 
         return result

{api_foundry_query_engine-0.8.32 → api_foundry_query_engine-0.8.34}/api_foundry_query_engine/dao/sql_delete_query_handler.py

@@ -56,6 +56,56 @@ class SQLDeleteSchemaQueryHandler(SQLSchemaQueryHandler):
 
         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():
@@ -81,7 +131,16 @@ class SQLDeleteSchemaQueryHandler(SQLSchemaQueryHandler):
                     + f"property: {concurrency_property.api_name}",
                 )
 
-        return (
-            f"DELETE FROM {self.table_expression}{self.search_condition} "
-            + f"RETURNING {self.select_list}"
-        )
+        # 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-0.8.32 → api_foundry_query_engine-0.8.34}/api_foundry_query_engine/dao/sql_insert_query_handler.py

@@ -82,6 +82,15 @@ class SQLInsertSchemaQueryHandler(SQLSchemaQueryHandler):
 
         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(".")
 
@@ -115,6 +124,25 @@ class SQLInsertSchemaQueryHandler(SQLSchemaQueryHandler):
                     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)