altcodepro-polydb-python 2.5.19__py3-none-any.whl → 2.5.21__py3-none-any.whl

{altcodepro_polydb_python-2.5.19.dist-info → altcodepro_polydb_python-2.5.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: altcodepro-polydb-python
-Version: 2.5.19
+Version: 2.5.21
 Summary: Production-ready multi-cloud database abstraction layer with connection pooling, retry logic, and thread safety
 Author: AltCodePro
 Project-URL: Homepage, https://github.com/altcodepro/polydb-python

{altcodepro_polydb_python-2.5.19.dist-info → altcodepro_polydb_python-2.5.21.dist-info}/RECORD

@@ -1,12 +1,12 @@
-altcodepro_polydb_python-2.5.19.dist-info/licenses/LICENSE,sha256=9X8GLocsBwy-5aR5JGOt2SAMDDPs9Qv-YnqmHBHOXrw,1067
+altcodepro_polydb_python-2.5.21.dist-info/licenses/LICENSE,sha256=9X8GLocsBwy-5aR5JGOt2SAMDDPs9Qv-YnqmHBHOXrw,1067
 polydb/PolyDB.py,sha256=Lp0QtG7D89Z6P6nt9fVoT8rVHAy8xlE2kFRSS70r-mk,23672
-polydb/__init__.py,sha256=p9dAWJ3-JNCeHgb1WzkTMkuURFQy-RUNI4QeD9zBVf0,1876
+polydb/__init__.py,sha256=fNrKwNBgwMJKrBhs_eaRu4XpQ3olREipIOiwBmv38b8,1876
 polydb/advanced_query.py,sha256=M9sKmdF2PsLZWSc-zKpXRcwaDumbYYTsibmL_IAjKP4,6931
 polydb/aio.py,sha256=0EQ6hXrf6N4If6pcht6L9B7qz0PU2yGahyGzEss2eQg,8340
 polydb/batch.py,sha256=ulvSdtVeofsOiVNVAQwrE9tXIIaP8fjiW1Sbpz3dcv0,4093
 polydb/cache.py,sha256=ArI0zRbuhAYd6kn4TPVMBHBptdRmuZyy05_hwIATUsQ,11784
 polydb/cloudDatabaseFactory.py,sha256=eJiNKycdaC9nO2BKWPjkig3GaNGkNjoJci6yVJC7A_c,25301
-polydb/databaseFactory.py,sha256=8A6Nmx0TTBxyVxLBMTBPp-sxuO7SeUWF5eVlG0I8WCE,54546
+polydb/databaseFactory.py,sha256=0gjc5wk0zkOsCqOY7ET8klaNG8wZMPJhKOvzmdYTwr0,59610
 polydb/errors.py,sha256=AtXCLdzkHE2ncUaE1P0wH5HmIyW3NXx9KHL-fCejjA4,1832
 polydb/json_safe.py,sha256=jj3ZA6gImGwgTO0dCZVcckjeUHtewa2HP6OA1-u6VZ0,137
 polydb/models.py,sha256=Pq_63FXu1IiTxl-RshZ2vmoe-5m5k6qft-tXpHLn-70,12600
@@ -17,22 +17,22 @@ polydb/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 polydb/query.py,sha256=17V-e70df9NaiaUYPN5_MQz7O0vRdBaCR4xlZU3F2YE,8511
 polydb/registry.py,sha256=RD_elvFXcmhTdCyZDm2f3ej0elxqhArnSJ2aO9k5VCU,2352
 polydb/retry.py,sha256=0rILN3-auuzomOXPveIAvgnhBbtXXGNKvxg6qcRgN4g,4926
-polydb/schema.py,sha256=jDjUuOaz2DANddhMTSxMwZ1MB-EOVDgDrCHbxkp-iM4,7712
+polydb/schema.py,sha256=v3lnD9jUoBippMj2eLNwvmykPygO0nFx806X7cmeb8Q,9840
 polydb/security.py,sha256=IF8Oh6Y6YU9xSjz_pi6lotfJuhIUJgP7cCmpGc8bz6w,20158
-polydb/types.py,sha256=Z1R8z06-WYoh7cnn0oE_2N10v6hdx7VJD7TNL5ynWhA,2667
+polydb/types.py,sha256=Kx_d9_XJP9UnIbABaVCOcWiBEem_cfUrDwiPc3uaxCY,2825
 polydb/utils.py,sha256=YS-BhBpQfQsOf-z_i1zw_kvMYwJ05Zn1S2Xt6K4_2ak,3171
 polydb/validation.py,sha256=DK9-AFndTr0cLodpc3KX0wnABDpw2vPB4H6hp67BJKE,4570
 polydb/adapters/AWSSecretsManagerAdapter.py,sha256=W4B3xhQFcBAlNlwQ4uTgcDmRrOmZr6v-suC4qihTpJw,2747
 polydb/adapters/AzureBlobStorageAdapter.py,sha256=ZTovSC_CVduGnIoIQUUeNxDQlf-IbFDBRzjGDk8U9Io,7084
 polydb/adapters/AzureFileStorageAdapter.py,sha256=VZNprqlBXCuWUgtqClNT-NrQmRf-XFYEiRA2BLbf-Sc,7046
-polydb/adapters/AzureKeyVaultAdapter.py,sha256=7Nizs9qGh6cytbZNgV78f-odOO4Z6sUlwm_HQYqt-pc,2339
+polydb/adapters/AzureKeyVaultAdapter.py,sha256=EtsrxI3X75nORnO0KbvKTVXJfliHd-gt3y9Mo8Npugs,3365
 polydb/adapters/AzureQueueAdapter.py,sha256=1e2HiFvkH1BI_JKS9fgays2J41kOfH6pUPbZDe1wmWA,13658
-polydb/adapters/AzureTableStorageAdapter.py,sha256=u2DsUIMOjYnBX_2G4abaLCjRaVOCORQQnwC4e0XrJ0Q,35567
+polydb/adapters/AzureTableStorageAdapter.py,sha256=oW80ZeCsj8hkIlmlrv404rsB8m5TA9_nHL5OM57WQSg,38068
 polydb/adapters/BlockchainBlobAdapter.py,sha256=85H3PxiL9rGDtK-sTsW26jOuUQ_SGipLSPu3s-juZRA,3298
 polydb/adapters/BlockchainFileAdapter.py,sha256=lZbRyC18LghZcVh5QyIRP7tCftNF_Ep1FKG0KRkvMmk,8335
 polydb/adapters/BlockchainKVAdapter.py,sha256=pvpiPshDE5Z_IRcSBvBwgAXT--86lgEyIsEUeqcmoE8,5422
 polydb/adapters/BlockchainQueueAdapter.py,sha256=n1MD1JJmHslwC_RrZrhlAVgXBZ4fXlV67eokxrhLelU,4195
-polydb/adapters/DynamoDBAdapter.py,sha256=XlNhS6lLeeET-1uZlz1m3nE3lS_DYGXaT6LB1reiLZs,19399
+polydb/adapters/DynamoDBAdapter.py,sha256=vVQig4hhbgnrI2gcCIqj8gGzycjt2d51HYWIH30kenU,19943
 polydb/adapters/EFSAdapter.py,sha256=yB243Mf7pCb60233CQag6z5GbOSU_hirzYZL26w5_88,2937
 polydb/adapters/FirestoreAdapter.py,sha256=WCYZ6EThZgDGsdJcKXBFXHckdLnIY9jvtVYHSb3z7ao,15260
 polydb/adapters/GCPFilestoreAdapter.py,sha256=LqYqGwFlbNxkYhx0uQ14sTeWPlyvWK6lKIpAxDEIC4A,3006
@@ -57,7 +57,7 @@ polydb/audit/__init__.py,sha256=VANh47kW5V9gi7anUCZ7LklQ6ofaFRmBKrPVitRxdw0,245
 polydb/audit/context.py,sha256=jbw58vDoslY2mEcS0qUBlEhYg54EoMk4Xcfuq1L3FuY,1945
 polydb/audit/manager.py,sha256=DgBkDcZlf_EotUm-RlKA1CWAoVi3DIUlRCsN4wzsfgc,1237
 polydb/audit/models.py,sha256=XHT-te2XpmdywfakKm1cVH09yi3C9Fa4FaBTZaJ5vqY,7044
-polydb/base/NoSQLKVAdapter.py,sha256=TJ9jyYiLA26WmxJjGuL5DbQ00ZN-RYTV-IznN7RwMw4,16927
+polydb/base/NoSQLKVAdapter.py,sha256=9nG--KZ1Q0-KTc6n_i1nBIGDlSgOVEei0-QhBmqC_tI,17175
 polydb/base/ObjectStorageAdapter.py,sha256=mr6UMGmAFOBKlJeoyubaUJ7x7BDZMlylqnuggIatEv0,2289
 polydb/base/QueueAdapter.py,sha256=PzTlEuc37TXEnYNdsrrmxzFworbieWBxljDXJ-qq4XQ,8206
 polydb/base/SecretsAdapter.py,sha256=RaWejh21oQji0TdEBa7P5JgD9y6N06M1aCBbLvzTQU0,990
@@ -68,7 +68,7 @@ polydb/observability/logging.py,sha256=FWYky-Mg1IhLpwuaKuLIsTROBZc9bI_-AO-y53nvE
 polydb/services/__init__.py,sha256=Zs3PZbHutgPdPjJatygvtYvKPZMBt1qKSqESbFRPHJs,241
 polydb/services/compliance_service.py,sha256=UMjCbQ4z13-w6pT4RLQpMi_u1zbShEpiz8kawA2WsSU,5075
 polydb/services/security_service.py,sha256=gGo_j9Ca_rgvxS7s6C5JUktugQBj1PV1DXpMnOYAGbI,4992
-altcodepro_polydb_python-2.5.19.dist-info/METADATA,sha256=jxSgbkqTALqYYLf5XwA6qNZPY--DLXDSdsxCwbItZR8,15599
-altcodepro_polydb_python-2.5.19.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-altcodepro_polydb_python-2.5.19.dist-info/top_level.txt,sha256=WgLFWJoYjUhwvyPxJFl6jYLrVFuBJDX3OABf4ocwk_E,7
-altcodepro_polydb_python-2.5.19.dist-info/RECORD,,
+altcodepro_polydb_python-2.5.21.dist-info/METADATA,sha256=SbnlRNiCE6ZiK4aVCr5-Znz4R4xUJpDQyh10PQYpO34,15599
+altcodepro_polydb_python-2.5.21.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+altcodepro_polydb_python-2.5.21.dist-info/top_level.txt,sha256=WgLFWJoYjUhwvyPxJFl6jYLrVFuBJDX3OABf4ocwk_E,7
+altcodepro_polydb_python-2.5.21.dist-info/RECORD,,

polydb/__init__.py

@@ -4,7 +4,7 @@ PolyDB - Enterprise Cloud-Independent Database Abstraction
 Full LINQ support, field-level audit, cache, soft delete, overflow storage
 """
 
-__version__ = "2.5.18"
+__version__ = "2.5.20"
 
 from .aio import AsyncDatabaseFactory, AsyncPolyDB
 from .audit.context import AuditContext

polydb/adapters/AzureKeyVaultAdapter.py

@@ -19,10 +19,24 @@ class AzureKeyVaultAdapter(SecretsAdapter):
         self._initialize_client()
 
     def _initialize_client(self) -> None:
-        from azure.identity import DefaultAzureCredential
         from azure.keyvault.secrets import SecretClient
 
-        self._client = SecretClient(vault_url=self.vault_url, credential=DefaultAzureCredential())
+        self._client = SecretClient(vault_url=self.vault_url, credential=self._build_credential())
+
+    @staticmethod
+    def _build_credential():
+        """Inside Azure Container Apps / App Service / Functions a managed identity is available
+        (IDENTITY_ENDPOINT / MSI_ENDPOINT). DefaultAzureCredential tries EnvironmentCredential FIRST, and a deployment that
+        also exports AZURE_CLIENT_ID + AZURE_CLIENT_SECRET (for some other purpose) then fails with AADSTS7000232
+        "MSI identity should not use ClientSecretCredential". So when a managed identity exists it goes first
+        (AZURE_CLIENT_ID, if set, names a user-assigned identity); the normal chain stays as the fallback, so local
+        development (az login, environment variables) behaves as before."""
+        from azure.identity import ChainedTokenCredential, DefaultAzureCredential, ManagedIdentityCredential
+
+        if os.getenv("IDENTITY_ENDPOINT") or os.getenv("MSI_ENDPOINT"):
+            client_id = os.getenv("AZURE_CLIENT_ID") or None
+            return ChainedTokenCredential(ManagedIdentityCredential(client_id=client_id), DefaultAzureCredential())
+        return DefaultAzureCredential()
 
     # Key Vault secret names may only contain alphanumerics and dashes --
     # our secret keys (e.g. "tenant-42/stripe/api_key") use slashes, so

polydb/adapters/AzureTableStorageAdapter.py

@@ -47,6 +47,59 @@ _RETRY_TOTAL = int(os.getenv("AZURE_TABLE_RETRY_TOTAL", "3"))
 logging.getLogger("azure").setLevel(logging.ERROR)
 
 
+
+def _is_table_missing(exc: BaseException) -> bool:
+    text = f"{type(exc).__name__} {exc}"
+    return "TableNotFound" in text or "The table specified does not exist" in text
+
+
+class _SelfHealingTableClient:
+    """Wraps an Azure TableClient so a table that disappears while the process is running (deleted by hand, a data
+    reset, a restore) is created again and the operation retried once, instead of failing with TableNotFound until
+    the process restarts. Lazy iterators (query_entities / list_entities) are healed only if the failure happens
+    before the first row was produced."""
+
+    _LAZY = ("query_entities", "list_entities")
+
+    def __init__(self, adapter: "AzureTableStorageAdapter", table_name: str, client: Any):
+        self._adapter = adapter
+        self._table_name = table_name
+        self._client = client
+
+    def _heal(self) -> None:
+        self._adapter._ensured_tables.discard(self._table_name)
+        self._adapter._client.create_table_if_not_exists(self._table_name)
+        self._adapter._ensured_tables.add(self._table_name)
+        logger.warning(f"Azure Table {self._table_name} was missing; created it again")
+
+    def __getattr__(self, name: str):
+        target = getattr(self._client, name)
+        if not callable(target):
+            return target
+        if name in self._LAZY:
+            def lazy(*args, **kwargs):
+                produced = False
+                try:
+                    for item in target(*args, **kwargs):
+                        produced = True
+                        yield item
+                except Exception as exc:  # noqa: BLE001
+                    if produced or not _is_table_missing(exc):
+                        raise
+                    self._heal()
+                    yield from getattr(self._client, name)(*args, **kwargs)
+            return lazy
+
+        def call(*args, **kwargs):
+            try:
+                return target(*args, **kwargs)
+            except Exception as exc:  # noqa: BLE001
+                if not _is_table_missing(exc):
+                    raise
+                self._heal()
+                return getattr(self._client, name)(*args, **kwargs)
+        return call
+
 class AzureTableStorageAdapter(NoSQLKVAdapter):
     """
     Azure Table Storage adapter with:
@@ -441,17 +494,21 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
                 try:
                     self._client.create_table_if_not_exists(table_name)
                     logger.info(f"✅ Azure Table ensured/created: {table_name}")
+                    self._ensured_tables.add(table_name)
                 except Exception as e:
                     msg = str(e)
-                    if "TableAlreadyExists" not in msg and "already exists" not in msg.lower():
-                        logger.warning(f"Could not create table {table_name}: {e}")
-                self._ensured_tables.add(table_name)
+                    if "TableAlreadyExists" in msg or "already exists" in msg.lower():
+                        self._ensured_tables.add(table_name)
+                    else:
+                        # Do NOT remember a failed creation as "ensured": the next call tries again instead of
+                        # failing with TableNotFound for the rest of the process's life.
+                        logger.error(f"Could not create table {table_name}: {e}")
 
             if cached is None:
                 cached = self._client.get_table_client(table_name=table_name)
                 self._table_clients_cache[table_name] = cached
 
-            return cached
+            return _SelfHealingTableClient(self, table_name, cached)
 
     def _restore_overflow_properties(self, entity_dict: JsonDict) -> JsonDict:
         restored = {}

polydb/adapters/DynamoDBAdapter.py

@@ -196,6 +196,13 @@ class DynamoDBAdapter(NoSQLKVAdapter):
     def _blob_key(self, model: type, pk: str, rk: str, checksum: str) -> str:
         return f"overflow/{self._table_name(model)}/{pk}/{rk}/{checksum}.json"
 
+    def _check_overflow(self, data: JsonDict):  # type: ignore[override]
+        """DynamoDB overflows inside `_put_raw` (`_maybe_overflow_to_s3`, into this adapter's own bucket), never in the
+        base class. The base whole-record overflow replaced the record with a stub pointing at a key in the separate
+        object store, which `_resolve_overflow` (it reads this adapter's bucket) can never find -- the record was lost
+        on read. Returning the data untouched leaves the one working path in charge."""
+        return data, None
+
     def _maybe_overflow_to_s3(
         self, model: type, pk: str, rk: str, payload: JsonDict
     ) -> Optional[JsonDict]:

polydb/base/NoSQLKVAdapter.py

@@ -291,7 +291,9 @@ class NoSQLKVAdapter:
     ) -> Tuple[List[JsonDict], Optional[str]]:
         # Basic implementation - override per provider
         offset = int(continuation_token) if continuation_token else 0
