fix(events): handle domain verification failed

The domain verfication failed events have a slightly different schema to
other organization domain events. This was causing the data to be parsed
incorrectly in the list events api resulting in empty `data` properties.

I've added the required interfaces, serializers, and deserializers to
capture the difference and parse the events successfully. I've also
added some unit tests for the serialization.

Author: noseworthy

src/common/interfaces/event.interface.ts

@@ -74,6 +74,10 @@ import {
   VaultDekDecryptedEventData,
   VaultDekDecryptedEventResponseData,
 } from '../../vault/interfaces/vault-event.interface';
+import {
+    OrganizationDomainVerificationFailed,
+    OrganizationDomainVerificationFailedResponse
+} from "../../organization-domains/interfaces/organization-domain-verification-failed.interface";
 
 export interface EventBase {
   id: string;
@@ -654,12 +658,12 @@ export interface OrganizationDomainVerifiedEventResponse extends EventResponseBa
 
 export interface OrganizationDomainVerificationFailedEvent extends EventBase {
   event: 'organization_domain.verification_failed';
-  data: OrganizationDomain;
+  data: OrganizationDomainVerificationFailed;
 }
 
 export interface OrganizationDomainVerificationFailedEventResponse extends EventResponseBase {
   event: 'organization_domain.verification_failed';
-  data: OrganizationDomainResponse;
+  data: OrganizationDomainVerificationFailedResponse;
 }
 
 export interface OrganizationDomainCreatedEvent extends EventBase {

src/common/serializers/event.serializer.ts

@@ -37,6 +37,9 @@ import {
   deserializeVaultDekReadEvent,
   deserializeVaultDekDecryptedEvent,
 } from '../../vault/serializers/vault-event.serializer';
+import {
+    deserializeOrganizationDomainVerificationFailed
+} from "../../organization-domains/serializers/organization-domain-verification-failed.serializer";
 
 export const deserializeEvent = (event: EventResponse): Event => {
   const eventBase: EventBase = {
@@ -209,8 +212,13 @@ export const deserializeEvent = (event: EventResponse): Event => {
         event: event.event,
         data: deserializeOrganization(event.data),
       };
-    case 'organization_domain.verified':
     case 'organization_domain.verification_failed':
+        return {
+            ...eventBase,
+            event: event.event,
+            data: deserializeOrganizationDomainVerificationFailed(event.data),
+        };
+    case 'organization_domain.verified':
     case 'organization_domain.created':
     case 'organization_domain.updated':
     case 'organization_domain.deleted':

src/events/events.spec.ts

@@ -1,34 +1,39 @@
 import fetch from 'jest-fetch-mock';
-import { fetchOnce, fetchSearchParams } from '../common/utils/test-utils';
+import {fetchOnce, fetchSearchParams} from '../common/utils/test-utils';
 import {
-  DsyncUserUpdatedEvent,
-  DsyncUserUpdatedEventResponse,
-  Event,
-  EventResponse,
-  FlagCreatedEvent,
-  FlagCreatedEventResponse,
-  ListResponse,
-  VaultDataCreatedEvent,
-  VaultDataCreatedEventResponse,
-  VaultDataUpdatedEvent,
-  VaultDataUpdatedEventResponse,
-  VaultDataReadEvent,
-  VaultDataReadEventResponse,
-  VaultDataDeletedEvent,
-  VaultDataDeletedEventResponse,
-  VaultNamesListedEvent,
-  VaultNamesListedEventResponse,
-  VaultMetadataReadEvent,
-  VaultMetadataReadEventResponse,
-  VaultKekCreatedEvent,
-  VaultKekCreatedEventResponse,
-  VaultDekReadEvent,
-  VaultDekReadEventResponse,
-  VaultDekDecryptedEvent,
-  VaultDekDecryptedEventResponse,
+    DsyncUserUpdatedEvent,
+    DsyncUserUpdatedEventResponse,
+    Event,
+    EventResponse,
+    FlagCreatedEvent,
+    FlagCreatedEventResponse,
+    ListResponse,
+    OrganizationDomainCreatedEvent,
+    OrganizationDomainCreatedEventResponse,
+    OrganizationDomainVerificationFailedEvent,
+    OrganizationDomainVerificationFailedEventResponse,
+    VaultDataCreatedEvent,
+    VaultDataCreatedEventResponse,
+    VaultDataDeletedEvent,
+    VaultDataDeletedEventResponse,
+    VaultDataReadEvent,
+    VaultDataReadEventResponse,
+    VaultDataUpdatedEvent,
+    VaultDataUpdatedEventResponse,
+    VaultDekDecryptedEvent,
+    VaultDekDecryptedEventResponse,
+    VaultDekReadEvent,
+    VaultDekReadEventResponse,
+    VaultKekCreatedEvent,
+    VaultKekCreatedEventResponse,
+    VaultMetadataReadEvent,
+    VaultMetadataReadEventResponse,
+    VaultNamesListedEvent,
+    VaultNamesListedEventResponse,
 } from '../common/interfaces';
-import { WorkOS } from '../workos';
-import { ConnectionType } from '../sso/interfaces';
+import {WorkOS} from '../workos';
+import {ConnectionType} from '../sso/interfaces';
+import {OrganizationDomainState, OrganizationDomainVerificationStrategy} from "../organization-domains/interfaces";
 
 describe('Event', () => {
   beforeEach(() => fetch.resetMocks());
@@ -693,5 +698,119 @@ describe('Event', () => {
         });
       });
     });
+
+    describe('organization domain events', () => {
+        it('deserializes organization_domain.created events', async () => {
+            const response: OrganizationDomainCreatedEventResponse = {
+                "event": "organization_domain.created",
+                "id": "event_01DOMAINCREATED001",
+                "data": {
+                    "id": "org_domain_01TESTDOMAIN",
+                    "state": OrganizationDomainState.Pending,
+                    "domain": "example.com",
+                    "object": "organization_domain",
+                    "created_at": "2026-04-06T06:24:06.749Z",
+                    "updated_at": "2026-04-06T06:24:06.749Z",
+                    "organization_id": "org_01TESTORGANIZATION",
+                    "verification_strategy": OrganizationDomainVerificationStrategy.Manual,
+                },
+                "context": {},
+                "created_at": "2026-04-06T06:24:06.776Z"
+            };
+
+            const expected: OrganizationDomainCreatedEvent = {
+                "event": "organization_domain.created",
+                "id": "event_01DOMAINCREATED001",
+                "data": {
+                    "id": "org_domain_01TESTDOMAIN",
+                    "state": OrganizationDomainState.Pending,
+                    "domain": "example.com",
+                    "object": "organization_domain",
+                    "createdAt": "2026-04-06T06:24:06.749Z",
+                    "updatedAt": "2026-04-06T06:24:06.749Z",
+                    "organizationId": "org_01TESTORGANIZATION",
+                    "verificationStrategy": OrganizationDomainVerificationStrategy.Manual,
+                },
+                "context": {},
+                "createdAt": "2026-04-06T06:24:06.776Z"
+            };
+
+            fetchOnce({
+                object: 'list',
+                data: [response],
+                list_metadata: {},
+            });
+
+            const list = await workos.events.listEvents({
+                events: ['organization_domain.created'],
+            });
+
+            expect(list).toEqual({
+                object: 'list',
+                data: [expected],
+                listMetadata: {},
+            });
+        });
+
+        it('deserializes organization_domain.verification_failed events', async () => {
+            const response: OrganizationDomainVerificationFailedEventResponse = {
+                "event": "organization_domain.verification_failed",
+                "id": "event_01DOMAIN0002",
+                "data": {
+                    "reason": "domain_verification_period_expired",
+                    "organization_domain": {
+                        "id": "org_domain_0TESTDOMAIN",
+                        "state": OrganizationDomainState.Failed,
+                        "domain": "example.com",
+                        "object": "organization_domain",
+                        "created_at": "2026-03-07T02:24:56.621Z",
+                        "updated_at": "2026-04-06T02:25:00.494Z",
+                        "organization_id": "org_01TESTORGANIZATION",
+                        "verification_token": "FAKETOKEN",
+                        "verification_strategy": OrganizationDomainVerificationStrategy.Dns
+                    }
+                },
+                "context": {},
+                "created_at": "2026-04-06T02:26:05.430Z"
+            };
+
+            const expected: OrganizationDomainVerificationFailedEvent = {
+                "event": "organization_domain.verification_failed",
+                "id": "event_01DOMAIN0002",
+                "data": {
+                    "reason": "domain_verification_period_expired",
+                    "organizationDomain": {
+                        "id": "org_domain_0TESTDOMAIN",
+                        "state": OrganizationDomainState.Failed,
+                        "domain": "example.com",
+                        "object": "organization_domain",
+                        "createdAt": "2026-03-07T02:24:56.621Z",
+                        "updatedAt": "2026-04-06T02:25:00.494Z",
+                        "organizationId": "org_01TESTORGANIZATION",
+                        "verificationToken": "FAKETOKEN",
+                        "verificationStrategy": OrganizationDomainVerificationStrategy.Dns
+                    }
+                },
+                "context": {},
+                "createdAt": "2026-04-06T02:26:05.430Z"
+            };
+
+            fetchOnce({
+                object: 'list',
+                data: [response],
+                list_metadata: {},
+            });
+
+            const list = await workos.events.listEvents({
+                events: ['organization_domain.verification_failed'],
+            });
+
+            expect(list).toEqual({
+                object: 'list',
+                data: [expected],
+                listMetadata: {},
+            });
+        });
+    });
   });
 });

