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

api_foundry_query_engine/dao/sql_subselect_query_handler.py

@@ -0,0 +1,63 @@
+from typing import Optional
+
+from api_foundry_query_engine.dao.sql_query_handler import SQLSchemaQueryHandler
+from api_foundry_query_engine.dao.sql_select_query_handler import SQLSelectSchemaQueryHandler
+from api_foundry_query_engine.operation import Operation
+from api_foundry_query_engine.utils.api_model import SchemaObjectAssociation
+
+
+class SQLSubselectSchemaQueryHandler(SQLSelectSchemaQueryHandler):
+    def __init__(
+        self,
+        operation: Operation,
+        relation: SchemaObjectAssociation,
+        parent_generator: SQLSchemaQueryHandler,
+    ) -> None:
+        super().__init__(
+            operation, relation.child_schema_object, parent_generator.engine
+        )
+        self.relation = relation
+        self.parent_generator = parent_generator
+
+    def selection_result_map(self) -> dict:
+        filter_str = self.operation.metadata_params.get("properties", "")
+        result = {self.relation.child_property: self.relation.child_property}
+
+        for relation_name, reg_exs in self.get_regex_map(filter_str).items():
+            if relation_name != self.relation.api_name:
+                continue
+
+            schema_object = self.relation.child_schema_object
+
+            # Filter and prefix keys for the current entity and regular expressions
+            filtered_keys = self.filter_and_prefix_keys(
+                reg_exs, schema_object.properties
+            )
+
+            # Extend the result map with the filtered keys
+            result.update(filtered_keys)
+
+        return result
+
+    @property
+    def placeholders(self) -> dict:
+        return self.search_placeholders
+
+    @property
+    def sql(self) -> Optional[str]:
+        if len(self.select_list_columns) == 1:  # then it only contains the key
+            return None
+
+        sql = (
+            f"SELECT {self.select_list} "
+            + f"FROM {self.relation.child_schema_object.table_name} "
+            + f"WHERE {self.relation.child_property} "
+            + f"IN ( SELECT {self.relation.parent_property} "
+            + f"FROM {self.parent_generator.table_expression}"
+            + f"{self.parent_generator.search_condition} "
+            #            + f"{order_by} {limit} {offset})"
+            + ")"
+        )
+        self.search_placeholders = self.parent_generator.search_placeholders
+        #        self._execute_sql(args["cursor"], sql, query_parameters)
+        return sql

api_foundry_query_engine/dao/sql_update_query_handler.py

@@ -0,0 +1,59 @@
+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
+
+
+class SQLUpdateSchemaQueryHandler(SQLSchemaQueryHandler):
+    def __init__(
+        self, operation: Operation, schema_object: SchemaObject, engine: str
+    ) -> None:
+        super().__init__(operation, schema_object, engine)
+
+    @property
+    def sql(self) -> str:
+        concurrency_property = self.schema_object.concurrency_property
+        if not concurrency_property:
+            return (
+                f"UPDATE {self.table_expression}{self.update_values}"
+                + f"{self.search_condition} RETURNING {self.select_list}"
+            )
+
+        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}",
+            )
+
+        return f"UPDATE {self.table_expression}{self.update_values}, {concurrency_property.column_name} = {self.concurrency_generator(concurrency_property)} {self.search_condition} RETURNING {self.select_list}"  # noqa E501
+
+    @property
+    def update_values(self) -> str:
+        self.store_placeholders = {}
+        columns = []
+
+        for name, value in self.operation.store_params.items():
+            try:
+                property = self.schema_object.properties[name]
+            except KeyError:
+                raise ApplicationException(
+                    400, f"Search condition column not found {name}"
+                )
+
+            placeholder = property.api_name
+            column_name = property.column_name
+
+            columns.append(f"{column_name} = {self.placeholder(property, placeholder)}")
+            self.store_placeholders[placeholder] = property.convert_to_db_value(value)
+
+        return f" SET {', '.join(columns)}"

api_foundry_query_engine/handler.py