-        results = self.query(model, query, limit=page_size + 1)
+        # Fetch through the end of THIS page (+1 to learn whether another follows) and drop what earlier pages already
+        # returned -- reading from the start every time made every page after the first a repeat of the first.
+        results = self.query(model, query, limit=offset + page_size + 1)[offset:]
 
         has_more = len(results) > page_size
         if has_more:

polydb/databaseFactory.py

@@ -19,7 +19,7 @@ from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
 
-from tenacity import retry, stop_after_attempt, wait_exponential
+from tenacity import retry, retry_if_exception, stop_after_attempt, wait_exponential
 
 from .adapters.PostgreSQLAdapter import PostgreSQLAdapter
 from .audit.context import AuditContext
@@ -32,6 +32,7 @@ from .errors import AdapterConfigurationError
 from .models import PageRequest, PageResult
 from .monitoring import HealthCheck, MetricsCollector, PerformanceMonitor
 from .query import QueryBuilder
+from .retry import _is_non_retryable
 from .security import DataMasking, FieldEncryption
 from .types import JsonDict, Lookup, ModelMeta
 
@@ -53,6 +54,31 @@ _DEFAULT_RETRY = retry(
     reraise=True,
 )
 
+_TRANSIENT_MARKERS = (
+    "timeout", "timed out", "connection reset", "connection refused", "connection closed", "connection aborted",
+    "server closed the connection", "temporarily unavailable", "too many requests", "throttl", "service unavailable",
+    "serverbusy", "503", "could not connect",
+)
+
+
+def _is_transient(exc: BaseException) -> bool:
+    if _is_non_retryable(exc):
+        return False
+    if isinstance(exc, (ConnectionError, TimeoutError)):
+        return True
+    s = str(exc).lower()
+    return any(m in s for m in _TRANSIENT_MARKERS)
+
+
+def _TRANSIENT_RETRY(fn):
+    return retry(
+        retry=retry_if_exception(_is_transient),
+        wait=wait_exponential(multiplier=0.5, min=0.5, max=6),
+        stop=stop_after_attempt(3),
+        reraise=True,
+    )(fn)
+
+
 _UNIQUE_VIOLATION_MARKERS = (
     "23505",  # Postgres SQLSTATE
     "duplicate key value violates",  # Postgres message
@@ -140,6 +166,7 @@ def _extract_meta(model: Union[type, str]) -> ModelMeta:
                 provider=raw.get("provider"),
                 cache=raw.get("cache", False),
                 cache_ttl=raw.get("cache_ttl"),
+                encrypted_fields=tuple(raw.get("encrypted_fields") or ()),
             )
     return ModelMeta(storage="nosql", table=None, collection=None)
 
