@hasna/connectors 0.4.0 → 0.4.2

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

@@ -0,0 +1,208 @@
+import { describe, test, expect, mock, beforeEach, afterEach } from 'bun:test';
+import { WebhooksApi } from './webhooks';
+import { ZendeskClient } from './client';
+
+describe('WebhooksApi', () => {
+  let client: ZendeskClient;
+  let webhooksApi: WebhooksApi;
+  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);
+    webhooksApi = new WebhooksApi(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 webhooks', async () => {
+      const mockWebhooks = [
+        { id: 'wh-1', name: 'Slack notification', status: 'active', endpoint: 'https://slack.com/webhook' },
+        { id: 'wh-2', name: 'CRM sync', status: 'inactive', endpoint: 'https://crm.com/api' },
+      ];
+      mockFetch({ webhooks: mockWebhooks });
+
+      const result = await webhooksApi.list();
+
+      expect(result).toEqual(mockWebhooks);
+    });
+  });
+
+  describe('get', () => {
+    test('returns a single webhook', async () => {
+      const mockWebhook = { id: 'wh-123', name: 'Test Webhook', status: 'active', endpoint: 'https://example.com' };
+      mockFetch({ webhook: mockWebhook });
+
+      const result = await webhooksApi.get('wh-123');
+
+      expect(result).toEqual(mockWebhook);
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/webhooks/wh-123.json');
+    });
+  });
+
+  describe('create', () => {
+    test('creates a new webhook', async () => {
+      const newWebhook = { id: 'wh-456', name: 'New Webhook', status: 'active', endpoint: 'https://new.com' };
+      mockFetch({ webhook: newWebhook }, 201);
+
+      const result = await webhooksApi.create({
+        webhook: {
+          name: 'New Webhook',
+          endpoint: 'https://new.com',
+          http_method: 'POST',
+          request_format: 'json',
+        },
+      });
+
+      expect(result).toEqual(newWebhook);
+      const [url, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/webhooks.json');
+      expect(options.method).toBe('POST');
+    });
+
+    test('creates webhook with authentication', async () => {
+      mockFetch({ webhook: { id: 'wh-1' } }, 201);
+
+      await webhooksApi.create({
+        webhook: {
+          name: 'Authenticated Webhook',
+          endpoint: 'https://api.com',
+          http_method: 'POST',
+          request_format: 'json',
+          authentication: {
+            type: 'bearer',
+            data: { token: 'secret-token' },
+          },
+        },
+      });
+
+      const [, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      const body = JSON.parse(options.body);
+      expect(body.webhook.authentication.type).toBe('bearer');
+    });
+  });
+
+  describe('update', () => {
+    test('updates a webhook', async () => {
+      const updatedWebhook = { id: 'wh-123', name: 'Updated Webhook', status: 'inactive' };
+      mockFetch({ webhook: updatedWebhook });
+
+      const result = await webhooksApi.update('wh-123', {
+        webhook: { status: 'inactive' },
+      });
+
+      expect(result).toEqual(updatedWebhook);
+      const [url, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/webhooks/wh-123.json');
+      expect(options.method).toBe('PATCH');
+    });
+  });
+
+  describe('delete', () => {
+    test('deletes a webhook', async () => {
+      global.fetch = mock(() =>
+        Promise.resolve({
+          ok: true,
+          status: 204,
+          headers: new Headers({}),
+          text: () => Promise.resolve(''),
+        } as Response)
+      );
+
+      await webhooksApi.delete('wh-123');
+
+      const [url, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/webhooks/wh-123.json');
+      expect(options.method).toBe('DELETE');
+    });
+  });
+
+  describe('clone', () => {
+    test('clones a webhook', async () => {
+      const clonedWebhook = { id: 'wh-789', name: 'Cloned Webhook' };
+      mockFetch({ webhook: clonedWebhook }, 201);
+
+      const result = await webhooksApi.clone('wh-123');
+
+      expect(result).toEqual(clonedWebhook);
+      const [, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      const body = JSON.parse(options.body);
+      expect(body.webhook.clone_webhook_id).toBe('wh-123');
+    });
+  });
+
+  describe('test', () => {
+    test('tests a webhook', async () => {
+      const testResult = { webhook_invocation: { id: 'inv-1', status: 'success' } };
+      mockFetch(testResult);
+
+      const result = await webhooksApi.test('wh-123', { request: { test: true } });
+
+      expect(result.webhook_invocation.status).toBe('success');
+      const [url, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/webhooks/wh-123/test.json');
+      expect(options.method).toBe('POST');
+    });
+  });
+
+  describe('getSigningSecret', () => {
+    test('gets signing secret', async () => {
+      mockFetch({ signing_secret: { secret: 'abc123' } });
+
+      const result = await webhooksApi.getSigningSecret('wh-123');
+
+      expect(result.signing_secret.secret).toBe('abc123');
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/webhooks/wh-123/signing_secret.json');
+    });
+  });
+
+  describe('resetSigningSecret', () => {
+    test('resets signing secret', async () => {
+      mockFetch({ signing_secret: { secret: 'new-secret' } });
+
+      const result = await webhooksApi.resetSigningSecret('wh-123');
+
+      expect(result.signing_secret.secret).toBe('new-secret');
+      const [, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(options.method).toBe('POST');
+    });
+  });
+
+  describe('listInvocations', () => {
+    test('lists webhook invocations', async () => {
+      const mockInvocations = [
+        { id: 'inv-1', webhook_id: 'wh-123', status: 'success' },
+        { id: 'inv-2', webhook_id: 'wh-123', status: 'failure' },
+      ];
+      mockFetch({ invocations: mockInvocations });
+
+      const result = await webhooksApi.listInvocations('wh-123');
+
+      expect(result.invocations).toEqual(mockInvocations);
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/webhooks/wh-123/invocations.json');
+    });
+  });
+});

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

@@ -0,0 +1,118 @@
+import type { ZendeskClient } from './client';
+import type {
+  ZendeskWebhook,
+  ZendeskWebhookResponse,
+  ZendeskWebhooksResponse,
+  CreateWebhookRequest,
+  UpdateWebhookRequest,
+  WebhookListParams,
+  WebhookInvocation,
+} from '../types';
+
+/**
+ * Zendesk Webhooks API
+ * @see https://developer.zendesk.com/api-reference/webhooks/webhooks-api/webhooks/
+ */
+export class WebhooksApi {
+  constructor(private readonly client: ZendeskClient) {}
+
+  /**
+   * List all webhooks
+   * @see https://developer.zendesk.com/api-reference/webhooks/webhooks-api/webhooks/#list-webhooks
+   */
+  async list(params?: WebhookListParams): Promise<ZendeskWebhook[]> {
+    const response = await this.client.get<ZendeskWebhooksResponse>('/webhooks.json', {
+      page: params?.page,
+      per_page: params?.per_page,
+      filter: params?.filter,
+      sort: params?.sort,
+    });
+    return response.webhooks;
+  }
+
+  /**
+   * Get a webhook by ID
+   * @see https://developer.zendesk.com/api-reference/webhooks/webhooks-api/webhooks/#show-webhook
+   */
+  async get(webhookId: string): Promise<ZendeskWebhook> {
+    const response = await this.client.get<ZendeskWebhookResponse>(`/webhooks/${webhookId}.json`);
+    return response.webhook;
+  }
+
+  /**
+   * Create a new webhook
+   * @see https://developer.zendesk.com/api-reference/webhooks/webhooks-api/webhooks/#create-or-clone-webhook
+   */
+  async create(data: CreateWebhookRequest): Promise<ZendeskWebhook> {
+    const response = await this.client.post<ZendeskWebhookResponse>('/webhooks.json', data);
+    return response.webhook;
+  }
+
+  /**
+   * Update a webhook
+   * @see https://developer.zendesk.com/api-reference/webhooks/webhooks-api/webhooks/#update-webhook
+   */
+  async update(webhookId: string, data: UpdateWebhookRequest): Promise<ZendeskWebhook> {
+    const response = await this.client.patch<ZendeskWebhookResponse>(`/webhooks/${webhookId}.json`, data);
+    return response.webhook;
+  }
+
+  /**
+   * Delete a webhook
+   * @see https://developer.zendesk.com/api-reference/webhooks/webhooks-api/webhooks/#delete-webhook
+   */
+  async delete(webhookId: string): Promise<void> {
+    await this.client.delete(`/webhooks/${webhookId}.json`);
+  }
+
+  /**
+   * Clone a webhook
+   * @see https://developer.zendesk.com/api-reference/webhooks/webhooks-api/webhooks/#create-or-clone-webhook
+   */
+  async clone(webhookId: string): Promise<ZendeskWebhook> {
+    const response = await this.client.post<ZendeskWebhookResponse>('/webhooks.json', {
+      webhook: { clone_webhook_id: webhookId },
+    });
+    return response.webhook;
+  }
+
+  /**
+   * Test a webhook
+   * @see https://developer.zendesk.com/api-reference/webhooks/webhooks-api/webhooks/#test-webhook
+   */
+  async test(webhookId: string, request: { request: unknown }): Promise<{ webhook_invocation: WebhookInvocation }> {
+    return this.client.post(`/webhooks/${webhookId}/test.json`, request);
+  }
+
+  /**
+   * Get webhook signing secret
+   * @see https://developer.zendesk.com/api-reference/webhooks/webhooks-api/webhooks/#show-webhook-signing-secret
+   */
+  async getSigningSecret(webhookId: string): Promise<{ signing_secret: { secret: string } }> {
+    return this.client.get(`/webhooks/${webhookId}/signing_secret.json`);
+  }
+
+  /**
+   * Reset webhook signing secret
+   * @see https://developer.zendesk.com/api-reference/webhooks/webhooks-api/webhooks/#reset-webhook-signing-secret
+   */
+  async resetSigningSecret(webhookId: string): Promise<{ signing_secret: { secret: string } }> {
+    return this.client.post(`/webhooks/${webhookId}/signing_secret.json`);
+  }
+
+  /**
+   * List webhook invocations (history)
+   * @see https://developer.zendesk.com/api-reference/webhooks/webhooks-api/webhooks/#list-webhook-invocations
+   */
+  async listInvocations(webhookId: string, params?: { page?: number; per_page?: number }): Promise<{ invocations: WebhookInvocation[] }> {
+    return this.client.get(`/webhooks/${webhookId}/invocations.json`, params);
+  }
+
+  /**
+   * Get a webhook invocation attempt
+   * @see https://developer.zendesk.com/api-reference/webhooks/webhooks-api/webhooks/#show-webhook-invocation-attempt
+   */
+  async getInvocationAttempt(webhookId: string, invocationId: string): Promise<{ invocation_attempt: WebhookInvocation }> {
+    return this.client.get(`/webhooks/${webhookId}/invocations/${invocationId}/attempts.json`);
+  }
+}