persistence-kit 3.6.0__tar.gz → 3.7.0__tar.gz

{persistence_kit-3.6.0 → persistence_kit-3.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: persistence-kit
-Version: 3.6.0
+Version: 3.7.0
 Summary: Reusable persistence and repository toolkit
 License: MIT
 License-File: LICENSE
@@ -69,6 +69,11 @@ Author: Andres Felipe Serrano Barrios
 - `security/`: reusable identity provider contracts, Cognito/memory adapters, and JWT verifiers
 - `repository/`: concrete repository implementations by backend
 - `repository_factory/`: entity registry, repository creation, and populated view repository
+- `resilience/`: retry policy and circuit breaker shared across the kit
+- `restclient/`: generic REST/HTTP client (transport, pluggable auth, endpoint resolvers, DTO mapper) with optional response caching
+- `cache/`: generic key-value cache with TTL (in-memory, Mongo, DynamoDB), selected by `CACHE_BACKEND`
+
+See `docs/restclient_and_cache.md` for the REST client and cache.
 
 Recommended rule:
 
@@ -167,6 +172,22 @@ from persistence_kit.repository_factory import (
     provide_view_repo,
     set_registry_initializer,
 )
+from persistence_kit.restclient import (
+    RestClient,
+    ServiceConfig,
+    register_rest_service,
+    get_rest_client,
+    provide_rest_client,
+    set_rest_registry_initializer,
+    decode,
+)
+from persistence_kit.cache import (
+    Cache,
+    InMemoryTTLCache,
+    get_cache,
+    CacheBackend,
+    CacheSettings,
+)
 ```
 
 Use internal paths only for implementation details, for example:
@@ -273,7 +294,10 @@ the reusable FastAPI local export route.
 
 ## Supported Environment Variables
 
-- `REPO_DATABASE=memory|mongo|postgres`
+- `REPO_DATABASE=memory|mongo|postgres|dynamodb`
+- `CACHE_BACKEND=memory|mongo|dynamodb` (default `memory`; backend for `get_cache` / the REST client cache)
+- `CACHE_NAMESPACE` (optional key prefix; isolates apps that share one cache, e.g. a common DynamoDB table)
+- `REST_SERVICE_URLS` (JSON map `{"service": "base_url"}` to override registered REST base URLs)
 - `MONGO_DSN`
 - `MONGO_DB`
 - `POSTGRES_USER`
@@ -281,6 +305,8 @@ the reusable FastAPI local export route.
 - `POSTGRES_HOST`
 - `POSTGRES_PORT`
 - `POSTGRES_DB`
+- `DYNAMODB_REGION`
+- `DYNAMODB_TABLE_PREFIX`
 
 ## Local Development
 

{persistence_kit-3.6.0 → persistence_kit-3.7.0}/README.md

@@ -25,6 +25,11 @@ Author: Andres Felipe Serrano Barrios
 - `security/`: reusable identity provider contracts, Cognito/memory adapters, and JWT verifiers
 - `repository/`: concrete repository implementations by backend
 - `repository_factory/`: entity registry, repository creation, and populated view repository
+- `resilience/`: retry policy and circuit breaker shared across the kit
+- `restclient/`: generic REST/HTTP client (transport, pluggable auth, endpoint resolvers, DTO mapper) with optional response caching
+- `cache/`: generic key-value cache with TTL (in-memory, Mongo, DynamoDB), selected by `CACHE_BACKEND`
+
+See `docs/restclient_and_cache.md` for the REST client and cache.
 
 Recommended rule:
 
@@ -123,6 +128,22 @@ from persistence_kit.repository_factory import (
     provide_view_repo,
     set_registry_initializer,
 )
+from persistence_kit.restclient import (
+    RestClient,
+    ServiceConfig,
+    register_rest_service,
+    get_rest_client,
+    provide_rest_client,
+    set_rest_registry_initializer,
+    decode,
+)
+from persistence_kit.cache import (
+    Cache,
+    InMemoryTTLCache,
+    get_cache,
+    CacheBackend,
+    CacheSettings,
+)
 ```
 
 Use internal paths only for implementation details, for example:
@@ -229,7 +250,10 @@ the reusable FastAPI local export route.
 
 ## Supported Environment Variables
 
-- `REPO_DATABASE=memory|mongo|postgres`
+- `REPO_DATABASE=memory|mongo|postgres|dynamodb`
+- `CACHE_BACKEND=memory|mongo|dynamodb` (default `memory`; backend for `get_cache` / the REST client cache)
+- `CACHE_NAMESPACE` (optional key prefix; isolates apps that share one cache, e.g. a common DynamoDB table)
+- `REST_SERVICE_URLS` (JSON map `{"service": "base_url"}` to override registered REST base URLs)
 - `MONGO_DSN`
 - `MONGO_DB`
 - `POSTGRES_USER`
@@ -237,6 +261,8 @@ the reusable FastAPI local export route.
 - `POSTGRES_HOST`
 - `POSTGRES_PORT`
 - `POSTGRES_DB`
+- `DYNAMODB_REGION`
+- `DYNAMODB_TABLE_PREFIX`
 
 ## Local Development
 

persistence_kit-3.7.0/persistence_kit/cache/__init__.py

@@ -0,0 +1,15 @@
+from persistence_kit.cache.contracts import Cache
+from persistence_kit.cache.factory import get_cache, reset_cache
+from persistence_kit.cache.memory import InMemoryTTLCache
+from persistence_kit.cache.namespaced import NamespacedCache
+from persistence_kit.settings.cache_settings import CacheBackend, CacheSettings
+
+__all__ = [
+    "Cache",
+    "InMemoryTTLCache",
+    "NamespacedCache",
+    "get_cache",
+    "reset_cache",
+    "CacheBackend",
+    "CacheSettings",
+]

persistence_kit-3.7.0/persistence_kit/cache/contracts.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from typing import Any, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class Cache(Protocol):
+    """Almacen clave-valor con expiracion opcional (TTL).
+
+    Los backends (memoria, Mongo, Dynamo) son intercambiables; el valor debe ser
+    serializable a JSON para los backends persistentes.
+    """
+
+    async def get(self, key: str) -> Any | None: ...
+
+    async def set(self, key: str, value: Any, ttl_seconds: float | None = None) -> None: ...
+
+    async def delete(self, key: str) -> None: ...
+
+    async def clear(self, prefix: str = "") -> int:
+        """Borra todas las claves que empiezan con ``prefix`` (o todo si vacio).
+        Devuelve cuantas borro."""
+        ...

persistence_kit-3.7.0/persistence_kit/cache/factory.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from functools import lru_cache
+
+from persistence_kit.cache.contracts import Cache
+from persistence_kit.settings.cache_settings import CacheBackend, CacheSettings
+
+
+@lru_cache
+def _mongo_collection(dsn: str, dbname: str, name: str):
+    from motor.motor_asyncio import AsyncIOMotorClient
+
+    return AsyncIOMotorClient(dsn, uuidRepresentation="standard")[dbname][name]
+
+
+@lru_cache
+def _cache_cached(name: str, backend: CacheBackend) -> Cache:
+    if backend is CacheBackend.MEMORY:
+        from persistence_kit.cache.memory import InMemoryTTLCache
+
+        return InMemoryTTLCache()
+
+    if backend is CacheBackend.MONGO:
+        from persistence_kit.cache.mongo import MongoCache
+        from persistence_kit.settings.repo_settings import RepoSettings
+
+        repo = RepoSettings()
+        collection = _mongo_collection(repo.mongo_dsn, repo.mongo_db, f"cache_{name}")
+        return MongoCache(collection)
+
+    if backend is CacheBackend.DYNAMODB:
+        raise NotImplementedError("DynamoCache pendiente (paso 2 del plan de cache).")
+
+    raise ValueError(f"Cache backend no soportado: {backend}")
+
+
+def get_cache(name: str = "default") -> Cache:
+    """Devuelve el cache para ``name``, con el backend elegido por el setting
+    ``CACHE_BACKEND`` (gemelo de ``get_repo`` con ``REPO_DATABASE``).
+
+    Si ``CACHE_NAMESPACE`` esta seteado, todas las claves se prefijan con el, para
+    aislar apps que comparten un mismo cache (p. ej. una tabla DynamoDB comun).
+    """
+    settings = CacheSettings()
+    cache = _cache_cached(name, settings.cache_backend)
+    if settings.cache_namespace:
+        from persistence_kit.cache.namespaced import NamespacedCache
+
+        return NamespacedCache(cache, settings.cache_namespace)
+    return cache
+
+
+def reset_cache() -> None:
+    _cache_cached.cache_clear()
+    _mongo_collection.cache_clear()

persistence_kit-3.7.0/persistence_kit/cache/memory.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import time
+from typing import Any
+
+
+class InMemoryTTLCache:
+    """Cache en memoria del proceso con expiracion perezosa por TTL.
+
+    Es por-proceso: cada instancia/tarea tiene la suya y se pierde al reiniciar.
+    """
+
+    def __init__(self) -> None:
+        self._store: dict[str, tuple[Any, float | None]] = {}
+
+    async def get(self, key: str) -> Any | None:
+        entry = self._store.get(key)
+        if entry is None:
+            return None
+        value, expires_at = entry
+        if expires_at is not None and time.monotonic() >= expires_at:
+            self._store.pop(key, None)
+            return None
+        return value
+
+    async def set(self, key: str, value: Any, ttl_seconds: float | None = None) -> None:
+        expires_at = time.monotonic() + ttl_seconds if ttl_seconds else None
+        self._store[key] = (value, expires_at)
+
+    async def delete(self, key: str) -> None:
+        self._store.pop(key, None)
+
+    async def clear(self, prefix: str = "") -> int:
+        keys = [key for key in self._store if key.startswith(prefix)]
+        for key in keys:
+            self._store.pop(key, None)
+        return len(keys)

persistence_kit-3.7.0/persistence_kit/cache/mongo.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import re
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+from motor.motor_asyncio import AsyncIOMotorCollection
+
+
+class MongoCache:
+    """Cache respaldado por una coleccion Mongo con indice TTL nativo sobre
+    ``expiresAt`` (el servidor borra los documentos expirados solo).
+
+    El monitor TTL de Mongo corre cada ~60s, por eso ``get`` valida la expiracion
+    ademas del indice, para no devolver un documento recien vencido.
+    """
+
+    def __init__(self, collection: AsyncIOMotorCollection) -> None:
+        self._col = collection
+        self._index_ready = False
+
+    async def _ensure_index(self) -> None:
+        if not self._index_ready:
+            await self._col.create_index("expiresAt", expireAfterSeconds=0)
+            self._index_ready = True
+
+    async def get(self, key: str) -> Any | None:
+        doc = await self._col.find_one({"_id": key})
+        if doc is None:
+            return None
+        expires_at = doc.get("expiresAt")
+        if expires_at is not None:
+            if expires_at.tzinfo is None:
+                expires_at = expires_at.replace(tzinfo=timezone.utc)
+            if expires_at <= datetime.now(timezone.utc):
+                return None
+        return doc.get("value")
+
+    async def set(self, key: str, value: Any, ttl_seconds: float | None = None) -> None:
+        await self._ensure_index()
+        doc: dict[str, Any] = {"_id": key, "value": value}
+        if ttl_seconds:
+            doc["expiresAt"] = datetime.now(timezone.utc) + timedelta(seconds=ttl_seconds)
+        await self._col.replace_one({"_id": key}, doc, upsert=True)
+
+    async def delete(self, key: str) -> None:
+        await self._col.delete_one({"_id": key})
+
+    async def clear(self, prefix: str = "") -> int:
+        if prefix:
+            query = {"_id": {"$regex": f"^{re.escape(prefix)}"}}
+        else:
+            query = {}
+        result = await self._col.delete_many(query)
+        return result.deleted_count

persistence_kit-3.7.0/persistence_kit/cache/namespaced.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import Any
+
+from persistence_kit.cache.contracts import Cache
+
+
+class NamespacedCache:
+    """Prefija todas las claves con ``namespace:`` para aislar aplicaciones que
+    comparten un mismo cache.
+
+    Util cuando varias apps (p. ej. store_manager y siga) usan la misma tabla
+    DynamoDB o la misma coleccion Mongo: cada app pone su ``CACHE_NAMESPACE`` y
+    sus claves no colisionan.
+    """
+
+    def __init__(self, inner: Cache, namespace: str) -> None:
+        self._inner = inner
+        self._prefix = f"{namespace}:"
+
+    async def get(self, key: str) -> Any | None:
+        return await self._inner.get(self._prefix + key)
+
+    async def set(self, key: str, value: Any, ttl_seconds: float | None = None) -> None:
+        await self._inner.set(self._prefix + key, value, ttl_seconds)
+
+    async def delete(self, key: str) -> None:
+        await self._inner.delete(self._prefix + key)
+
+    async def clear(self, prefix: str = "") -> int:
+        return await self._inner.clear(self._prefix + prefix)

{persistence_kit-3.6.0 → persistence_kit-3.7.0}/persistence_kit/restclient/__init__.py

@@ -58,8 +58,10 @@ from persistence_kit.restclient.resolver import (
     StaticEndpointResolver,
 )
 from persistence_kit.restclient.retry import RetryPolicy
+from persistence_kit.restclient.caching import CachingRestClient
 
 __all__ = [
+    "CachingRestClient",
     "RestClient",
     "RestRequest",
     "RestResponse",

persistence_kit-3.7.0/persistence_kit/restclient/caching.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import asyncio
+import base64
+import hashlib
+import json as _json
+import logging
+import time
+from typing import Any, Awaitable, Callable, Mapping
+
+from persistence_kit.cache.contracts import Cache
+from persistence_kit.restclient.contracts import RestClient, RestResponse
+
+logger = logging.getLogger(__name__)
+
+OnChange = Callable[[str], None]
+
+
+def _serialize(response: RestResponse) -> dict[str, Any]:
+    return {
+        "status_code": response.status_code,
+        "headers": dict(response.headers),
+        "content_b64": base64.b64encode(response.content).decode("ascii"),
+        "url": response.url,
+    }
+
+
+def _deserialize(data: Mapping[str, Any]) -> RestResponse:
+    return RestResponse(
+        status_code=data["status_code"],
+        headers=dict(data["headers"]),
+        content=base64.b64decode(data["content_b64"]),
+        url=data["url"],
+    )
+
+
+class CachingRestClient:
+    """Decora un RestClient con cache de respuestas idempotentes (GET) y
+    deteccion de cambios por hash de contenido.
+
+    La cacheabilidad se controla por la config del servicio
+    (``cache_ttl_seconds``) o por-llamada con el parametro ``cache_ttl`` de
+    ``request``: ``None`` usa el default del servicio, ``0`` no cachea esa
+    llamada (bypass), y un valor ``> 0`` cachea con ese TTL.
+
+    Cada entry guarda ``{response, hash, stored_at}``. Dentro del TTL fresco se
+    sirve del cache; dentro de la ventana ``stale-while-revalidate`` se sirve el
+    valor viejo Y se dispara una revalidacion en background (sin bloquear, sin
+    jobs): re-consulta, compara el hash y, si cambio, actualiza y llama
+    ``on_change(key)``.
+    """
+
+    def __init__(
+        self,
+        inner: RestClient,
+        cache: Cache,
+        *,
+        default_ttl_seconds: float | None = None,
+        default_swr_seconds: float = 0.0,
+        name: str = "",
+        on_change: OnChange | None = None,
+        cacheable_methods: tuple[str, ...] = ("GET",),
+    ) -> None:
+        self._inner = inner
+        self._cache = cache
+        self._default_ttl = default_ttl_seconds
+        self._default_swr = default_swr_seconds
+        self._name = name
+        self._on_change = on_change
+        self._methods = frozenset(method.upper() for method in cacheable_methods)
+        self._inflight: set[str] = set()
+
+    def _key(self, method: str, service: str, params: Mapping[str, Any] | None) -> str:
+        params_repr = _json.dumps(params or {}, sort_keys=True, default=str)
+        return f"{self._name}|{method}|{service}|{params_repr}"
+
+    async def request(
+        self,
+        method: str,
+        service: str,
+        *,
+        params: Mapping[str, Any] | None = None,
+        json: Any | None = None,
+        xml: Any | None = None,
+        content: bytes | None = None,
+        content_type: str | None = None,
+        soap_action: str | None = None,
+        headers: Mapping[str, str] | None = None,
+        cache_ttl: float | None = None,
+    ) -> RestResponse:
+        fresh = cache_ttl if cache_ttl is not None else self._default_ttl
+        swr = self._default_swr
+
+        cacheable = (
+            method.upper() in self._methods
+            and json is None
+            and xml is None
+            and content is None
+            and fresh is not None
+            and fresh > 0
+        )
+
+        async def _fetch() -> RestResponse:
+            return await self._inner.request(
+                method,
+                service,
+                params=params,
+                json=json,
+                xml=xml,
+                content=content,
+                content_type=content_type,
+                soap_action=soap_action,
+                headers=headers,
+            )
+
+        if not cacheable:
+            return await _fetch()
+
+        key = self._key(method.upper(), service, params)
+        entry = await self._cache.get(key)
+        now = time.time()
+
+        if entry is not None:
+            age = now - entry.get("stored_at", now)
+            if age < fresh:
+                return _deserialize(entry["response"])
+            if swr and age < fresh + swr:
+                self._schedule_revalidate(key, entry.get("hash"), _fetch, fresh, swr)
+                return _deserialize(entry["response"])
+
+        response = await _fetch()
+        if response.is_success:
+            await self._store(key, response, fresh, swr, now)
+        return response
+
+    async def _store(
+        self, key: str, response: RestResponse, fresh: float, swr: float, now: float
+    ) -> None:
+        value = {
+            "response": _serialize(response),
+            "hash": hashlib.sha256(response.content).hexdigest(),
+            "stored_at": now,
+        }
+        await self._cache.set(key, value, fresh + (swr or 0.0))
+
+    def _schedule_revalidate(
+        self,
+        key: str,
+        old_hash: str | None,
+        fetch: Callable[[], Awaitable[RestResponse]],
+        fresh: float,
+        swr: float,
+    ) -> None:
+        if key in self._inflight:
+            return
+        self._inflight.add(key)
+
+        async def _run() -> None:
+            try:
+                response = await fetch()
+                if response.is_success:
+                    new_hash = hashlib.sha256(response.content).hexdigest()
+                    await self._store(key, response, fresh, swr, time.time())
+                    if new_hash != old_hash:
+                        logger.info("cache: cambio detectado en %s", key)
+                        if self._on_change is not None:
+                            self._on_change(key)
+            except Exception:
+                logger.exception("cache: fallo revalidando %s", key)
+            finally:
+                self._inflight.discard(key)
+
+        asyncio.create_task(_run())
+
+    async def aclose(self) -> None:
+        await self._inner.aclose()

{persistence_kit-3.6.0 → persistence_kit-3.7.0}/persistence_kit/restclient/client.py

@@ -72,6 +72,7 @@ class HttpxRestClient(ModelMappingMixin):
         content_type: str | None = None,
         soap_action: str | None = None,
         headers: Mapping[str, str] | None = None,
+        cache_ttl: float | None = None,
     ) -> RestResponse:
         url = await self._resolver.resolve(service)
         request = prepare_request(

{persistence_kit-3.6.0 → persistence_kit-3.7.0}/persistence_kit/restclient/config.py

@@ -15,6 +15,9 @@ class ServiceConfig(BaseModel):
     raise_for_status: bool = True
     default_headers: dict[str, str] = Field(default_factory=dict)
     user_agent: str | None = None
+    cacheable: bool = False
+    cache_ttl_seconds: float | None = None
+    cache_stale_while_revalidate_seconds: float = 0.0
 
     @classmethod
     def from_settings(cls, settings: Any, **overrides: Any) -> "ServiceConfig":

{persistence_kit-3.6.0 → persistence_kit-3.7.0}/persistence_kit/restclient/contracts.py

@@ -94,6 +94,7 @@ class RestClient(Protocol):
         content_type: str | None = None,
         soap_action: str | None = None,
         headers: Mapping[str, str] | None = None,
+        cache_ttl: float | None = None,
     ) -> RestResponse: ...
 
     async def aclose(self) -> None: ...

{persistence_kit-3.6.0 → persistence_kit-3.7.0}/persistence_kit/restclient/memory.py

@@ -82,6 +82,7 @@ class MemoryRestClient(ModelMappingMixin):
         content_type: str | None = None,
         soap_action: str | None = None,
         headers: Mapping[str, str] | None = None,
+        cache_ttl: float | None = None,
     ) -> RestResponse:
         url = await self._resolver.resolve(service) if self._resolver else service
         request = prepare_request(

{persistence_kit-3.6.0 → persistence_kit-3.7.0}/persistence_kit/restclient/provider.py

@@ -46,6 +46,7 @@ def register_rest_service(
     config: ServiceConfig | None = None,
     retry_policy: RetryPolicy | None = None,
     circuit_breaker: CircuitBreaker | None = None,
+    on_cache_change: Callable[[str], None] | None = None,
     replace: bool = False,
 ) -> None:
     default_rest_registry().register(
@@ -56,6 +57,7 @@ def register_rest_service(
         config=config,
         retry_policy=retry_policy,
         circuit_breaker=circuit_breaker,
+        on_cache_change=on_cache_change,
         replace=replace,
     )
 

{persistence_kit-3.6.0 → persistence_kit-3.7.0}/persistence_kit/restclient/registry.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, Callable
 
 from persistence_kit.resilience import CircuitBreaker
 from persistence_kit.restclient.auth.base import NoAuth
@@ -24,6 +24,7 @@ class RegisteredService:
     authenticator: Authenticator
     retry_policy: RetryPolicy | None = None
     circuit_breaker: CircuitBreaker | None = None
+    on_cache_change: Callable[[str], None] | None = None
 
 
 class RestClientRegistry:
@@ -59,6 +60,7 @@ class RestClientRegistry:
         config: ServiceConfig | None = None,
         retry_policy: RetryPolicy | None = None,
         circuit_breaker: CircuitBreaker | None = None,
+        on_cache_change: Callable[[str], None] | None = None,
         replace: bool = False,
     ) -> "RestClientRegistry":
         if name in self._services and not replace:
@@ -70,6 +72,7 @@ class RestClientRegistry:
             authenticator=authenticator or NoAuth(),
             retry_policy=retry_policy,
             circuit_breaker=circuit_breaker,
+            on_cache_change=on_cache_change,
         )
         self._clients.pop(name, None)
         return self