@@ -348,7 +375,42 @@ class DatabaseFactory:
         return result
 
     def _run(self, fn: Callable[[], Any]) -> Any:
-        return fn()
+        """Run one storage operation, retrying only TRANSIENT failures (connection loss, timeouts, throttling) with
+        exponential backoff when retries are enabled. Constraint violations, bad arguments and anything the retry
+        classifier marks non-retryable are raised at once -- a retry could not change their outcome."""
+        if not self._enable_retries:
+            return fn()
+        return _TRANSIENT_RETRY(fn)()
+
+    def _audit_write(
+        self, action: str, name: str, meta: ModelMeta, entity_id: Any, success: bool,
+        before: Optional[JsonDict], after: Optional[JsonDict], error: Optional[str],
+    ) -> None:
+        """Record a write in the audit log. Never raises: an audit failure must not turn a completed write into an
+        error. Encrypted fields are masked so the log never holds their plaintext."""
+        if not (self._enable_audit and self._audit):
+            return
+
+        def _mask(row: Optional[JsonDict]) -> Optional[JsonDict]:
+            if not row or not meta.encrypted_fields:
+                return row
+            return {k: ("[encrypted]" if k in meta.encrypted_fields else v) for k, v in row.items()}
+
+        try:
+            before_m, after_m = _mask(before), _mask(after)
+            changed = (
+                sorted(k for k in set(after_m or {}) | set(before_m or {}) if (before_m or {}).get(k) != (after_m or {}).get(k))
+                if before_m is not None and after_m is not None else None
+            )
+            if isinstance(entity_id, dict):
+                entity_id = entity_id.get("id")
+            self._audit.record(
+                action=action, model=name, entity_id=None if entity_id is None else str(entity_id),
+                storage_type=meta.storage, provider=meta.provider or "default", success=success,
+                before=before_m, after=after_m, error=error, changed_fields=changed,
+            )
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("Audit write failed (non-fatal): %s", exc)
 
     def _is_sql(self, meta: ModelMeta, override: Optional[EngineOverride] = None) -> bool:
         if override and override.force_sql:
