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

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

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

{modmex_lambda-0.5.4 → modmex_lambda-0.5.6}/modmex_lambda/dependencies.py

@@ -4,21 +4,23 @@ from __future__ import annotations
 
 import inspect
 from importlib import import_module
-from typing import TYPE_CHECKING, Any, Callable, Protocol
+from typing import TYPE_CHECKING, Any, Callable, Protocol, TypeVar
 
 if TYPE_CHECKING:
     from modmex_lambda.connectors import AwsConnectorsModule
 
 
+T = TypeVar("T")
+
 class DependencyResolver(Protocol):
     """Resolves a dependency token into the value passed to a handler."""
 
     def resolve(
         self,
-        dependency: Callable[..., Any] | type[Any],
+        dependency: type[T],
         *,
         values: dict[str, Any] | None = None,
-    ) -> Any:
+    ) -> T:
         ...
 
 
@@ -27,10 +29,10 @@ class DefaultDependencyResolver:
 
     def resolve(
         self,
-        dependency: Callable[..., Any] | type[Any],
+        dependency: type[T],
         *,
         values: dict[str, Any] | None = None,
-    ) -> Any:
+    ) -> T:
         return dependency(**(values or {}))
 
 
@@ -42,10 +44,10 @@ class InjectorDependencyResolver:
 
     def resolve(
         self,
-        dependency: Callable[..., Any] | type[Any],
+        dependency: type[T],
         *,
         values: dict[str, Any] | None = None,
-    ) -> Any:
+    ) -> T:
         kwargs = values or {}
 
         if hasattr(self.injector, "call_with_injection") and not inspect.isclass(dependency):

{modmex_lambda-0.5.4 → modmex_lambda-0.5.6}/modmex_lambda/persistence/dynamodb/keys.py

@@ -28,10 +28,11 @@ 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": str(entity_id),
+            "pk": f"{self.discriminator}{self.separator}{entity_id}",
             "sk": self.discriminator,
         }
 
@@ -41,64 +42,61 @@ class SingleEntityKeyStrategy(KeyStrategy):
 
 @dataclass(frozen=True)
 class TenantScopedSortKeyStrategy(KeyStrategy):
-    """Use entity id as pk and discriminator plus tenant id as sk."""
+    """Use discriminator + entity id as pk and tenant name + tenant id as sk."""
 
     discriminator: str
-    separator: 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": str(entity_id),
-            "sk": self._sort_key(tenant_id),
+            "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})
 
-    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."""
+    """Use tenant name + tenant id as pk and discriminator + entity id as sk."""
 
     discriminator: str
-    separator: 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": str(tenant_id),
-            "sk": self._sort_key(entity_id),
+            "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})
 
-    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."""
+    """Use aggregate name + aggregate id as pk and discriminator + entity id as sk."""
 
+    discriminator: str
     aggregate_name: str
-    entity_name: str
+    aggregate_field: 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}",
+            "sk": f"{self.discriminator}{self.separator}{entity_id}",
         }
 
     def key_for_entity(self, entity: Any, **context: Any) -> dict[str, str]:

{modmex_lambda-0.5.4 → modmex_lambda-0.5.6}/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.4 → modmex_lambda-0.5.6}/pyproject.toml

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

@@ -30,34 +30,39 @@ def test_key_strategy_is_abstract() -> None:
 def test_single_entity_key_strategy_uses_id_as_pk_and_discriminator_as_sk() -> None:
     strategy = SingleEntityKeyStrategy("thing")
 
-    assert strategy.key_for_id("thing-1") == {"pk": "thing-1", "sk": "thing"}
-    assert strategy.key_for_entity(Thing(id="thing-2")) == {"pk": "thing-2", "sk": "thing"}
-    assert strategy.key_for_entity({"id": "thing-3"}) == {"pk": "thing-3", "sk": "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"}
 
 
 def test_tenant_scoped_sort_key_strategy_uses_entity_id_and_tenant_scoped_sk() -> None:
     strategy = TenantScopedSortKeyStrategy("thing")
 
     assert strategy.key_for_id("thing-1", tenant_id="acme") == {
-        "pk": "thing-1",
-        "sk": "thing#acme",
+        "pk": "thing#thing-1",
+        "sk": "tenant#acme",
     }
     assert strategy.key_for_entity(Thing(id="thing-2", tenant_id="modmex")) == {
-        "pk": "thing-2",
-        "sk": "thing#modmex",
+        "pk": "thing#thing-2",
+        "sk": "tenant#modmex",
     }
     assert strategy.key_for_entity(Thing(id="thing-3", tenant_id="ignored"), tenant_id="acme") == {
-        "pk": "thing-3",
-        "sk": "thing#acme",
+        "pk": "thing#thing-3",
+        "sk": "tenant#acme",
     }
 
 
 def test_tenant_scoped_sort_key_strategy_supports_custom_field_and_separator() -> None:
-    strategy = TenantScopedSortKeyStrategy("thing", separator=":", tenant_field="account_id")
+    strategy = TenantScopedSortKeyStrategy(
+        "thing",
+        tenant_name="account",
+        separator=":",
+        tenant_field="account_id",
+    )
 
     assert strategy.key_for_entity(Thing(id="thing-1", account_id="acct-1")) == {
-        "pk": "thing-1",
-        "sk": "thing:acct-1",
+        "pk": "thing:thing-1",
+        "sk": "account:acct-1",
     }
 
 
@@ -65,26 +70,31 @@ def test_tenant_partition_key_strategy_uses_tenant_as_pk_and_entity_scoped_sk()
     strategy = TenantPartitionKeyStrategy("thing")
 
     assert strategy.key_for_id("thing-1", tenant_id="acme") == {
-        "pk": "acme",
+        "pk": "tenant#acme",
         "sk": "thing#thing-1",
     }
     assert strategy.key_for_entity(Thing(id="thing-2", tenant_id="modmex")) == {
-        "pk": "modmex",
+        "pk": "tenant#modmex",
         "sk": "thing#thing-2",
     }
 
 
 def test_tenant_partition_key_strategy_supports_custom_field_and_separator() -> None:
-    strategy = TenantPartitionKeyStrategy("thing", separator=":", tenant_field="account_id")
+    strategy = TenantPartitionKeyStrategy(
+        "thing",
+        tenant_name="account",
+        separator=":",
+        tenant_field="account_id",
+    )
 
     assert strategy.key_for_entity(Thing(id="thing-1", account_id="acct-1")) == {
-        "pk": "acct-1",
+        "pk": "account:acct-1",
         "sk": "thing:thing-1",
     }
 
 
 def test_aggregate_key_strategy_uses_aggregate_pk_and_entity_sk() -> None:
-    strategy = AggregateKeyStrategy("order", "item")
+    strategy = AggregateKeyStrategy("item", "order", "aggregate_id")
 
     assert strategy.key_for_id("item-1", aggregate_id="order-1") == {
         "pk": "order#order-1",
@@ -97,7 +107,7 @@ 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("order", "item", separator=":", aggregate_field="order_id")
+    strategy = AggregateKeyStrategy("item", "order", separator=":", aggregate_field="order_id")
 
     assert strategy.key_for_entity(Thing(id="item-1", order_id="order-1")) == {
         "pk": "order:order-1",

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