@hasna/connectors 0.3.16 → 0.4.1

package/connectors/connect-zendesk/src/api/tickets.test.ts

@@ -0,0 +1,215 @@
+import { describe, test, expect, mock, beforeEach, afterEach } from 'bun:test';
+import { TicketsApi } from './tickets';
+import { ZendeskClient } from './client';
+
+describe('TicketsApi', () => {
+  let client: ZendeskClient;
+  let ticketsApi: TicketsApi;
+  let originalFetch: typeof global.fetch;
+
+  const mockConfig = {
+    email: 'test@example.com',
+    apiToken: 'test-api-token-12345',
+    baseUrl: 'https://test.zendesk.com/api/v2',
+  };
+
+  beforeEach(() => {
+    client = new ZendeskClient(mockConfig);
+    ticketsApi = new TicketsApi(client);
+    originalFetch = global.fetch;
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+  });
+
+  const mockFetch = (response: unknown, status = 200) => {
+    global.fetch = mock(() =>
+      Promise.resolve({
+        ok: status >= 200 && status < 300,
+        status,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        text: () => Promise.resolve(JSON.stringify(response)),
+      } as Response)
+    );
+  };
+
+  describe('list', () => {
+    test('returns list of tickets', async () => {
+      const mockTickets = [
+        { id: 1, subject: 'Ticket 1', status: 'open' },
+        { id: 2, subject: 'Ticket 2', status: 'pending' },
+      ];
+      mockFetch({ tickets: mockTickets });
+
+      const result = await ticketsApi.list();
+
+      expect(result).toEqual(mockTickets);
+    });
+
+    test('passes pagination params', async () => {
+      mockFetch({ tickets: [] });
+
+      await ticketsApi.list({ page: 2, per_page: 50 });
+
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('page=2');
+      expect(url).toContain('per_page=50');
+    });
+
+    test('passes sort params', async () => {
+      mockFetch({ tickets: [] });
+
+      await ticketsApi.list({ sort_by: 'updated_at', sort_order: 'desc' });
+
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('sort_by=updated_at');
+      expect(url).toContain('sort_order=desc');
+    });
+  });
+
+  describe('get', () => {
+    test('returns a single ticket', async () => {
+      const mockTicket = { id: 123, subject: 'Test Ticket', status: 'open' };
+      mockFetch({ ticket: mockTicket });
+
+      const result = await ticketsApi.get(123);
+
+      expect(result).toEqual(mockTicket);
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/tickets/123.json');
+    });
+  });
+
+  describe('create', () => {
+    test('creates a new ticket', async () => {
+      const newTicket = { id: 456, subject: 'New Ticket', status: 'new' };
+      mockFetch({ ticket: newTicket }, 201);
+
+      const result = await ticketsApi.create({
+        ticket: {
+          subject: 'New Ticket',
+          comment: { body: 'Description' },
+        },
+      });
+
+      expect(result).toEqual(newTicket);
+      const [url, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/tickets.json');
+      expect(options.method).toBe('POST');
+    });
+
+    test('creates ticket with full payload', async () => {
+      mockFetch({ ticket: { id: 1 } }, 201);
+
+      await ticketsApi.create({
+        ticket: {
+          subject: 'Test',
+          comment: { body: 'Description', public: true },
+          priority: 'high',
+          type: 'problem',
+          status: 'open',
+          tags: ['urgent', 'vip'],
+          assignee_id: 123,
+          group_id: 456,
+        },
+      });
+
+      const [, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      const body = JSON.parse(options.body);
+      expect(body.ticket.priority).toBe('high');
+      expect(body.ticket.type).toBe('problem');
+      expect(body.ticket.tags).toEqual(['urgent', 'vip']);
+    });
+  });
+
+  describe('update', () => {
+    test('updates a ticket', async () => {
+      const updatedTicket = { id: 123, subject: 'Updated', status: 'pending' };
+      mockFetch({ ticket: updatedTicket });
+
+      const result = await ticketsApi.update(123, {
+        ticket: { status: 'pending' },
+      });
+
+      expect(result).toEqual(updatedTicket);
+      const [url, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/tickets/123.json');
+      expect(options.method).toBe('PUT');
+    });
+
+    test('updates ticket with comment', async () => {
+      mockFetch({ ticket: { id: 123 } });
+
+      await ticketsApi.update(123, {
+        ticket: {
+          status: 'solved',
+          comment: { body: 'This is resolved', public: true },
+        },
+      });
+
+      const [, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      const body = JSON.parse(options.body);
+      expect(body.ticket.comment.body).toBe('This is resolved');
+    });
+  });
+
+  describe('delete', () => {
+    test('deletes a ticket', async () => {
+      global.fetch = mock(() =>
+        Promise.resolve({
+          ok: true,
+          status: 204,
+          headers: new Headers({}),
+          text: () => Promise.resolve(''),
+        } as Response)
+      );
+
+      await ticketsApi.delete(123);
+
+      const [url, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/tickets/123.json');
+      expect(options.method).toBe('DELETE');
+    });
+  });
+
+  describe('listByUser', () => {
+    test('lists tickets for a user', async () => {
+      const mockTickets = [{ id: 1, requester_id: 456 }];
+      mockFetch({ tickets: mockTickets });
+
+      const result = await ticketsApi.listByUser(456);
+
+      expect(result).toEqual(mockTickets);
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/users/456/tickets/requested.json');
+    });
+  });
+
+  describe('listByOrganization', () => {
+    test('lists tickets for an organization', async () => {
+      const mockTickets = [{ id: 1, organization_id: 789 }];
+      mockFetch({ tickets: mockTickets });
+
+      const result = await ticketsApi.listByOrganization(789);
+
+      expect(result).toEqual(mockTickets);
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/organizations/789/tickets.json');
+    });
+  });
+
+  describe('search', () => {
+    test('searches tickets with query', async () => {
+      const mockTickets = [{ id: 1, subject: 'Error in login' }];
+      mockFetch({ tickets: mockTickets });
+
+      const result = await ticketsApi.search('login error');
+
+      expect(result).toEqual(mockTickets);
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/search.json');
+      expect(url).toContain('query=type%3Aticket+login+error');
+    });
+  });
+});

package/connectors/connect-zendesk/src/api/tickets.ts

@@ -0,0 +1,103 @@
+import type { ZendeskClient } from './client';
+import type {
+  ZendeskTicket,
+  ZendeskTicketResponse,
+  ZendeskTicketsResponse,
+  CreateTicketRequest,
+  UpdateTicketRequest,
+  TicketListParams,
+} from '../types';
+
+/**
+ * Zendesk Tickets API
+ * @see https://developer.zendesk.com/api-reference/ticketing/tickets/tickets/
+ */
+export class TicketsApi {
+  constructor(private readonly client: ZendeskClient) {}
+
+  /**
+   * List all tickets
+   * @see https://developer.zendesk.com/api-reference/ticketing/tickets/tickets/#list-tickets
+   */
+  async list(params?: TicketListParams): Promise<ZendeskTicket[]> {
+    const response = await this.client.get<ZendeskTicketsResponse>('/tickets.json', {
+      page: params?.page,
+      per_page: params?.per_page,
+      sort_by: params?.sort_by,
+      sort_order: params?.sort_order,
+    });
+    return response.tickets;
+  }
+
+  /**
+   * Get a ticket by ID
+   * @see https://developer.zendesk.com/api-reference/ticketing/tickets/tickets/#show-ticket
+   */
+  async get(ticketId: number): Promise<ZendeskTicket> {
+    const response = await this.client.get<ZendeskTicketResponse>(`/tickets/${ticketId}.json`);
+    return response.ticket;
+  }
+
+  /**
+   * Create a new ticket
+   * @see https://developer.zendesk.com/api-reference/ticketing/tickets/tickets/#create-ticket
+   */
+  async create(data: CreateTicketRequest): Promise<ZendeskTicket> {
+    const response = await this.client.post<ZendeskTicketResponse>('/tickets.json', data);
+    return response.ticket;
+  }
+
+  /**
+   * Update a ticket
+   * @see https://developer.zendesk.com/api-reference/ticketing/tickets/tickets/#update-ticket
+   */
+  async update(ticketId: number, data: UpdateTicketRequest): Promise<ZendeskTicket> {
+    const response = await this.client.put<ZendeskTicketResponse>(`/tickets/${ticketId}.json`, data);
+    return response.ticket;
+  }
+
+  /**
+   * Delete a ticket
+   * @see https://developer.zendesk.com/api-reference/ticketing/tickets/tickets/#delete-ticket
+   */
+  async delete(ticketId: number): Promise<void> {
+    await this.client.delete(`/tickets/${ticketId}.json`);
+  }
+
+  /**
+   * List tickets assigned to a user
+   * @see https://developer.zendesk.com/api-reference/ticketing/tickets/tickets/#list-tickets
+   */
+  async listByUser(userId: number, params?: TicketListParams): Promise<ZendeskTicket[]> {
+    const response = await this.client.get<ZendeskTicketsResponse>(`/users/${userId}/tickets/requested.json`, {
+      page: params?.page,
+      per_page: params?.per_page,
+    });
+    return response.tickets;
+  }
+
+  /**
+   * List tickets assigned to an organization
+   * @see https://developer.zendesk.com/api-reference/ticketing/tickets/tickets/#list-tickets
+   */
+  async listByOrganization(organizationId: number, params?: TicketListParams): Promise<ZendeskTicket[]> {
+    const response = await this.client.get<ZendeskTicketsResponse>(`/organizations/${organizationId}/tickets.json`, {
+      page: params?.page,
+      per_page: params?.per_page,
+    });
+    return response.tickets;
+  }
+
+  /**
+   * Search tickets
+   * @see https://developer.zendesk.com/api-reference/ticketing/tickets/tickets/#list-tickets
+   */
+  async search(query: string, params?: TicketListParams): Promise<ZendeskTicket[]> {
+    const response = await this.client.get<ZendeskTicketsResponse>('/search.json', {
+      query: `type:ticket ${query}`,
+      page: params?.page,
+      per_page: params?.per_page,
+    });
+    return response.tickets;
+  }
+}

package/connectors/connect-zendesk/src/api/triggers.test.ts

@@ -0,0 +1,204 @@
+import { describe, test, expect, mock, beforeEach, afterEach } from 'bun:test';
+import { TriggersApi } from './triggers';
+import { ZendeskClient } from './client';
+
+describe('TriggersApi', () => {
+  let client: ZendeskClient;
+  let triggersApi: TriggersApi;
+  let originalFetch: typeof global.fetch;
+
+  const mockConfig = {
+    email: 'test@example.com',
+    apiToken: 'test-api-token-12345',
+    baseUrl: 'https://test.zendesk.com/api/v2',
+  };
+
+  beforeEach(() => {
+    client = new ZendeskClient(mockConfig);
+    triggersApi = new TriggersApi(client);
+    originalFetch = global.fetch;
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+  });
+
+  const mockFetch = (response: unknown, status = 200) => {
+    global.fetch = mock(() =>
+      Promise.resolve({
+        ok: status >= 200 && status < 300,
+        status,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        text: () => Promise.resolve(JSON.stringify(response)),
+      } as Response)
+    );
+  };
+
+  describe('list', () => {
+    test('returns list of triggers', async () => {
+      const mockTriggers = [
+        { id: 1, title: 'Auto-reply trigger', active: true, actions: [] },
+        { id: 2, title: 'Escalation trigger', active: false, actions: [] },
+      ];
+      mockFetch({ triggers: mockTriggers });
+
+      const result = await triggersApi.list();
+
+      expect(result).toEqual(mockTriggers);
+    });
+
+    test('filters by active status', async () => {
+      mockFetch({ triggers: [] });
+
+      await triggersApi.list({ active: true });
+
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('active=true');
+    });
+
+    test('filters by category', async () => {
+      mockFetch({ triggers: [] });
+
+      await triggersApi.list({ category_id: 'notifications' });
+
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('category_id=notifications');
+    });
+  });
+
+  describe('listActive', () => {
+    test('returns active triggers', async () => {
+      mockFetch({ triggers: [{ id: 1, active: true, actions: [] }] });
+
+      const result = await triggersApi.listActive();
+
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/triggers/active.json');
+      expect(result.length).toBe(1);
+    });
+  });
+
+  describe('get', () => {
+    test('returns a single trigger', async () => {
+      const mockTrigger = { id: 123, title: 'Test Trigger', active: true, actions: [] };
+      mockFetch({ trigger: mockTrigger });
+
+      const result = await triggersApi.get(123);
+
+      expect(result).toEqual(mockTrigger);
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/triggers/123.json');
+    });
+  });
+
+  describe('create', () => {
+    test('creates a new trigger', async () => {
+      const newTrigger = { id: 456, title: 'New Trigger', active: true, actions: [] };
+      mockFetch({ trigger: newTrigger }, 201);
+
+      const result = await triggersApi.create({
+        trigger: {
+          title: 'New Trigger',
+          actions: [{ field: 'status', value: 'open' }],
+          conditions: {
+            all: [{ field: 'status', operator: 'is', value: 'new' }],
+          },
+        },
+      });
+
+      expect(result).toEqual(newTrigger);
+      const [url, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/triggers.json');
+      expect(options.method).toBe('POST');
+    });
+  });
+
+  describe('update', () => {
+    test('updates a trigger', async () => {
+      const updatedTrigger = { id: 123, title: 'Updated Trigger', active: false, actions: [] };
+      mockFetch({ trigger: updatedTrigger });
+
+      const result = await triggersApi.update(123, {
+        trigger: { active: false },
+      });
+
+      expect(result).toEqual(updatedTrigger);
+      const [, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(options.method).toBe('PUT');
+    });
+  });
+
+  describe('delete', () => {
+    test('deletes a trigger', async () => {
+      global.fetch = mock(() =>
+        Promise.resolve({
+          ok: true,
+          status: 204,
+          headers: new Headers({}),
+          text: () => Promise.resolve(''),
+        } as Response)
+      );
+
+      await triggersApi.delete(123);
+
+      const [url, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/triggers/123.json');
+      expect(options.method).toBe('DELETE');
+    });
+  });
+
+  describe('reorder', () => {
+    test('reorders triggers', async () => {
+      mockFetch({});
+
+      await triggersApi.reorder([3, 1, 2]);
+
+      const [url, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/triggers/reorder.json');
+      expect(options.method).toBe('PUT');
+      const body = JSON.parse(options.body);
+      expect(body.trigger_ids).toEqual([3, 1, 2]);
+    });
+  });
+
+  describe('search', () => {
+    test('searches triggers by title', async () => {
+      mockFetch({ triggers: [{ id: 1, title: 'Auto-reply', actions: [] }] });
+
+      const result = await triggersApi.search('auto');
+
+      expect(result.length).toBe(1);
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/triggers/search.json');
+      expect(url).toContain('query=auto');
+    });
+  });
+
+  describe('listRevisions', () => {
+    test('lists trigger revisions', async () => {
+      const mockRevisions = [
+        { id: 1, author_id: 100, created_at: '2024-01-01', url: '/revisions/1' },
+      ];
+      mockFetch({ trigger_revisions: mockRevisions });
+
+      const result = await triggersApi.listRevisions(123);
+
+      expect(result).toEqual(mockRevisions);
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/triggers/123/revisions.json');
+    });
+  });
+
+  describe('getRevision', () => {
+    test('gets a specific revision', async () => {
+      const mockTrigger = { id: 123, title: 'Old Version', actions: [] };
+      mockFetch({ trigger: mockTrigger });
+
+      const result = await triggersApi.getRevision(123, 1);
+
+      expect(result).toEqual(mockTrigger);
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/triggers/123/revisions/1.json');
+    });
+  });
+});

package/connectors/connect-zendesk/src/api/triggers.ts

@@ -0,0 +1,125 @@
+import type { ZendeskClient } from './client';
+import type {
+  ZendeskTrigger,
+  ZendeskTriggerResponse,
+  ZendeskTriggersResponse,
+  CreateTriggerRequest,
+  UpdateTriggerRequest,
+  TriggerListParams,
+} from '../types';
+
+/**
+ * Zendesk Triggers API
+ * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/triggers/
+ */
+export class TriggersApi {
+  constructor(private readonly client: ZendeskClient) {}
+
+  /**
+   * List all triggers
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/triggers/#list-triggers
+   */
+  async list(params?: TriggerListParams): Promise<ZendeskTrigger[]> {
+    const response = await this.client.get<ZendeskTriggersResponse>('/triggers.json', {
+      page: params?.page,
+      per_page: params?.per_page,
+      active: params?.active,
+      category_id: params?.category_id,
+      sort_by: params?.sort_by,
+      sort_order: params?.sort_order,
+    });
+    return response.triggers;
+  }
+
+  /**
+   * List active triggers
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/triggers/#list-active-triggers
+   */
+  async listActive(params?: TriggerListParams): Promise<ZendeskTrigger[]> {
+    const response = await this.client.get<ZendeskTriggersResponse>('/triggers/active.json', {
+      page: params?.page,
+      per_page: params?.per_page,
+      category_id: params?.category_id,
+      sort_by: params?.sort_by,
+      sort_order: params?.sort_order,
+    });
+    return response.triggers;
+  }
+
+  /**
+   * Get a trigger by ID
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/triggers/#show-trigger
+   */
+  async get(triggerId: number): Promise<ZendeskTrigger> {
+    const response = await this.client.get<ZendeskTriggerResponse>(`/triggers/${triggerId}.json`);
+    return response.trigger;
+  }
+
+  /**
+   * Create a new trigger
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/triggers/#create-trigger
+   */
+  async create(data: CreateTriggerRequest): Promise<ZendeskTrigger> {
+    const response = await this.client.post<ZendeskTriggerResponse>('/triggers.json', data);
+    return response.trigger;
+  }
+
+  /**
+   * Update a trigger
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/triggers/#update-trigger
+   */
+  async update(triggerId: number, data: UpdateTriggerRequest): Promise<ZendeskTrigger> {
+    const response = await this.client.put<ZendeskTriggerResponse>(`/triggers/${triggerId}.json`, data);
+    return response.trigger;
+  }
+
+  /**
+   * Delete a trigger
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/triggers/#delete-trigger
+   */
+  async delete(triggerId: number): Promise<void> {
+    await this.client.delete(`/triggers/${triggerId}.json`);
+  }
+
+  /**
+   * Reorder triggers
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/triggers/#reorder-triggers
+   */
+  async reorder(triggerIds: number[]): Promise<void> {
+    await this.client.put('/triggers/reorder.json', { trigger_ids: triggerIds });
+  }
+
+  /**
+   * Search triggers by title
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/triggers/#search-triggers
+   */
+  async search(query: string, params?: TriggerListParams): Promise<ZendeskTrigger[]> {
+    const response = await this.client.get<ZendeskTriggersResponse>('/triggers/search.json', {
+      query,
+      page: params?.page,
+      per_page: params?.per_page,
+      active: params?.active,
+    });
+    return response.triggers;
+  }
+
+  /**
+   * Get trigger revision (history)
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/triggers/#list-trigger-revisions
+   */
+  async listRevisions(triggerId: number): Promise<Array<{ id: number; author_id: number; created_at: string; url: string }>> {
+    const response = await this.client.get<{ trigger_revisions: Array<{ id: number; author_id: number; created_at: string; url: string }> }>(
+      `/triggers/${triggerId}/revisions.json`
+    );
+    return response.trigger_revisions;
+  }
+
+  /**
+   * Get a specific trigger revision
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/triggers/#show-trigger-revision
+   */
+  async getRevision(triggerId: number, revisionId: number): Promise<ZendeskTrigger> {
+    const response = await this.client.get<ZendeskTriggerResponse>(`/triggers/${triggerId}/revisions/${revisionId}.json`);
+    return response.trigger;
+  }
+}