Add display_name parameter to tables.create() (#163)

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

Author: Abel Milash

src/PowerPlatform/Dataverse/data/_batch.py

@@ -86,6 +86,7 @@ class _TableCreate:
     columns: Dict[str, Any]
     solution: Optional[str] = None
     primary_column: Optional[str] = None
+    display_name: Optional[str] = None
 
 
 @dataclass
@@ -409,7 +410,7 @@ def _require_entity_metadata(self, table: str) -> str:
         return ent["MetadataId"]
 
     def _resolve_table_create(self, op: _TableCreate) -> List[_RawRequest]:
-        return [self._od._build_create_entity(op.table, op.columns, op.solution, op.primary_column)]
+        return [self._od._build_create_entity(op.table, op.columns, op.solution, op.primary_column, op.display_name)]
 
     def _resolve_table_delete(self, op: _TableDelete) -> List[_RawRequest]:
         metadata_id = self._require_entity_metadata(op.table)

src/PowerPlatform/Dataverse/data/_odata.py

@@ -1636,6 +1636,7 @@ def _create_table(
         schema: Dict[str, Any],
         solution_unique_name: Optional[str] = None,
         primary_column_schema_name: Optional[str] = None,
+        display_name: Optional[str] = None,
     ) -> Dict[str, Any]:
         """Create a custom table with specified columns.
 
@@ -1647,6 +1648,8 @@ def _create_table(
         :type solution_unique_name: ``str`` | ``None``
         :param primary_column_schema_name: Optional primary column schema name.
         :type primary_column_schema_name: ``str`` | ``None``
+        :param display_name: Optional display name shown in the Power Platform UI. Defaults to ``table_schema_name``.
+        :type display_name: ``str`` | ``None``
 
         :return: Metadata summary for the created table including created column schema names.
         :rtype: ``dict[str, Any]``
@@ -1692,7 +1695,7 @@ def _create_table(
 
         metadata = self._create_entity(
             table_schema_name=table_schema_name,
-            display_name=table_schema_name,
+            display_name=display_name or table_schema_name,
             attributes=attributes,
             solution_unique_name=solution_unique_name,
         )
@@ -2099,6 +2102,7 @@ def _build_create_entity(
         columns: Dict[str, Any],
         solution: Optional[str] = None,
         primary_column: Optional[str] = None,
+        display_name: Optional[str] = None,
     ) -> _RawRequest:
         """Build an EntityDefinitions POST request without sending it."""
         if primary_column:
@@ -2114,12 +2118,13 @@ def _build_create_entity(
                     subcode=VALIDATION_UNSUPPORTED_COLUMN_TYPE,
                 )
             attributes.append(attr)
+        label = display_name or table
         body = {
             "@odata.type": "Microsoft.Dynamics.CRM.EntityMetadata",
             "SchemaName": table,
-            "DisplayName": self._label(table),
-            "DisplayCollectionName": self._label(table + "s"),
-            "Description": self._label(f"Custom entity for {table}"),
+            "DisplayName": self._label(label),
+            "DisplayCollectionName": self._label(label + "s"),
+            "Description": self._label(f"Custom entity for {label}"),
             "OwnershipType": "UserOwned",
             "HasActivities": False,
             "HasNotes": True,

src/PowerPlatform/Dataverse/operations/batch.py

@@ -358,6 +358,7 @@ def create(
         *,
         solution: Optional[str] = None,
         primary_column: Optional[str] = None,
+        display_name: Optional[str] = None,
     ) -> None:
         """
         Add a table-create operation to the batch.
@@ -375,13 +376,17 @@ def create(
         :type solution: str or None
         :param primary_column: Optional primary column schema name.
         :type primary_column: str or None
+        :param display_name: Human-readable display name shown in the Power Platform UI.
+            When omitted, defaults to the table schema name.
+        :type display_name: str or None
         """
         self._batch._items.append(
             _TableCreate(
                 table=table,
                 columns=columns,
                 solution=solution,
                 primary_column=primary_column,
+                display_name=display_name,
             )
         )
 

src/PowerPlatform/Dataverse/operations/tables.py

@@ -74,6 +74,7 @@ def create(
         *,
         solution: Optional[str] = None,
         primary_column: Optional[str] = None,
+        display_name: Optional[str] = None,
     ) -> TableInfo:
         """Create a custom table with the specified columns.
 
@@ -96,6 +97,10 @@ def create(
             customization prefix (e.g. ``"new_ProductName"``). If not provided,
             defaults to ``"{prefix}_Name"``.
         :type primary_column: :class:`str` or None
+        :param display_name: Human-readable display name shown in the Power
+            Platform UI (e.g. ``"Product"``). When omitted, defaults to the
+            table schema name.
+        :type display_name: :class:`str` or None
 
         :return: Table metadata with ``schema_name``, ``entity_set_name``,
             ``logical_name``, ``metadata_id``, and ``columns_created``.
@@ -124,6 +129,7 @@ class ItemStatus(IntEnum):
                     },
                     solution="MySolution",
                     primary_column="new_ProductName",
+                    display_name="Product",
                 )
                 print(f"Created: {result['table_schema_name']}")
         """
@@ -133,6 +139,7 @@ class ItemStatus(IntEnum):
                 columns,
                 solution,
                 primary_column,
+                display_name,
             )
             return TableInfo.from_dict(raw)
 

tests/unit/data/test_batch_serialization.py

@@ -691,7 +691,7 @@ def test_dispatch_table_create(self):
         od._build_create_entity.return_value = MagicMock()
         op = _TableCreate(table="new_Widget", columns={"new_name": str})
         result = client._resolve_item(op)
-        od._build_create_entity.assert_called_once_with("new_Widget", {"new_name": str}, None, None)
+        od._build_create_entity.assert_called_once_with("new_Widget", {"new_name": str}, None, None, None)
         self.assertEqual(len(result), 1)
 
     def test_dispatch_table_delete(self):

tests/unit/data/test_odata_internal.py

@@ -1824,6 +1824,22 @@ def test_primary_column_schema_name_used_when_provided(self):
         self.assertIsNotNone(primary_attr)
         self.assertEqual(primary_attr["SchemaName"], "new_CustomName")
 
+    def test_display_name_used_in_payload_when_provided(self):
+        """_create_table uses provided display_name in the POST payload DisplayName."""
+        self._setup_for_create()
+        self.od._create_table("new_TestTable", {}, display_name="My Test Table")
+        post_json = self.od._request.call_args.kwargs["json"]
+        label_value = post_json["DisplayName"]["LocalizedLabels"][0]["Label"]
+        self.assertEqual(label_value, "My Test Table")
+
+    def test_display_name_defaults_to_schema_name(self):
+        """_create_table defaults DisplayName to table_schema_name when display_name is omitted."""
+        self._setup_for_create()
+        self.od._create_table("new_TestTable", {})
+        post_json = self.od._request.call_args.kwargs["json"]
+        label_value = post_json["DisplayName"]["LocalizedLabels"][0]["Label"]
+        self.assertEqual(label_value, "new_TestTable")
+
 
 class TestCreateColumns(unittest.TestCase):
     """Unit tests for _ODataClient._create_columns."""

tests/unit/test_client_deprecations.py

@@ -203,6 +203,7 @@ def test_create_table_warns(self):
             {"new_Price": "decimal"},
             "MySolution",
             "new_ProductName",
+            None,
         )
         self.assertEqual(result["table_schema_name"], "new_Product")
         self.assertEqual(result["columns_created"], ["new_Price"])

tests/unit/test_tables_operations.py

@@ -53,12 +53,34 @@ def test_create(self):
             columns,
             "MySolution",
             "new_ProductName",
+            None,
         )
         self.assertIsInstance(result, TableInfo)
         self.assertEqual(result.schema_name, "new_Product")
         self.assertEqual(result["table_schema_name"], "new_Product")
         self.assertEqual(result["entity_set_name"], "new_products")
 
+    def test_create_with_display_name(self):
+        """create() should forward display_name to _create_table."""
+        raw = {
+            "table_schema_name": "new_Product",
+            "entity_set_name": "new_products",
+            "table_logical_name": "new_product",
+            "metadata_id": "meta-guid-1",
+            "columns_created": [],
+        }
+        self.client._odata._create_table.return_value = raw
+
+        self.client.tables.create("new_Product", {}, display_name="Product")
+
+        self.client._odata._create_table.assert_called_once_with(
+            "new_Product",
+            {},
+            None,
+            None,
+            "Product",
+        )
+
     # ------------------------------------------------------------------ delete
 
     def test_delete(self):