@@ -432,9 +494,12 @@ class DatabaseFactory:
                 with monitor as m:
                     result = self._run(_op)
                     m.rows_affected = 1
-                    return result
-            return self._run(_op)
-        except Exception:
+            else:
+                result = self._run(_op)
+            self._audit_write("create", name, meta, entity_id, True, None, after_plain, None)
+            return result
+        except Exception as exc:
+            self._audit_write("create", name, meta, entity_id, False, None, None, str(exc))
             raise
 
     # ──────────────────────────────────────────────────────────
@@ -467,14 +532,26 @@ class DatabaseFactory:
         projected = bool(fields or omit)
         sql_columns = select_columns(fields, omit, columns)
 
+        drop_deleted = False
         if self._soft_delete and not include_deleted:
-            query = self._apply_soft_delete_filter(query)
+            if self._is_sql(meta, engine_override):
+                query = self._apply_soft_delete_filter(query)
+            else:
+                # A NoSQL equality filter on `deleted_at = None` matches nothing when the attribute was never written
+                # (Azure Table, DynamoDB), so filter the returned rows instead.
+                drop_deleted = True
 
         adapters = self._adapters_for(model, meta, engine_override)
         use_external_cache = (
             self._enable_cache and self._cache and getattr(meta, "cache", False) and not projected
         )
         encrypted_fields = getattr(meta, "encrypted_fields", [])