src/organization-domains/interfaces/organization-domain-verification-failed.interface.ts

@@ -0,0 +1,11 @@
+import {OrganizationDomain, OrganizationDomainResponse} from "./organization-domain.interface";
+
+export interface OrganizationDomainVerificationFailed {
+  reason: string;
+  organizationDomain: OrganizationDomain;
+}
+
+export interface OrganizationDomainVerificationFailedResponse {
+  reason: string;
+  organization_domain: OrganizationDomainResponse;
+}

src/organization-domains/serializers/organization-domain-verification-failed.serializer.ts

@@ -0,0 +1,19 @@
+import {
+    OrganizationDomainVerificationFailed,
+    OrganizationDomainVerificationFailedResponse
+} from "../interfaces/organization-domain-verification-failed.interface";
+import {deserializeOrganizationDomain, serializeOrganizationDomain} from "./organization-domain.serializer";
+
+export const deserializeOrganizationDomainVerificationFailed = (
+    organizationDomainVerificationFailed: OrganizationDomainVerificationFailedResponse,
+): OrganizationDomainVerificationFailed => ({
+    reason: organizationDomainVerificationFailed.reason,
+    organizationDomain: deserializeOrganizationDomain(organizationDomainVerificationFailed.organization_domain),
+});
+
+export const serializeOrganizationDomainVerificationFailed = (
+    organizationDomainVerificationFailed: OrganizationDomainVerificationFailed,
+): OrganizationDomainVerificationFailedResponse => ({
+    reason: organizationDomainVerificationFailed.reason,
+    organization_domain: serializeOrganizationDomain(organizationDomainVerificationFailed.organizationDomain)
+});