feature: add DAL (#586)

Author: ran-isenberg

cdk/my_service/service_stack.py

@@ -1,7 +1,7 @@
 import os
 from pathlib import Path
 
-from aws_cdk import Stack
+from aws_cdk import Stack, Tags
 from constructs import Construct
 from git import Repo
 from my_service.api_construct import ApiConstruct  # type: ignore
@@ -27,6 +27,7 @@ class ServiceStack(Stack):
 
     def __init__(self, scope: Construct, id: str, **kwargs) -> None:
         super().__init__(scope, id, **kwargs)
+        Tags.of(self).add('service_name', 'Order')
 
         # This construct should be deployed in a different repo and have its own pipeline so updates can be decoupled
         # from running the service pipeline and without redeploying the service lambdas. For the sake of this template

poetry.lock

@@ -0,0 +1,37 @@
+import uuid
+
+import boto3
+from botocore.exceptions import ClientError
+from cachetools import TTLCache, cached
+from mypy_boto3_dynamodb import DynamoDBServiceResource
+from mypy_boto3_dynamodb.service_resource import Table
+from pydantic import ValidationError
+
+from service.dal.schemas.db import OrderEntry
+from service.handlers.utils.observability import logger, tracer
+from service.schemas.exceptions import InternalServerException
+
+
+# cache dynamodb connection data for no longer than 5 minutes
+@cached(cache=TTLCache(maxsize=1, ttl=300))
+def _get_db_handler(table_name: str) -> Table:
+    dynamodb: DynamoDBServiceResource = boto3.resource('dynamodb')
+    return dynamodb.Table(table_name)
+
+
+@tracer.capture_method(capture_response=False)
+def create_order_in_db(table_name: str, customer_name: str, order_item_count: int) -> OrderEntry:
+    order_id = str(uuid.uuid4())
+    logger.info('trying to save order', extra={'order_id': order_id})
+    try:
+        entry = OrderEntry(order_id=order_id, customer_name=customer_name, order_item_count=order_item_count)
+        logger.info('opening connection to dynamodb table', extra={'table_name': table_name})
+        table: Table = _get_db_handler(table_name)
+        table.put_item(Item=entry.dict())
+    except (ClientError, ValidationError) as exc:
+        error_msg = 'failed to create order'
+        logger.exception(error_msg, extra={'exception': str(exc), 'customer_name': customer_name})
+        raise InternalServerException(error_msg) from exc
+
+    logger.info('finished create order', extra={'order_id': order_id, 'order_item_count': order_item_count, 'customer_name': customer_name})
+    return entry

service/dal/__init__.py

@@ -0,0 +1,15 @@
+from typing import Annotated
+from uuid import UUID
+
+from pydantic import BaseModel, Field, PositiveInt, validator
+
+
+class OrderEntry(BaseModel):
+    order_item_count: PositiveInt
+    customer_name: Annotated[str, Field(min_length=1, max_length=20)]
+    order_id: str  # primary key
+
+    @validator('order_id')
+    def valid_uuid(cls, v):
+        UUID(v, version=4)
+        return v

service/dal/db_handler.py

@@ -16,7 +16,7 @@
 from service.handlers.utils.observability import logger, metrics, tracer
 from service.logic.handle_create_request import handle_create_request
 from service.schemas.exceptions import InternalServerException
-from service.schemas.output import Output
+from service.schemas.output import CreateOrderOutput
 
 
 @init_environment_variables(model=MyHandlerEnvVars)
@@ -45,7 +45,7 @@ def create_order(event: Dict[str, Any], context: LambdaContext) -> Dict[str, Any
 
     metrics.add_metric(name='ValidEvents', unit=MetricUnit.Count, value=1)
     try:
-        response: Output = handle_create_request(
+        response: CreateOrderOutput = handle_create_request(
             customer_name=input.customer_name,
             order_item_count=input.order_item_count,
             table_name=env_vars.TABLE_NAME,

service/dal/schemas/__init__.py

@@ -1,20 +1,13 @@
-import uuid
-
-import boto3
-from botocore.exceptions import ClientError
-from cachetools import TTLCache, cached
-from mypy_boto3_dynamodb import DynamoDBServiceResource
-from mypy_boto3_dynamodb.service_resource import Table
-
+from service.dal.db_handler import create_order_in_db
+from service.dal.schemas.db import OrderEntry
 from service.handlers.schemas.dynamic_configuration import FeatureFlagsNames
 from service.handlers.utils.dynamic_configuration import get_dynamic_configuration_store
 from service.handlers.utils.observability import logger, tracer
-from service.schemas.exceptions import InternalServerException
-from service.schemas.output import Output
+from service.schemas.output import CreateOrderOutput
 
 
 @tracer.capture_method(capture_response=False)
-def handle_create_request(customer_name: str, order_item_count: int, table_name: str) -> Output:
+def handle_create_request(customer_name: str, order_item_count: int, table_name: str) -> CreateOrderOutput:
     logger.info('starting to handle create request', extra={'order_item_count': order_item_count, 'customer_name': customer_name})
 
     # feature flags example
@@ -32,26 +25,6 @@ def handle_create_request(customer_name: str, order_item_count: int, table_name:
     )
     logger.debug('premium feature flag value', extra={'premium': premium})
 
-    return _create_order_in_db(table_name, customer_name, order_item_count)
-
-
-# cache dynamodb connection data for no longer than 5 minutes
-@cached(cache=TTLCache(maxsize=1, ttl=300))
-def _get_db_handler(table_name: str) -> Table:
-    dynamodb: DynamoDBServiceResource = boto3.resource('dynamodb')
-    logger.info('opening connection to dynamodb table', extra={'table_name': table_name})
-    return dynamodb.Table(table_name)
-
-
-def _create_order_in_db(table_name: str, customer_name: str, order_item_count: int):
-    order_id = str(uuid.uuid4())
-    try:
-        table: Table = _get_db_handler(table_name)
-        table.put_item(Item={'order_id': order_id, 'customer_name': customer_name, 'count': order_item_count})
-    except ClientError as exc:
-        error_msg = 'failed to create order'
-        logger.exception(error_msg, extra={'exception': str(exc), 'customer_name': customer_name})
-        raise InternalServerException(error_msg) from exc
-
-    logger.info('finished create order', extra={'order_id': order_id, 'order_item_count': order_item_count, 'customer_name': customer_name})
-    return Output(customer_name=customer_name, order_item_count=order_item_count, order_id=order_id)
+    order: OrderEntry = create_order_in_db(table_name, customer_name, order_item_count)
+    # convert from db entry to output, they won't always be the same
+    return CreateOrderOutput(customer_name=order.customer_name, order_item_count=order.order_item_count, order_id=order.order_id)

service/dal/schemas/db.py

@@ -4,7 +4,7 @@
 from pydantic import BaseModel, Field, PositiveInt, validator
 
 
-class Output(BaseModel):
+class CreateOrderOutput(BaseModel):
     order_item_count: PositiveInt
     customer_name: Annotated[str, Field(min_length=1, max_length=20)]
     order_id: str

service/handlers/create_order.py

@@ -61,15 +61,15 @@ def test_handler_200_ok(mocker, table_name: str):
     response = dynamodb_table.get_item(Key={'order_id': body_dict['order_id']})
     assert 'Item' in response  # order was found
     assert response['Item']['customer_name'] == customer_name
-    assert response['Item']['count'] == order_item_count
+    assert response['Item']['order_item_count'] == order_item_count
 
 
 def test_internal_server_error(mocker):
 
     def db_mock_function(table_name: str):
         raise ClientError(error_response={}, operation_name='put_item')
 
-    db_mock = mocker.patch('service.logic.handle_create_request._get_db_handler')
+    db_mock = mocker.patch('service.dal.db_handler._get_db_handler')
     db_mock.side_effect = db_mock_function
     body = Input(customer_name='RanTheBuilder', order_item_count=5)
     response = create_order(generate_api_gw_event(body.dict()), generate_context())

service/logic/handle_create_request.py

@@ -3,30 +3,30 @@
 import pytest
 from aws_lambda_powertools.utilities.parser import ValidationError
 
-from service.schemas.output import Output
+from service.schemas.output import CreateOrderOutput
 
 order_id = str(uuid.uuid4())
 
 
 def test_invalid_items_type():
     with pytest.raises(ValidationError):
-        Output(order_id=order_id, customer_name='3333', order_item_count='a')
+        CreateOrderOutput(order_id=order_id, customer_name='3333', order_item_count='a')
 
 
 def test_invalid_items_negative():
     with pytest.raises(ValidationError):
-        Output(order_id=order_id, customer_name='3333', order_item_count=-1)
+        CreateOrderOutput(order_id=order_id, customer_name='3333', order_item_count=-1)
 
 
 def test_invalid_items_zero():
     with pytest.raises(ValidationError):
-        Output(order_id=order_id, customer_name='3333', order_item_count=0)
+        CreateOrderOutput(order_id=order_id, customer_name='3333', order_item_count=0)
 
 
 def test_invalid_order_id():
     with pytest.raises(ValidationError):
-        Output(order_id='2', customer_name='3333', order_item_count=2)
+        CreateOrderOutput(order_id='2', customer_name='3333', order_item_count=2)
 
 
 def test_valid_output():
-    Output(customer_name='222', order_item_count=4, order_id=order_id)
+    CreateOrderOutput(customer_name='222', order_item_count=4, order_id=order_id)

service/schemas/output.py

@@ -1,7 +1,7 @@
 import pytest
 from botocore.exceptions import ClientError
 
-from service.logic.handle_create_request import _create_order_in_db
+from service.dal.db_handler import create_order_in_db
 from service.schemas.exceptions import InternalServerException
 
 
@@ -10,8 +10,8 @@ def test_raise_exception(mocker):
     def db_mock_function(table_name: str):
         raise ClientError(error_response={}, operation_name='put_item')
 
-    db_mock = mocker.patch('service.logic.handle_create_request._get_db_handler')
+    db_mock = mocker.patch('service.dal.db_handler._get_db_handler')
     db_mock.side_effect = db_mock_function
     with pytest.raises(InternalServerException):
-        _create_order_in_db(table_name='table', customer_name='customer', order_item_count=5)
+        create_order_in_db(table_name='table', customer_name='customer', order_item_count=5)
     db_mock.assert_called