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

api_foundry_query_engine/.pre-commit-config.yaml

@@ -0,0 +1,22 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v3.4.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+
+  - repo: https://github.com/psf/black
+    rev: 23.12.1
+    hooks:
+    -   id: black
+        language_version: python3.11
+
+  - repo: https://github.com/PyCQA/flake8
+    rev: 7.0.0
+    hooks:
+      - id: flake8
+        args: [--max-line-length=120]
+
+exclude: '^$'

api_foundry_query_engine/__init__.py

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

api_foundry_query_engine/adapters/adapter.py

@@ -0,0 +1,73 @@
+import abc
+from typing import Mapping, Optional
+
+from api_foundry_query_engine.operation import Operation
+from api_foundry_query_engine.services.transactional_service import TransactionalService
+from api_foundry_query_engine.utils.logger import logger
+from api_foundry_query_engine.services.service import Service
+
+log = logger(__name__)
+
+
+class Adapter(metaclass=abc.ABCMeta):
+    service: Service
+    config: Mapping[str, str]
+
+    @classmethod
+    def __subclasshook__(cls, __subclass: type) -> bool:
+        return (
+            hasattr(__subclass, "marshal")
+            and callable(__subclass.marshal)
+            and hasattr(__subclass, "umarshal")
+            and callable(__subclass.unmarshal)
+        )
+
+    def __init__(
+        self, config: Mapping[str, str] = {}, service: Optional[Service] = None
+    ) -> None:
+        self.config = config
+        self.service = (
+            service if service is not None else TransactionalService(config=self.config)
+        )
+
+    def unmarshal(self, event) -> Operation:
+        """
+        Unmarshal the event in a tuple for processing
+
+        Parameters:
+        - event (dict): Lambda event object.
+
+        Returns:
+        - Operation containing the entity, action, and parameters
+        """
+        raise NotImplementedError
+
+    def marshal(self, result: list[dict]):
+        """
+        Marshal the result into a event response
+
+        Parameters:
+        - result (list): the data set to return in the response
+
+        Returns:
+        - the event response
+        """
+        return result
+
+    def process_event(self, event):
+        """
+        Process Lambda event using a domain function.
+
+        Parameters:
+        - service_function (callable): The service function to be executed.
+        - event (dict): Lambda event object.
+
+        Returns:
+        - any: Result of the domain function.
+        """
+        operation = self.unmarshal(event)
+
+        result = self.service.execute(operation)
+        log.debug("adapter result: %s", result)
+
+        return self.marshal(result)

api_foundry_query_engine/adapters/case_change_adapter.py

@@ -0,0 +1,79 @@
+from humps import camelize, decamelize
+
+from api_foundry_query_engine.adapters.adapter import Adapter
+from api_foundry_query_engine.utils.logger import logger
+from api_foundry_query_engine.operation import Operation
+
+log = logger(__name__)
+
+
+class CaseChangeAdapter(Adapter):
+    """
+    Handles changing case from snake to camel and back
+    """
+
+    def unmarshal(self, event) -> Operation:
+        """
+        Unmarshal the event in a tuple for processing
+
+        Parameters:
+        - event (dict): Lambda event object.
+
+        Returns:
+        - tuple: Tuple containing entity operation, store_params, query_params and metadata params.
+        """
+        operation = super().unmarshal(event)
+
+        # determine case
+        self.camel_case = (
+            operation.metadata_params.get("_case", "snake") == "camel"
+            or self.__check_camel_case(operation.store_params)
+            or self.__check_camel_case(operation.query_params)
+        )
+        log.info("camel_case: %s", self.camel_case)
+
+        if self.camel_case:
+            return Operation(
+                path=operation.entity,
+                action=operation.action,
+                store_params=decamelize(operation.store_params),
+                query_params=decamelize(operation.query_params),
+                metadata_params=operation.metadata_params,
+            )
+
+        return operation
+
+    def marshal(self, result: list[dict]):
+        """
+        Marshal the result into a event response
+
+        Parameters:
+        - result (list): the data set to return in the response
+
+        Returns:
+        - the event response
+        """
+        super().marshal(result)
+
+        if not self.camel_case:
+            return result
+
+        converted_result = []
+        for item in result:
+            converted_result.append(camelize(item))
+
+        # convert back to camel case if needed
+        return converted_result
+
+    def __check_camel_case(self, params: dict) -> bool:
+        if params is not None:
+            # check the keys for an upper case character
+            for param in params:
+                if (
+                    param != param.lower()
+                    and param != param.upper()
+                    and "_" not in param
+                ):
+                    return True
+
+        return False

