more tests and updated readme

Author: timabilov

README.md

@@ -197,6 +197,18 @@ def update_user(user_id, name):
 # For manually resetting entity pass table name
 # for composite key pass tuple
 cache.invalidate_entity(User.__table__, user_id)  
+
+
+
+# Complex queries
+
+# Here we explicitly *have* to say that we stick to order entity to be tracked for changes
+@memory_cache(Order, id_key=lambda item: item[0].id)
+def get_orders_with_user(session: Session, order_id: str) -> List[Row[Tuple[Order, User]]]:
+    nonlocal call_count
+    call_count += 1
+    return session.query(Order, User).join(User).filter(Order.id == order_id).all()
+
 ```
 
 #### Django Integration
@@ -355,6 +367,7 @@ Main class for creating cache decorators.
 ```python
 cache = EntityCache(
     backend=None,  # CacheBackend instance (optional, will use in-memory if None)
+    global_supported_id_types=(int, str, UUID)  # Tuple of primitive types that are considered valid entity IDs.
     locked_ttl=3600,  # Default locked TTL in seconds, in case if set, decorator cannot override this value (optional)
     fail_on_missing_id=True, # Raise an error if an ID cannot be extracted from the result
     serializer=json.dumps,  # Custom serializer function (optional)
@@ -375,7 +388,8 @@ The traditional decorator for caching function results:
 ```python
 @cache(
     entity="user",  # Type of entity returned (string) or ORM model class (optional)
-    id_key="id",  # Field name or callable resolved to entity ID, not relevant on flat lists (optional)
+    id_key=None,  # default = 'id'. Field name or callable resolved to entity ID, not relevant on flat lists (optional)
+    supported_id_types = (int, str, UUID) # Types that are treated as valid entity IDs when extracted
     cache_key=None,  # Custom cache key for function (optional)
     normalize_args=False,  # Whether to normalize arguments (optional)
     ttl=None,  # Override default TTL, raises error if locked_ttl is set (optional)
@@ -404,24 +418,7 @@ def get_article(article_id):
 
 #### @cache.tracks()
 
-A more expressive alias for `@cache()` that clearly communicates the function's results will be cached and entity references will be tracked:
-
-```python
-@cache.tracks(
-    entity="user",  # Type of entity returned by this function (string or ORM model class)
-    id_key="id",    # How to extract entity IDs from results
-    # All other parameters from @cache() are supported
-)
-def get_user(user_id):
-    # ...
-
-# With ORM model class
-from myapp.models import User  # SQLAlchemy or Django model
-
-@cache.tracks(User)  # Automatically uses table name and extracts primary key
-def get_user(user_id):
-    # ...
-```
+A more expressive alias for `@cache()`
 
 #### @cache.invalidates()
 
@@ -568,7 +565,9 @@ poetry install
 
 ## TODO
 - [ ] Automatic ORM model detection, @cache.orm()
-- [ ] Refactory & Cleanup
+- [ ] MyPy Refactory & Cleanup
+- [ ] Introduce proper reverse index interface to not lock into Redis OSS comp
+- [ ] * By default RedisCompReverser should be used with multi-exec capability
 - [ ] Stale refs sweep scheduler / CLI comand
 - [ ] Tests
 

cacheref/cache.py

@@ -90,12 +90,12 @@ def update_user(user_id, data):
     def __init__(
         self,
         backend: Optional[CacheBackend] = None,
+        global_supported_id_types: Optional[Tuple] = (int, str, UUID),
         locked_ttl: Optional[int] = None,
         fail_on_missing_id: bool = True,
         serializer: Optional[Callable] = None,
         deserializer: Optional[Callable] = None,
         debug: bool = False,
-        global_supported_id_types: Optional[Tuple] = (int, str, UUID),
         enabled: bool = True,
     ):
         """
@@ -561,8 +561,8 @@ def _cache(self, fn_result: Any, func: Callable,
                     logger.debug("[Reverse index] Recache ready to execute")
                 else:
                     logger.debug("[Reverse index] Skipping reverse index recache"\
-                                 " for as either no entity or result is empty"\
-                                 f"{func=} {entity=} {fn_result=}")
+                                 f" for {func=} as either no entity or result is empty"\
+                                 f" {entity=} {fn_result=}")
                 pipeline.execute()
             except Exception as e:
                 logger.warning("Cache backend operations failed: %s", e, exc_info=True)

tests/test_sqlalchemy_integration.py

@@ -1,9 +1,10 @@
 """Tests for SQLAlchemy integration with cacheref."""
 
 import uuid
-from typing import List, Optional
+from typing import List, Optional, Tuple
 
 import pytest
+from sqlalchemy import Row
 from sqlalchemy.orm import as_declarative, declared_attr
 
 from cacheref import EntityCache
@@ -366,3 +367,53 @@ def get_order_by_product_id(session: Session, product_id: int) -> List[OrderItem
     oi = ois[0]
     assert oi.quantity == 3
     assert call_count == 2
+
+
+def test_cache_pair_of_objects_by_join(db_session):
+    """Test that caching with SQLAlchemy model works correctly."""
+    # Create cache
+    memory_cache = EntityCache(backend=MemoryBackend(key_prefix="sqlalchemy_test:"), debug=True)
+
+    # Counter to track function calls
+    call_count = 0
+
+    # Create cached function that selects product as entity for reference from returned pairs
+    @memory_cache(Order, id_key=lambda item: item[0].id)
+    def get_orders_with_user(session: Session, order_id: str) -> List[Row[Tuple[Order, User]]]:
+        nonlocal call_count
+        call_count += 1
+        return session.query(Order, User).join(User).filter(Order.id == order_id).all()
+    order_id = "order-123"
+    orders_with_user: List[Row[Tuple[Order, User]]] = get_orders_with_user(db_session, order_id)
+    assert len(orders_with_user) == 1, db_session.query(Product).filter(Product.product_id == order_id).all()
+    order, user = orders_with_user[0]
+    assert order is not None
+    assert order.id == order_id
+    assert order.user_id == 1
+    assert user is not None
+    assert user.id == 1
+    assert user.name == "Test User"
+    assert call_count == 1
+    # Second call should use the cache
+    orders_with_user: List[Row[Tuple[Order, User]]] = get_orders_with_user(db_session, order_id)
+    assert len(orders_with_user) == 1, db_session.query(Product).filter(Product.product_id == order_id).all()
+    order, user = orders_with_user[0]
+    assert order is not None
+    assert order.id == order_id
+    assert order.user_id == 1
+    assert user is not None
+    assert user.id == 1
+    assert user.name == "Test User"
+    assert call_count == 1
+    # Third call after invalidation should call the function
+    memory_cache.invalidate_entity(Order.__tablename__, order_id)
+    orders_with_user: List[Row[Tuple[Order, User]]] = get_orders_with_user(db_session, order_id)
+    assert len(orders_with_user) == 1, db_session.query(Product).filter(Product.product_id == order_id).all()
+    order, user = orders_with_user[0]
+    assert order is not None
+    assert order.id == order_id
+    assert order.user_id == 1
+    assert user is not None
+    assert user.id == 1
+    assert user.name == "Test User"
+    assert call_count == 2