Add Events API beta (#741)

* Add Events API beta

* Remove console log

* Lint

* Update pagination options

* Use listEvents

Author: alisherry

src/audit-trail/audit-trail.ts

@@ -1,5 +1,5 @@
 import { CreateEventOptions } from './interfaces/create-event-options.interface';
-import { Event } from './interfaces/event.interface';
+import { AuditTrailEvent } from './interfaces/event.interface';
 import { EventOptions } from './interfaces/event-options.interface';
 import { List } from '../common/interfaces/list.interface';
 import { ListEventsOptions } from './interfaces/list-events-options.interface';
@@ -15,7 +15,9 @@ export class AuditTrail {
     await this.workos.post('/events', event, { idempotencyKey });
   }
 
-  async listEvents(options?: ListEventsOptions): Promise<List<Event>> {
+  async listEvents(
+    options?: ListEventsOptions,
+  ): Promise<List<AuditTrailEvent>> {
     const { data } = await this.workos.get('/events', {
       query: options,
     });

src/audit-trail/interfaces/event.interface.ts

@@ -1,10 +1,10 @@
-export interface EventAction {
+export interface AuditTrailEventAction {
   object: 'event_action';
   id: string;
   name: string;
 }
 
-export interface Event {
+export interface AuditTrailEvent {
   object: 'event';
   id: string;
   group: string;
@@ -17,7 +17,7 @@ export interface Event {
   target_name: string;
   target_id: string;
   occurred_at: Date;
-  action: EventAction;
+  action: AuditTrailEventAction;
   metadata?: {
     [key: string]: string;
   };

src/audit-trail/interfaces/index.ts

@@ -1,4 +1,4 @@
 export { CreateEventOptions } from './create-event-options.interface';
 export { EventOptions } from './event-options.interface';
-export { Event } from './event.interface';
+export { AuditTrailEvent } from './event.interface';
 export { ListEventsOptions } from './list-events-options.interface';

src/events/events.spec.ts

@@ -0,0 +1,50 @@
+import axios from 'axios';
+
+import MockAdapater from 'axios-mock-adapter';
+
+import { List } from '../common/interfaces/list.interface';
+import { WorkOS } from '../workos';
+import { Event } from './interfaces/event.interface';
+
+const mock = new MockAdapater(axios);
+
+describe('Event', () => {
+  afterEach(() => mock.resetHistory());
+
+  const workos = new WorkOS('sk_test_Sz3IQjepeSWaI4cMS4ms4sMuU');
+
+  const eventResponse: Event = {
+    id: 'event_01234ABCD',
+    created_at: '2020-05-06 04:21:48.649164',
+    event: 'dsync.user.created',
+    data: {
+      id: 'event_01234ABCD',
+    },
+  };
+
+  describe('listEvents', () => {
+    const eventsListResponse: List<Event> = {
+      object: 'list',
+      data: [eventResponse],
+      list_metadata: {},
+    };
+
+    it(`requests Events`, async () => {
+      mock.onGet('/events', {}).replyOnce(200, eventsListResponse);
+
+      const list = await workos.events.listEvents({});
+
+      expect(list).toEqual(eventsListResponse);
+    });
+
+    it(`requests Events with a valid event name`, async () => {
+      mock.onGet('/events').replyOnce(200, eventsListResponse);
+
+      const list = await workos.events.listEvents({
+        events: ['connection.activated'],
+      });
+
+      expect(list).toEqual(eventsListResponse);
+    });
+  });
+});

src/events/events.ts

@@ -0,0 +1,15 @@
+import { WorkOS } from '../workos';
+import { Event } from './interfaces/event.interface';
+import { List } from '../common/interfaces/list.interface';
+import { ListEventOptions } from './interfaces';
+
+export class Events {
+  constructor(private readonly workos: WorkOS) {}
+
+  async listEvents(options: ListEventOptions): Promise<List<Event>> {
+    const { data } = await this.workos.get(`/events`, {
+      query: options,
+    });
+    return data;
+  }
+}

src/events/interfaces/event.interface.ts

@@ -0,0 +1,106 @@
+interface EventBase {
+  id: string;
+  created_at: string;
+}
+
+export interface ConnectionActivatedEvent extends EventBase {
+  event: 'connection.activated';
+  data: Record<string, unknown>;
+}
+
+export interface ConnectionDeactivatedEvent extends EventBase {
+  event: 'connection.deactivated';
+  data: Record<string, unknown>;
+}
+
+export interface ConnectionDeletedEvent extends EventBase {
+  event: 'connection.deleted';
+  data: Record<string, unknown>;
+}
+
+export interface DsyncActivatedEvent extends EventBase {
+  event: 'dsync.activated';
+  data: Record<string, unknown>;
+}
+
+export interface DsyncDeactivatedEvent extends EventBase {
+  event: 'dsync.deactivated';
+  data: Record<string, unknown>;
+}
+
+export interface DsyncDeletedEvent extends EventBase {
+  event: 'dsync.deleted';
+  data: Record<string, unknown>;
+}
+
+export interface DsyncGroupCreatedEvent extends EventBase {
+  event: 'dsync.group.created';
+  data: Record<string, unknown>;
+}
+
+export interface DsyncGroupDeletedEvent extends EventBase {
+  event: 'dsync.group.deleted';
+  data: Record<string, unknown>;
+}
+
+export interface DsyncGroupUpdatedEvent extends EventBase {
+  event: 'dsync.group.updated';
+  data: Record<string, unknown>;
+}
+
+export interface DsyncGroupUserAddedEvent extends EventBase {
+  event: 'dsync.group.user_added';
+  data: Record<string, unknown>;
+}
+
+export interface DsyncGroupUserRemovedEvent extends EventBase {
+  event: 'dsync.group.user_removed';
+  data: Record<string, unknown>;
+}
+
+export interface DsyncUserCreatedEvent extends EventBase {
+  event: 'dsync.user.created';
+  data: Record<string, unknown>;
+}
+
+export interface DsyncUserDeletedEvent extends EventBase {
+  event: 'dsync.user.deleted';
+  data: Record<string, unknown>;
+}
+
+export interface DsyncUserUpdatedEvent extends EventBase {
+  event: 'dsync.user.updated';
+  data: Record<string, unknown>;
+}
+
+export type Event =
+  | ConnectionActivatedEvent
+  | ConnectionDeactivatedEvent
+  | ConnectionDeletedEvent
+  | DsyncActivatedEvent
+  | DsyncDeactivatedEvent
+  | DsyncDeletedEvent
+  | DsyncGroupCreatedEvent
+  | DsyncGroupUpdatedEvent
+  | DsyncGroupDeletedEvent
+  | DsyncGroupUserAddedEvent
+  | DsyncGroupUserRemovedEvent
+  | DsyncUserCreatedEvent
+  | DsyncUserUpdatedEvent
+  | DsyncUserDeletedEvent;
+
+export type EventNames =
+  | 'connection.activated'
+  | 'connection.deactivated'
+  | 'connection.deleted'
+  | 'dsync.activated'
+  | 'dsync.deactivated'
+  | 'dsync.deleted'
+  | 'dsync.group.created'
+  | 'dsync.group.deleted'
+  | 'dsync.group.updated'
+  | 'dsync.group.user_added'
+  | 'dsync.group.user_removed'
+  | 'dsync.user.created'
+  | 'dsync.user.deleted'
+  | 'dsync.user.updated';

src/events/interfaces/index.ts

@@ -0,0 +1,2 @@
+export * from './list-events-options.interface';
+export * from './event.interface';

src/events/interfaces/list-events-options.interface.ts

@@ -0,0 +1,9 @@
+import { EventNames } from './event.interface';
+
+export interface ListEventOptions {
+  events?: EventNames[];
+  rangeStart?: string;
+  rangeEnd?: string;
+  limit?: number;
+  after?: string;
+}

src/index.ts

@@ -6,6 +6,7 @@ export * from './common/exceptions';
 export * from './common/interfaces';
 export * from './directory-sync/interfaces';
 export * from './directory-sync/utils/get-primary-email';
+export * from './events/interfaces';
 export * from './organizations/interfaces';
 export * from './passwordless/interfaces';
 export * from './portal/interfaces';

src/workos.ts

@@ -16,6 +16,7 @@ import {
   WorkOSResponseError,
 } from './common/interfaces';
 import { DirectorySync } from './directory-sync/directory-sync';
+import { Events } from './events/events';
 import { Organizations } from './organizations/organizations';
 import { Passwordless } from './passwordless/passwordless';
 import { Portal } from './portal/portal';
@@ -42,6 +43,7 @@ export class WorkOS {
   readonly sso = new SSO(this);
   readonly webhooks = new Webhooks();
   readonly mfa = new Mfa(this);
+  readonly events = new Events(this);
 
   constructor(readonly key?: string, readonly options: WorkOSOptions = {}) {
     if (!key) {