+        # The cache key must cover everything that changes the result: the query, the window, and the session variables
+        # (e.g. the tenant a row-level-security policy filters by) -- otherwise two callers share an entry.
+        cache_key_query = {
+            "q": query or {}, "limit": limit, "offset": offset,
+            "sv": sorted((session_vars or {}).items()), "e": bool(engine_override),
+        }
 
         def _op() -> List[JsonDict]:
             if self._is_sql(meta, engine_override):
@@ -497,22 +574,27 @@ class DatabaseFactory:
                 nosql_kwargs: Dict[str, Any] = {}
                 if projected:
                     nosql_kwargs = {"fields": fields, "omit": omit}
+                skip = offset or 0
                 raw = adapters.nosql.query(
-                    cls, query=query, limit=limit, no_cache=no_cache or bool(use_external_cache),
-                    **nosql_kwargs,
+                    cls, query=query, limit=(limit + skip) if limit else None,
+                    no_cache=no_cache or bool(use_external_cache), **nosql_kwargs,
                 )
+                if skip:
+                    raw = raw[skip:]  # NoSQL adapters take no offset: read through it, then drop the skipped rows
+            if drop_deleted:
+                raw = [r for r in raw if not r.get("deleted_at")]
             if self.encryption and encrypted_fields:
                 raw = [self.encryption.decrypt_fields(r, encrypted_fields) for r in raw]
             if self._cache and use_external_cache and not no_cache:
                 ttl = cache_ttl or getattr(meta, "cache_ttl", 300)
                 try:
