modmex-lambda 0.5.5__tar.gz → 0.5.7__tar.gz

{modmex_lambda-0.5.5 → modmex_lambda-0.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modmex-lambda
-Version: 0.5.5
+Version: 0.5.7
 Summary: Ultra-lightweight AWS Lambda utilities for API Gateway routing and event handling.
 Author: Modmex
 License: MIT

modmex_lambda-0.5.7/modmex_lambda/persistence/dynamodb/keys.py

@@ -0,0 +1,212 @@
+"""Reusable DynamoDB key strategies.
+
+These helpers keep key-shaping decisions explicit while letting repositories
+stay focused on persistence behavior.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any, Callable, Mapping
+
+
+
+AggregateNameResolver = Callable[..., str]
+AggregateIdResolver = Callable[..., str]
+
+
+class KeyStrategy(ABC):
+    """Build DynamoDB primary keys for ids and entities."""
+
+    @abstractmethod
+    def key_for_id(self, record_id: Any, **context: Any) -> dict[str, str]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def key_for_record(self, record: Any, **context: Any) -> dict[str, str]:
+        raise NotImplementedError
+
+
+@dataclass(frozen=True)
+class SingleEntityKeyStrategy(KeyStrategy):
+    """Use the record id as pk and a fixed discriminator as sk."""
+
+    discriminator: str
+    separator: str = "#"
+
+    def key_for_id(self, record_id: Any, **context: Any) -> dict[str, str]:
+        return {
+            "pk": f"{self.discriminator}{self.separator}{record_id}",
+            "sk": self.discriminator,
+        }
+
+    def key_for_record(self, record: Any, **context: Any) -> dict[str, str]:
+        return self.key_for_id(_record_attr(record, "id"), **context)
+
+
+@dataclass(frozen=True)
+class TenantScopedSortKeyStrategy(KeyStrategy):
+    """Use discriminator + record id as pk and tenant name + tenant id as sk."""
+
+    discriminator: str
+    tenant_name: str = "tenant"
+    tenant_field: str = "tenant_id"
+    separator: str = "#"
+
+    def key_for_id(self, record_id: Any, **context: Any) -> dict[str, str]:
+        tenant_id = _context_value(context, self.tenant_field)
+        return {
+            "pk": f"{self.discriminator}{self.separator}{record_id}",
+            "sk": f"{self.tenant_name}{self.separator}{tenant_id}",
+        }
+
+    def key_for_record(self, record: Any, **context: Any) -> dict[str, str]:
+        tenant_id = _context_or_record_value(context, record, self.tenant_field)
+        return self.key_for_id(_record_attr(record, "id"), **{self.tenant_field: tenant_id})
+
+
+
+@dataclass(frozen=True)
+class TenantPartitionKeyStrategy(KeyStrategy):
+    """Use tenant name + tenant id as pk and discriminator + record id as sk."""
+
+    discriminator: str
+    tenant_name: str = "tenant"
+    tenant_field: str = "tenant_id"
+    separator: str = "#"
+
+    def key_for_id(self, record_id: Any, **context: Any) -> dict[str, str]:
+        tenant_id = _context_value(context, self.tenant_field)
+        return {
+            "pk": f"{self.tenant_name}{self.separator}{tenant_id}",
+            "sk": f"{self.discriminator}{self.separator}{record_id}",
+        }
+
+    def key_for_record(self, record: Any, **context: Any) -> dict[str, str]:
+        tenant_id = _context_or_record_value(context, record, self.tenant_field)
+        return self.key_for_id(_record_attr(record, "id"), **{self.tenant_field: tenant_id})
+
+@dataclass(frozen=True)
+class AggregateKeyStrategy(KeyStrategy):
+    """Use aggregate name + aggregate id as pk and discriminator + record id as sk."""
+
+    discriminator: str
+    aggregate_name: str | AggregateNameResolver
+    aggregate_field: str | AggregateIdResolver
+    separator: str = "#"
+
+    def key_for_id(self, record_id: Any, **context: Any) -> dict[str, str]:
+        aggregate_name = self._resolve_aggregate_name(
+            record=None,
+            record_id=record_id,
+            context=context,
+        )
+
+        aggregate_id = self._resolve_aggregate_id(
+            record=None,
+            record_id=record_id,
+            context=context,
+        )
+
+        return self._build_key(
+            aggregate_name=aggregate_name,
+            aggregate_id=aggregate_id,
+            record_id=record_id,
+        )
+
+    def key_for_record(self, record: Any, **context: Any) -> dict[str, str]:
+        record_id = _record_attr(record, "id")
+
+        aggregate_name = self._resolve_aggregate_name(
+            record=record,
+            record_id=record_id,
+            context=context,
+        )
+
+        aggregate_id = self._resolve_aggregate_id(
+            record=record,
+            record_id=record_id,
+            context=context,
+        )
+
+        return self._build_key(
+            aggregate_name=aggregate_name,
+            aggregate_id=aggregate_id,
+            record_id=record_id,
+        )
+
+    def _build_key(
+        self,
+        *,
+        aggregate_name: str,
+        aggregate_id: Any,
+        record_id: Any,
+    ) -> dict[str, str]:
+        return {
+            "pk": f"{aggregate_name}{self.separator}{aggregate_id}",
+            "sk": f"{self.discriminator}{self.separator}{record_id}",
+        }
+
+    def _resolve_aggregate_name(
+        self,
+        *,
+        record: Any | None,
+        record_id: Any,
+        context: Mapping[str, Any],
+    ) -> str:
+        if callable(self.aggregate_name):
+            return self.aggregate_name(
+                record=record,
+                record_id=record_id,
+                context=context,
+            )
+
+        return self.aggregate_name
+
+    def _resolve_aggregate_id(
+        self,
+        *,
+        record: Any | None,
+        record_id: Any,
+        context: Mapping[str, Any],
+    ) -> Any:
+        if callable(self.aggregate_field):
+            return self.aggregate_field(
+                record=record,
+                record_id=record_id,
+                context=context,
+            )
+
+        if record is None:
+            return _context_value(context, self.aggregate_field)
+
+        return _context_or_record_value(context, record, self.aggregate_field)
+    
+
+
+def _context_value(context: dict[str, Any], field_name: str) -> Any:
+    if field_name in context and context[field_name] is not None:
+        return context[field_name]
+    raise KeyError(f"Missing required key context: {field_name}")
+
+
+def _context_or_record_value(context: dict[str, Any], record: Any, field_name: str) -> Any:
+    if field_name in context and context[field_name] is not None:
+        return context[field_name]
+    value = _record_attr(record, field_name)
+    if value is not None:
+        return value
+    raise AttributeError(f"record is missing required field: {field_name}")
+
+
+def _record_attr(record: Any, field_name: str) -> Any:
+    if isinstance(record, dict):
+        try:
+            return record[field_name]
+        except KeyError as exc:
+            raise AttributeError(f"record is missing required field: {field_name}") from exc
+    try:
+        return getattr(record, field_name)
+    except AttributeError as exc:
+        raise AttributeError(f"record is missing required field: {field_name}") from exc

{modmex_lambda-0.5.5 → modmex_lambda-0.5.7}/modmex_lambda/persistence/dynamodb/materialized_views.py

@@ -55,7 +55,7 @@ class MaterializedViewMixin(DynamoDBUpdateRequestMixin):
 
     def materialized_key(self, uow: dict[str, Any], entity: dict[str, Any]) -> dict[str, Any]:
         return {
-            "pk": entity["id"],
+            "pk": entity.get('pk') or entity.get('id'),
             "sk": entity.get("sk", self.discriminator),
         }
 

{modmex_lambda-0.5.5 → modmex_lambda-0.5.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "modmex-lambda"
-version = "0.5.5"
+version = "0.5.7"
 description = "Ultra-lightweight AWS Lambda utilities for API Gateway routing and event handling."
 readme = "README.md"
 requires-python = ">=3.10,<4.0"

modmex_lambda-0.5.7/tests/persistence/test_dynamodb_keys.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import pytest
+
+from modmex_lambda.persistence.dynamodb import (
+    AggregateKeyStrategy,
+    KeyStrategy,
+    SingleEntityKeyStrategy,
+    TenantPartitionKeyStrategy,
+    TenantScopedSortKeyStrategy,
+)
+
+
+@dataclass
+class Thing:
+    id: str
+    tenant_id: str | None = None
+    aggregate_id: str | None = None
+    account_id: str | None = None
+    order_id: str | None = None
+
+
+def test_key_strategy_is_abstract() -> None:
+    with pytest.raises(TypeError):
+        KeyStrategy()
+
+
+def test_single_record_key_strategy_uses_id_as_pk_and_discriminator_as_sk() -> None:
+    strategy = SingleEntityKeyStrategy("thing")
+
+    assert strategy.key_for_id("thing-1") == {"pk": "thing#thing-1", "sk": "thing"}
+    assert strategy.key_for_record(Thing(id="thing-2")) == {"pk": "thing#thing-2", "sk": "thing"}
+    assert strategy.key_for_record({"id": "thing-3"}) == {"pk": "thing#thing-3", "sk": "thing"}
+
+
+def test_tenant_scoped_sort_key_strategy_uses_record_id_and_tenant_scoped_sk() -> None:
+    strategy = TenantScopedSortKeyStrategy("thing")
+
+    assert strategy.key_for_id("thing-1", tenant_id="acme") == {
+        "pk": "thing#thing-1",
+        "sk": "tenant#acme",
+    }
+    assert strategy.key_for_record(Thing(id="thing-2", tenant_id="modmex")) == {
+        "pk": "thing#thing-2",
+        "sk": "tenant#modmex",
+    }
+    assert strategy.key_for_record(Thing(id="thing-3", tenant_id="ignored"), tenant_id="acme") == {
+        "pk": "thing#thing-3",
+        "sk": "tenant#acme",
+    }
+
+
+def test_tenant_scoped_sort_key_strategy_supports_custom_field_and_separator() -> None:
+    strategy = TenantScopedSortKeyStrategy(
+        "thing",
+        tenant_name="account",
+        separator=":",
+        tenant_field="account_id",
+    )
+
+    assert strategy.key_for_record(Thing(id="thing-1", account_id="acct-1")) == {
+        "pk": "thing:thing-1",
+        "sk": "account:acct-1",
+    }
+
+
+def test_tenant_partition_key_strategy_uses_tenant_as_pk_and_record_scoped_sk() -> None:
+    strategy = TenantPartitionKeyStrategy("thing")
+
+    assert strategy.key_for_id("thing-1", tenant_id="acme") == {
+        "pk": "tenant#acme",
+        "sk": "thing#thing-1",
+    }
+    assert strategy.key_for_record(Thing(id="thing-2", tenant_id="modmex")) == {
+        "pk": "tenant#modmex",
+        "sk": "thing#thing-2",
+    }
+
+
+def test_tenant_partition_key_strategy_supports_custom_field_and_separator() -> None:
+    strategy = TenantPartitionKeyStrategy(
+        "thing",
+        tenant_name="account",
+        separator=":",
+        tenant_field="account_id",
+    )
+
+    assert strategy.key_for_record(Thing(id="thing-1", account_id="acct-1")) == {
+        "pk": "account:acct-1",
+        "sk": "thing:thing-1",
+    }
+
+
+def test_aggregate_key_strategy_uses_aggregate_pk_and_record_sk() -> None:
+    strategy = AggregateKeyStrategy("item", "order", "aggregate_id")
+
+    assert strategy.key_for_id("item-1", aggregate_id="order-1") == {
+        "pk": "order#order-1",
+        "sk": "item#item-1",
+    }
+    assert strategy.key_for_record(Thing(id="item-2", aggregate_id="order-2")) == {
+        "pk": "order#order-2",
+        "sk": "item#item-2",
+    }
+
+
+def test_aggregate_key_strategy_supports_custom_field_and_separator() -> None:
+    strategy = AggregateKeyStrategy("item", "order", separator=":", aggregate_field="order_id")
+
+    assert strategy.key_for_record(Thing(id="item-1", order_id="order-1")) == {
+        "pk": "order:order-1",
+        "sk": "item:item-1",
+    }
+
+
+def test_aggregate_key_strategy_for_entity_with_callable() -> None:
+    strategy = AggregateKeyStrategy(
+        discriminator="audit",
+        aggregate_name=lambda record, **_: record.entity_type,
+        aggregate_field=lambda record, **_: record.entity_id,
+    )
+
+    @dataclass
+    class Audit:
+        id: str
+        entity_type: str
+        entity_id: str
+
+    entity = Audit(id="audit-1", entity_type="order", entity_id="order-1")
+
+    assert strategy.key_for_record(entity) == {
+        "pk": "order#order-1",
+        "sk": "audit#audit-1",
+    }
+
+
+def test_aggregate_key_strategy_for_id_with_callable() -> None:
+    strategy = AggregateKeyStrategy(
+        discriminator="audit",
+        aggregate_name=lambda context, **_: context["entity_type"],
+        aggregate_field=lambda context, **_: context["entity_id"],
+    )
+
+    assert strategy.key_for_id(
+        "audit-1",
+        entity_type="order",
+        entity_id="order-1",
+    ) == {
+        "pk": "order#order-1",
+        "sk": "audit#audit-1",
+    }
+
+
+def test_aggregate_key_strategy_callable_aggregate_name_supports_record_and_id() -> None:
+    @dataclass
+    class Audit:
+        id: str
+        entity_type: str
+        entity_id: str
+
+    strategy = AggregateKeyStrategy(
+        discriminator="audit",
+        aggregate_name=lambda record=None, context=None, **_: (
+            record.entity_type if record is not None else context["entity_type"]
+        ),
+        aggregate_field=lambda record=None, context=None, **_: (
+            record.entity_id if record is not None else context["entity_id"]
+        ),
+        separator="#",
+    )
+
+    entity = Audit(
+        id="audit-1",
+        entity_type="order",
+        entity_id="order-1",
+    )
+
+    assert strategy.key_for_record(entity) == {
+        "pk": "order#order-1",
+        "sk": "audit#audit-1",
+    }
+
+    assert strategy.key_for_id(
+        "audit-1",
+        entity_type="order",
+        entity_id="order-1",
+    ) == {
+        "pk": "order#order-1",
+        "sk": "audit#audit-1",
+    }
+
+
+
+def test_required_context_errors_are_explicit() -> None:
+    strategy = TenantPartitionKeyStrategy("thing")
+
+    with pytest.raises(KeyError, match="tenant_id"):
+        strategy.key_for_id("thing-1")
+
+    with pytest.raises(AttributeError, match="tenant_id"):
+        strategy.key_for_record(Thing(id="thing-1"))

{modmex_lambda-0.5.5 → modmex_lambda-0.5.7}/tests/persistence/test_dynamodb_materialized_views.py

@@ -56,7 +56,7 @@ def test_materialized_view_mixin_replicates_event_entity_with_stream_fields(monk
             "timestamp": 1548967022000,
             "thing": {
                 "id": "thing-1",
-                "pk": "ignored",
+                "pk": "thing#thing-1",
                 "sk": "thing",
                 "name": "Desk",
             },
@@ -65,7 +65,7 @@ def test_materialized_view_mixin_replicates_event_entity_with_stream_fields(monk
 
     request = ThingMaterializer().to_materialized_update_request(uow)
 
-    assert request["Key"] == {"pk": "thing-1", "sk": "thing"}
+    assert request["Key"] == {"pk": "thing#thing-1", "sk": "thing"}
     assert request["ExpressionAttributeValues"][":id"] == "thing-1"
     assert request["ExpressionAttributeValues"][":name"] == "Desk"
     assert request["ExpressionAttributeValues"][":discriminator"] == "thing"

modmex_lambda-0.5.5/modmex_lambda/persistence/dynamodb/keys.py

@@ -1,133 +0,0 @@
-"""Reusable DynamoDB key strategies.
-
-These helpers keep key-shaping decisions explicit while letting repositories
-stay focused on persistence behavior.
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from typing import Any
-
-
-class KeyStrategy(ABC):
-    """Build DynamoDB primary keys for ids and entities."""
-
-    @abstractmethod
-    def key_for_id(self, entity_id: Any, **context: Any) -> dict[str, str]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def key_for_entity(self, entity: Any, **context: Any) -> dict[str, str]:
-        raise NotImplementedError
-
-
-@dataclass(frozen=True)
-class SingleEntityKeyStrategy(KeyStrategy):
-    """Use the entity id as pk and a fixed discriminator as sk."""
-
-    discriminator: str
-
-    def key_for_id(self, entity_id: Any, **context: Any) -> dict[str, str]:
-        return {
-            "pk": str(entity_id),
-            "sk": self.discriminator,
-        }
-
-    def key_for_entity(self, entity: Any, **context: Any) -> dict[str, str]:
-        return self.key_for_id(_entity_attr(entity, "id"), **context)
-
-
-@dataclass(frozen=True)
-class TenantScopedSortKeyStrategy(KeyStrategy):
-    """Use entity id as pk and discriminator plus tenant id as sk."""
-
-    discriminator: str
-    separator: str = "#"
-    tenant_field: str = "tenant_id"
-
-    def key_for_id(self, entity_id: Any, **context: Any) -> dict[str, str]:
-        tenant_id = _context_value(context, self.tenant_field)
-        return {
-            "pk": str(entity_id),
-            "sk": self._sort_key(tenant_id),
-        }
-
-    def key_for_entity(self, entity: Any, **context: Any) -> dict[str, str]:
-        tenant_id = _context_or_entity_value(context, entity, self.tenant_field)
-        return self.key_for_id(_entity_attr(entity, "id"), **{self.tenant_field: tenant_id})
-
-    def _sort_key(self, tenant_id: Any) -> str:
-        return f"{self.discriminator}{self.separator}{tenant_id}"
-
-
-@dataclass(frozen=True)
-class TenantPartitionKeyStrategy(KeyStrategy):
-    """Use tenant id as pk and discriminator plus entity id as sk."""
-
-    discriminator: str
-    separator: str = "#"
-    tenant_field: str = "tenant_id"
-
-    def key_for_id(self, entity_id: Any, **context: Any) -> dict[str, str]:
-        tenant_id = _context_value(context, self.tenant_field)
-        return {
-            "pk": str(tenant_id),
-            "sk": self._sort_key(entity_id),
-        }
-
-    def key_for_entity(self, entity: Any, **context: Any) -> dict[str, str]:
-        tenant_id = _context_or_entity_value(context, entity, self.tenant_field)
-        return self.key_for_id(_entity_attr(entity, "id"), **{self.tenant_field: tenant_id})
-
-    def _sort_key(self, entity_id: Any) -> str:
-        return f"{self.discriminator}{self.separator}{entity_id}"
-
-
-@dataclass(frozen=True)
-class AggregateKeyStrategy(KeyStrategy):
-    """Use aggregate id as pk and entity name plus entity id as sk."""
-
-    aggregate_name: str
-    entity_name: str
-    separator: str = "#"
-    aggregate_field: str = "aggregate_id"
-
-    def key_for_id(self, entity_id: Any, **context: Any) -> dict[str, str]:
-        aggregate_id = _context_value(context, self.aggregate_field)
-        return {
-            "pk": f"{self.aggregate_name}{self.separator}{aggregate_id}",
-            "sk": f"{self.entity_name}{self.separator}{entity_id}",
-        }
-
-    def key_for_entity(self, entity: Any, **context: Any) -> dict[str, str]:
-        aggregate_id = _context_or_entity_value(context, entity, self.aggregate_field)
-        return self.key_for_id(_entity_attr(entity, "id"), **{self.aggregate_field: aggregate_id})
-
-
-def _context_value(context: dict[str, Any], field_name: str) -> Any:
-    if field_name in context and context[field_name] is not None:
-        return context[field_name]
-    raise KeyError(f"Missing required key context: {field_name}")
-
-
-def _context_or_entity_value(context: dict[str, Any], entity: Any, field_name: str) -> Any:
-    if field_name in context and context[field_name] is not None:
-        return context[field_name]
-    value = _entity_attr(entity, field_name)
-    if value is not None:
-        return value
-    raise AttributeError(f"Entity is missing required field: {field_name}")
-
-
-def _entity_attr(entity: Any, field_name: str) -> Any:
-    if isinstance(entity, dict):
-        try:
-            return entity[field_name]
-        except KeyError as exc:
-            raise AttributeError(f"Entity is missing required field: {field_name}") from exc
-    try:
-        return getattr(entity, field_name)
-    except AttributeError as exc:
-        raise AttributeError(f"Entity is missing required field: {field_name}") from exc