feat(audience): add audience SDK routes

.changeset/brave-lizards-stare.md

@@ -0,0 +1,5 @@
+---
+"lettr": minor
+---
+
+Add /audience routes (lists, contacts, topics, properties, segments) under client.audience

packages/lettr/src/audience-contacts.ts

@@ -0,0 +1,133 @@
+import type { HttpClient } from "./http";
+import type {
+  AudienceContact,
+  BulkAttachContactsListsData,
+  BulkAudienceContactListsRequest,
+  BulkCreateAudienceContactsData,
+  BulkCreateAudienceContactsRequest,
+  BulkDetachContactsListsData,
+  CreateAudienceContactRequest,
+  ListAudienceContactsData,
+  ListAudienceContactsParams,
+  Result,
+  UpdateAudienceContactRequest,
+} from "./types";
+
+export class AudienceContacts {
+  constructor(private http: HttpClient) {}
+
+  async list(
+    params?: ListAudienceContactsParams
+  ): Promise<Result<ListAudienceContactsData>> {
+    return this.http.request<ListAudienceContactsData>(
+      "GET",
+      "/audience/contacts",
+      { query: params as Record<string, string | number | undefined> }
+    );
+  }
+
+  async create(
+    data: CreateAudienceContactRequest
+  ): Promise<Result<AudienceContact>> {
+    return this.http.request<AudienceContact>("POST", "/audience/contacts", {
+      body: data,
+    });
+  }
+
+  async bulkCreate(
+    data: BulkCreateAudienceContactsRequest
+  ): Promise<Result<BulkCreateAudienceContactsData>> {
+    return this.http.request<BulkCreateAudienceContactsData>(
+      "POST",
+      "/audience/contacts/bulk",
+      { body: data }
+    );
+  }
+
+  async get(contactId: string): Promise<Result<AudienceContact>> {
+    return this.http.request<AudienceContact>(
+      "GET",
+      `/audience/contacts/${encodeURIComponent(contactId)}`
+    );
+  }
+
+  async update(
+    contactId: string,
+    data: UpdateAudienceContactRequest
+  ): Promise<Result<AudienceContact>> {
+    return this.http.request<AudienceContact>(
+      "PATCH",
+      `/audience/contacts/${encodeURIComponent(contactId)}`,
+      { body: data }
+    );
+  }
+
+  async delete(contactId: string): Promise<Result<void>> {
+    return this.http.request<void>(
+      "DELETE",
+      `/audience/contacts/${encodeURIComponent(contactId)}`
+    );
+  }
+
+  async attachList(
+    contactId: string,
+    listId: string
+  ): Promise<Result<{ message: string }>> {
+    return this.http.request<{ message: string }>(
+      "POST",
+      `/audience/contacts/${encodeURIComponent(contactId)}/lists/${encodeURIComponent(listId)}`,
+      { unwrap: false }
+    );
+  }
+
+  async detachList(
+    contactId: string,
+    listId: string
+  ): Promise<Result<void>> {
+    return this.http.request<void>(
+      "DELETE",
+      `/audience/contacts/${encodeURIComponent(contactId)}/lists/${encodeURIComponent(listId)}`
+    );
+  }
+
+  async bulkAttachLists(
+    data: BulkAudienceContactListsRequest
+  ): Promise<Result<BulkAttachContactsListsData>> {
+    return this.http.request<BulkAttachContactsListsData>(
+      "POST",
+      "/audience/contacts/lists/bulk",
+      { body: data }
+    );
+  }
+
+  async bulkDetachLists(
+    data: BulkAudienceContactListsRequest
+  ): Promise<Result<BulkDetachContactsListsData>> {
+    return this.http.request<BulkDetachContactsListsData>(
+      "DELETE",
+      "/audience/contacts/lists/bulk",
+      { body: data }
+    );
+  }
+
+  async subscribeTopic(
+    contactId: string,
+    topicId: string
+  ): Promise<Result<{ message: string }>> {
+    return this.http.request<{ message: string }>(
+      "POST",
+      `/audience/contacts/${encodeURIComponent(contactId)}/topics/${encodeURIComponent(topicId)}`,
+      { unwrap: false }
+    );
+  }
+
+  async unsubscribeTopic(
+    contactId: string,
+    topicId: string
+  ): Promise<Result<void>> {
+    return this.http.request<void>(
+      "DELETE",
+      `/audience/contacts/${encodeURIComponent(contactId)}/topics/${encodeURIComponent(topicId)}`
+    );
+  }
+}