@@ -0,0 +1,48 @@
+import json
+import logging
+import os
+import yaml
+
+from api_foundry_query_engine.utils.app_exception import ApplicationException
+from api_foundry_query_engine.utils.api_model import APIModel
+
+from api_foundry_query_engine.adapters.gateway_adapter import GatewayAdapter
+
+log = logging.getLogger(__name__)
+
+api_model = None
+adapter = GatewayAdapter()
+
+
+def lambda_handler(event, _):
+    log.debug(f"event: {event}")
+    try:
+        if not api_model:
+            with open(os.environ.get("API_SPEC", "/var/task/api_spec.yaml"), "r") as file:
+                api_model = APIModel(yaml.safe_load(file))
+
+        response = adapter.process_event(event)
+
+        # Ensure the response conforms to API Gateway requirements
+        return {
+            "isBase64Encoded": False,
+            "statusCode": 200,
+            "headers": {"Content-Type": "application/json"},
+            "body": json.dumps(response),
+        }
+    except ApplicationException as e:
+        log.error(f"exception: {e}", exc_info=True)
+        return {
+            "isBase64Encoded": False,
+            "statusCode": e.status_code,
+            "headers": {"Content-Type": "application/json"},
+            "body": json.dumps({"message": f"exception: {e}"}),
+        }
+    except Exception as e:
+        log.error(f"exception: {e}", exc_info=True)
+        return {
+            "isBase64Encoded": False,
+            "statusCode": 500,
+            "headers": {"Content-Type": "application/json"},
+            "body": json.dumps({"message": f"exception: {e}"}),
+        }

api_foundry_query_engine/operation.py

@@ -0,0 +1,15 @@
+class Operation:
+    def __init__(
+        self,
+        *,
+        entity: str,
+        action: str,
+        query_params={},
+        store_params={},
+        metadata_params={},
+    ):
+        self.entity = entity
+        self.action = action
+        self.query_params = query_params
+        self.store_params = store_params
+        self.metadata_params = metadata_params

api_foundry_query_engine/services/service.py

@@ -0,0 +1,60 @@
+import hashlib
+import json
+import os
+
+from api_foundry_query_engine.utils.logger import logger
+from api_foundry_query_engine.operation import Operation
+
+log = logger(__name__)
+
+
+class Service:
+    def execute(self, operation: Operation) -> list[dict]:
+        raise NotImplementedError
+
+
+class ServiceAdapter(Service):
+    def execute(self, operation):
+        super().execute(operation)
+
+
+class MutationPublisher(ServiceAdapter):
+    def execute(self, operation):
+        result = super().execute(operation)
+        self.publish_notification(operation)
+        return result
+
+    def publish_notification(self, operation):
+        topic_arn = os.environ.get("BROADCAST_TOPIC", None)
+        log.debug(f"Topic ARN: {topic_arn}")
+
+        if topic_arn is not None:
+            log.debug("Sending message")
+            message = {
+                "entity": operation.api_name,
+                "action": operation.action,
+                "store_params": operation.store_params,
+                "query_params": operation.query_params,
+            }
+
+            message_str = json.dumps({"default": json.dumps(message)})
+            log.debug(f"message_str: {message_str}")
+            hash_object = hashlib.sha256(message_str.encode("utf-8"))
+            hex_dig = hash_object.hexdigest()
+
+            msg_id = self.__client("sns").publish(
+                TopicArn=topic_arn,
+                MessageStructure="json",
+                MessageDeduplicationId=hex_dig,
+                MessageGroupId=operation.api_name,
+                Message=message_str,
+            )
+            log.info(f"publish msg id {msg_id}")
+
+    def __client(client_type, region: str = os.environ.get("AWS_REGION", "us-east-1")):
+        import boto3
+
+        session = boto3.session.Session()
+        if session:
+            return session.client(client_type, region_name=region)
+        return boto3.client(client_type, region_name=region)

api_foundry_query_engine/services/transactional_service.py

@@ -0,0 +1,43 @@
+import traceback
+
+from api_foundry_query_engine.utils.logger import logger
+from api_foundry_query_engine.utils.app_exception import ApplicationException
+from api_foundry_query_engine.operation import Operation
+from api_foundry_query_engine.services.service import ServiceAdapter
+from api_foundry_query_engine.connectors.connection_factory import connection_factory
+from api_foundry_query_engine.dao.operation_dao import OperationDAO
+from api_foundry_query_engine.utils.api_model import get_path_operation, get_schema_object
+
+log = logger(__name__)
+
+
+class TransactionalService(ServiceAdapter):
+    def execute(self, operation: Operation):
+        path_operation = get_path_operation(operation.entity, operation.action)
+        if path_operation:
+            database = path_operation.database
+        else:
+            schema_object = get_schema_object(operation.entity)
+            if schema_object:
+                database = schema_object.database
+            else:
+                raise ApplicationException(500, f"Unknown operation: {operation.entity}")
+
+        connection = connection_factory.get_connection(database)
+
+        try:
+            result = None
+            cursor = connection.cursor()
+            try:
+                result = OperationDAO(operation, connection.engine()).execute(cursor)
+            finally:
+                cursor.close()
+            if operation.action != "read":
+                connection.commit()
+            return result
+        except Exception as error:
+            log.error(f"transaction exception: {error}")
+            log.error(f"traceback: {traceback.format_exc()}")
+            raise error
+        finally:
+            connection.close()