-                    self._cache.set(name, query or {}, raw, ttl)
+                    self._cache.set(name, cache_key_query, raw, ttl)
                 except Exception as _ce:
                     logger.warning("Cache set failed (non-fatal): %s", _ce)
             return raw
 
         if self._cache and use_external_cache and not no_cache:
-            cached = self._cache.get(name, query or {})
+            cached = self._cache.get(name, cache_key_query)
             if cached is not None:
                 return cached
 
@@ -677,9 +759,12 @@ class DatabaseFactory:
                 with monitor as m:
                     result = self._run(_op)
                     m.rows_affected = 1
-                    return result
-            return self._run(_op)
-        except Exception:
+            else:
+                result = self._run(_op)
+            self._audit_write("update", name, meta, entity_id, True, before, after_plain, None)
+            return result
+        except Exception as exc:
+            self._audit_write("update", name, meta, entity_id, False, before, None, str(exc))
             raise
 
     # ──────────────────────────────────────────────────────────
@@ -737,9 +822,12 @@ class DatabaseFactory:
                 with monitor as m:
                     result = self._run(_op)
                     m.rows_affected = 1
-                    return result
-            return self._run(_op)
-        except Exception:
+            else:
+                result = self._run(_op)
+            self._audit_write("upsert", name, meta, (after_plain or {}).get('id'), True, None, after_plain, None)
+            return result
+        except Exception as exc:
+            self._audit_write("upsert", name, meta, None, False, None, None, str(exc))
             raise
 
     # ──────────────────────────────────────────────────────────
