api-foundry-query-engine 0.8.0__tar.gz → 0.8.2__tar.gz

{api_foundry_query_engine-0.8.0 → api_foundry_query_engine-0.8.2}/.gitignore

@@ -9,3 +9,5 @@ htmlcov/
 .coverage.*
 .coverage
 .vscode/
+temp/
+volume/

{api_foundry_query_engine-0.8.0 → api_foundry_query_engine-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: api-foundry-query-engine
-Version: 0.8.0
+Version: 0.8.2
 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.2/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-0.8.0 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/adapters/adapter.py

@@ -1,5 +1,5 @@
 import abc
-from typing import Optional
+from typing import Mapping, Optional
 
 from api_foundry_query_engine.operation import Operation
 from api_foundry_query_engine.services.transactional_service import TransactionalService
@@ -11,6 +11,7 @@ log = logger(__name__)
 
 class Adapter(metaclass=abc.ABCMeta):
     service: Service
+    config: Mapping[str, str]
 
     @classmethod
     def __subclasshook__(cls, __subclass: type) -> bool:
@@ -21,8 +22,13 @@ class Adapter(metaclass=abc.ABCMeta):
             and callable(__subclass.unmarshal)
         )
 
-    def __init__(self, service: Optional[Service] = None) -> None:
-        self.service = service if service is not None else TransactionalService()
+    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:
         """

{api_foundry_query_engine-0.8.0 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/connectors/connection_factory.py

@@ -1,6 +1,6 @@
+from typing import Mapping
 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
@@ -11,9 +11,11 @@ log = logger(__name__)
 
 class ConnectionFactory:
     db_config_map: dict[str, dict]
+    config: Mapping[str, str]
 
-    def __init__(self):
+    def __init__(self, config: Mapping[str, str] = {}):
         self.db_config_map = dict()
+        self.config = config
 
     def get_connection(self, database: str) -> Connection:
         """
@@ -33,7 +35,11 @@ class ConnectionFactory:
         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)
+            # 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(f"secret_name: {secret_name}")
 
             if secret_name:
@@ -66,15 +72,18 @@ class ConnectionFactory:
         Returns:
         - dict: The database configuration obtained from the secret.
         """
-        endpoint_url = os.environ.get("AWS_ENDPOINT_URL")  # LocalStack endpoint
+        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 = os.environ.get("SECRET_ACCOUNT_ID", None)
+        secret_account_id = self.config.get("SECRET_ACCOUNT_ID", None)
         log.debug(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)
+            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",
@@ -94,7 +103,7 @@ class ConnectionFactory:
             log.info(f"endpoint_url: {endpoint_url}")
             secretsmanager = boto3.client(
                 "secretsmanager",
-                #                endpoint_url=endpoint_url,
+                endpoint_url=endpoint_url,
             )
 
         # Get the secret value from AWS Secrets Manager
@@ -104,6 +113,3 @@ class ConnectionFactory:
 
         # Return the parsed JSON secret string
         return json.loads(db_secret.get("SecretString"))
-
-
-connection_factory = ConnectionFactory()

{api_foundry_query_engine-0.8.0 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/connectors/postgres_connection.py

@@ -9,17 +9,18 @@ class PostgresCursor(Cursor):
     def __init__(self, cursor):
         self.__cursor = cursor
 
-    def execute(self, sql: str, parameters: dict, result_columns: list[str]) -> list:
+    def execute(self, sql: str, params: dict, selection_results: dict) -> list[dict]:
         """
         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.
+        - params (dict): Parameters to be used in the SQL statement.
+        - selection_results (dict): Mapping of result columns.
 
         Returns:
-        - None
+        - list[dict]: List of result records as dictionaries.
 
         Raises:
         - AppException: Custom exception for handling database-related errors.
@@ -30,12 +31,12 @@ class PostgresCursor(Cursor):
 
         try:
             # Execute the SQL statement with parameters
-            self.__cursor.execute(sql, parameters)
+            self.__cursor.execute(sql, params)
             result = []
             for record in self.__cursor:
