fix: create ir.model.data entries when using create() method

When records are created using the create() method (in fail mode or
when load() falls back to create()), XML IDs were not being persisted
to ir.model.data. This caused XML IDs to be missing after import.

Added _create_xmlid_entry() helper function that:
- Parses module and name from XML ID (uses __import__ for IDs without prefix)
- Creates or updates ir.model.data entry for each created record
- Handles edge cases like existing entries with different res_id

This ensures XML IDs are properly persisted regardless of whether
records are created via load() or create().

Author: bosd

src/odoo_data_flow/import_threaded.py

@@ -701,13 +701,79 @@ def _handle_create_error(  # noqa C901
     return error_message, failed_line, error_summary
 
 
-def _create_batch_individually(
+def _create_xmlid_entry(
+    model: Any,
+    xml_id: str,
+    res_id: int,
+    model_name: str,
+) -> bool:
+    """Create an ir.model.data entry for a record created via create().
+
+    When records are created using Odoo's create() method instead of load(),
+    the XML ID is not automatically persisted. This function creates the
+    ir.model.data entry to ensure the XML ID is saved.
+
+    Args:
+        model: The Odoo model proxy (used to access other models)
+        xml_id: The external ID (e.g., 'MODULE.identifier' or just 'identifier')
+        res_id: The database ID of the created record
+        model_name: The model name (e.g., 'res.partner')
+
+    Returns:
+        True if the ir.model.data entry was created successfully, False otherwise.
+    """
+    try:
+        # Parse module and name from XML ID
+        if "." in xml_id:
+            module, name = xml_id.split(".", 1)
+        else:
+            # Use __import__ as the default module for records without a prefix
+            module = "__import__"
+            name = xml_id
+
+        # Get ir.model.data model
+        ir_model_data = model.browse().env["ir.model.data"]
+
+        # Check if entry already exists
+        existing = ir_model_data.search([
+            ("module", "=", module),
+            ("name", "=", name),
+        ], limit=1)
+
+        if existing:
+            # Update existing entry if it points to a different record
+            if existing.res_id != res_id:
+                log.debug(
+                    f"Updating existing ir.model.data entry for {xml_id} "
+                    f"from res_id={existing.res_id} to res_id={res_id}"
+                )
+                existing.write({"res_id": res_id, "model": model_name})
+            return True
+
+        # Create new ir.model.data entry
+        ir_model_data.create({
+            "module": module,
+            "name": name,
+            "model": model_name,
+            "res_id": res_id,
+        })
+        log.debug(
+            f"Created ir.model.data entry: {module}.{name} -> {model_name}({res_id})"
+        )
+        return True
+    except Exception as e:
+        log.warning(f"Failed to create ir.model.data entry for {xml_id}: {e}")
+        return False
+
+
+def _create_batch_individually(  # noqa: C901
     model: Any,
     batch_lines: list[list[Any]],
     batch_header: list[str],
     uid_index: int,
     context: dict[str, Any],
     ignore_list: list[str],
+    model_name: str = "",
 ) -> dict[str, Any]:
     """Fallback to create records one-by-one to get detailed errors."""
     id_map: dict[str, int] = {}
@@ -758,6 +824,12 @@ def _create_batch_individually(
 
             new_record = model.create(converted_vals, context=context)
             id_map[sanitized_source_id] = new_record.id
+
+            # Create ir.model.data entry for XML ID since create() doesn't do it
+            if model_name:
+                _create_xmlid_entry(
+                    model, sanitized_source_id, new_record.id, model_name
+                )
         except IndexError as e:
             error_message = f"Malformed row detected (row {i + 1} in batch): {e}"
             failed_lines.append([*line, error_message])
@@ -863,13 +935,15 @@ def _execute_load_batch(  # noqa: C901
     )
     uid_index = thread_state["unique_id_field_index"]
     ignore_list = thread_state.get("ignore_list", [])
+    model_name = thread_state.get("model_name", "")
 
     if thread_state.get("force_create"):
         progress.console.print(
             f"Batch {batch_number}: Fail mode active, using `create` method."
         )
         result = _create_batch_individually(
-            model, batch_lines, batch_header, uid_index, context, ignore_list
+            model, batch_lines, batch_header, uid_index, context,
+            ignore_list, model_name
         )
         result["success"] = bool(result.get("id_map"))
         return result
@@ -1168,6 +1242,7 @@ def _execute_load_batch(  # noqa: C901
                             uid_index,
                             context,
                             ignore_list,
+                            model_name,
                         )
                         # Update id_map with new successes
                         aggregated_id_map.update(fallback_result.get("id_map", {}))
@@ -1296,6 +1371,7 @@ def _execute_load_batch(  # noqa: C901
                             uid_index,
                             context,
                             ignore_list,
+                            model_name,
                         )
                         aggregated_id_map.update(fallback_result.get("id_map", {}))
                         aggregated_failed_lines.extend(
@@ -1319,6 +1395,7 @@ def _execute_load_batch(  # noqa: C901
                 uid_index,
                 context,
                 ignore_list,
+                model_name,
             )
             aggregated_id_map.update(fallback_result.get("id_map", {}))
             aggregated_failed_lines.extend(fallback_result.get("failed_lines", []))
@@ -1581,6 +1658,7 @@ def _orchestrate_pass_1(
 
     thread_state_1 = {
         "model": model_obj,
+        "model_name": model_name,
         "context": context,
         "unique_id_field_index": pass_1_uid_index,
         "batch_header": pass_1_header,

tests/test_import_threaded.py

@@ -608,6 +608,93 @@ def test_filter_ignored_columns(self) -> None:
         assert new_data == [["1", "Alice"], ["2", "Bob"]]
 
 
+class TestXmlIdCreation:
+    """Tests for XML ID creation when using create() method."""
+
+    def test_create_xmlid_entry_with_module_prefix(self) -> None:
+        """Test XML ID creation with module prefix (e.g., 'my_module.identifier')."""
+        from odoo_data_flow.import_threaded import _create_xmlid_entry
+
+        mock_model = MagicMock()
+        mock_ir_model_data = MagicMock()
+        mock_ir_model_data.search.return_value = []  # No existing entry
+        mock_model.browse.return_value.env = {"ir.model.data": mock_ir_model_data}
+
+        result = _create_xmlid_entry(mock_model, "my_module.partner_001", 42, "res.partner")
+
+        assert result is True
+        mock_ir_model_data.create.assert_called_once_with({
+            "module": "my_module",
+            "name": "partner_001",
+            "model": "res.partner",
+            "res_id": 42,
+        })
+
+    def test_create_xmlid_entry_without_module_prefix(self) -> None:
+        """Test XML ID creation without module prefix (uses __import__)."""
+        from odoo_data_flow.import_threaded import _create_xmlid_entry
+
+        mock_model = MagicMock()
+        mock_ir_model_data = MagicMock()
+        mock_ir_model_data.search.return_value = []  # No existing entry
+        mock_model.browse.return_value.env = {"ir.model.data": mock_ir_model_data}
+
+        result = _create_xmlid_entry(mock_model, "PARTNER_001", 42, "res.partner")
+
+        assert result is True
+        mock_ir_model_data.create.assert_called_once_with({
+            "module": "__import__",
+            "name": "PARTNER_001",
+            "model": "res.partner",
+            "res_id": 42,
+        })
+
+    def test_create_xmlid_entry_existing_entry_same_res_id(self) -> None:
+        """Test that existing entries with same res_id are not updated."""
+        from odoo_data_flow.import_threaded import _create_xmlid_entry
+
+        mock_model = MagicMock()
+        mock_existing = MagicMock()
+        mock_existing.res_id = 42  # Same res_id
+        mock_ir_model_data = MagicMock()
+        mock_ir_model_data.search.return_value = mock_existing
+        mock_model.browse.return_value.env = {"ir.model.data": mock_ir_model_data}
+
+        result = _create_xmlid_entry(mock_model, "my_module.partner_001", 42, "res.partner")
+
+        assert result is True
+        mock_ir_model_data.create.assert_not_called()
+        mock_existing.write.assert_not_called()
+
+    def test_create_xmlid_entry_existing_entry_different_res_id(self) -> None:
+        """Test that existing entries with different res_id are updated."""
+        from odoo_data_flow.import_threaded import _create_xmlid_entry
+
+        mock_model = MagicMock()
+        mock_existing = MagicMock()
+        mock_existing.res_id = 99  # Different res_id
+        mock_ir_model_data = MagicMock()
+        mock_ir_model_data.search.return_value = mock_existing
+        mock_model.browse.return_value.env = {"ir.model.data": mock_ir_model_data}
+
+        result = _create_xmlid_entry(mock_model, "my_module.partner_001", 42, "res.partner")
+
+        assert result is True
+        mock_ir_model_data.create.assert_not_called()
+        mock_existing.write.assert_called_once_with({"res_id": 42, "model": "res.partner"})
+
+    def test_create_xmlid_entry_handles_exception(self) -> None:
+        """Test that exceptions during XML ID creation are handled gracefully."""
+        from odoo_data_flow.import_threaded import _create_xmlid_entry
+
+        mock_model = MagicMock()
+        mock_model.browse.side_effect = Exception("Connection error")
+
+        result = _create_xmlid_entry(mock_model, "my_module.partner_001", 42, "res.partner")
+
+        assert result is False
+
+
 class TestRecursiveBatching:
     """Tests for the recursive batch creation logic."""