@@ -850,9 +938,12 @@ class DatabaseFactory:
                 with monitor as m:
                     result = self._run(_op)
                     m.rows_affected = 1
-                    return result
-            return self._run(_op)
-        except Exception:
+            else:
+                result = self._run(_op)
+            self._audit_write("delete", name, meta, entity_id, True, before, None, None)
+            return result
+        except Exception as exc:
+            self._audit_write("delete", name, meta, entity_id, False, before, None, str(exc))
             raise
 
     # ──────────────────────────────────────────────────────────
@@ -906,8 +997,12 @@ class DatabaseFactory:
         name = _model_name(model)
         meta = _extract_meta(model)
 
+        drop_deleted = False
         if self._soft_delete and not include_deleted:
-            query = self._apply_soft_delete_filter(query)
+            if self._is_sql(meta, engine_override):
+                query = self._apply_soft_delete_filter(query)
+            else:
+                drop_deleted = True
 
         adapters = self._adapters_for(model, meta, engine_override)
         encrypted_fields = getattr(meta, "encrypted_fields", [])
@@ -924,6 +1019,8 @@ class DatabaseFactory:
                     else type(name, (), {"__polydb__": meta.__dict__})
                 )
                 raw, token = adapters.nosql.query_page(cls, query, page_size, continuation_token)
