Fix: add ManyToOneRelationships to list_table_relationships

_list_table_relationships now fetches all 3 relationship types:
- OneToManyRelationships (incoming: where table is referenced)
- ManyToOneRelationships (outgoing: where table has a lookup) <-- NEW
- ManyToManyRelationships

This was critical for sql_joins() and odata_expands() which need
outgoing lookups. Without ManyToOne, custom table lookups were
invisible to the helpers.

Also fixed: create_lookup_field requires lowercase logical names
(not SchemaName) -- documented in copilot-instructions.

Live-validated: 47/47 SQL tests passed on Aurora VM.
Unit tests: 756 passed.

Author: Saurabh Badenkal

src/PowerPlatform/Dataverse/data/_relationships.py

@@ -184,8 +184,9 @@ def _list_table_relationships(
     ) -> List[Dict[str, Any]]:
         """List all relationships for a specific table.
 
-        Issues ``GET EntityDefinitions({MetadataId})/OneToManyRelationships``
-        and ``GET EntityDefinitions({MetadataId})/ManyToManyRelationships``,
+        Issues ``GET EntityDefinitions({MetadataId})/OneToManyRelationships``,
+        ``GET EntityDefinitions({MetadataId})/ManyToOneRelationships``, and
+        ``GET EntityDefinitions({MetadataId})/ManyToManyRelationships``,
         then combines the results.
 
         :param table_schema_name: Schema name of the table (e.g. ``"account"``).
@@ -222,12 +223,14 @@ def _list_table_relationships(
             params["$select"] = ",".join(select)
 
         one_to_many_url = f"{self.api}/EntityDefinitions({metadata_id})/OneToManyRelationships"
+        many_to_one_url = f"{self.api}/EntityDefinitions({metadata_id})/ManyToOneRelationships"
         many_to_many_url = f"{self.api}/EntityDefinitions({metadata_id})/ManyToManyRelationships"
 
         r1 = self._request("get", one_to_many_url, headers=self._headers(), params=params)
-        r2 = self._request("get", many_to_many_url, headers=self._headers(), params=params)
+        r2 = self._request("get", many_to_one_url, headers=self._headers(), params=params)
+        r3 = self._request("get", many_to_many_url, headers=self._headers(), params=params)
 
-        return r1.json().get("value", []) + r2.json().get("value", [])
+        return r1.json().get("value", []) + r2.json().get("value", []) + r3.json().get("value", [])
 
     def _extract_id_from_header(self, header_value: Optional[str]) -> Optional[str]:
         """

tests/unit/data/test_relationships.py

@@ -402,52 +402,60 @@ def _make_response(self, value):
         return r
 
     def test_uses_one_to_many_and_many_to_many_urls(self):
-        """Test that both OneToMany and ManyToMany URLs are queried."""
+        """Test that OneToMany, ManyToOne, and ManyToMany URLs are queried."""
         self.client._mock_request.side_effect = [
             self._make_response([]),
             self._make_response([]),
+            self._make_response([]),
         ]
 
         self.client._list_table_relationships("account")
 
         calls = self.client._mock_request.call_args_list
-        self.assertEqual(len(calls), 2)
-        self.assertIn("OneToManyRelationships", calls[0][0][1])
-        self.assertIn("ManyToManyRelationships", calls[1][0][1])
+        self.assertEqual(len(calls), 3)
+        urls = [call[0][1] for call in calls]
+        self.assertTrue(any("OneToManyRelationships" in u for u in urls))
+        self.assertTrue(any("ManyToOneRelationships" in u for u in urls))
+        self.assertTrue(any("ManyToManyRelationships" in u for u in urls))
 
     def test_uses_metadata_id_in_urls(self):
-        """Test that the entity MetadataId is used in both URLs."""
+        """Test that the entity MetadataId is used in all three URLs."""
         self.client._mock_request.side_effect = [
             self._make_response([]),
             self._make_response([]),
+            self._make_response([]),
         ]
 
         self.client._list_table_relationships("account")
 
         calls = self.client._mock_request.call_args_list
-        self.assertIn("ent-guid-1", calls[0][0][1])
-        self.assertIn("ent-guid-1", calls[1][0][1])
+        for call in calls:
+            self.assertIn("ent-guid-1", call[0][1])
 
     def test_combines_one_to_many_and_many_to_many_results(self):
-        """Test that results from both sub-requests are combined."""
+        """Test that results from all three sub-requests are combined."""
         one_to_many = [{"SchemaName": "rel_1tm", "MetadataId": "r1"}]
-        many_to_many = [{"SchemaName": "rel_mtm", "MetadataId": "r2"}]
+        many_to_one = [{"SchemaName": "rel_mt1", "MetadataId": "r2"}]
+        many_to_many = [{"SchemaName": "rel_mtm", "MetadataId": "r3"}]
         self.client._mock_request.side_effect = [
             self._make_response(one_to_many),
+            self._make_response(many_to_one),
             self._make_response(many_to_many),
         ]
 
         result = self.client._list_table_relationships("account")
 
-        self.assertEqual(len(result), 2)
+        self.assertEqual(len(result), 3)
         self.assertEqual(result[0]["SchemaName"], "rel_1tm")
-        self.assertEqual(result[1]["SchemaName"], "rel_mtm")
+        self.assertEqual(result[1]["SchemaName"], "rel_mt1")
+        self.assertEqual(result[2]["SchemaName"], "rel_mtm")
 
     def test_filter_param_is_forwarded(self):
-        """Test that $filter is sent to both sub-requests."""
+        """Test that $filter is sent to all three sub-requests."""
         self.client._mock_request.side_effect = [
             self._make_response([]),
             self._make_response([]),
+            self._make_response([]),
         ]
 
         self.client._list_table_relationships("account", filter="IsManaged eq false")
@@ -458,10 +466,11 @@ def test_filter_param_is_forwarded(self):
             self.assertEqual(params["$filter"], "IsManaged eq false")
 
     def test_select_param_is_forwarded(self):
-        """Test that $select is sent to both sub-requests."""
+        """Test that $select is sent to all three sub-requests."""
         self.client._mock_request.side_effect = [
             self._make_response([]),
             self._make_response([]),
+            self._make_response([]),
         ]
 
         self.client._list_table_relationships("account", select=["SchemaName", "MetadataId"])