api_foundry_query_engine/utils/api_model.py

@@ -0,0 +1,175 @@
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from api_foundry_query_engine.utils.logger import logger
+
+log = logger(__name__)
+
+
+class SchemaObjectProperty:
+    """Represents a property of a schema object."""
+
+    def __init__(self, data: Dict[str, Any]):
+        self.api_name = data.get("api_name")
+        self.column_name = data.get("column_name")
+        self.type = data.get("type")
+        self.api_type = data.get("api_type")
+        self.column_type = data.get("column_type")
+        self.required = data.get("required", False)
+        self.min_length = data.get("min_length")
+        self.max_length = data.get("max_length")
+        self.pattern = data.get("pattern")
+        self.default = data.get("default")
+        self.key_type = data.get("key_type")
+        self.sequence_name = data.get("sequence_name")
+        self.concurrency_control = data.get("concurrency_control")
+
+    def __repr__(self):
+        return f"SchemaObjectProperty(api_name={self.api_name}, column_name={self.column_name}, type={self.type})"
+    
+    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, lambda x: x)
+        return conversion_func(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, lambda x: x)
+        return conversion_func(value)
+
+
+
+class SchemaObjectAssociation:
+    """Represents an association (relationship) between schema objects."""
+
+    def __init__(self, parent_schema: str, data: Dict[str, Any]):
+        self.parent_schema = parent_schema
+        self.schema_name = data.get("schema_name")
+        self.api_name = data.get("api_name")
+        self.type = data.get("type")
+        self._child_property = data.get("child_property")
+        self._parent_property = data.get("parent_property")
+
+    @property
+    def child_property(self) -> str:
+        return self._child_property if self._child_property else get_schema_object(self.schema_name).primary_key.column_name
+
+    @property
+    def parent_property(self) -> str:
+        return self._parent_property if self._parent_property else get_schema_object(self.parent_schema).primary_key.column_name
+
+    def __repr__(self):
+        return f"SchemaObjectAssociation(name={self.api_name}, child_property={self._child_property}, parent_property={self.parent_property})"
+
+    @property
+    def child_schema_object(self) -> "SchemaObject":
+        return get_schema_object(self.schema_name)
+
+
+
+class SchemaObject:
+    """Represents a schema object in the API configuration."""
+
+    def __init__(self, data: Dict[str, Any]):
+        self.api_name = data.get("api_name")
+        self.database = data.get("database")
+        self.table_name = data.get("table_name")
+        self.properties = {
+            name: SchemaObjectProperty(prop_data)
+            for name, prop_data in data.get("properties", {}).items()
+        }
+        self.relations = {
+            name: SchemaObjectAssociation(self.api_name, assoc_data)
+            for name, assoc_data in data.get("relations", {}).items()
+        }
+        self.concurrency_property = (
+            self.properties[data.get("concurrency_property")]
+            if data.get("concurrency_property")
+            else None
+        )
+        self._primary_key = data.get("primary_key")
+
+    def __repr__(self):
+        return f"SchemaObject(table_name={self.table_name}, primary_key={self.primary_key})"
+
+    @property
+    def primary_key(self):
+        return self.properties.get(self._primary_key)
+
+class PathOperation:
+    """Represents a path operation in the API configuration."""
+
+    def __init__(self, data: Dict[str, Any]):
+        self.entity = data["entity"]
+        self.action = data["action"]
+        self.sql = data["sql"]
+        self.database = data["database"]
+        self.inputs = {
+            name: SchemaObjectProperty(input_data)
+            for name, input_data in data.get("inputs", {}).items()
+        }
+        self.outputs = {
+            name: SchemaObjectProperty(output_data)
+            for name, output_data in data.get("outputs", {}).items()
+        }
+
+    def __repr__(self):
+        return f"PathOperation(entity={self.entity}, method={self.method})"
+
+
+schema_objects = None
+path_operations = None
+
+def get_schema_object(name: str) -> Optional[SchemaObject]:
+    """Returns a schema object by name."""
+    global schema_objects
+    return schema_objects.get(name)
+
+def get_path_operation(path: str, method:str) -> Optional[PathOperation]:
+    """Returns a path operation by name."""
+    log.info(f"path: {path}, method: {method}")
+    global path_operations
+    return path_operations.get(f"{path}_{method}")
+
+
+class APIModel:
+    """Class to load and expose the API configuration as objects."""
+
+    def __init__(self, config: Dict[str, Any]):
+        print("building api_model")
+        global schema_objects
+        schema_objects = {
+            name: SchemaObject(schema_data)
+            for name, schema_data in config.get("schema_objects", {}).items()
+        }
+        global path_operations
+        path_operations = {
+            name: PathOperation(path_data)
+            for name, path_data in config.get("path_operations", {}).items()
+        }
+
+    def __repr__(self):
+        return f"APIModel(schema_objects={list(self.schema_objects.keys())}, path_operations={list(self.path_operations.keys())})"
+

