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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modmex-lambda
-Version: 0.5.6
+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.6 → modmex_lambda-0.5.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "modmex-lambda"
-version = "0.5.6"
+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.6 → modmex_lambda-0.5.7}/tests/persistence/test_dynamodb_keys.py

@@ -27,26 +27,26 @@ def test_key_strategy_is_abstract() -> None:
         KeyStrategy()
 
 
-def test_single_entity_key_strategy_uses_id_as_pk_and_discriminator_as_sk() -> None:
+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_entity(Thing(id="thing-2")) == {"pk": "thing#thing-2", "sk": "thing"}
-    assert strategy.key_for_entity({"id": "thing-3"}) == {"pk": "thing#thing-3", "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_entity_id_and_tenant_scoped_sk() -> None:
+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_entity(Thing(id="thing-2", tenant_id="modmex")) == {
+    assert strategy.key_for_record(Thing(id="thing-2", tenant_id="modmex")) == {
         "pk": "thing#thing-2",
         "sk": "tenant#modmex",
     }
-    assert strategy.key_for_entity(Thing(id="thing-3", tenant_id="ignored"), tenant_id="acme") == {
+    assert strategy.key_for_record(Thing(id="thing-3", tenant_id="ignored"), tenant_id="acme") == {
         "pk": "thing#thing-3",
         "sk": "tenant#acme",
     }
@@ -60,20 +60,20 @@ def test_tenant_scoped_sort_key_strategy_supports_custom_field_and_separator() -
         tenant_field="account_id",
     )
 
-    assert strategy.key_for_entity(Thing(id="thing-1", account_id="acct-1")) == {
+    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_entity_scoped_sk() -> None:
+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_entity(Thing(id="thing-2", tenant_id="modmex")) == {
+    assert strategy.key_for_record(Thing(id="thing-2", tenant_id="modmex")) == {
         "pk": "tenant#modmex",
         "sk": "thing#thing-2",
     }
@@ -87,20 +87,20 @@ def test_tenant_partition_key_strategy_supports_custom_field_and_separator() ->
         tenant_field="account_id",
     )
 
-    assert strategy.key_for_entity(Thing(id="thing-1", account_id="acct-1")) == {
+    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_entity_sk() -> None:
+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_entity(Thing(id="item-2", aggregate_id="order-2")) == {
+    assert strategy.key_for_record(Thing(id="item-2", aggregate_id="order-2")) == {
         "pk": "order#order-2",
         "sk": "item#item-2",
     }
@@ -109,12 +109,90 @@ def test_aggregate_key_strategy_uses_aggregate_pk_and_entity_sk() -> None:
 def test_aggregate_key_strategy_supports_custom_field_and_separator() -> None:
     strategy = AggregateKeyStrategy("item", "order", separator=":", aggregate_field="order_id")
 
-    assert strategy.key_for_entity(Thing(id="item-1", order_id="order-1")) == {
+    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")
 
@@ -122,4 +200,4 @@ def test_required_context_errors_are_explicit() -> None:
         strategy.key_for_id("thing-1")
 
     with pytest.raises(AttributeError, match="tenant_id"):
-        strategy.key_for_entity(Thing(id="thing-1"))
+        strategy.key_for_record(Thing(id="thing-1"))

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

@@ -1,131 +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
-    separator: str = "#"
-
-    def key_for_id(self, entity_id: Any, **context: Any) -> dict[str, str]:
-        return {
-            "pk": f"{self.discriminator}{self.separator}{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 discriminator + entity 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, entity_id: Any, **context: Any) -> dict[str, str]:
-        tenant_id = _context_value(context, self.tenant_field)
-        return {
-            "pk": f"{self.discriminator}{self.separator}{entity_id}",
-            "sk": f"{self.tenant_name}{self.separator}{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})
-
-
-
-@dataclass(frozen=True)
-class TenantPartitionKeyStrategy(KeyStrategy):
-    """Use tenant name + tenant id as pk and discriminator + entity id as sk."""
-
-    discriminator: str
-    tenant_name: str = "tenant"
-    tenant_field: str = "tenant_id"
-    separator: str = "#"
-
-    def key_for_id(self, entity_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}{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})
-
-@dataclass(frozen=True)
-class AggregateKeyStrategy(KeyStrategy):
-    """Use aggregate name + aggregate id as pk and discriminator + entity id as sk."""
-
-    discriminator: str
-    aggregate_name: str
-    aggregate_field: str
-    separator: str = "#"
-    
-
-    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.discriminator}{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