-                # Convert record tuple to dictionary using result_columns
+                # Convert record tuple to dictionary using selection_results
                 result.append(
-                    {col: value for col, value in zip(result_columns, record)}
+                    {col: value for col, value in zip(selection_results, record)}
                 )
 
             return result
@@ -80,7 +81,7 @@ class PostgresConnection(Connection):
         """
         from psycopg2 import connect
 
-        dbname = self.db_config["dbname"]
+        dbname = self.db_config["database"]
         user = self.db_config["username"]
         password = self.db_config["password"]
         host = self.db_config["host"]

{api_foundry_query_engine-0.8.0 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/dao/operation_dao.py

@@ -21,8 +21,8 @@ from api_foundry_query_engine.dao.dao import DAO
 from api_foundry_query_engine.connectors.connection import Cursor
 from api_foundry_query_engine.operation import Operation
 from api_foundry_query_engine.utils.api_model import (
-    get_schema_object,
     get_path_operation,
+    get_schema_object,
 )
 from api_foundry_query_engine.dao.sql_query_handler import SQLQueryHandler
 
@@ -60,6 +60,10 @@ class OperationDAO(DAO):
                 return self._query_handler
 
             schema_object = get_schema_object(self.operation.entity)
+            if not schema_object:
+                raise ApplicationException(
+                    500, f"Unknown operation: {self.operation.entity}"
+                )
             if self.operation.action == "read":
                 self._query_handler = SQLSelectSchemaQueryHandler(
                     self.operation, schema_object, self.engine
@@ -82,25 +86,31 @@ class OperationDAO(DAO):
                 )
         return self._query_handler
 
-    def execute(self, cursor: Cursor) -> Union[list[dict], dict]:
+    def execute(self, connector, operation=None) -> Union[list[dict], dict]:
         """
-        Execute the database operation based on the provided cursor.
+        Execute the database operation based on the provided connector.
 
         Args:
-            cursor (Cursor): The database cursor.
+            connector (Connection): The database connection.
+            operation (Operation, optional): The operation to perform.
 
         Returns:
             list[dict]: A list of dictionaries containing the results
             of the operation.
         """
 
+        # Use self.operation if operation is not provided
+        op = operation if operation is not None else self.operation
+        # Assume connector has a 'cursor()' method to get a Cursor
+        cursor = connector.cursor()
+
         result = self.__fetch_record_set(self.query_handler, cursor)
 
-        if self.operation.action == "read":
-            if self.operation.metadata_params.get("count", False):
+        if op.action == "read":
+            if op.metadata_params.get("count", False):
                 return result[0]
             self.__fetch_many(result, cursor)
-        elif self.operation.action in ["update", "delete"] and len(result) == 0:
+        elif op.action in ["update", "delete"] and len(result) == 0:
             raise ApplicationException(400, "No records were modified")
 
         return result

{api_foundry_query_engine-0.8.0 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/dao/sql_custom_query_handler.py

@@ -30,7 +30,7 @@ class SQLCustomQueryHandler(SQLQueryHandler):
         return self._placeholders
 
     @property
-    def select_list_columns(self) -> List[SchemaObjectProperty]:
+    def select_list_columns(self) -> List[str]:
         raise NotImplementedError()
 
     @property

{api_foundry_query_engine-0.8.0 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/dao/sql_insert_query_handler.py

@@ -70,22 +70,29 @@ class SQLInsertSchemaQueryHandler(SQLSchemaQueryHandler):
         placeholders = []
         columns = []
 
-        allowed_properties = self.check_permissions(
+        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(f"allowed properties: {allowed_properties}")
+
+        import json
+
         for name, value in self.operation.store_params.items():
             parts = name.split(".")
 
-            try:
-                if len(parts) > 1:
-                    raise ApplicationException(
-                        400,
-                        "Properties can not be set on associated objects " + name,
-                    )
+            if len(parts) > 1:
+                raise ApplicationException(
+                    400,
+                    "Properties can not be set on associated objects " + name,
+                )
 
-                property = allowed_properties[parts[0]]
-            except KeyError:
+            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:
@@ -95,10 +102,18 @@ class SQLInsertSchemaQueryHandler(SQLSchemaQueryHandler):
                     )
 
             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))
-            self.store_placeholders[property.api_name] = property.convert_to_db_value(
-                value
-            )
+            # 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)
 
         if self.key_property:
             if self.key_property.key_type == "sequence":

{api_foundry_query_engine-0.8.0 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/dao/sql_query_handler.py

@@ -150,7 +150,7 @@ class SQLQueryHandler:
 
     def placeholder(self, property: SchemaObjectProperty, param: str = "") -> str:
         if len(param) == 0:
-            param = property.api_name
+            param = property.api_name if property.api_name is not None else ""
 
         if self.engine == "oracle":
             if property.column_type == "date":
@@ -166,7 +166,7 @@ class SQLQueryHandler:
         self,
         permission_type: str,
         permissions: Optional[dict],
-        properties: Optional[List[str]],
+        properties: Dict[str, SchemaObjectProperty],
     ) -> Dict[str, SchemaObjectProperty]:
         """
         Checks the user's permissions for the specified permission type.