api_foundry_query_engine/adapters/gateway_adapter.py

@@ -0,0 +1,191 @@
+import json
+from typing import Any, Dict, List, Optional, Tuple
+
+from api_foundry_query_engine.adapters.adapter import Adapter
+from api_foundry_query_engine.operation import Operation
+from api_foundry_query_engine.utils.app_exception import ApplicationException
+
+actions_map = {
+    "GET": "read",
+    "POST": "create",
+    "PUT": "update",
+    "DELETE": "delete",
+}
+
+
+class GatewayAdapter(Adapter):
+    def marshal(self, result: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """
+        Marshal the result into a event response
+
+        Parameters:
+        - result (list): the data set to return in the response
+
+        Returns:
+        - the event response
+        """
+        return super().marshal(result)
+
+    def unmarshal(self, event: Dict[str, Any]) -> Operation:
+        """
+        Get parameters from the Lambda event.
+
+        Parameters:
+        - event (dict): Lambda event object.
+
+        Returns:
+        - tuple: Tuple containing data, query and metadata parameters.
+        """
+        resource = event.get("resource")
+        if resource is not None and "/" in resource:
+            parts = resource.split("/")
+            entity = parts[1] if len(parts) > 1 else None
+        else:
+            entity = None
+
+        method = str(event.get("httpMethod", "")).upper()
+        action = actions_map.get(method, "read")
+
+        # Extract JWT claims early for batch operations
+        claims = event.get("requestContext", {}).get("authorizer", {})
+
+        # Handle different authorizer types
+        if isinstance(claims, dict):
+            # TOKEN authorizer puts claims directly in authorizer object
+            if "sub" in claims or "iss" in claims:
+                # Already have JWT claims at top level
+                pass
+            elif "claims" in claims:
+                # Some configurations nest claims
+                claims = claims["claims"]
+            elif "iam" in claims:
+                # IAM authorizer fallback
+                claims = claims["iam"]
+            elif "lambda" in claims:
+                # Lambda authorizer fallback
+                claims = claims["lambda"]
+            else:
+                # Empty or unknown format
+                claims = {}
+        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)
+        # Required scope pattern: read|write|delete:<entity>
+        if entity and scope_str:
+            required_action = {
+                "GET": "read",
+                "POST": "write",
+                "PUT": "write",
+                "PATCH": "write",
+                "DELETE": "delete",
+            }.get(method, "read")
+            required_scope = f"{required_action}:{entity}"
+            token_scopes = set(str(scope_str).split())
+
+            def _has_scope(required: str) -> bool:
+                return (
+                    required in token_scopes
+                    or f"{required_action}:*" in token_scopes
+                    or "*" in token_scopes
+                    or "*:*" in token_scopes
+                )
+
+            if not _has_scope(required_scope):
+                raise ApplicationException(
+                    401,
+                    ("insufficient_scope: required_scope=" + required_scope),
+                )
+
+        return Operation(
+            entity=entity,
+            action=action,
+            store_params=store_params,
+            query_params=query_params,
+            metadata_params=metadata_params,
+            claims=claims,
+        )
+
+    def _convert_parameters(
+        self, parameters: Optional[Dict[str, Any]]
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Convert parameters to appropriate types.
+
+        Parameters:
+        - parameters (dict): Dictionary of parameters.
+
+        Returns:
+        - dict: Dictionary with parameters converted to appropriate types.
+        """
+        if parameters is None:
+            return None
+
+        result = {}
+        for parameter, value in parameters.items():
+            try:
+                result[parameter] = int(value)
+            except ValueError:
+                try:
+                    result[parameter] = float(value)
+                except ValueError:
+                    result[parameter] = value
+        return result
+
+    def split_params(
+        self, parameters: Dict[str, Any]
+    ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """
+        Split a dictionary into two dictionaries based on keys.
+
+        Parameters:
+        - dictionary (dict): Input dictionary.
+
+        Returns:
+        - tuple: A tuple containing two dictionaries.
+                The first dictionary contains metadata_params,
+                and the second dictionary query_params.
+        """
+        query_params = {}
+        metadata_params = {}
+
+        for key, value in parameters.items():
+            if key.startswith("__"):
+                metadata_params[key] = value
+            else:
+                query_params[key] = value
+
+        return query_params, metadata_params

api_foundry_query_engine/adapters/security_adapter.py

@@ -0,0 +1,106 @@
+from typing import Optional
+
+from api_foundry_query_engine.operation import Operation
+from api_foundry_query_engine.services.service import Service
+from api_foundry_query_engine.adapters.adapter import Adapter
+from api_foundry_query_engine.utils.logger import logger
+
+log = logger(__name__)
+
+
+class SecurityAdapter(Adapter):
+    def __init__(self, service: Optional[Service] = None, permissions: dict = None):
+        """
+        Initialize SecurityAdapter with a service and permissions.
+
+        Parameters:
+        - service (Service): The service used to process operations.
+        - permissions (dict): A dictionary containing the user's permissions,
+                              structured as:
+                              {
+                                  "read": ["field1", "field2", ...],
+                                  "write": ["field3", "field4", ...]
+                              }
+        """
+        super().__init__(service)
+        self.permissions = permissions or {"read": [], "write": []}
+
+    def unmarshal(self, event) -> Operation:
+        """
+        Unmarshal the event into an Operation object after validating query and store params.
+
+        Parameters:
+        - event (dict): Lambda event object.
+
+        Returns:
+        - Operation: The validated operation.
+        """
+        entity = event.get("entity")
+        action = event.get("action")
+        query_params = event.get("query_params", {})
+        store_params = event.get("store_params", {})
+
+        # Validate read permissions for query_params
+        invalid_query_params = [
+            key for key in query_params if key not in self.permissions["read"]
+        ]
+        if invalid_query_params:
+            raise PermissionError(
+                f"Query parameters not permitted: {invalid_query_params}"
+            )
+
+        # Validate write permissions for store_params
+        invalid_store_params = [
+            key for key in store_params if key not in self.permissions["write"]
+        ]
+        if invalid_store_params:
+            raise PermissionError(
+                f"Store parameters not permitted: {invalid_store_params}"
+            )
+
+        return Operation(
+            entity=entity,
+            action=action,
+            query_params=query_params,
+            store_params=store_params,
+        )
+
+    def marshal(self, result: list[dict]):
+        """
+        Filter the result based on read permissions before returning.
+
+        Parameters:
+        - result (list[dict]): The data set to return in the response.
+
+        Returns:
+        - list[dict]: Filtered response with only permitted fields.
+        """
+        filtered_result = []
+        for record in result:
+            filtered_record = {
+                key: value
+                for key, value in record.items()
+                if key in self.permissions["read"]
+            }
+            filtered_result.append(filtered_record)
+
+        return filtered_result
+
+    def process_event(self, event):
+        """
+        Process Lambda event using a domain function.
+
+        Parameters:
+        - event (dict): Lambda event object.
+
+        Returns:
+        - any: Result of the domain function.
+        """
+        try:
+            operation = self.unmarshal(event)
+            result = self.service.execute(operation)
+            log.debug("adapter result: %s", result)
+            return self.marshal(result)
+        except PermissionError as e:
+            log.error("Permission error: %s", e)
+            return {"error": str(e), "status": "permission_denied"}

api_foundry_query_engine/connectors/connection.py

@@ -0,0 +1,32 @@
+from api_foundry_query_engine.utils.logger import logger
+
+# Initialize the logger
+log = logger(__name__)
+
+db_config_map = dict()
+
+
+class Cursor:
+    def execute(self, sql: str, params: dict, selection_results: dict) -> list[dict]:
+        raise NotImplementedError
+
+    def close(self):
+        raise NotImplementedError
+
+
+class Connection:
+    def __init__(self, db_config: dict) -> None:
+        super().__init__()
+        self.db_config = db_config
+
+    def engine(self) -> str:
+        return self.db_config["engine"]
+
+    def cursor(self) -> Cursor:
+        raise NotImplementedError
+
+    def commit(self):
+        raise NotImplementedError
+
+    def close(self):
+        raise NotImplementedError

api_foundry_query_engine/connectors/connection_factory.py

@@ -0,0 +1,115 @@
+from typing import Mapping
+import boto3
+import json
+
+from api_foundry_query_engine.connectors.connection import Connection
+from api_foundry_query_engine.utils.app_exception import ApplicationException
+from api_foundry_query_engine.utils.logger import logger
+
+log = logger(__name__)
+
+
+class ConnectionFactory:
+    db_config_map: dict[str, dict]
+    config: Mapping[str, str]
+
+    def __init__(self, config: Mapping[str, str] = {}):
+        self.db_config_map = dict()
+        self.config = config
+
+    def get_connection(self, database: str) -> Connection:
+        """
+        Factory function to create a database connector based on the
+        specified engine and schema.
+
+        Args:
+        - engine (str): The database engine type
+                ('postgres', 'oracle', or 'mysql').
+        - schema (str): The schema for the database.
+
+        Returns:
+        - Connector: An instance of the appropriate Connector subclass.
+        """
+
+        # Get the secret name based on the engine and database from the secrets map
+        log.info("database: %s", database)
+        db_config = self.db_config_map.get(database)
+        if not db_config:
+            # Use config dict for secrets
+            secrets_map = self.config.get("SECRETS", {})
+            if isinstance(secrets_map, str):
+                secrets_map = json.loads(secrets_map)
+            secret_name = secrets_map.get(database)
+            log.debug("secret_name: %s", secret_name)
+
+            if secret_name:
+                db_config = self.__get_secret(secret_name)
+            else:
+                raise ValueError(f"Secret not found for database: {database}")
+
+        engine = db_config.get("engine")
+        if not engine:
+            raise ApplicationException(
+                500, "Database 'engine' is not defined in the secret."
+            )
+
+        if engine == "postgres":
+            from .postgres_connection import PostgresConnection
+
+            return PostgresConnection(db_config)
+
+        # Add support for other engines here if needed in the future
+
+        raise ValueError(f"Unsupported database engine: {engine}")
+
+    def __get_secret(self, db_secret_name: str):
+        """
+        Get the secret from AWS Secrets Manager.
+
+        Parameters:
+        - db_secret_name (str): The name of the AWS Secrets Manager secret.
+
+        Returns:
+        - dict: The database configuration obtained from the secret.
+        """
+        if self.config.get(db_secret_name):
+            return self.config.get(db_secret_name)
+
+        endpoint_url = self.config.get("AWS_ENDPOINT_URL")  # LocalStack endpoint
+        sts_client = boto3.client("sts", endpoint_url=endpoint_url)
+
+        secret_account_id = self.config.get("SECRET_ACCOUNT_ID", None)
+        log.debug("secret_account_id: %s", secret_account_id)
+
+        if secret_account_id:
+            # If a secret account ID is provided, assume a role in that account
+            secret_role = self.config.get("ROLE_NAME", None)
+            assume_role_response = sts_client.assume_role(
+                RoleArn=f"arn:aws:iam::{secret_account_id}:role/{secret_role}",
+                RoleSessionName="AssumeRoleSession",
+            )
+
+            credentials = assume_role_response["Credentials"]
+
+            secretsmanager = boto3.client(
+                "secretsmanager",
+                aws_access_key_id=credentials["AccessKeyId"],
+                aws_secret_access_key=credentials["SecretAccessKey"],
+                aws_session_token=credentials["SessionToken"],
+                endpoint_url=endpoint_url,
+            )
+        else:
+            # If no secret account ID is provided, use the default account
+            log.info("endpoint_url: %s", endpoint_url)
+            secretsmanager = boto3.client(
+                "secretsmanager",
+                endpoint_url=endpoint_url,
+            )
+
+        # Get the secret value from AWS Secrets Manager
+        log.info("db_secret_name: %s", db_secret_name)
+        db_secret = secretsmanager.get_secret_value(SecretId=db_secret_name)
+        log.debug("loading secret name: %s", db_secret)
+
+        # Return the parsed JSON secret string
+        return json.loads(db_secret.get("SecretString"))

api_foundry_query_engine/connectors/oracle_connector.py

@@ -0,0 +1,29 @@
+from api_foundry_query_engine.utils.logger import logger
+from api_foundry_query_engine.utils.app_exception import ApplicationException
+from api_foundry_query_engine.connectors.connection import Connector
+
+log = logger(__name__)
+
+
+class OracleConnnector(Connector):
+    def __init__(self, db_secret_name: str) -> None:
+        super().__init__(db_secret_name)
+
+    def close(self):
+        pass
+
+    def execute(self, cursor, sql: str, parameters: dict):
+        from oracledb import Error, IntegrityError, ProgrammingError
+
+        log.debug("sql: %s, parameters: %s", sql, parameters)
+        try:
+            cursor.execute(sql, parameters)
+        except IntegrityError as err:
+            (error,) = err.args
+            raise ApplicationException(409, error.message)
+        except ProgrammingError as err:
+            (error,) = err.args
+            raise ApplicationException(400, error.message)
+        except Error as err:
+            (error,) = err.args
+            raise ApplicationException(500, error.message)