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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modmex-lambda
-Version: 0.5.6
+Version: 0.5.8
 Summary: Ultra-lightweight AWS Lambda utilities for API Gateway routing and event handling.
 Author: Modmex
 License: MIT
@@ -13,7 +13,7 @@ Classifier: Programming Language :: Python :: 3.14
 Requires-Python: <4.0,>=3.10
 Requires-Dist: boto3<2.0.0,>=1.24.66
 Requires-Dist: injector<1.0.0,>=0.24.0
-Requires-Dist: modmex<2.0.0,>=1.1.10
+Requires-Dist: modmex<2.0.0,>=1.1.12
 Requires-Dist: pydash<9.0.0,>=5.1.2
 Requires-Dist: reactivex<5.0.0,>=4.0.4
 Requires-Dist: typing-extensions<5.0.0,>=4.5.0

modmex_lambda-0.5.8/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.8}/poetry.lock

@@ -246,16 +246,16 @@ files = [
 
 [[package]]
 name = "modmex"
-version = "1.1.10"
+version = "1.1.12"
 description = "Lightweight Python models built on dataclasses with validation, serialization, and type-safe data mapping"
 optional = false
 python-versions = ">=3.10"
 groups = ["main"]
 files = [
-    {file = "modmex-1.1.10-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:4ccb2436ece4d58b384e50847183b49c65d713e046fd3325ac2ce1c1498f1835"},
-    {file = "modmex-1.1.10-cp310-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:72d6667236a2937b1f7a79725bf7e0d2beef16bf317f4b37f5254a2333b002ee"},
-    {file = "modmex-1.1.10-cp310-abi3-win_amd64.whl", hash = "sha256:13751a4b3a39fdc6dc566527f5410694be009848df90ed07cbf793ad1d888dd9"},
-    {file = "modmex-1.1.10.tar.gz", hash = "sha256:9082d7e8319f4b8380b4e69edb1b60cfa61756b3ab1909f388285d90d4df3c08"},
+    {file = "modmex-1.1.12-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:af76140cf31556cfc82dc2c407f9d72cf67594c17348c9eb57e6fb5f883be39f"},
+    {file = "modmex-1.1.12-cp310-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:e8394ab4da78bd9ab1c53ef5552fa4a3fef3659f894a0cb1f0bb6a5fa8dd26cb"},
+    {file = "modmex-1.1.12-cp310-abi3-win_amd64.whl", hash = "sha256:7cd27992488c233b2ad0c90f83b74debe6dc316c28aa4322b76ddb0d3ae16ec0"},
+    {file = "modmex-1.1.12.tar.gz", hash = "sha256:654e276f196bf025d84b58150015cd0ee5de7e1feb52d74e5263de84f259c0f2"},
 ]
 
 [package.dependencies]
@@ -604,4 +604,4 @@ injector = ["injector"]
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.10,<4.0"
-content-hash = "4643613426d3b53766edd33cd497692e9b86fb855390112785c6da9c7a4ad45d"
+content-hash = "01ddd2e647add817fae38770a828cea5f1d2c93ca33aa0e8a193b2d5155f318e"

{modmex_lambda-0.5.6 → modmex_lambda-0.5.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "modmex-lambda"
-version = "0.5.6"
+version = "0.5.8"
 description = "Ultra-lightweight AWS Lambda utilities for API Gateway routing and event handling."
 readme = "README.md"
 requires-python = ">=3.10,<4.0"
@@ -18,12 +18,12 @@ classifiers = [
 license = { text = "MIT" }
 authors = [{ name = "Modmex" }]
 dependencies = [
-    "modmex (>=1.1.10,<2.0.0)",
     "boto3>=1.24.66,<2.0.0",
     "injector>=0.24.0,<1.0.0",
     "pydash>=5.1.2,<9.0.0",
     "reactivex>=4.0.4,<5.0.0",
     "typing-extensions>=4.5.0,<5.0.0",
+    "modmex (>=1.1.12,<2.0.0)",
 ]
 
 [project.optional-dependencies]

{modmex_lambda-0.5.6 → modmex_lambda-0.5.8}/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