@@ -90,13 +93,27 @@ class RestClientRegistry:
                 "Instala con `persistence-kit[restclient]`."
             ) from exc
 
-        client = HttpxRestClient(
+        client: RestClient = HttpxRestClient(
             config=service.config,
             resolver=service.resolver,
             authenticator=service.authenticator,
             retry_policy=service.retry_policy,
             circuit_breaker=service.circuit_breaker,
         )
+
+        if service.config.cache_ttl_seconds or service.config.cacheable:
+            from persistence_kit.cache.factory import get_cache
+            from persistence_kit.restclient.caching import CachingRestClient
+
+            client = CachingRestClient(
+                client,
+                get_cache("restclient"),
+                default_ttl_seconds=service.config.cache_ttl_seconds,
+                default_swr_seconds=service.config.cache_stale_while_revalidate_seconds,
+                name=name,
+                on_change=service.on_cache_change,
+            )
+
         self._clients[name] = client
         return client
 

persistence_kit-3.7.0/persistence_kit/settings/cache_settings.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class CacheBackend(str, Enum):
+    MEMORY = "memory"
+    MONGO = "mongo"
+    DYNAMODB = "dynamodb"
+
+
+class CacheSettings(BaseSettings):
+    cache_backend: CacheBackend = CacheBackend.MEMORY
+    cache_namespace: str = ""
+
+    model_config = SettingsConfigDict(env_file=".env", extra="ignore")

{persistence_kit-3.6.0 → persistence_kit-3.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "persistence-kit"
-version = "3.6.0"
+version = "3.7.0"
 description = "Reusable persistence and repository toolkit"
 authors = ["Andres Felipe Serrano Barrios <andresfserrano1@gmail.com>"]
 readme = "README.md"