feat: support SMTP, default SMTP and in-platform notification channels

`CatalogSmtp` and `CatalogDefaultSmtp` had been sitting commented out with a
TODO blaming the generated client:

    # TODO: there is an issue with generated client which causes these two
    # classes to fail. type in declarative_notification_channel_destination.py
    # contains only WEBHOOK as valid value

That was the oneOf-flattening defect fixed in the previous commit, so
`destination` could only ever be a webhook. With the generated composed model
now accepting every member, add the missing destinations and widen the union:

  * CatalogSmtp - custom SMTP server
  * CatalogDefaultSmtp - the platform's own mail server
  * CatalogInPlatform - in-platform notifications

`destination` becomes `CatalogNotificationChannelDestination`, the union the
commented-out code intended.

Also drop the runtime monkeypatch that re-populated
`NotificationChannelDestination.allowed_values[("type",)]`. It treated one
symptom of the same defect from outside the generated client; the template fix
covers every collapsed composed model, so patching class attributes at import
time is no longer needed.

Reading a channel needs an explicit `from_api` rather than cattrs: the four
destination classes have no uniquely-required field to disambiguate a union on
(IN_PLATFORM carries nothing but its type), so dispatch on `type` the way
`_provider_config_from_api` does for LLM providers. It keeps only the fields
each class declares, because the API sends some we do not model - reading a
webhook returns `has_secret_key` - and dropping those matches what cattrs did
before and keeps reads working when the API grows a field.

Author: hkad98

packages/gooddata-sdk/src/gooddata_sdk/__init__.py

