@hasna/connectors 0.4.0 → 0.4.2

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

@@ -0,0 +1,180 @@
+import { describe, test, expect, mock, beforeEach, afterEach } from 'bun:test';
+import { UsersApi } from './users';
+import { ZendeskClient } from './client';
+
+describe('UsersApi', () => {
+  let client: ZendeskClient;
+  let usersApi: UsersApi;
+  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);
+    usersApi = new UsersApi(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 users', async () => {
+      const mockUsers = [
+        { id: 1, name: 'User 1', email: 'user1@example.com', role: 'end-user' },
+        { id: 2, name: 'User 2', email: 'user2@example.com', role: 'agent' },
+      ];
+      mockFetch({ users: mockUsers });
+
+      const result = await usersApi.list();
+
+      expect(result).toEqual(mockUsers);
+    });
+
+    test('filters by role', async () => {
+      mockFetch({ users: [] });
+
+      await usersApi.list({ role: 'agent' });
+
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('role=agent');
+    });
+  });
+
+  describe('get', () => {
+    test('returns a single user', async () => {
+      const mockUser = { id: 123, name: 'Test User', email: 'test@example.com', role: 'end-user' };
+      mockFetch({ user: mockUser });
+
+      const result = await usersApi.get(123);
+
+      expect(result).toEqual(mockUser);
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/users/123.json');
+    });
+  });
+
+  describe('me', () => {
+    test('returns current authenticated user', async () => {
+      const mockUser = { id: 999, name: 'Current User', email: 'me@example.com', role: 'admin' };
+      mockFetch({ user: mockUser });
+
+      const result = await usersApi.me();
+
+      expect(result).toEqual(mockUser);
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/users/me.json');
+    });
+  });
+
+  describe('create', () => {
+    test('creates a new user', async () => {
+      const newUser = { id: 456, name: 'New User', email: 'new@example.com', role: 'end-user' };
+      mockFetch({ user: newUser }, 201);
+
+      const result = await usersApi.create({
+        user: {
+          name: 'New User',
+          email: 'new@example.com',
+        },
+      });
+
+      expect(result).toEqual(newUser);
+      const [url, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/users.json');
+      expect(options.method).toBe('POST');
+    });
+  });
+
+  describe('update', () => {
+    test('updates a user', async () => {
+      const updatedUser = { id: 123, name: 'Updated Name', email: 'test@example.com', role: 'agent' };
+      mockFetch({ user: updatedUser });
+
+      const result = await usersApi.update(123, {
+        user: { name: 'Updated Name', role: 'agent' },
+      });
+
+      expect(result).toEqual(updatedUser);
+      const [url, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/users/123.json');
+      expect(options.method).toBe('PUT');
+    });
+  });
+
+  describe('delete', () => {
+    test('deletes a user', async () => {
+      global.fetch = mock(() =>
+        Promise.resolve({
+          ok: true,
+          status: 204,
+          headers: new Headers({}),
+          text: () => Promise.resolve(''),
+        } as Response)
+      );
+
+      await usersApi.delete(123);
+
+      const [url, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/users/123.json');
+      expect(options.method).toBe('DELETE');
+    });
+  });
+
+  describe('searchByEmail', () => {
+    test('searches users by email', async () => {
+      const mockUsers = [{ id: 1, email: 'test@example.com' }];
+      mockFetch({ users: mockUsers });
+
+      const result = await usersApi.searchByEmail('test@example.com');
+
+      expect(result).toEqual(mockUsers);
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/users/search.json');
+      expect(url).toContain('query=test%40example.com');
+    });
+  });
+
+  describe('searchByName', () => {
+    test('searches users by name', async () => {
+      const mockUsers = [{ id: 1, name: 'John Doe' }];
+      mockFetch({ users: mockUsers });
+
+      const result = await usersApi.searchByName('John');
+
+      expect(result).toEqual(mockUsers);
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/users/search.json');
+      expect(url).toContain('query=John');
+    });
+  });
+
+  describe('listByOrganization', () => {
+    test('lists users for an organization', async () => {
+      const mockUsers = [{ id: 1, organization_id: 789 }];
+      mockFetch({ users: mockUsers });
+
+      const result = await usersApi.listByOrganization(789);
+
+      expect(result).toEqual(mockUsers);
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/organizations/789/users.json');
+    });
+  });
+});

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

@@ -0,0 +1,108 @@
+import type { ZendeskClient } from './client';
+import type {
+  ZendeskUser,
+  ZendeskUserResponse,
+  ZendeskUsersResponse,
+  CreateUserRequest,
+  UpdateUserRequest,
+  UserListParams,
+} from '../types';
+
+/**
+ * Zendesk Users API
+ * @see https://developer.zendesk.com/api-reference/ticketing/users/users/
+ */
+export class UsersApi {
+  constructor(private readonly client: ZendeskClient) {}
+
+  /**
+   * List all users
+   * @see https://developer.zendesk.com/api-reference/ticketing/users/users/#list-users
+   */
+  async list(params?: UserListParams): Promise<ZendeskUser[]> {
+    const response = await this.client.get<ZendeskUsersResponse>('/users.json', {
+      page: params?.page,
+      per_page: params?.per_page,
+      role: params?.role,
+    });
+    return response.users;
+  }
+
+  /**
+   * Get a user by ID
+   * @see https://developer.zendesk.com/api-reference/ticketing/users/users/#show-user
+   */
+  async get(userId: number): Promise<ZendeskUser> {
+    const response = await this.client.get<ZendeskUserResponse>(`/users/${userId}.json`);
+    return response.user;
+  }
+
+  /**
+   * Create a new user
+   * @see https://developer.zendesk.com/api-reference/ticketing/users/users/#create-user
+   */
+  async create(data: CreateUserRequest): Promise<ZendeskUser> {
+    const response = await this.client.post<ZendeskUserResponse>('/users.json', data);
+    return response.user;
+  }
+
+  /**
+   * Update a user
+   * @see https://developer.zendesk.com/api-reference/ticketing/users/users/#update-user
+   */
+  async update(userId: number, data: UpdateUserRequest): Promise<ZendeskUser> {
+    const response = await this.client.put<ZendeskUserResponse>(`/users/${userId}.json`, data);
+    return response.user;
+  }
+
+  /**
+   * Delete a user
+   * @see https://developer.zendesk.com/api-reference/ticketing/users/users/#delete-user
+   */
+  async delete(userId: number): Promise<void> {
+    await this.client.delete(`/users/${userId}.json`);
+  }
+
+  /**
+   * Search users by email
+   * @see https://developer.zendesk.com/api-reference/ticketing/users/users/#search-users
+   */
+  async searchByEmail(email: string): Promise<ZendeskUser[]> {
+    const response = await this.client.get<ZendeskUsersResponse>('/users/search.json', {
+      query: email,
+    });
+    return response.users;
+  }
+
+  /**
+   * Search users by name
+   * @see https://developer.zendesk.com/api-reference/ticketing/users/users/#search-users
+   */
+  async searchByName(name: string): Promise<ZendeskUser[]> {
+    const response = await this.client.get<ZendeskUsersResponse>('/users/search.json', {
+      query: name,
+    });
+    return response.users;
+  }
+
+  /**
+   * List users in an organization
+   * @see https://developer.zendesk.com/api-reference/ticketing/users/users/#list-users
+   */
+  async listByOrganization(organizationId: number, params?: UserListParams): Promise<ZendeskUser[]> {
+    const response = await this.client.get<ZendeskUsersResponse>(`/organizations/${organizationId}/users.json`, {
+      page: params?.page,
+      per_page: params?.per_page,
+    });
+    return response.users;
+  }
+
+  /**
+   * Get the currently authenticated user
+   * @see https://developer.zendesk.com/api-reference/ticketing/users/users/#show-the-currently-authenticated-user
+   */
+  async me(): Promise<ZendeskUser> {
+    const response = await this.client.get<ZendeskUserResponse>('/users/me.json');
+    return response.user;
+  }
+}

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

@@ -0,0 +1,223 @@
+import { describe, test, expect, mock, beforeEach, afterEach } from 'bun:test';
+import { ViewsApi } from './views';
+import { ZendeskClient } from './client';
+
+describe('ViewsApi', () => {
+  let client: ZendeskClient;
+  let viewsApi: ViewsApi;
+  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);
+    viewsApi = new ViewsApi(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 views', async () => {
+      const mockViews = [
+        { id: 1, title: 'All Unsolved Tickets', active: true },
+        { id: 2, title: 'My Open Tickets', active: true },
+      ];
+      mockFetch({ views: mockViews });
+
+      const result = await viewsApi.list();
+
+      expect(result).toEqual(mockViews);
+    });
+
+    test('passes filter params', async () => {
+      mockFetch({ views: [] });
+
+      await viewsApi.list({ active: true, group_id: 123 });
+
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('active=true');
+      expect(url).toContain('group_id=123');
+    });
+  });
+
+  describe('listActive', () => {
+    test('returns active views', async () => {
+      mockFetch({ views: [{ id: 1, active: true }] });
+
+      const result = await viewsApi.listActive();
+
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/views/active.json');
+      expect(result.length).toBe(1);
+    });
+  });
+
+  describe('listCompact', () => {
+    test('returns compact view list', async () => {
+      mockFetch({ views: [{ id: 1, title: 'View' }] });
+
+      await viewsApi.listCompact();
+
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/views/compact.json');
+    });
+  });
+
+  describe('get', () => {
+    test('returns a single view', async () => {
+      const mockView = { id: 123, title: 'Test View', active: true };
+      mockFetch({ view: mockView });
+
+      const result = await viewsApi.get(123);
+
+      expect(result).toEqual(mockView);
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/views/123.json');
+    });
+  });
+
+  describe('create', () => {
+    test('creates a new view', async () => {
+      const newView = { id: 456, title: 'New View', active: true };
+      mockFetch({ view: newView }, 201);
+
+      const result = await viewsApi.create({
+        view: {
+          title: 'New View',
+          conditions: {
+            all: [{ field: 'status', operator: 'is', value: 'open' }],
+          },
+        },
+      });
+
+      expect(result).toEqual(newView);
+      const [url, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/views.json');
+      expect(options.method).toBe('POST');
+    });
+  });
+
+  describe('update', () => {
+    test('updates a view', async () => {
+      const updatedView = { id: 123, title: 'Updated View' };
+      mockFetch({ view: updatedView });
+
+      const result = await viewsApi.update(123, {
+        view: { title: 'Updated View' },
+      });
+
+      expect(result).toEqual(updatedView);
+      const [, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(options.method).toBe('PUT');
+    });
+  });
+
+  describe('delete', () => {
+    test('deletes a view', async () => {
+      global.fetch = mock(() =>
+        Promise.resolve({
+          ok: true,
+          status: 204,
+          headers: new Headers({}),
+          text: () => Promise.resolve(''),
+        } as Response)
+      );
+
+      await viewsApi.delete(123);
+
+      const [url, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/views/123.json');
+      expect(options.method).toBe('DELETE');
+    });
+  });
+
+  describe('execute', () => {
+    test('executes a view', async () => {
+      const mockResult = {
+        rows: [{ ticket: { id: 1 } }],
+        count: 1,
+      };
+      mockFetch(mockResult);
+
+      const result = await viewsApi.execute(123);
+
+      expect(result).toEqual(mockResult);
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/views/123/execute.json');
+    });
+  });
+
+  describe('count', () => {
+    test('gets view count', async () => {
+      const mockCount = { view_count: { view_id: 123, value: 42, pretty: '42', fresh: true } };
+      mockFetch(mockCount);
+
+      const result = await viewsApi.count(123);
+
+      expect(result.view_count.value).toBe(42);
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/views/123/count.json');
+    });
+  });
+
+  describe('counts', () => {
+    test('gets multiple view counts', async () => {
+      mockFetch({ view_counts: [{ view_id: 1, value: 10 }, { view_id: 2, value: 20 }] });
+
+      const result = await viewsApi.counts([1, 2]);
+
+      expect(result.view_counts.length).toBe(2);
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/views/count_many.json');
+      expect(url).toContain('ids=1%2C2');
+    });
+  });
+
+  describe('search', () => {
+    test('searches views by title', async () => {
+      mockFetch({ views: [{ id: 1, title: 'Urgent' }] });
+
+      const result = await viewsApi.search('urgent');
+
+      expect(result.length).toBe(1);
+      const [url] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/views/search.json');
+      expect(url).toContain('query=urgent');
+    });
+  });
+
+  describe('preview', () => {
+    test('previews a view', async () => {
+      mockFetch({ rows: [], count: 0 });
+
+      await viewsApi.preview({
+        view: {
+          title: 'Preview',
+          conditions: { all: [] },
+        },
+      });
+
+      const [url, options] = (global.fetch as ReturnType<typeof mock>).mock.calls[0];
+      expect(url).toContain('/views/preview.json');
+      expect(options.method).toBe('POST');
+    });
+  });
+});

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

@@ -0,0 +1,145 @@
+import type { ZendeskClient } from './client';
+import type {
+  ZendeskView,
+  ZendeskViewResponse,
+  ZendeskViewsResponse,
+  ZendeskViewCountResponse,
+  ZendeskViewExecuteResponse,
+  CreateViewRequest,
+  UpdateViewRequest,
+  ViewListParams,
+} from '../types';
+
+/**
+ * Zendesk Views API
+ * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/views/
+ */
+export class ViewsApi {
+  constructor(private readonly client: ZendeskClient) {}
+
+  /**
+   * List all views
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/views/#list-views
+   */
+  async list(params?: ViewListParams): Promise<ZendeskView[]> {
+    const response = await this.client.get<ZendeskViewsResponse>('/views.json', {
+      page: params?.page,
+      per_page: params?.per_page,
+      active: params?.active,
+      group_id: params?.group_id,
+      sort_by: params?.sort_by,
+      sort_order: params?.sort_order,
+    });
+    return response.views;
+  }
+
+  /**
+   * List active views
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/views/#list-active-views
+   */
+  async listActive(params?: ViewListParams): Promise<ZendeskView[]> {
+    const response = await this.client.get<ZendeskViewsResponse>('/views/active.json', {
+      page: params?.page,
+      per_page: params?.per_page,
+      group_id: params?.group_id,
+      sort_by: params?.sort_by,
+      sort_order: params?.sort_order,
+    });
+    return response.views;
+  }
+
+  /**
+   * List compact views (minimal data)
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/views/#list-views-compact
+   */
+  async listCompact(): Promise<ZendeskView[]> {
+    const response = await this.client.get<ZendeskViewsResponse>('/views/compact.json');
+    return response.views;
+  }
+
+  /**
+   * Get a view by ID
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/views/#show-view
+   */
+  async get(viewId: number): Promise<ZendeskView> {
+    const response = await this.client.get<ZendeskViewResponse>(`/views/${viewId}.json`);
+    return response.view;
+  }
+
+  /**
+   * Create a new view
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/views/#create-view
+   */
+  async create(data: CreateViewRequest): Promise<ZendeskView> {
+    const response = await this.client.post<ZendeskViewResponse>('/views.json', data);
+    return response.view;
+  }
+
+  /**
+   * Update a view
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/views/#update-view
+   */
+  async update(viewId: number, data: UpdateViewRequest): Promise<ZendeskView> {
+    const response = await this.client.put<ZendeskViewResponse>(`/views/${viewId}.json`, data);
+    return response.view;
+  }
+
+  /**
+   * Delete a view
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/views/#delete-view
+   */
+  async delete(viewId: number): Promise<void> {
+    await this.client.delete(`/views/${viewId}.json`);
+  }
+
+  /**
+   * Execute a view (get tickets matching view criteria)
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/views/#execute-view
+   */
+  async execute(viewId: number, params?: { page?: number; per_page?: number; sort_by?: string; sort_order?: 'asc' | 'desc' }): Promise<ZendeskViewExecuteResponse> {
+    return this.client.get<ZendeskViewExecuteResponse>(`/views/${viewId}/execute.json`, params);
+  }
+
+  /**
+   * Get ticket count for a view
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/views/#show-view-count
+   */
+  async count(viewId: number): Promise<ZendeskViewCountResponse> {
+    return this.client.get<ZendeskViewCountResponse>(`/views/${viewId}/count.json`);
+  }
+
+  /**
+   * Get ticket counts for multiple views
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/views/#show-view-counts
+   */
+  async counts(viewIds: number[]): Promise<{ view_counts: Array<{ view_id: number; value: number; url: string }> }> {
+    return this.client.get<{ view_counts: Array<{ view_id: number; value: number; url: string }> }>('/views/count_many.json', {
+      ids: viewIds.join(','),
+    });
+  }
+
+  /**
+   * Preview a view (test conditions without saving)
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/views/#preview-view
+   */
+  async preview(data: CreateViewRequest): Promise<ZendeskViewExecuteResponse> {
+    return this.client.post<ZendeskViewExecuteResponse>('/views/preview.json', data);
+  }
+
+  /**
+   * Get count for a preview view
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/views/#preview-view-count
+   */
+  async previewCount(data: CreateViewRequest): Promise<ZendeskViewCountResponse> {
+    return this.client.post<ZendeskViewCountResponse>('/views/preview/count.json', data);
+  }
+
+  /**
+   * Search views by title
+   * @see https://developer.zendesk.com/api-reference/ticketing/business-rules/views/#search-views
+   */
+  async search(query: string): Promise<ZendeskView[]> {
+    const response = await this.client.get<ZendeskViewsResponse>('/views/search.json', { query });
+    return response.views;
+  }
+}