@@ -240,7 +240,7 @@ class SQLQueryHandler:
             ]
             sql = f"{column} {'NOT ' if operand == 'not-in' else ''}IN ({', '.join(assignments)})"  # noqa E501
         else:
-            sql = f"{column} {operand} {self.placeholder(property, placeholder_name)}"
+            sql = f"{column} {operand} {self.placeholder(property, str(placeholder_name))}"
         return sql
 
     def generate_placeholders(
@@ -346,7 +346,7 @@ class SQLSchemaQueryHandler(SQLQueryHandler):
 
     @property
     def table_expression(self) -> str:
-        return self.schema_object.table_name
+        return self.schema_object.table_name or ""
 
     @property
     def selection_results(self) -> Dict:
@@ -393,9 +393,9 @@ class SQLSchemaQueryHandler(SQLQueryHandler):
                 raise ApplicationException(
                     400,
                     "Concurrency settings prohibit multi-record updates "
-                    + self.schema_object.api_name
+                    + str(self.schema_object.api_name)
                     + ", property: "
-                    + property.api_name,
+                    + str(property.api_name),
                 )
 
             assignment, holders = self.search_value_assignment(property, value)

{api_foundry_query_engine-0.8.0 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/dao/sql_select_query_handler.py

@@ -50,7 +50,7 @@ class SQLSelectSchemaQueryHandler(SQLSchemaQueryHandler):
                         raise ApplicationException(
                             400,
                             "Invalid selection property "
-                            + self.schema_object.api_name
+                            + str(self.schema_object.api_name)
                             + " does not have a property "
                             + parts[0],
                         )
@@ -59,7 +59,7 @@ class SQLSelectSchemaQueryHandler(SQLSchemaQueryHandler):
                         raise ApplicationException(
                             400,
                             "Property not found, "
-                            + relation.child_schema_object.api_name
+                            + str(relation.child_schema_object.api_name)
                             + " does not have property "
                             + parts[1],
                         )
@@ -67,17 +67,20 @@ class SQLSelectSchemaQueryHandler(SQLSchemaQueryHandler):
                     prefix = self.prefix_map[parts[0]]
                 else:
                     property = self.schema_object.properties[parts[0]]
+                    if self.schema_object.api_name is None:
+                        raise ApplicationException(
+                            500,
+                            "schema_object.api_name is None, cannot use as key in prefix_map",
+                        )
                     prefix = self.prefix_map[self.schema_object.api_name]
             except KeyError:
                 raise ApplicationException(
                     500,
-                    (
-                        "Invalid query parameter, property not found. "
-                        + "schema object: "
-                        + self.schema_object.api_name
-                        + ", property: "
-                        + name
-                    ),
+                    "Invalid query parameter, property not found. "
+                    + "schema object: "
+                    + str(self.schema_object.api_name)
+                    + ", property: "
+                    + name,
                 )
 
             assignment, holders = self.search_value_assignment(property, value, prefix)
@@ -90,13 +93,13 @@ class SQLSelectSchemaQueryHandler(SQLSchemaQueryHandler):
     @property
     def table_expression(self) -> str:
         joins = []
-        parent_prefix = self.prefix_map[self.schema_object.api_name]
+        parent_prefix = self.prefix_map[str(self.schema_object.api_name)]
         for name, relation in self.schema_object.relations.items():
-            child_prefix = self.prefix_map[relation.api_name]
+            child_prefix = self.prefix_map[str(relation.api_name)]
             if child_prefix in self.active_prefixes:
                 joins.append(
                     "INNER JOIN "
-                    + relation.child_schema_object.table_name
+                    + str(relation.child_schema_object.table_name)
                     + " AS "
                     + child_prefix
                     + " ON "
@@ -110,9 +113,9 @@ class SQLSelectSchemaQueryHandler(SQLSchemaQueryHandler):
                 )
 
         return (
-            self.schema_object.table_name
+            str(self.schema_object.table_name)
             + " AS "
-            + self.prefix_map[self.schema_object.api_name]
+            + str(self.prefix_map[str(self.schema_object.api_name)])
             + (f" {' '.join(joins)}" if len(joins) > 0 else "")
         )
 
@@ -152,7 +155,7 @@ class SQLSelectSchemaQueryHandler(SQLSchemaQueryHandler):
                     raise ApplicationException(
                         400,
                         "Bad object association: "
-                        + schema_object.api_name
+                        + str(schema_object.api_name)
                         + " does not have a "
                         + relation
                         + " property",
@@ -202,14 +205,14 @@ class SQLSelectSchemaQueryHandler(SQLSchemaQueryHandler):
             component = (
                 parts[0]
                 if len(parts) > 1
-                else self.prefix_map[self.schema_object.api_name]
+                else self.prefix_map[str(self.schema_object.api_name)]
             )
             object = object_set.get(component, {})
             if not object:
                 object_set[component] = object
             object[property.api_name] = property.convert_to_api_value(value)
 
-        result = object_set[self.prefix_map[self.schema_object.api_name]]
+        result = object_set[self.prefix_map[str(self.schema_object.api_name)]]
         for name, prefix in self.prefix_map.items():
             if name != self.schema_object.api_name and prefix in object_set:
                 result[name] = object_set[prefix]
@@ -239,7 +242,7 @@ class SQLSelectSchemaQueryHandler(SQLSchemaQueryHandler):
             # handle entity prefix
             field_parts = field_name.split(".")
             if len(field_parts) == 1:
-                prefix = self.prefix_map[self.schema_object.api_name]
+                prefix = self.prefix_map[str(self.schema_object.api_name)]
                 property = self.schema_object.properties.get(field_parts[0])
                 if not property:
                     raise ApplicationException(

{api_foundry_query_engine-0.8.0 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/dao/sql_update_query_handler.py

@@ -39,25 +39,36 @@ class SQLUpdateSchemaQueryHandler(SQLSchemaQueryHandler):
 
     @property
     def update_values(self) -> str:
-        allowed_properties = self.check_permissions(
+        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
+        }
         self.store_placeholders = {}
         columns = []
         invalid_columns = []
 
+        import json
+
         for name, value in self.operation.store_params.items():
-            if name not in allowed_properties:
+            property = allowed_properties.get(name, None)
+            if property is None:
                 invalid_columns.append(name)
-            else:
-                property = allowed_properties.get(name, None)
+                continue
 
-                placeholder = property.api_name
-                column_name = property.column_name
+            placeholder = (
+                str(property.api_name) if property.api_name is not None else name
+            )
+            column_name = property.column_name
 
-                columns.append(
-                    f"{column_name} = {self.placeholder(property, placeholder)}"
-                )
+            columns.append(f"{column_name} = {self.placeholder(property, placeholder)}")
+            # Serialize embedded objects to JSON
+            if property.api_type == "object":
+                self.store_placeholders[placeholder] = json.dumps(value)
+            else:
                 self.store_placeholders[placeholder] = property.convert_to_db_value(
                     value
                 )

api_foundry_query_engine-0.8.2/api_foundry_query_engine/lambda_handler.py

@@ -0,0 +1,55 @@
+import json
+import logging
+import os
+from typing import Optional, Mapping
+
+from api_foundry_query_engine.utils.app_exception import ApplicationException
+from api_foundry_query_engine.adapters.gateway_adapter import GatewayAdapter
+
+log = logging.getLogger(__name__)
+
+engine_config: Optional[Mapping[str, str]] = None
+adapter: Optional[GatewayAdapter] = None
+
+
+class QueryEngine:
+    def __init__(self, config: Mapping[str, str]):
+        self.adapter = GatewayAdapter(config)
+
+    def handler(self, event):
+        log.debug(f"event: {event}")
+        try:
+            response = self.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}"}),
+            }
+
+
+def handler(event, _):
+    global engine_config, adapter
+    if engine_config is None:
+        engine_config = os.environ
+
+    query_engine = QueryEngine(engine_config)
+    return query_engine.handler(event)

{api_foundry_query_engine-0.8.0 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/services/service.py

@@ -1,6 +1,5 @@
 import hashlib
 import json
-import os
 
 from api_foundry_query_engine.utils.logger import logger
 from api_foundry_query_engine.operation import Operation
@@ -9,23 +8,32 @@ log = logger(__name__)
 
 
 class Service:
+    def __init__(self, config: dict = {}):
+        self.config = config
+
     def execute(self, operation: Operation) -> list[dict]:
         raise NotImplementedError
 
 
 class ServiceAdapter(Service):
-    def execute(self, operation):
-        super().execute(operation)
+    def __init__(self, config: dict = {}):
+        super().__init__(config)
+
+    def execute(self, operation: Operation) -> list[dict]:
+        return super().execute(operation)
 
 
 class MutationPublisher(ServiceAdapter):
+    def __init__(self, config: dict = {}):
+        super().__init__(config)
+
     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)
+        topic_arn = self.config.get("BROADCAST_TOPIC", None)
         log.debug(f"Topic ARN: {topic_arn}")
 
         if topic_arn is not None:
@@ -51,10 +59,11 @@ class MutationPublisher(ServiceAdapter):
             )
             log.info(f"publish msg id {msg_id}")
 
-    def __client(client_type, region: str = os.environ.get("AWS_REGION", "us-east-1")):
+    def __client(self, client_type):
         import boto3
 
-        session = boto3.session.Session()
+        region = self.config.get("AWS_REGION", "us-east-1")
+        session = boto3.Session()
         if session:
             return session.client(client_type, region_name=region)
         return boto3.client(client_type, region_name=region)

{api_foundry_query_engine-0.8.0 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/services/transactional_service.py

@@ -1,10 +1,11 @@
 import traceback
+from typing import Mapping
 
 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.connectors.connection_factory import ConnectionFactory
 from api_foundry_query_engine.dao.operation_dao import OperationDAO
 from api_foundry_query_engine.utils.api_model import (
     get_path_operation,
@@ -15,7 +16,12 @@ log = logger(__name__)
 
 
 class TransactionalService(ServiceAdapter):
-    def execute(self, operation: Operation):
+    def __init__(self, config: Mapping[str, str]):
+        super().__init__()
+        self.config = config
+        self.connection_factory = ConnectionFactory(config)
+
+    def execute(self, operation: Operation) -> list[dict]:
         path_operation = get_path_operation(operation.entity, operation.action)
         if path_operation:
             database = path_operation.database
@@ -28,17 +34,15 @@ class TransactionalService(ServiceAdapter):
                     500, f"Unknown operation: {operation.entity}"
                 )
 
-        connection = connection_factory.get_connection(database)
+        # Pass config to connection_factory if needed (future extension)
+        connection = self.connection_factory.get_connection(database)
 
         try:
-            result = None
-            cursor = connection.cursor()
-            try:
-                result = OperationDAO(operation, connection.engine()).execute(cursor)
-            finally:
-                cursor.close()
+            result = OperationDAO(operation, connection.engine()).execute(connection)
             if operation.action != "read":
                 connection.commit()
+            if isinstance(result, dict):
+                return [result]
             return result
         except Exception as error:
             log.error(f"transaction exception: {error}")

{api_foundry_query_engine-0.8.0 → api_foundry_query_engine-0.8.2}/api_foundry_query_engine/utils/api_model.py

@@ -1,12 +1,29 @@
+import os
 import yaml
 
 from datetime import datetime
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Mapping, Optional
 
 from api_foundry_query_engine.utils.logger import logger
 
 log = logger(__name__)
 
+api_model = None
+
+
+def get_schema_object(name: str) -> Optional["SchemaObject"]:
+    global api_model
+    if api_model is None:
+        return None
+    return api_model.schema_objects.get(name)
+
+
+def get_path_operation(path: str, method: str) -> Optional["PathOperation"]:
+    global api_model
+    if api_model is None:
+        return None
+    return api_model.path_operations.get(f"{path}_{method}")
+
 
 class SchemaObjectProperty:
     """Represents a property of a schema object."""
@@ -42,7 +59,9 @@ class SchemaObjectProperty:
             "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)
+        conversion_func = conversion_mapping.get(
+            self.column_type if self.column_type is not None else "string", lambda x: x
+        )
         return conversion_func(value)
 
     def convert_to_api_value(self, value) -> Optional[Any]:
@@ -58,7 +77,9 @@ class SchemaObjectProperty:
             "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)
+        conversion_func = conversion_mapping.get(
+            self.api_type if self.api_type is not None else "string", lambda x: x
+        )
         return conversion_func(value)
 
 
@@ -75,19 +96,39 @@ class SchemaObjectAssociation:
 
     @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
-        )
+        if self._child_property:
+            return self._child_property
+        if not self.schema_name:
+            raise ValueError("schema_name is None in SchemaObjectAssociation")
+        child_schema = get_schema_object(self.schema_name)
+        if not child_schema:
+            raise ValueError(f"SchemaObject '{self.schema_name}' not found")
+        if not child_schema.primary_key:
+            raise ValueError(f"Primary key not defined for schema '{self.schema_name}'")
+        column_name = getattr(child_schema.primary_key, "column_name", None)
+        if column_name is None:
+            raise ValueError(
+                f"Primary key property does not have 'column_name' for schema '{self.schema_name}'"
+            )
+        return 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
-        )
+        if self._parent_property:
+            return self._parent_property
+        parent_schema_obj = get_schema_object(self.parent_schema)
+        if not parent_schema_obj:
+            raise ValueError(f"SchemaObject '{self.parent_schema}' not found")
+        if not parent_schema_obj.primary_key:
+            raise ValueError(
+                f"Primary key not defined for schema '{self.parent_schema}'"
+            )
+        column_name = getattr(parent_schema_obj.primary_key, "column_name", None)
+        if column_name is None:
+            raise ValueError(
+                f"Primary key property does not have 'column_name' for schema '{self.parent_schema}'"
+            )
+        return column_name
 
     def __repr__(self):
         return (
@@ -98,30 +139,37 @@ class SchemaObjectAssociation:
 
     @property
     def child_schema_object(self) -> "SchemaObject":
-        return get_schema_object(self.schema_name)
+        if self.schema_name is None:
+            raise ValueError("schema_name is None in SchemaObjectAssociation")
+        schema_obj = get_schema_object(self.schema_name)
+        if schema_obj is None:
+            raise ValueError(f"SchemaObject '{self.schema_name}' not found")
+        return schema_obj
 
 
 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 = {
+        self.api_name: str = str(data.get("api_name"))
+        self.database: str = str(data.get("database"))
+        self.table_name: str = str(data.get("table_name"))
+        self.properties: Dict[str, SchemaObjectProperty] = {
             name: SchemaObjectProperty(prop_data)
             for name, prop_data in data.get("properties", {}).items()
         }
         self.relations = {
-            name: SchemaObjectAssociation(self.api_name, assoc_data)
+            name: SchemaObjectAssociation(
+                self.api_name if self.api_name is not None else "", assoc_data
+            )
             for name, assoc_data in data.get("relations", {}).items()
         }
         self.concurrency_property = (
-            self.properties[data.get("concurrency_property")]
+            self.properties[str(data.get("concurrency_property"))]
             if data.get("concurrency_property")
             else None
         )
-        self._primary_key = data.get("primary_key")
+        self._primary_key: str = str(data.get("primary_key"))
         self.permissions = data.get("permissions")
 
     def __repr__(self):
@@ -136,39 +184,22 @@ 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 = {
+        self.entity: str = data["entity"]
+        self.action: str = data["action"]
+        self.sql: str = data["sql"]
+        self.database: str = data["database"]
+        self.inputs: Dict[str, SchemaObjectProperty] = {
             name: SchemaObjectProperty(input_data)
             for name, input_data in data.get("inputs", {}).items()
         }
-        self.outputs = {
+        self.outputs: Dict[str, SchemaObjectProperty] = {
             name: SchemaObjectProperty(output_data)
             for name, output_data in data.get("outputs", {}).items()
         }
         self.permissions = data.get("security")
 
     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}")
+        return f"PathOperation(entity={self.entity}, action={self.action})"
 
 
 class APIModel:
@@ -176,17 +207,21 @@ class APIModel:
 
     def __init__(self, config: Dict[str, Any]):
         print("building api_model")
-        global schema_objects
-        schema_objects = {
+        self.schema_objects = {
             name: SchemaObject(schema_data)
             for name, schema_data in config.get("schema_objects", {}).items()
         }
-        global path_operations
-        path_operations = {
+        self.path_operations = {
             name: PathOperation(path_data)
             for name, path_data in config.get("path_operations", {}).items()
         }
 
+    def get_path_operation(self, path: str, method: str) -> Optional[PathOperation]:
+        """Returns a path operation by name."""
+        if self.path_operations is None:
+            return None
+        return self.path_operations.get(f"{path}_{method}")
+
     def __repr__(self):
         return (
             f"APIModel(schema_objects={list(self.schema_objects.keys())}, "
@@ -194,6 +229,13 @@ class APIModel:
         )
 
 
-def load_api(filename: str):
-    with open(filename, "r") as file:
-        APIModel(yaml.safe_load(file))
+def set_api_model(engine_config: Mapping[str, str]):
+    global api_model
+    if api_model is None:
+        if engine_config.get("API_SPEC"):
+            api_model = APIModel(yaml.safe_load(engine_config["API_SPEC"]))
+        else:
+            with open(
+                os.environ.get("API_SPEC", "/var/task/api_spec.yaml"), "r"
+            ) as file:
+                api_model = APIModel(yaml.safe_load(file))

{api_foundry_query_engine-0.8.0 → api_foundry_query_engine-0.8.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "api-foundry-query-engine"
-version = "0.8.0"
+version = "0.8.2"
 authors = [
     { name="Daniel Repik", email="danrepik@icloud.com" },
 ]

api_foundry_query_engine-0.8.0/api_foundry_query_engine/lambda_handler.py

@@ -1,43 +0,0 @@
-import json
-import logging
-import os
-
-from api_foundry_query_engine.utils.app_exception import ApplicationException
-from api_foundry_query_engine.adapters.gateway_adapter import GatewayAdapter
-from api_foundry_query_engine.utils.api_model import load_api
-
-log = logging.getLogger(__name__)
-
-
-load_api(os.environ.get("API_SPEC", "/var/task/api_spec.yaml"))
-adapter = GatewayAdapter()
-
-
-def handler(event, _):
-    log.debug(f"event: {event}")
-    try:
-        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}"}),
-        }