packages/lettr/src/audience-lists.ts

@@ -0,0 +1,66 @@
+import type { HttpClient } from "./http";
+import type {
+  AudienceList,
+  BulkDeleteAudienceListsData,
+  BulkDeleteAudienceListsRequest,
+  CreateAudienceListRequest,
+  ListAudienceListsData,
+  ListAudienceListsParams,
+  Result,
+  UpdateAudienceListRequest,
+} from "./types";
+
+export class AudienceLists {
+  constructor(private http: HttpClient) {}
+
+  async list(
+    params?: ListAudienceListsParams
+  ): Promise<Result<ListAudienceListsData>> {
+    return this.http.request<ListAudienceListsData>("GET", "/audience/lists", {
+      query: params as Record<string, string | number | undefined>,
+    });
+  }
+
+  async create(
+    data: CreateAudienceListRequest
+  ): Promise<Result<AudienceList>> {
+    return this.http.request<AudienceList>("POST", "/audience/lists", {
+      body: data,
+    });
+  }
+
+  async get(listId: string): Promise<Result<AudienceList>> {
+    return this.http.request<AudienceList>(
+      "GET",
+      `/audience/lists/${encodeURIComponent(listId)}`
+    );
+  }
+
+  async update(
+    listId: string,
+    data: UpdateAudienceListRequest
+  ): Promise<Result<AudienceList>> {
+    return this.http.request<AudienceList>(
+      "PATCH",
+      `/audience/lists/${encodeURIComponent(listId)}`,
+      { body: data }
+    );
+  }
+
+  async delete(listId: string): Promise<Result<void>> {
+    return this.http.request<void>(
+      "DELETE",
+      `/audience/lists/${encodeURIComponent(listId)}`
+    );
+  }
+
+  async bulkDelete(
+    data: BulkDeleteAudienceListsRequest
+  ): Promise<Result<BulkDeleteAudienceListsData>> {
+    return this.http.request<BulkDeleteAudienceListsData>(
+      "DELETE",
+      "/audience/lists/bulk",
+      { body: data }
+    );
+  }
+}

packages/lettr/src/audience-properties.ts

@@ -0,0 +1,58 @@
+import type { HttpClient } from "./http";
+import type {
+  AudienceProperty,
+  CreateAudiencePropertyRequest,
+  ListAudiencePropertiesData,
+  ListAudiencePropertiesParams,
+  Result,
+  UpdateAudiencePropertyRequest,
+} from "./types";
+
+export class AudienceProperties {
+  constructor(private http: HttpClient) {}
+
+  async list(
+    params?: ListAudiencePropertiesParams
+  ): Promise<Result<ListAudiencePropertiesData>> {
+    return this.http.request<ListAudiencePropertiesData>(
+      "GET",
+      "/audience/properties",
+      { query: params as Record<string, string | number | undefined> }
+    );
+  }
+
+  async create(
+    data: CreateAudiencePropertyRequest
+  ): Promise<Result<AudienceProperty>> {
+    return this.http.request<AudienceProperty>(
+      "POST",
+      "/audience/properties",
+      { body: data }
+    );
+  }
+
+  async get(propertyId: string): Promise<Result<AudienceProperty>> {
+    return this.http.request<AudienceProperty>(
+      "GET",
+      `/audience/properties/${encodeURIComponent(propertyId)}`
+    );
+  }
+
+  async update(
+    propertyId: string,
+    data: UpdateAudiencePropertyRequest
+  ): Promise<Result<AudienceProperty>> {
+    return this.http.request<AudienceProperty>(
+      "PATCH",
+      `/audience/properties/${encodeURIComponent(propertyId)}`,
+      { body: data }
+    );
+  }
+
+  async delete(propertyId: string): Promise<Result<void>> {
+    return this.http.request<void>(
+      "DELETE",
+      `/audience/properties/${encodeURIComponent(propertyId)}`
+    );
+  }
+}

