@hasna/connectors 1.3.45 → 1.3.46

package/connectors/tidio/src/api/client.ts

@@ -1,10 +1,11 @@
 import type { TidioConfig } from '../types';
 import { parseTidioError } from '../types';
 
-const DEFAULT_BASE_URL = 'https://api.tidio.co/v1';
+export const DEFAULT_BASE_URL = 'https://api.tidio.com/';
+export const TIDIO_ACCEPT_HEADER = 'application/json; version=1';
 
 export interface RequestOptions {
-  method?: 'GET' | 'POST' | 'PATCH' | 'DELETE';
+  method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
   params?: Record<string, string | number | boolean | undefined>;
   body?: Record<string, unknown> | unknown[] | string | null;
   headers?: Record<string, string>;
@@ -12,19 +13,24 @@ export interface RequestOptions {
 }
 
 export class TidioClient {
-  private readonly apiKey: string;
+  private readonly clientId: string;
+  private readonly clientSecret: string;
   private readonly baseUrl: string;
 
   constructor(config: TidioConfig) {
-    if (!config.apiKey) {
-      throw new Error('API key is required');
+    if (!config.clientId) {
+      throw new Error('Client ID is required');
     }
-    this.apiKey = config.apiKey;
+    if (!config.clientSecret) {
+      throw new Error('Client secret is required');
+    }
+    this.clientId = config.clientId;
+    this.clientSecret = config.clientSecret;
     this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
   }
 
   private buildUrl(path: string, params?: Record<string, string | number | boolean | undefined>): string {
-    const url = new URL(`${this.baseUrl}${path}`);
+    const url = new URL(path.replace(/^\//, ''), this.baseUrl);
 
     if (params) {
       Object.entries(params).forEach(([key, value]) => {
@@ -54,12 +60,13 @@ export class TidioClient {
     const url = this.buildUrl(path, params);
 
     const requestHeaders: Record<string, string> = {
-      'X-Tidio-Openapi-Key': this.apiKey,
-      'Accept': 'application/json',
+      'Accept': TIDIO_ACCEPT_HEADER,
+      'X-Tidio-Openapi-Client-Id': this.clientId,
+      'X-Tidio-Openapi-Client-Secret': this.clientSecret,
       ...headers,
     };
 
-    if (body !== undefined && body !== null && ['POST', 'PATCH'].includes(method)) {
+    if (body !== undefined && body !== null && ['POST', 'PUT', 'PATCH'].includes(method)) {
       requestHeaders['Content-Type'] = 'application/json';
     }
 
@@ -68,7 +75,7 @@ export class TidioClient {
       headers: requestHeaders,
     };
 
-    if (body !== undefined && body !== null && ['POST', 'PATCH'].includes(method)) {
+    if (body !== undefined && body !== null && ['POST', 'PUT', 'PATCH'].includes(method)) {
       fetchOptions.body = typeof body === 'string' ? body : JSON.stringify(body);
     }
 
@@ -76,7 +83,7 @@ export class TidioClient {
       const response = await fetch(url, fetchOptions);
 
       if (response.status === 204) {
-        return {} as T;
+        return undefined as T;
       }
 
       let data: unknown;
@@ -122,6 +129,10 @@ export class TidioClient {
     return this.request<T>(path, { method: 'POST', body: body as Record<string, unknown>, params });
   }
 
+  async put<T>(path: string, body?: Record<string, unknown> | object, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
+    return this.request<T>(path, { method: 'PUT', body: body as Record<string, unknown>, params });
+  }
+
   async patch<T>(path: string, body?: Record<string, unknown> | object, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
     return this.request<T>(path, { method: 'PATCH', body: body as Record<string, unknown>, params });
   }
@@ -130,9 +141,9 @@ export class TidioClient {
     return this.request<T>(path, { method: 'DELETE', params });
   }
 
-  getApiKeyPreview(): string {
-    if (this.apiKey.length > 10) {
-      return `${this.apiKey.substring(0, 6)}...${this.apiKey.substring(this.apiKey.length - 4)}`;
+  getClientIdPreview(): string {
+    if (this.clientId.length > 10) {
+      return `${this.clientId.substring(0, 6)}...${this.clientId.substring(this.clientId.length - 4)}`;
     }
     return '***';
   }

package/connectors/tidio/src/api/index.ts

@@ -1,29 +1,53 @@
 import type {
-  TidioConfig,
+  BatchContactsParams,
+  AskLyroTicketParams,
   Contact,
-  Conversation,
-  Message,
-  Operator,
+  ContactMessage,
+  ContactProperty,
+  CreateContactParams,
+  CreateLyroQaDataSourceParams,
+  CreateTicketAsContactParams,
   Department,
-  Tag,
-  Automation,
-  CannedResponse,
-  Webhook,
-  Project,
+  ListContactMessagesParams,
   ListContactsParams,
-  CreateContactParams,
+  ListLyroDataSourcesParams,
+  ListTicketsParams,
+  LyroDataSource,
+  MessageAccepted,
+  Operator,
+  PaginatedResponse,
+  Product,
+  Project,
+  ReplyTicketParams,
+  ScrapeLyroWebsiteParams,
+  SendContactMessageParams,
+  TidioConfig,
+  Ticket,
+  TicketCustomField,
+  TicketTag,
   UpdateContactParams,
-  ListConversationsParams,
-  ListMessagesParams,
-  SendMessageParams,
-  SetConversationStatusParams,
-  AssignConversationParams,
-  CreateTagParams,
-  CreateCannedResponseParams,
-  CreateWebhookParams,
+  UpdateTicketParams,
+  UpsertLyroWebsiteDataSourceParams,
+  UuidResponse,
 } from '../types';
 import { TidioClient } from './client';
 
+function compactRecord(input: Record<string, unknown>): Record<string, unknown> {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+}
+
+function contactBody(params: CreateContactParams | UpdateContactParams): Record<string, unknown> {
+  return compactRecord({
+    email: params.email,
+    phone: params.phone,
+    first_name: params.firstName,
+    last_name: params.lastName,
+    distinct_id: params.distinctId,
+    properties: params.properties,
+    email_consent: params.emailConsent,
+  });
+}
+
 export class Tidio {
   private readonly client: TidioClient;
 
@@ -32,24 +56,24 @@ export class Tidio {
   }
 
   static fromEnv(): Tidio {
-    const apiKey = process.env.TIDIO_API_KEY;
-    if (!apiKey) {
-      throw new Error('TIDIO_API_KEY environment variable is required');
+    const clientId = process.env.TIDIO_CLIENT_ID;
+    const clientSecret = process.env.TIDIO_CLIENT_SECRET;
+    if (!clientId || !clientSecret) {
+      throw new Error('TIDIO_CLIENT_ID and TIDIO_CLIENT_SECRET environment variables are required');
     }
-    return new Tidio({ apiKey });
+    return new Tidio({ clientId, clientSecret });
   }
 
-  getApiKeyPreview(): string {
-    return this.client.getApiKeyPreview();
+  getClientIdPreview(): string {
+    return this.client.getClientIdPreview();
   }
 
   getClient(): TidioClient {
     return this.client;
   }
 
-  // Contacts
-  async listContacts(params: ListContactsParams = {}): Promise<unknown> {
-    return this.client.get('/contacts', {
+  async listContacts(params: ListContactsParams = {}): Promise<PaginatedResponse<Contact>> {
+    return this.client.get<PaginatedResponse<Contact>>('/contacts', {
       limit: params.limit,
       cursor: params.cursor,
       updated_after: params.updatedAfter,
@@ -57,161 +81,194 @@ export class Tidio {
     });
   }
 
-  async getContact(id: string): Promise<Contact> {
-    return this.client.get<Contact>(`/contacts/${encodeURIComponent(id)}`);
+  async getContact(contactId: string): Promise<Contact> {
+    return this.client.get<Contact>(`/contacts/${encodeURIComponent(contactId)}`);
   }
 
-  async createContact(params: CreateContactParams): Promise<Contact> {
-    if (!params.email && !params.phone && !params.externalId) {
-      throw new Error('createContact requires email, phone, or externalId');
+  async createContact(params: CreateContactParams): Promise<UuidResponse> {
+    if (!params.email && !params.phone && !params.firstName && !params.lastName && !params.distinctId) {
+      throw new Error('createContact requires email, phone, firstName, lastName, or distinctId');
     }
-    return this.client.post<Contact>('/contacts', {
-      email: params.email,
-      phone: params.phone,
-      name: params.name,
-      external_id: params.externalId,
-      tags: params.tags,
-      properties: params.properties,
-      subscriber: params.subscriber,
-      consent: params.consent,
+    return this.client.post<UuidResponse>('/contacts', contactBody(params));
+  }
+
+  async createContactsBatch(params: BatchContactsParams<CreateContactParams>): Promise<unknown> {
+    return this.client.post('/contacts/batch', {
+      contacts: params.contacts.map(contactBody),
     });
   }
 
-  async updateContact(id: string, params: UpdateContactParams): Promise<Contact> {
-    const body = {
-      email: params.email,
-      phone: params.phone,
-      name: params.name,
-      external_id: params.externalId,
-      tags: params.tags,
-      properties: params.properties,
-      subscriber: params.subscriber,
-      consent: params.consent,
-    };
-    if (!Object.values(body).some(v => v !== undefined)) {
+  async updateContact(contactId: string, params: UpdateContactParams): Promise<void> {
+    const body = contactBody(params);
+    if (Object.keys(body).length === 0) {
       throw new Error('updateContact requires at least one update field');
     }
-    return this.client.patch<Contact>(`/contacts/${encodeURIComponent(id)}`, body);
+    await this.client.patch(`/contacts/${encodeURIComponent(contactId)}`, body);
   }
 
-  async deleteContact(id: string): Promise<unknown> {
-    return this.client.delete(`/contacts/${encodeURIComponent(id)}`);
+  async updateContactsBatch(params: BatchContactsParams<UpdateContactParams>): Promise<unknown> {
+    return this.client.patch('/contacts/batch', {
+      contacts: params.contacts.map(contactBody),
+    });
   }
 
-  // Conversations
-  async listConversations(params: ListConversationsParams = {}): Promise<unknown> {
-    return this.client.get('/conversations', {
-      limit: params.limit,
-      cursor: params.cursor,
-      status: params.status,
-      channel: params.channel,
-      updated_after: params.updatedAfter,
+  async deleteContact(contactId: string): Promise<void> {
+    await this.client.delete(`/contacts/${encodeURIComponent(contactId)}`);
+  }
+
+  async getContactProperties(): Promise<PaginatedResponse<ContactProperty>> {
+    return this.client.get<PaginatedResponse<ContactProperty>>('/contact-properties');
+  }
+
+  async getContactViewedPages(contactId: string): Promise<unknown> {
+    return this.client.get(`/contacts/${encodeURIComponent(contactId)}/viewed-pages`);
+  }
+
+  async listContactMessages(
+    contactId: string,
+    params: ListContactMessagesParams = {},
+  ): Promise<PaginatedResponse<ContactMessage>> {
+    return this.client.get<PaginatedResponse<ContactMessage>>(
+      `/contacts/${encodeURIComponent(contactId)}/messages`,
+      {
+        cursor: params.cursor,
+      },
+    );
+  }
+
+  async sendContactMessage(contactId: string, params: SendContactMessageParams): Promise<MessageAccepted> {
+    return this.client.post<MessageAccepted>(`/contacts/${encodeURIComponent(contactId)}/messages`, {
+      message: params.message,
     });
   }
 
-  async getConversation(id: string): Promise<Conversation> {
-    return this.client.get<Conversation>(`/conversations/${encodeURIComponent(id)}`);
+  async listOperators(): Promise<PaginatedResponse<Operator>> {
+    return this.client.get<PaginatedResponse<Operator>>('/operators');
+  }
+
+  async listDepartments(): Promise<PaginatedResponse<Department>> {
+    return this.client.get<PaginatedResponse<Department>>('/departments');
+  }
+
+  async getProject(): Promise<Project> {
+    return this.client.get<Project>('/project');
   }
 
-  async listConversationMessages(id: string, params: ListMessagesParams = {}): Promise<unknown> {
-    return this.client.get(`/conversations/${encodeURIComponent(id)}/messages`, {
+  async listTickets(params: ListTicketsParams = {}): Promise<PaginatedResponse<Ticket>> {
+    return this.client.get<PaginatedResponse<Ticket>>('/tickets', {
       limit: params.limit,
       cursor: params.cursor,
+      status: params.status,
+      priority: params.priority,
     });
   }
 
-  async sendConversationMessage(id: string, params: SendMessageParams): Promise<Message> {
-    return this.client.post<Message>(`/conversations/${encodeURIComponent(id)}/messages`, {
-      type: params.type,
-      content: params.content,
-      media_url: params.mediaUrl,
-      private: params.private,
-      operator_id: params.operatorId,
-    });
+  async getTicket(ticketId: string): Promise<Ticket> {
+    return this.client.get<Ticket>(`/tickets/${encodeURIComponent(ticketId)}`);
   }
 
-  async setConversationStatus(id: string, params: SetConversationStatusParams): Promise<Conversation> {
-    return this.client.patch<Conversation>(`/conversations/${encodeURIComponent(id)}/status`, {
-      status: params.status,
-      snoozed_until: params.snoozedUntil,
+  async createTicketAsContact(params: CreateTicketAsContactParams): Promise<UuidResponse> {
+    return this.client.post<UuidResponse>('/tickets/as-contact', {
+      contact_id: params.contactId,
+      message: params.message,
+      subject: params.subject,
+      priority: params.priority,
     });
   }
 
-  async assignConversation(id: string, params: AssignConversationParams): Promise<Conversation> {
-    return this.client.patch<Conversation>(`/conversations/${encodeURIComponent(id)}/assignment`, {
-      operator_id: params.operatorId,
-      department_id: params.departmentId,
-    });
+  async updateTicket(ticketId: string, params: UpdateTicketParams): Promise<Ticket> {
+    return this.client.patch<Ticket>(
+      `/tickets/${encodeURIComponent(ticketId)}`,
+      compactRecord({
+        status: params.status,
+        priority: params.priority,
+        assignee_id: params.assigneeId,
+        department_id: params.departmentId,
+      }),
+    );
   }
 
-  // Operators
-  async listOperators(): Promise<unknown> {
-    return this.client.get('/operators');
+  async replyToTicket(ticketId: string, params: ReplyTicketParams): Promise<UuidResponse> {
+    return this.client.post<UuidResponse>(`/tickets/${encodeURIComponent(ticketId)}/reply`, {
+      message: params.message,
+      author_type: params.authorType,
+    });
   }
 
-  async getOperator(id: string): Promise<Operator> {
-    return this.client.get<Operator>(`/operators/${encodeURIComponent(id)}`);
+  async deleteTicket(ticketId: string): Promise<void> {
+    await this.client.delete(`/tickets/${encodeURIComponent(ticketId)}`);
   }
 
-  // Departments
-  async listDepartments(): Promise<unknown> {
-    return this.client.get('/departments');
+  async getTicketTags(): Promise<TicketTag[]> {
+    return this.client.get<TicketTag[]>('/tickets/tags');
   }
 
-  // Tags
-  async listTags(): Promise<unknown> {
-    return this.client.get('/tags');
+  async getTicketCustomFields(): Promise<TicketCustomField[]> {
+    return this.client.get<TicketCustomField[]>('/tickets/custom-fields');
   }
 
-  async createTag(params: CreateTagParams): Promise<Tag> {
-    return this.client.post<Tag>('/tags', {
-      name: params.name,
-      color: params.color,
-    });
+  async upsertProducts(products: Product[]): Promise<unknown> {
+    return this.client.put('/products/batch', { products });
   }
 
-  async deleteTag(id: string): Promise<unknown> {
-    return this.client.delete(`/tags/${encodeURIComponent(id)}`);
+  async deleteProduct(productId: string): Promise<void> {
+    await this.client.delete(`/products/${encodeURIComponent(productId)}`);
   }
 
-  // Automations
-  async listAutomations(): Promise<unknown> {
-    return this.client.get('/automations');
+  async listLyroDataSources(params: ListLyroDataSourcesParams = {}): Promise<PaginatedResponse<LyroDataSource>> {
+    return this.client.get<PaginatedResponse<LyroDataSource>>('/lyro/data-sources', {
+      cursor: params.cursor,
+      limit: params.limit,
+      kind: params.kind,
+      parent_id: params.parentId ?? undefined,
+    });
   }
 
-  // Canned responses
-  async listCannedResponses(): Promise<unknown> {
-    return this.client.get('/canned-responses');
+  async createLyroQaDataSource(params: CreateLyroQaDataSourceParams): Promise<UuidResponse> {
+    return this.client.post<UuidResponse>(
+      '/lyro/data-sources/qa',
+      compactRecord({
+        question: params.question,
+        answer: params.answer,
+        parent_id: params.parentId,
+      }),
+    );
   }
 
-  async createCannedResponse(params: CreateCannedResponseParams): Promise<CannedResponse> {
-    return this.client.post<CannedResponse>('/canned-responses', {
-      shortcut: params.shortcut,
-      content: params.content,
-      department_id: params.departmentId,
+  async updateLyroQaDataSource(dataSourceId: string, params: CreateLyroQaDataSourceParams): Promise<unknown> {
+    return this.client.put(`/lyro/data-sources/qa/${encodeURIComponent(dataSourceId)}`, {
+      question: params.question,
+      answer: params.answer,
+      parent_id: params.parentId,
     });
   }
 
-  // Webhooks
-  async listWebhooks(): Promise<unknown> {
-    return this.client.get('/webhooks');
+  async upsertLyroWebsiteDataSource(params: UpsertLyroWebsiteDataSourceParams): Promise<unknown> {
+    return this.client.put(
+      '/lyro/data-sources/website',
+      compactRecord({
+        url: params.url,
+        title: params.title,
+        content: params.content,
+      }),
+    );
   }
 
-  async createWebhook(params: CreateWebhookParams): Promise<Webhook> {
-    return this.client.post<Webhook>('/webhooks', {
+  async scrapeLyroWebsiteDataSource(params: ScrapeLyroWebsiteParams): Promise<UuidResponse> {
+    return this.client.post<UuidResponse>('/lyro/data-sources/website/scrape', {
       url: params.url,
-      events: params.events,
-      secret: params.secret,
     });
   }
 
-  async deleteWebhook(id: string): Promise<unknown> {
-    return this.client.delete(`/webhooks/${encodeURIComponent(id)}`);
-  }
-
-  // Project
-  async getProject(): Promise<Project> {
-    return this.client.get<Project>('/project');
+  async askLyroToAnswerTicket(params: AskLyroTicketParams): Promise<unknown> {
+    return this.client.post('/lyro/tickets', {
+      ticket_id: params.ticketId,
+      subject: params.subject,
+      contact_email: params.contactEmail,
+      contact_name: params.contactName,
+      recipient_email: params.recipientEmail,
+      messages: params.messages,
+    });
   }
 }