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

api_foundry_query_engine/adapters/adapter.py

@@ -0,0 +1,67 @@
+import abc
+from typing import 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
+
+    @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, service: Optional[Service] = None) -> None:
+        self.service = service if service is not None else TransactionalService()
+
+    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(f"adapter result: {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(f"camel_case: {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,112 @@
+import json
+
+from api_foundry_query_engine.adapters.adapter import Adapter
+from api_foundry_query_engine.operation import Operation
+
+actions_map = {
+    "GET": "read",
+    "POST": "create",
+    "PUT": "update",
+    "DELETE": "delete",
+}
+
+
+class GatewayAdapter(Adapter):
+    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 super().marshal(result)
+
+    def unmarshal(self, event):
+        """
+        Get parameters from the Lambda event.
+
+        Parameters:
+        - event (dict): Lambda event object.
+
+        Returns:
+        - tuple: Tuple containing data, query and metadata parameters.
+        """
+        entity = event.get("resource").split("/")[1]
+        action = actions_map.get(event.get("httpMethod").upper(), "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)
+
+        return Operation(
+            entity=entity,
+            action=action,
+            store_params=store_params,
+            query_params=query_params,
+            metadata_params=metadata_params,
+        )
+
+    def _convert_parameters(self, parameters):
+        """
+        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):
+        """
+        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/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,110 @@
+import boto3
+import json
+import os
+
+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]
+
+    def __init__(self):
+        self.db_config_map = dict()
+
+    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(f"database: {database}")
+        db_config = self.db_config_map.get(database)
+        if not db_config:
+            secret_name = json.loads(os.environ.get("SECRETS", "{}")).get(database)
+            log.info(f"secret_name: {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.
+        """
+        endpoint_url = os.environ.get("AWS_ENDPOINT_URL")  # LocalStack endpoint
+        sts_client = boto3.client("sts", endpoint_url=endpoint_url)
+
+        secret_account_id = os.environ.get("SECRET_ACCOUNT_ID", None)
+        log.info(f"secret_account_id: {secret_account_id}")
+
+        if secret_account_id:
+            # If a secret account ID is provided, assume a role in that account
+            secret_role = os.environ.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(f"endpoint_url: {endpoint_url}")
+            secretsmanager = boto3.client(
+                "secretsmanager",
+                #                endpoint_url=endpoint_url,
+            )
+
+        # Get the secret value from AWS Secrets Manager
+        log.info(f"db_secret_name: {db_secret_name}")
+        db_secret = secretsmanager.describe_secret(SecretId=db_secret_name)
+        db_secret = secretsmanager.get_secret_value(SecretId=db_secret_name)
+        log.debug(f"loading secret name: {db_secret}")
+
+        # Return the parsed JSON secret string
+        return json.loads(db_secret.get("SecretString"))
+
+
+connection_factory = ConnectionFactory()

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(f"sql: {sql}, parameters: {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)

api_foundry_query_engine/connectors/postgres_connection.py

@@ -0,0 +1,105 @@
+from api_foundry_query_engine.connectors.connection import Connection, Cursor
+from api_foundry_query_engine.utils.logger import logger
+
+# Initialize the logger
+log = logger(__name__)
+
+
+class PostgresCursor(Cursor):
+    def __init__(self, cursor):
+        self.__cursor = cursor
+
+    def execute(self, sql: str, parameters: dict, result_columns: list[str]) -> list:
+        """
+        Execute SQL statements on the PostgreSQL database.
+
+        Parameters:
+        - cursor: The database cursor.
+        - sql (str): The SQL statement to execute.
+        - parameters (dict): Parameters to be used in the SQL statement.
+
+        Returns:
+        - None
+
+        Raises:
+        - AppException: Custom exception for handling database-related errors.
+        """
+        from psycopg2 import Error, IntegrityError, ProgrammingError
+
+        log.info(f"sql: {sql}, parameters: {parameters}")
+
+        try:
+            # Execute the SQL statement with parameters
+            log.info(f"sql: {self.__cursor.mogrify(sql, parameters)}")
+            self.__cursor.execute(sql, parameters)
+            result = []
+            for record in self.__cursor:
+                # Convert record tuple to dictionary using result_columns
+                result.append(
+                    {col: value for col, value in zip(result_columns, record)}
+                )
+
+            return result
+        except IntegrityError as err:
+            # Handle integrity constraint violation (e.g., duplicate key)
+            raise Exception(409, err.pgerror)
+        except ProgrammingError as err:
+            # Handle programming errors (e.g., syntax error in SQL)
+            raise Exception(400, err.pgerror)
+        except Error as err:
+            # Handle other database errors
+            raise Exception(500, err.pgerror)
+
+    def close(self):
+        self.__cursor.close()
+
+
+class PostgresConnection(Connection):
+    def __init__(self, db_config: dict) -> None:
+        super().__init__(db_config)
+        self.__connection = self.get_connection()
+
+    def cursor(self) -> Cursor:
+        return PostgresCursor(self.__connection.cursor())
+
+    def close(self):
+        self.__connection.close()
+
+    def commit(self):
+        self.__connection.commit()
+
+    def get_connection(self):
+        """
+        Get a connection to the PostgreSQL database.
+
+        Parameters:
+        - schema (str, optional): The database schema to set for the
+            connection.
+
+        Returns:
+        - connection: A connection to the PostgreSQL database.
+        """
+        from psycopg2 import connect
+
+        dbname = self.db_config["dbname"]
+        user = self.db_config["username"]
+        password = self.db_config["password"]
+        host = self.db_config["host"]
+        port = self.db_config.get("port", 5432)
+        additional_config = self.db_config.get("configuration", {})
+
+        # Merge additional configuration parameters with the main connection parameters
+        connection_params = {
+            "dbname": dbname,
+            "user": user,
+            "password": password,
+            "host": host,
+            "port": port,
+        }
+
+        connection_params.update(additional_config)
+
+        log.info(f"connection_params: {connection_params}")
+
+        # Create a connection to the PostgreSQL database
+        return connect(**connection_params)

api_foundry_query_engine/dao/dao.py

@@ -0,0 +1,23 @@
+import abc
+from typing import Union
+
+from api_foundry_query_engine.connectors.connection import Connection
+from api_foundry_query_engine.operation import Operation
+
+
+class DAO(metaclass=abc.ABCMeta):
+    @classmethod
+    def __subclasshook__(cls, __subclass: type) -> bool:
+        return hasattr(__subclass, "execute") and callable(__subclass.execute)
+
+    def execute(
+        self, connector: Connection, operation: Operation
+    ) -> Union[list[dict], dict]:
+        raise NotImplementedError
+
+
+class DAOAdapter(DAO):
+    def execute(
+        self, connector: Connection, operation: Operation
+    ) -> Union[list[dict], dict]:
+        return super().execute(connector, operation)