+                if drop_deleted:
+                    raw = [r for r in raw if not r.get("deleted_at")]
             if self.encryption and encrypted_fields:
                 raw = [self.encryption.decrypt_fields(r, encrypted_fields) for r in raw]
             return raw, token

polydb/schema.py

@@ -131,6 +131,27 @@ class SchemaBuilder:
 
         return sql
 
+    def to_add_missing_columns(self, table_name: str) -> List[str]:
+        """`ALTER TABLE ... ADD COLUMN IF NOT EXISTS` for every non-key column. `CREATE TABLE IF NOT EXISTS` never adds a
+        column that was declared after the table was first created; appending these to the same migration makes an edited
+        column list reach existing tables. Added columns are always nullable (existing rows have no value) and never
+        UNIQUE; a declared default is kept."""
+        validate_table_name(table_name)
+        keys = set(self.primary_keys or [])
+        out: List[str] = []
+        for col in self.columns:
+            if col.name in keys or col.primary_key:
+                continue
+            parts = [validate_column_name(col.name)]
+            if col.type == ColumnType.VARCHAR and col.max_length:
+                parts.append(f"VARCHAR({col.max_length})")
+            else:
+                parts.append(col.type.value)
+            if col.default is not None:
+                parts.append(_render_default(col.default))
+            out.append(f"ALTER TABLE {table_name} ADD COLUMN IF NOT EXISTS {' '.join(parts)};")
+        return out
+
     def to_create_indexes(self, table_name: str) -> List[str]:
         """Generate CREATE INDEX statements"""
         statements = []
@@ -185,15 +206,31 @@ class MigrationManager:
 
         # Check if already applied
         existing = self.sql.execute(
-            "SELECT version FROM polydb_migrations WHERE version = %s", [version], fetch_one=True
+            "SELECT version, checksum FROM polydb_migrations WHERE version = %s", [version], fetch_one=True
         )
 
-        if existing:
-            return False
-
         # Calculate checksum
         checksum = hashlib.sha256(up_sql.encode()).hexdigest()
 
+        if existing:
+            stored = existing.get("checksum") if isinstance(existing, dict) else None
+            if not stored or stored == checksum:
+                return False
+            # The DDL under this version was edited (a column added, an index changed). Re-apply it -- the statements
+            # this codebase generates are idempotent (IF NOT EXISTS) -- and remember the new checksum. A failure here
+            # must not stop a deployment from starting: keep the old checksum so the next start tries again.
+            try:
+                self.sql.execute(up_sql)
+                self.sql.execute(
+                    "UPDATE polydb_migrations SET checksum = %s WHERE version = %s", [checksum, version]
+                )
+                return True
+            except Exception as exc:  # noqa: BLE001
+                import logging
+
+                logging.getLogger(__name__).warning("Re-applying edited migration %s failed (kept old): %s", version, exc)
+                return False
+
         try:
             # Execute migration
             self.sql.execute(up_sql)

polydb/types.py

@@ -24,6 +24,8 @@ class ModelMeta:
     provider: Optional[str] = None
     cache: bool = False
     cache_ttl: Optional[int] = None
+    # Fields stored encrypted when the factory has encryption enabled (a tuple: the dataclass is frozen/hashable).
+    encrypted_fields: Tuple[str, ...] = ()
 
 
 @runtime_checkable