altcodepro-polydb-python 2.5.8__tar.gz → 2.5.10__tar.gz

{altcodepro_polydb_python-2.5.8/src/altcodepro_polydb_python.egg-info → altcodepro_polydb_python-2.5.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: altcodepro-polydb-python
-Version: 2.5.8
+Version: 2.5.10
 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.8 → altcodepro_polydb_python-2.5.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "altcodepro-polydb-python"
-version = "2.5.8"
+version = "2.5.10"
 description = "Production-ready multi-cloud database abstraction layer with connection pooling, retry logic, and thread safety"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"

{altcodepro_polydb_python-2.5.8 → altcodepro_polydb_python-2.5.10/src/altcodepro_polydb_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: altcodepro-polydb-python
-Version: 2.5.8
+Version: 2.5.10
 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.8 → altcodepro_polydb_python-2.5.10}/src/altcodepro_polydb_python.egg-info/SOURCES.txt

@@ -90,6 +90,8 @@ tests/test_aws.py
 tests/test_azure.py
 tests/test_azure_queue_receipt_handle.py
 tests/test_azure_table_empty_filter.py
+tests/test_azure_table_id_property_persisted.py
+tests/test_azure_table_id_return_value_sanitization_mismatch.py
 tests/test_azure_table_unpack_entity.py
 tests/test_blockchain.py
 tests/test_cloud_factory.py

{altcodepro_polydb_python-2.5.8 → altcodepro_polydb_python-2.5.10}/src/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.8"
+__version__ = "2.5.10"
 
 from .cloudDatabaseFactory import CloudDatabaseFactory
 from .databaseFactory import DatabaseFactory

{altcodepro_polydb_python-2.5.8 → altcodepro_polydb_python-2.5.10}/src/polydb/adapters/AzureTableStorageAdapter.py

@@ -493,6 +493,33 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
             table_client = self._get_table_client(model)
             safe_pk = self._sanitize_pk_rk(pk)
             safe_rk = self._sanitize_pk_rk(rk)
+            # Persist "id" as a REAL, queryable property whenever the
+            # caller's own data didn't already supply one -- not just
+            # synthesized onto this call's own return value below
+            # (`restored["id"] = safe_rk`), which only ever helped the
+            # ONE caller holding that return value. _query_raw already
+            # does the equivalent synthesis on the READ side (`out["id"]
+            # = ent_dict["RowKey"]` when absent) for a query's own
+            # results, but that can't fix a *filtered* read: a later
+            # `read_one(model, {"id": X, ...})` -- the ordinary
+            # id-addressed lookup every `update()`/`patch()` call makes
+            # for its own "before" read -- builds a real OData `id eq
+            # 'X'` filter against whatever property is actually named
+            # "id" on the stored entity. When the original create's own
+            # data never included one (true for essentially any model
+            # whose caller doesn't explicitly generate an id, default
+            # pk_field/rk_field or a custom mapping alike), that property
+            # never existed, so the filter matched nothing -- `before`
+            # came back None, and DatabaseFactory.update()'s own pk/rk
+            # recovery (see this file's own 2.5.7 changelog entry for the
+            # closely related bug) had nothing to recover from, falling
+            # through to a literal `str(None) == "None"` PartitionKey.
+            # Reproduced directly before this fix, not assumed: a create
+            # with no "id" in its own payload, followed by
+            # read_one(model, {"id": <the id the create call itself
+            # returned>}), always returned None.
+            if "id" not in data:
+                data = {**data, "id": safe_rk}
             entity = self._pack_entity(model, safe_pk, safe_rk, data)
             MAX_PROPERTY_CHARS = 30 * 1024
 
@@ -539,7 +566,26 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
             table_client.upsert_entity(reference_entity)
 
             restored = self._unpack_entity(model, entity)
-            restored["id"] = safe_rk
+            # Mirror the write-side condition above (line ~521): only
+            # synthesize "id" onto the return value when the caller's own
+            # data didn't already supply one. Unconditionally overwriting
+            # it with safe_rk here was a real, reproduced bug -- whenever
+            # the caller's own id needed RowKey sanitization (contains a
+            # character Azure forbids in a RowKey: ':', ' ', '#', '?',
+            # '/', '\'), the PERSISTED "id" property kept the caller's
+            # original, unsanitized value (data["id"], written untouched
+            # via reference_entity above) while this return value handed
+            # back the sanitized safe_rk instead -- two different strings
+            # for the same row. Any caller holding onto that return
+            # value's own "id" (e.g. building a follow-up
+            # read_one(model, {"id": ...}) call, or an id.map() over a
+            # create_many result) would then filter for a value that
+            # never matches any real stored "id" property, silently
+            # getting nothing back. Reproduced directly before this fix:
+            # data={"id": "a:b"} on a model with a rk_field whose value
+            # contains ":" persisted "id"="a:b" but returned "id"="a_b".
+            if "id" not in data:
+                restored["id"] = safe_rk
 
             return restored
 

altcodepro_polydb_python-2.5.10/tests/test_azure_table_id_property_persisted.py

@@ -0,0 +1,175 @@
+"""Unit tests (no Azurite needed) for a real, reproduced bug: `_put_raw`
+never persisted a real "id" property on the entity unless the caller's own
+write payload already had one -- only synthesized it onto that one call's
+own RETURN value (`restored["id"] = safe_rk`). A later id-addressed lookup
+(`read_one(model, {"id": X, ...})`, the "before" read every
+`DatabaseFactory.update()`/`patch()` call makes) builds a real OData
+`id eq 'X'` filter against whatever property is actually named "id" on the
+stored entity -- which, for any model whose caller doesn't explicitly set
+"id" at create time (default pk_field/rk_field or a custom deterministic
+mapping alike), never existed. `before` therefore always came back None,
+cascading into `DatabaseFactory.update()`'s own pk/rk recovery logic
+finding nothing to recover from and falling through to a literal
+`str(None) == "None"` PartitionKey -- the same class of bug this file's own
+2.5.7 changelog entry already documents for a related codepath.
+
+Reproduces the bug on the OLD code shape directly (a create whose own
+payload has no "id" never lands a real "id" property), then proves the fix
+closes it (a create with no "id" DOES land a real, filterable "id"
+property equal to the physical RowKey, and a create that ALREADY supplies
+its own "id" is left completely untouched).
+"""
+
+import pytest
+
+pytest.importorskip("azure.data.tables")  # adapter needs the SDK to import
+
+from polydb.adapters.AzureTableStorageAdapter import AzureTableStorageAdapter  # noqa: E402
+
+
+class _Model:
+    __name__ = "users"
+
+
+class _FakeTableClient:
+    """A minimal, real filter-evaluating fake -- unlike
+    test_azure_table_empty_filter.py's own fake (which only needs to tell
+    a None filter apart from a non-None one), this one has to actually
+    match `_query_raw`'s real OData-shaped filter string against stored
+    entities, since that's the exact mechanism this bug lives in."""
+
+    def __init__(self):
+        self.store: dict[tuple, dict] = {}
+
+    def upsert_entity(self, entity, **kw):
+        self.store[(entity["PartitionKey"], entity["RowKey"])] = dict(entity)
+
+    def query_entities(self, query_filter=None, **kw):
+        if query_filter is None:
+            return list(self.store.values())
+        conditions = []
+        for part in query_filter.split(" and "):
+            prop, _, raw_val = part.partition(" eq ")
+            if raw_val.startswith("'") and raw_val.endswith("'"):
+                val = raw_val[1:-1].replace("''", "'")
+            elif raw_val == "null":
+                val = None
+            elif raw_val in ("true", "false"):
+                val = raw_val == "true"
+            else:
+                val = float(raw_val) if "." in raw_val else int(raw_val)
+            conditions.append((prop, val))
+        return [
+            e for e in self.store.values() if all(e.get(prop) == val for prop, val in conditions)
+        ]
+
+
+def _adapter(fake):
+    adp = object.__new__(AzureTableStorageAdapter)  # bypass live-connection __init__
+    adp._get_table_client = lambda model: fake
+    adp._blob_service = None
+    adp.object_storage = None
+    return adp
+
+
+def test_a_create_with_no_id_in_its_own_payload_still_lands_a_real_filterable_id_property():
+    """The actual bug: users.identity_key-style deterministic addressing
+    (pk_field=rk_field="identity_key", "id" never in the create payload)."""
+    fake = _FakeTableClient()
+    adapter = _adapter(fake)
+
+    data = {
+        "identity_key": "email:sireesh.psvs@gmail.com",
+        "tenant_id": "altcodepro",
+        "email": "sireesh.psvs@gmail.com",
+        "auth_method": "password",
+    }
+    created = adapter._put_raw(
+        _Model, "email:sireesh.psvs@gmail.com", "email:sireesh.psvs@gmail.com", data
+    )
+
+    returned_id = created["id"]
+    assert returned_id == "email_sireesh.psvs@gmail.com"  # sanitized (colon -> underscore)
+
+    # The load-bearing assertion: the STORED entity itself (not just this
+    # one call's own return value) now has a real "id" property.
+    stored = fake.store[("email_sireesh.psvs@gmail.com", "email_sireesh.psvs@gmail.com")]
+    assert stored["id"] == returned_id
+
+    # And the ordinary id-addressed lookup every update()/patch() "before"
+    # read performs now actually finds the row -- reproduced BROKEN before
+    # this fix (would have returned []).
+    found = adapter._query_raw(_Model, {"id": returned_id, "tenant_id": "altcodepro"}, None)
+    assert len(found) == 1
+    assert found[0]["email"] == "sireesh.psvs@gmail.com"
+
+
+def test_a_create_that_already_supplies_its_own_id_is_left_untouched():
+    fake = _FakeTableClient()
+    adapter = _adapter(fake)
+
+    data = {"id": "caller-chosen-id", "tenant_id": "t1", "name": "x"}
+    created = adapter._put_raw(_Model, "t1", "caller-chosen-id", data)
+
+    assert created["id"] == "caller-chosen-id"
+    stored = fake.store[("t1", "caller-chosen-id")]
+    assert stored["id"] == "caller-chosen-id"
+
+
+def test_two_different_identities_never_collide_and_both_are_independently_findable():
+    fake = _FakeTableClient()
+    adapter = _adapter(fake)
+
+    for email in ("sireesh.psvs@gmail.com", "pangaluri2010@gmail.com"):
+        key = f"email:{email}"
+        adapter._put_raw(
+            _Model,
+            key,
+            key,
+            {
+                "identity_key": key,
+                "tenant_id": "altcodepro",
+                "email": email,
+            },
+        )
+
+    assert len(fake.store) == 2
+    for email in ("sireesh.psvs@gmail.com", "pangaluri2010@gmail.com"):
+        rows = adapter._query_raw(_Model, {"email": email}, None)
+        assert len(rows) == 1 and rows[0]["email"] == email
+
+
+def test_repeat_put_for_the_same_identity_key_upserts_the_same_row_not_a_duplicate():
+    """The actual, originally-reported symptom this whole chain of fixes
+    exists to close: a second signup attempt for the same email must
+    collapse onto the SAME physical row, never mint a new one."""
+    fake = _FakeTableClient()
+    adapter = _adapter(fake)
+
+    key = "email:sireesh.psvs@gmail.com"
+    adapter._put_raw(
+        _Model,
+        key,
+        key,
+        {
+            "identity_key": key,
+            "tenant_id": "altcodepro",
+            "email": "sireesh.psvs@gmail.com",
+            "display_name": "Sireesh",
+        },
+    )
+    adapter._put_raw(
+        _Model,
+        key,
+        key,
+        {
+            "identity_key": key,
+            "tenant_id": "altcodepro",
+            "email": "sireesh.psvs@gmail.com",
+            "display_name": "Sireesh Updated",
+        },
+    )
+
+    assert len(fake.store) == 1
+    only_row = next(iter(fake.store.values()))
+    assert only_row["display_name"] == "Sireesh Updated"

altcodepro_polydb_python-2.5.10/tests/test_azure_table_id_return_value_sanitization_mismatch.py

@@ -0,0 +1,151 @@
+"""Unit tests (no Azurite needed) for a real, reproduced bug: `_put_raw`
+unconditionally overwrote its own RETURN value's "id" field with `safe_rk`
+(the Azure-RowKey-sanitized value) even when the caller's own write payload
+already supplied a real "id" -- so whenever that caller-supplied id needed
+RowKey sanitization (contains a character Azure forbids in a RowKey: ':',
+' ', '#', '?', '/', '\\'), the PERSISTED entity's "id" property (written
+verbatim from the caller's own `data`, untouched) and the RETURNED value's
+"id" (always `safe_rk`) silently disagreed.
+
+This is a distinct bug from the one `test_azure_table_id_property_persisted.py`
+already covers and fixed (2.5.9: a create with NO "id" in its own payload
+never landed a real "id" property at all) -- that fix's own condition
+(`if "id" not in data: data = {**data, "id": safe_rk}`) only ever touches
+the WRITE side. The return-value line right below it (`restored["id"] =
+safe_rk`) had no matching condition, so it fired even when `data["id"]`
+was already present and different from `safe_rk`.
+
+Real, reproduced downstream symptom (altcodepro-blueprint-engine): the
+`artifacts` model deliberately builds a colon-joined deterministic id
+(`project_id + ':' + definition_id`) with `rk_field` pointing at that same
+value. `core.db.create_many`'s own CEL-built row data already supplies
+this "id" explicitly. The persisted entity's "id" property therefore kept
+the real, colon-joined value -- but every returned row's own "id" (what a
+workflow's `steps.<create_step>.created.map(c, ...c.id...)` reads to
+enqueue a follow-up job) came back with the colon sanitized to an
+underscore instead. The follow-up job's own `core.db.get(id=<that wrong,
+sanitized value>)` then built an OData `id eq '<sanitized>'` filter that
+matched nothing -- every real row existed, but was unreachable by the very
+id its own creation step just handed out.
+"""
+
+import pytest
+
+pytest.importorskip("azure.data.tables")  # adapter needs the SDK to import
+
+from polydb.adapters.AzureTableStorageAdapter import AzureTableStorageAdapter  # noqa: E402
+
+
+class _Model:
+    __name__ = "artifacts"
+
+
+class _FakeTableClient:
+    """The same real filter-evaluating fake
+    test_azure_table_id_property_persisted.py already establishes -- reused
+    verbatim rather than re-derived, since this bug lives in the identical
+    `_query_raw` OData-filter mechanism."""
+
+    def __init__(self):
+        self.store: dict[tuple, dict] = {}
+
+    def upsert_entity(self, entity, **kw):
+        self.store[(entity["PartitionKey"], entity["RowKey"])] = dict(entity)
+
+    def query_entities(self, query_filter=None, **kw):
+        if query_filter is None:
+            return list(self.store.values())
+        conditions = []
+        for part in query_filter.split(" and "):
+            prop, _, raw_val = part.partition(" eq ")
+            if raw_val.startswith("'") and raw_val.endswith("'"):
+                val = raw_val[1:-1].replace("''", "'")
+            elif raw_val == "null":
+                val = None
+            elif raw_val in ("true", "false"):
+                val = raw_val == "true"
+            else:
+                val = float(raw_val) if "." in raw_val else int(raw_val)
+            conditions.append((prop, val))
+        return [
+            e for e in self.store.values() if all(e.get(prop) == val for prop, val in conditions)
+        ]
+
+
+def _adapter(fake):
+    adp = object.__new__(AzureTableStorageAdapter)  # bypass live-connection __init__
+    adp._get_table_client = lambda model: fake
+    adp._blob_service = None
+    adp.object_storage = None
+    return adp
+
+
+def test_a_caller_supplied_id_needing_rowkey_sanitization_is_returned_unsanitized():
+    """The actual reported bug, reproduced with the real shape:
+    project_id + ':' + definition_id, used as both "id" and the rk_field
+    value -- ':' is not a legal Azure RowKey character."""
+    fake = _FakeTableClient()
+    adapter = _adapter(fake)
+
+    caller_id = "485533b9-8d0f-4e5f-92da-670cedfe92f5:backend.backend_schema"
+    data = {
+        "id": caller_id,
+        "artifact_id": caller_id,
+        "project_slug": "community-platform-187",
+        "tenant_id": "altcodepro",
+        "name": "Backend Schema",
+    }
+    created = adapter._put_raw(_Model, "community-platform-187", caller_id, data)
+
+    # The load-bearing assertion: the RETURN value's "id" must equal what
+    # the caller actually supplied -- never the sanitized RowKey. Before
+    # the fix this was "485533b9-...-670cedfe92f5_backend.backend_schema"
+    # (colon silently replaced with underscore).
+    assert created["id"] == caller_id
+
+    # And it must agree with what's genuinely persisted -- the real
+    # invariant this bug violated (two different strings for the same
+    # row's own "id").
+    safe_rk = adapter._sanitize_pk_rk(caller_id)
+    stored = fake.store[("community-platform-187", safe_rk)]
+    assert stored["id"] == caller_id == created["id"]
+
+    # The actual downstream failure this caused: a follow-up step (e.g.
+    # start_artifact_generation's own load_artifact) doing
+    # core.db.get(id=<the id create_many just returned>) must find the
+    # row. Reproduced BROKEN before this fix -- querying by the correct,
+    # returned id found nothing, because the stored property and the
+    # returned value disagreed.
+    found = adapter._query_raw(_Model, {"id": created["id"], "tenant_id": "altcodepro"}, None)
+    assert len(found) == 1
+    assert found[0]["name"] == "Backend Schema"
+
+
+def test_a_caller_supplied_id_needing_no_sanitization_is_unaffected():
+    """Negative control: when the caller's own id is already RowKey-safe,
+    safe_rk == the caller's id anyway, so this bug was invisible -- exactly
+    why it slipped past every existing test until now."""
+    fake = _FakeTableClient()
+    adapter = _adapter(fake)
+
+    data = {"id": "caller-chosen-id", "tenant_id": "t1", "name": "x"}
+    created = adapter._put_raw(_Model, "t1", "caller-chosen-id", data)
+
+    assert created["id"] == "caller-chosen-id"
+    stored = fake.store[("t1", "caller-chosen-id")]
+    assert stored["id"] == "caller-chosen-id"
+
+
+def test_no_id_in_payload_still_synthesizes_safe_rk_onto_both_sides():
+    """The 2.5.9 case must still work identically -- this fix only adds a
+    condition around the return-value line, it must not touch the
+    no-id-supplied path at all."""
+    fake = _FakeTableClient()
+    adapter = _adapter(fake)
+
+    data = {"identity_key": "email:x@example.com", "tenant_id": "altcodepro"}
+    created = adapter._put_raw(_Model, "email:x@example.com", "email:x@example.com", data)
+
+    assert created["id"] == "email_x@example.com"
+    stored = fake.store[("email_x@example.com", "email_x@example.com")]
+    assert stored["id"] == created["id"] == "email_x@example.com"