Fix new objects not indexed: use obj.__dict__ fallback when _p_oid is None

ZODB assigns OIDs in Connection.commit(), which runs after before_commit
hooks (where IndexQueue flushes). All new objects therefore have _p_oid=None
at catalog_object() time, causing the catalog to silently skip them.

When zoid is None, store pending catalog data in obj.__dict__[ANNOTATION_KEY]
instead of set_pending(). CatalogStateProcessor.process() has an existing
fallback that pops ANNOTATION_KEY from the state dict during store(), so the
annotation is never persisted to the database.

Fixes #27.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: jensens

CHANGES.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 1.0.0b14
+
+### Fixed
+
+- Fix new objects not being indexed in PostgreSQL.
+  ZODB assigns object IDs (`_p_oid`) during `Connection.commit()`, which runs
+  *after* `before_commit` hooks (where the IndexQueue flushes). All new objects
+  therefore have `_p_oid=None` at `catalog_object()` call time, causing the
+  catalog to silently skip them.  The fix stores pending catalog data directly
+  in `obj.__dict__` under the `_pgcatalog_pending` key when no OID is available
+  yet; `CatalogStateProcessor.process()` pops and uses it during `store()` so
+  the annotation is never persisted to the database.  Fixes #27.
+
 ## 1.0.0b13
 
 ### Fixed

src/plone/pgcatalog/catalog.py

@@ -56,6 +56,7 @@
 from plone.pgcatalog.pool import get_pool
 from plone.pgcatalog.pool import get_request_connection
 from plone.pgcatalog.pool import get_storage_connection
+from plone.pgcatalog.processor import ANNOTATION_KEY
 from plone.pgcatalog.query import apply_security_filters
 from plone.pgcatalog.search import _PendingBrain
 from plone.pgcatalog.search import _run_search
@@ -423,11 +424,6 @@ def _set_pg_annotation(self, obj, uid=None):
                 return False
 
         zoid = self._obj_to_zoid(obj)
-        if zoid is None:
-            log.debug(
-                "_set_pg_annotation: no _p_oid on %s at %s", type(obj).__name__, uid
-            )
-            return False
 
         wrapper = self._wrap_object(obj)
         idx = self._extract_idx(wrapper)
@@ -440,15 +436,38 @@ def _set_pg_annotation(self, obj, uid=None):
         idx["path_parent"] = parent_path
         idx["path_depth"] = path_depth
 
-        set_pending(
-            zoid,
-            {
-                "path": uid,
-                "idx": idx,
-                "searchable_text": searchable_text,
-                "content_type": content_type,
-            },
-        )
+        pending_data = {
+            "path": uid,
+            "idx": idx,
+            "searchable_text": searchable_text,
+            "content_type": content_type,
+        }
+
+        if zoid is None:
+            # New object: _p_oid not yet assigned by ZODB (OIDs are assigned
+            # during Connection.commit(), after before-commit hooks run).
+            # Store catalog data directly in the object's __dict__ as
+            # ANNOTATION_KEY.  When ZODB later calls storage.store() for this
+            # object, CatalogStateProcessor.process() finds and pops the key
+            # from the JSON state before writing to PG, so it does not persist
+            # in the database.  Safe for new objects because CMFEditions does
+            # not version content at creation time.
+            log.debug(
+                "_set_pg_annotation: no _p_oid on %s at %s, using __dict__ fallback",
+                type(obj).__name__,
+                uid,
+            )
+            try:
+                obj.__dict__[ANNOTATION_KEY] = pending_data
+            except AttributeError:
+                log.warning(
+                    "_set_pg_annotation: can't store annotation on %s (no __dict__)",
+                    type(obj).__name__,
+                )
+                return False
+            return True
+
+        set_pending(zoid, pending_data)
         # Mark the object as dirty so ZODB stores it (triggering the processor)
         obj._p_changed = True
         log.debug(

tests/test_catalog_plone.py

@@ -229,14 +229,29 @@ def _cm(_self):
 
 
 class TestCatalogObjectWritePath:
-    def test_skips_pg_without_p_oid(self):
+    def test_new_object_uses_dict_fallback(self):
+        """New objects (no _p_oid yet) store catalog data in obj.__dict__."""
+        from plone.pgcatalog.processor import ANNOTATION_KEY
+
         tool = PlonePGCatalogTool.__new__(PlonePGCatalogTool)
         obj = mock.Mock(spec=["getPhysicalPath"])
         obj.getPhysicalPath.return_value = ("", "plone", "doc")
-        # No _p_oid → _set_pg_annotation bails early, no pending write
-        with mock.patch("plone.pgcatalog.catalog.set_pending") as pending_mock:
+        # No _p_oid → uses __dict__ fallback, set_pending NOT called
+        with (
+            mock.patch.object(PlonePGCatalogTool, "_wrap_object", return_value=obj),
+            mock.patch.object(PlonePGCatalogTool, "_extract_idx", return_value={}),
+            mock.patch.object(
+                PlonePGCatalogTool, "_extract_searchable_text", return_value=None
+            ),
+            mock.patch(
+                "plone.pgcatalog.catalog.extract_content_type", return_value=None
+            ),
+            mock.patch("plone.pgcatalog.catalog.set_pending") as pending_mock,
+        ):
             tool.catalog_object(obj)
             pending_mock.assert_not_called()
+            assert ANNOTATION_KEY in obj.__dict__
+            assert obj.__dict__[ANNOTATION_KEY]["path"] == "/plone/doc"
 
     def test_sets_pending_annotation(self):
         """catalog_object() sets PG pending annotation (no BTree writes)."""