api_foundry_query_engine/utils/app_exception.py

@@ -0,0 +1,22 @@
+class ApplicationException(Exception):
+    """Custom exception class for application errors."""
+
+    def __init__(self, status_code: int, message: str):
+        """
+        Initialize the ApplicationException.
+
+        Args:
+        - status_code (int): The HTTP status code associated with the
+            exception.
+        - message (str): The error message.
+        """
+        super().__init__(message)
+        self.status_code = status_code
+        self.message = message
+
+    def __str__(self):
+        """Return a string representation of the exception."""
+        return (
+            f"ApplicationException(status_code={self.status_code}, "
+            + f"message='{self.message}')"
+        )

api_foundry_query_engine/utils/logger.py

@@ -0,0 +1,60 @@
+import logging
+import os
+
+# Configuring the logging module with basic settings, including format and log level,
+# where the log level is obtained from the environment variable LOGGING_LEVEL
+# with a default of DEBUG, and force=True to ensure the configuration is applied immediately.
+logging.basicConfig(
+    format="%(name)s:%(lineno)s - %(levelname)s - %(message)s",
+    level=os.getenv("LOGGING_LEVEL", "DEBUG").upper(),
+    force=True,
+)
+
+WARN = logging.WARN
+INFO = logging.INFO
+DEBUG = logging.DEBUG
+
+
+def logger(name=None):
+    """
+    Function to create a logger with a specified name or default name.
+
+    Parameters:
+        name (str): Name of the logger. If not provided, the root logger is returned.
+
+    Returns:
+        logging.Logger: Logger object with the specified name or the root logger.
+
+    """
+    # Retrieving the logging level from the environment variable LOGGING_LEVEL
+    # with a default of DEBUG, and converting it to uppercase
+    loggingLevel = os.getenv("LOGGING_LEVEL", "DEBUG").upper()
+
+    # Setting the logging level for the root logger to the obtained logging level
+    logging.getLogger().setLevel(loggingLevel)
+
+    # Returning a logger object with the specified name or the root logger
+    return logging.getLogger(name)
+
+
+def write_logging_file(file_name, content):
+    """
+    Function to write a given string to a file in the temp/logging folder.
+
+    Parameters:
+        file_name (str): Name of the file to write the content to.
+        content (str): The string content to write to the file.
+
+    """
+    # Define the directory path
+    dir_path = os.path.join("temp", "logging")
+
+    # Ensure the directory exists
+    os.makedirs(dir_path, exist_ok=True)
+
+    # Define the file path
+    file_path = os.path.join(dir_path, file_name)
+
+    # Write the content to the file
+    with open(file_path, "w") as file:
+        file.write(content + "\n")

api_foundry_query_engine-0.0.1.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.3
+Name: api-foundry-query-engine
+Version: 0.0.1
+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
+Author-email: Daniel Repik <danrepik@icloud.com>
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.9
+Requires-Dist: boto3
+Requires-Dist: pyhumps
+Requires-Dist: pyyaml

api_foundry_query_engine-0.0.1.dist-info/RECORD