@@ -140,6 +140,10 @@
 )
 from gooddata_sdk.catalog.organization.layout.notification_channel import (
     CatalogDeclarativeNotificationChannel,
+    CatalogDefaultSmtp,
+    CatalogInPlatform,
+    CatalogNotificationChannelDestination,
+    CatalogSmtp,
     CatalogWebhook,
 )
 from gooddata_sdk.catalog.organization.service import (

packages/gooddata-sdk/src/gooddata_sdk/catalog/organization/layout/notification_channel.py

@@ -1,53 +1,25 @@
 # (C) 2024 GoodData Corporation
+from __future__ import annotations
+
 import builtins
+from typing import Any, Union
 
 from attrs import define, field
+from attrs import fields as attrs_fields
 from gooddata_api_client.model.declarative_notification_channel import DeclarativeNotificationChannel
-from gooddata_api_client.model.notification_channel_destination import NotificationChannelDestination
+from gooddata_api_client.model.default_smtp import DefaultSmtp
+from gooddata_api_client.model.in_platform import InPlatform
+from gooddata_api_client.model.smtp import Smtp
 from gooddata_api_client.model.webhook import Webhook
 
 from gooddata_sdk.catalog.base import Base
-
-# The generator collapses the `type` enums of NotificationChannelDestination's oneOf children
-# into the last child's single value (IN_PLATFORM), so valid destinations of the other types
-# fail client-side validation on both serialization and response parsing. Restore the full set.
-NotificationChannelDestination.allowed_values[("type",)].update(
-    {
-        "WEBHOOK": "WEBHOOK",
-        "SMTP": "SMTP",
-        "DEFAULT_SMTP": "DEFAULT_SMTP",
-        "IN_PLATFORM": "IN_PLATFORM",
-    }
-)
-
-# TODO: there is an issue with generated client which causes these two classes to fail
-# type in gooddata_api_client/model/declarative_notification_channel_destination.py contains only WEBHOOK as valid value
-# @define(kw_only=True)
-# class CatalogDefaultSmtp(Base):
-#     from_email: Optional[str] = None
-#     from_email_name: Optional[str] = None
-#
-#     @staticmethod
-#     def client_class() -> Type[DefaultSmtp]:
-#         return DefaultSmtp
-#
-#
-# @define(kw_only=True)
-# class CatalogSmtp(Base):
-#     from_email: Optional[str] = None
-#     from_email_name: Optional[str] = None
-#     host: Optional[str] = None
-#     password: Optional[str] = None
-#     port: Optional[int] = None
-#     username: Optional[str] = None
-#
-#     @staticmethod
-#     def client_class() -> Type[Smtp]:
-#         return Smtp
+from gooddata_sdk.utils import safeget
 
 
 @define(kw_only=True)
 class CatalogWebhook(Base):
+    """Webhook destination for notifications."""
+
     type: str = field(default="WEBHOOK", init=False)
     url: str
     token: str | None = field(default=None, eq=False)
@@ -58,6 +30,85 @@ def client_class() -> builtins.type[Webhook]:
         return Webhook
 
 
+@define(kw_only=True)
+class CatalogSmtp(Base):
+    """Custom SMTP destination for notifications.
+
+    `host`, `port`, `username` and `password` are required by the API on create
+    and update, but are optional here because reads never return the password.
+    """
+
+    type: str = field(default="SMTP", init=False)
+    from_email: str | None = None
+    from_email_name: str | None = None
+    host: str | None = None
+    port: int | None = None
+    username: str | None = None
+    password: str | None = field(default=None, eq=False)
+
+    @staticmethod
+    def client_class() -> builtins.type[Smtp]:
+        return Smtp
+
+
+@define(kw_only=True)
+class CatalogDefaultSmtp(Base):
+    """Default SMTP destination for notifications - the platform's own mail server."""
+
+    type: str = field(default="DEFAULT_SMTP", init=False)
+    from_email: str | None = None
+    from_email_name: str | None = None
+
+    @staticmethod
+    def client_class() -> builtins.type[DefaultSmtp]:
+        return DefaultSmtp
+
+
+@define(kw_only=True)
+class CatalogInPlatform(Base):
+    """In-platform destination for notifications."""
+
+    type: str = field(default="IN_PLATFORM", init=False)
+
+    @staticmethod
+    def client_class() -> builtins.type[InPlatform]:
+        return InPlatform
+
+
+CatalogNotificationChannelDestination = Union[
+    CatalogWebhook,
+    CatalogSmtp,
+    CatalogDefaultSmtp,
+    CatalogInPlatform,
+]
+
+_DESTINATION_BY_TYPE: dict[str, builtins.type[CatalogNotificationChannelDestination]] = {
+    "WEBHOOK": CatalogWebhook,
+    "SMTP": CatalogSmtp,
+    "DEFAULT_SMTP": CatalogDefaultSmtp,
+    "IN_PLATFORM": CatalogInPlatform,
+}
+
+
+def _destination_from_api(data: dict[str, Any]) -> CatalogNotificationChannelDestination:
+    """Build the right destination class from a `destination` payload.
+
+    Dispatched on `type` explicitly rather than left to cattrs: the four
+    destination classes have no uniquely-required field to disambiguate a
+    union on (`IN_PLATFORM` carries nothing but its type).
+    """
+    destination_type = safeget(data, ["type"])
+    destination_class = _DESTINATION_BY_TYPE.get(destination_type)
+    if destination_class is None:
+        raise ValueError(f"Unknown notification channel destination type: {destination_type}")
+    # Keep only what the class can take: `type` is init=False (implied by the
+    # class itself) and the API sends fields we do not model - `has_secret_key`
+    # on a webhook, for one. Silently ignoring those matches how cattrs used to
+    # structure this and keeps reads working when the API grows a field.
+    accepted = {f.name for f in attrs_fields(destination_class) if f.init}
+    return destination_class(**{k: v for k, v in data.items() if k in accepted})
+
+
 @define(kw_only=True)
 class CatalogDeclarativeNotificationChannel(Base):
     id: str
@@ -66,9 +117,22 @@ class CatalogDeclarativeNotificationChannel(Base):
     destination_type: str | None = None
     custom_dashboard_url: str | None = None
     allowed_recipients: str | None = None
-    # destination: Optional[Union[CatalogDefaultSmtp, CatalogSmtp, CatalogWebhook]] = None
-    destination: CatalogWebhook | None = None
+    destination: CatalogNotificationChannelDestination | None = None
 
     @staticmethod
     def client_class() -> builtins.type[DeclarativeNotificationChannel]:
         return DeclarativeNotificationChannel
+
+    @classmethod
+    def from_api(cls, entity: dict[str, Any]) -> CatalogDeclarativeNotificationChannel:
+        data = entity if isinstance(entity, dict) else entity.to_dict(camel_case=False)
+        raw_destination = safeget(data, ["destination"])
+        return cls(
+            id=data["id"],
+            name=safeget(data, ["name"]),
+            description=safeget(data, ["description"]),
+            destination_type=safeget(data, ["destination_type"]),
+            custom_dashboard_url=safeget(data, ["custom_dashboard_url"]),
+            allowed_recipients=safeget(data, ["allowed_recipients"]),
+            destination=_destination_from_api(raw_destination) if raw_destination is not None else None,
+        )

packages/gooddata-sdk/tests/catalog/unit_tests/test_notification_channel_destinations.py

@@ -0,0 +1,133 @@
+# (C) 2026 GoodData Corporation
+"""Tests for the notification channel destination union.
+
+`CatalogSmtp` / `CatalogDefaultSmtp` used to be commented out in the SDK with a
+TODO pointing at the generated client: the composed destination model accepted a
+single `type` only, so `to_api()` raised `ApiValueError` for every other
+destination. That was the same oneOf-flattening defect covered by
+`test_composed_oneof_unions.py`; with it fixed in `model_utils`, all four
+destinations are usable and `NotificationChannelDestination.allowed_values` no
+longer has to be monkeypatched at import time.
+"""
+
+from __future__ import annotations
+
+import pytest
+from gooddata_api_client.model.json_api_notification_channel_in_attributes_destination import (
+    JsonApiNotificationChannelInAttributesDestination,
+)
+from gooddata_api_client.model.notification_channel_destination import NotificationChannelDestination
+from gooddata_sdk import (
+    CatalogDeclarativeNotificationChannel,
+    CatalogDefaultSmtp,
+    CatalogInPlatform,
+    CatalogSmtp,
+    CatalogWebhook,
+)
+
+DESTINATIONS = {
+    "WEBHOOK": (
+        CatalogWebhook(url="https://webhook.site/hook", token="secret"),
+        {"type": "WEBHOOK", "url": "https://webhook.site/hook", "token": "secret"},
+    ),
+    "SMTP": (
+        CatalogSmtp(
+            from_email="sender@example.com",
+            from_email_name="Sender",
+            host="smtp.example.com",
+            port=587,
+            username="user",
+            password="secret",
+        ),
+        {
+            "type": "SMTP",
+            "from_email": "sender@example.com",
+            "from_email_name": "Sender",
+            "host": "smtp.example.com",
+            "port": 587,
+            "username": "user",
+            "password": "secret",
+        },
+    ),
+    "DEFAULT_SMTP": (
+        CatalogDefaultSmtp(from_email="sender@example.com", from_email_name="Sender"),
+        {"type": "DEFAULT_SMTP", "from_email": "sender@example.com", "from_email_name": "Sender"},
+    ),
+    "IN_PLATFORM": (CatalogInPlatform(), {"type": "IN_PLATFORM"}),
+}
+
+
+@pytest.mark.parametrize("destination_type", sorted(DESTINATIONS))
+def test_destination_to_api(destination_type: str) -> None:
+    """Every destination must survive `to_api()`, not just WEBHOOK."""
+    destination, expected = DESTINATIONS[destination_type]
+
+    assert destination.to_api().to_dict() == expected
+
+
+@pytest.mark.parametrize("destination_type", sorted(DESTINATIONS))
+def test_notification_channel_to_api_carries_the_destination(destination_type: str) -> None:
+    destination, expected = DESTINATIONS[destination_type]
+    channel = CatalogDeclarativeNotificationChannel(
+        id=f"channel-{destination_type.lower()}",
+        name=f"Channel {destination_type}",
+        destination=destination,
+        allowed_recipients="CREATOR",
+    )
+
+    api_object = channel.to_api()
+
+    assert api_object.to_dict()["destination"] == expected
+
+
+@pytest.mark.parametrize("destination_type", sorted(DESTINATIONS))
+def test_notification_channel_round_trips(destination_type: str) -> None:
+    """`from_api` must rebuild the concrete destination class, not a webhook."""
+    destination, _ = DESTINATIONS[destination_type]
+    channel = CatalogDeclarativeNotificationChannel(
+        id=f"channel-{destination_type.lower()}",
+        name=f"Channel {destination_type}",
+        destination=destination,
+        custom_dashboard_url="https://dashboard.site",
+        allowed_recipients="CREATOR",
+    )
+
+    restored = CatalogDeclarativeNotificationChannel.from_api(channel.to_dict(camel_case=False))
+
+    assert restored == channel
+    assert type(restored.destination) is type(destination)
+    assert restored.destination is not None
+    assert restored.destination.type == destination_type
+
+
+def test_from_api_rejects_an_unknown_destination_type() -> None:
+    with pytest.raises(ValueError, match="Unknown notification channel destination type: TELEPATHY"):
+        CatalogDeclarativeNotificationChannel.from_api({"id": "channel", "destination": {"type": "TELEPATHY"}})
+
+
+@pytest.mark.parametrize(
+    "model",
+    [NotificationChannelDestination, JsonApiNotificationChannelInAttributesDestination],
+    ids=["shared", "json_api"],
+)
+@pytest.mark.parametrize("destination_type", sorted(DESTINATIONS))
+def test_generated_destination_models_accept_every_type(model, destination_type: str) -> None:
+    """Pin the generated composed models too - this is where the defect lived."""
+    _, payload = DESTINATIONS[destination_type]
+
+    destination = model(**payload)
+
+    assert destination.type == destination_type
+
+
+def test_destination_model_class_attribute_is_still_collapsed() -> None:
+    """Guard the reason the monkeypatch could go: the fix is at validation time.
+
+    The generator still writes a single-variant enum onto the composed parent -
+    nothing regenerates that away - so this documents that the models above pass
+    because `model_utils` unions the members, not because the class attribute
+    got fixed.
+    """
+    collapsed = NotificationChannelDestination.allowed_values.get(("type",), {})
+
+    assert len(collapsed) == 1