packages/lettr/src/audience-segments.ts

@@ -0,0 +1,56 @@
+import type { HttpClient } from "./http";
+import type {
+  AudienceSegment,
+  CreateAudienceSegmentRequest,
+  ListAudienceSegmentsData,
+  ListAudienceSegmentsParams,
+  Result,
+  UpdateAudienceSegmentRequest,
+} from "./types";
+
+export class AudienceSegments {
+  constructor(private http: HttpClient) {}
+
+  async list(
+    params?: ListAudienceSegmentsParams
+  ): Promise<Result<ListAudienceSegmentsData>> {
+    return this.http.request<ListAudienceSegmentsData>(
+      "GET",
+      "/audience/segments",
+      { query: params as Record<string, string | number | undefined> }
+    );
+  }
+
+  async create(
+    data: CreateAudienceSegmentRequest
+  ): Promise<Result<AudienceSegment>> {
+    return this.http.request<AudienceSegment>("POST", "/audience/segments", {
+      body: data,
+    });
+  }
+
+  async get(segmentId: string): Promise<Result<AudienceSegment>> {
+    return this.http.request<AudienceSegment>(
+      "GET",
+      `/audience/segments/${encodeURIComponent(segmentId)}`
+    );
+  }
+
+  async update(
+    segmentId: string,
+    data: UpdateAudienceSegmentRequest
+  ): Promise<Result<AudienceSegment>> {
+    return this.http.request<AudienceSegment>(
+      "PATCH",
+      `/audience/segments/${encodeURIComponent(segmentId)}`,
+      { body: data }
+    );
+  }
+
+  async delete(segmentId: string): Promise<Result<void>> {
+    return this.http.request<void>(
+      "DELETE",
+      `/audience/segments/${encodeURIComponent(segmentId)}`
+    );
+  }
+}

packages/lettr/src/audience-topics.ts

@@ -0,0 +1,56 @@
+import type { HttpClient } from "./http";
+import type {
+  AudienceTopic,
+  CreateAudienceTopicRequest,
+  ListAudienceTopicsData,
+  ListAudienceTopicsParams,
+  Result,
+  UpdateAudienceTopicRequest,
+} from "./types";
+
+export class AudienceTopics {
+  constructor(private http: HttpClient) {}
+
+  async list(
+    params?: ListAudienceTopicsParams
+  ): Promise<Result<ListAudienceTopicsData>> {
+    return this.http.request<ListAudienceTopicsData>(
+      "GET",
+      "/audience/topics",
+      { query: params as Record<string, string | number | undefined> }
+    );
+  }
+
+  async create(
+    data: CreateAudienceTopicRequest
+  ): Promise<Result<AudienceTopic>> {
+    return this.http.request<AudienceTopic>("POST", "/audience/topics", {
+      body: data,
+    });
+  }
+
+  async get(topicId: string): Promise<Result<AudienceTopic>> {
+    return this.http.request<AudienceTopic>(
+      "GET",
+      `/audience/topics/${encodeURIComponent(topicId)}`
+    );
+  }
+
+  async update(
+    topicId: string,
+    data: UpdateAudienceTopicRequest
+  ): Promise<Result<AudienceTopic>> {
+    return this.http.request<AudienceTopic>(
+      "PATCH",
+      `/audience/topics/${encodeURIComponent(topicId)}`,
+      { body: data }
+    );
+  }
+
+  async delete(topicId: string): Promise<Result<void>> {
+    return this.http.request<void>(
+      "DELETE",
+      `/audience/topics/${encodeURIComponent(topicId)}`
+    );
+  }
+}