@@ -0,0 +1,27 @@
+api_foundry_query_engine/handler.py,sha256=f7mo67G4rFE-WZq8nldrWbt2qjGR_OXygbXz6_Oh5us,1535
+api_foundry_query_engine/operation.py,sha256=otkRKUfyTW2mWpy5mt2tM7k1w_a-4S068sjYtOeNqRM,374
+api_foundry_query_engine/adapters/adapter.py,sha256=c4X7U3zWh5feR4NbIAPL-oY7-hLd2tiHITGPSXR7ZMQ,1901
+api_foundry_query_engine/adapters/case_change_adapter.py,sha256=JhVOl3b4Dp2n5-u_-4MaO9FgCwCOnDzQ0oyJJYcTAMc,2314
+api_foundry_query_engine/adapters/gateway_adapter.py,sha256=bUZvDM28QEEVjFnI1SBrwyY9iazY-QD1hQgMyBc3wq4,3168
+api_foundry_query_engine/connectors/connection.py,sha256=aGm6R5wt1MW8_5wsrPYW6DI3jnaDhFc9a6CYzLuNVlk,702
+api_foundry_query_engine/connectors/connection_factory.py,sha256=3Dj5qYT_bwzfl8XxQzqoe32qkGioXYo65BfQT3fBckM,3958
+api_foundry_query_engine/connectors/oracle_connector.py,sha256=EtRoOqM8puUS62hoKyd2Gu2ghwPHXbXCtdlnOP50UcU,1020
+api_foundry_query_engine/connectors/postgres_connection.py,sha256=0yM5Q6jaIT2hrYuiQxMftZkMYihrefMQVFKpn6XC4OE,3349
+api_foundry_query_engine/dao/dao.py,sha256=aBFJ0WT0PhMitCJa5_PRBjDeBNj9hLDePRa-awnLtRg,684
+api_foundry_query_engine/dao/operation_dao.py,sha256=LZN22vZ0WVjLIQk0SjSFw4aiU1_Ej2k7luPITwVS9eo,5376
+api_foundry_query_engine/dao/sql_custom_query_handler.py,sha256=C7lXAzOkN4TdVByoOXZ2qLrc8vznilkbHh7mOiYNl5M,2423
+api_foundry_query_engine/dao/sql_delete_query_handler.py,sha256=WByOIUQ83qlzcSFgppxxOWTodvV1cj7t3JZo2u3Oqbs,1656
+api_foundry_query_engine/dao/sql_insert_query_handler.py,sha256=VF1TRsodNUoTR6MzOaujHTslLjEttg2poBj_z5e-WP8,4423
+api_foundry_query_engine/dao/sql_query_handler.py,sha256=r7Car7KznJ3gI2E5bzjgw2TH4Sew12rWG3pAb4nAfno,12566
+api_foundry_query_engine/dao/sql_select_query_handler.py,sha256=ZwqBE0cibsOT-AKrY1DMBwreqRIhytTe0oVcxGJk3vE,11841
+api_foundry_query_engine/dao/sql_subselect_query_handler.py,sha256=URDe-p4k2csP5ncGnJkPQCxwITpWGXRqzXJH5st4Wgw,2392
+api_foundry_query_engine/dao/sql_update_query_handler.py,sha256=1gz44r-PhpqGamC_subZ0zSSd5Wr9EnZQLkQoEj0-jg,2585
+api_foundry_query_engine/services/service.py,sha256=0imMvYgNVgNPlyiZ70pC1ZhIvFCCZIcj8igtGum07Mg,1915
+api_foundry_query_engine/services/transactional_service.py,sha256=Pf08l7uhlvZ2JqFkBb89FDMXnwj_OjWhQDFLUAu3PxM,1692
+api_foundry_query_engine/utils/api_model.py,sha256=xB8IY-y2FgE08llWTkm6EDDc-qyAD_mKh54FByfaGjI,6388
+api_foundry_query_engine/utils/app_exception.py,sha256=8F5DEL8ovY0vJBXE3RERTA26u7kthcSX0VqViplZhdE,704
+api_foundry_query_engine/utils/logger.py,sha256=24u7AAVyzaPuS2nHSCq1SDemerJ8pCF5lde2NtIbwuo,1892
+api_foundry_query_engine-0.0.1.dist-info/METADATA,sha256=dqfJMtvB1Ruoy-3djxzfTcsfyMqADpubZpIcSwgJ3yw,761
+api_foundry_query_engine-0.0.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+api_foundry_query_engine-0.0.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+api_foundry_query_engine-0.0.1.dist-info/RECORD,,

api_foundry_query_engine-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.25.0
+Root-Is-Purelib: true
+Tag: py3-none-any