@ikatec/digisac-api-sdk 1.2.0

package/src/apis/transcripts/TranscriptsApi.ts

@@ -0,0 +1,17 @@
+import type { ApiClient } from '../../core/ApiClient'
+import type { HasGetOne } from '../../core/types'
+import type { TranscriptResponse } from './types'
+
+export class TranscriptsApi implements HasGetOne<TranscriptResponse> {
+  private readonly client: ApiClient
+  private readonly basePath = '/transcripts'
+
+  constructor(client: ApiClient) {
+    this.client = client
+  }
+
+  /** Triggers audio transcription for a message by dispatching an async job, and marks it as transcribing. */
+  getOne(id: string, headers?: Record<string, string>): Promise<TranscriptResponse> {
+    return this.client.get<TranscriptResponse>(`${this.basePath}/${id}`, headers)
+  }
+}

package/src/apis/transcripts/index.ts

@@ -0,0 +1,2 @@
+export { TranscriptsApi } from './TranscriptsApi'
+export type * from './types'

package/src/apis/transcripts/types.ts

@@ -0,0 +1,5 @@
+export type TranscriptResponse = {
+  id: string
+  isTranscribing: boolean
+  transcribeError: boolean
+}

package/src/apis/users/UsersApi.ts

@@ -0,0 +1,9 @@
+import type { ApiClient } from '../../core/ApiClient'
+import { BaseCrudApi } from '../../core/BaseCrudApi'
+import type { User, CreateUserPayload, UpdateUserPayload } from './types'
+
+export class UsersApi extends BaseCrudApi<User, CreateUserPayload, UpdateUserPayload> {
+  constructor(client: ApiClient) {
+    super(client, '/users')
+  }
+}

package/src/apis/users/index.ts

@@ -0,0 +1,2 @@
+export { UsersApi } from './UsersApi'
+export type * from './types'

package/src/apis/users/types.ts

@@ -0,0 +1,70 @@
+import type { Department } from '../departments/types'
+import type { Role } from '../roles/types'
+import type { Timetable } from '../timetable/types'
+
+export type UserStatus = 'online' | 'offline' | 'away'
+
+export type UserPreferences = {
+  audioSpeed?: number
+  isShowTagsChat?: boolean
+}
+
+export type User = {
+  id: string
+  name: string
+  email: string
+  phoneNumber: string | null
+  branch: string | null
+  isSuperAdmin: boolean
+  isClientUser: boolean
+  active: boolean
+  language: string
+  isFirstLogin: boolean
+  status: UserStatus
+  clientsStatus: Record<string, string> | null
+  offlineAt: string | null
+  isActiveInternalChat: boolean
+  passwordExpiresAt: string | null
+  otpAuthActive: boolean | null
+  preferences: UserPreferences
+  archivedAt: string | null
+  accountId: string
+  timetableId: string | null
+  createdAt: string
+  updatedAt: string
+  deletedAt: string | null
+  // relationships
+  timetable?: Timetable | null
+  roles?: Role[]
+  departments?: Department[]
+}
+
+export type UserRelationships = 'timetable' | 'roles' | 'departments'
+
+export type CreateUserPayload = {
+  name: string
+  email: string
+  password: string
+  passwordConfirmation: string
+  phoneNumber?: string
+  branch?: string
+  isClientUser?: boolean
+  roles?: string[]
+  departments?: string[]
+  services?: string[]
+  scheduleId?: string
+}
+
+export type UpdateUserPayload = {
+  name?: string
+  email?: string
+  phoneNumber?: string | null
+  branch?: string | null
+  isClientUser?: boolean
+  roles?: string[]
+  departments?: string[]
+  services?: string[]
+  timetableId?: string | null
+  preferences?: UserPreferences
+  language?: string
+}

package/src/apis/webhooks/WebhooksApi.ts

@@ -0,0 +1,9 @@
+import type { ApiClient } from '../../core/ApiClient'
+import { BaseCrudApi } from '../../core/BaseCrudApi'
+import type { Webhook, CreateWebhookPayload, UpdateWebhookPayload } from './types'
+
+export class WebhooksApi extends BaseCrudApi<Webhook, CreateWebhookPayload, UpdateWebhookPayload> {
+  constructor(client: ApiClient) {
+    super(client, '/me/webhooks')
+  }
+}

package/src/apis/webhooks/index.ts

@@ -0,0 +1,2 @@
+export { WebhooksApi } from './WebhooksApi'
+export type * from './types'

package/src/apis/webhooks/types.ts

@@ -0,0 +1,37 @@
+import type { Service } from '../services/types'
+
+export type Webhook = {
+  id: string
+  name: string
+  url: string
+  type: string
+  active: boolean
+  events: string[]
+  errorAt: string | null
+  errorNotifiedAt: string | null
+  userId: string
+  accountId: string
+  createdAt: string
+  updatedAt: string
+  deletedAt: string | null
+  // relationships
+  services?: Service[]
+}
+
+export type WebhookRelationships = 'services'
+
+export type CreateWebhookPayload = {
+  name: string
+  url: string
+  type: string
+  events: string[]
+  active?: boolean
+}
+
+export type UpdateWebhookPayload = {
+  name?: string
+  url?: string
+  type?: string
+  events?: string[]
+  active?: boolean
+}

package/src/apis/whatsappBusinessTemplates/WhatsappBusinessTemplatesApi.ts

@@ -0,0 +1,17 @@
+import type { ApiClient } from '../../core/ApiClient'
+import { BaseCrudApi } from '../../core/BaseCrudApi'
+import type {
+  WhatsappBusinessTemplate,
+  CreateWhatsappBusinessTemplatePayload,
+  UpdateWhatsappBusinessTemplatePayload,
+} from './types'
+
+export class WhatsappBusinessTemplatesApi extends BaseCrudApi<
+  WhatsappBusinessTemplate,
+  CreateWhatsappBusinessTemplatePayload,
+  UpdateWhatsappBusinessTemplatePayload
+> {
+  constructor(client: ApiClient) {
+    super(client, '/whatsapp-business-templates')
+  }
+}

package/src/apis/whatsappBusinessTemplates/index.ts

@@ -0,0 +1,2 @@
+export { WhatsappBusinessTemplatesApi } from './WhatsappBusinessTemplatesApi'
+export type * from './types'

package/src/apis/whatsappBusinessTemplates/types.ts

@@ -0,0 +1,46 @@
+export type WhatsappBusinessTemplateMessageType = 'text_only' | 'interactive'
+
+export type WhatsappBusinessTemplateLanguage = 'pt_BR' | 'es' | 'en'
+
+export type WhatsappBusinessTemplateCategory = 'AUTHENTICATION' | 'MARKETING' | 'UTILITY'
+
+export type WhatsappBusinessTemplate = {
+  id: string
+  internalName: string | null
+  category: string
+  components: Record<string, unknown>[]
+  language: string
+  name: string
+  namespace: string
+  rejectedReason: string | null
+  status: string
+  messageType: string
+  serviceId: string
+  accountId: string
+  idGupshup: string | null
+  quality: string | null
+  archivedAt: string | null
+  createdAt: string
+  updatedAt: string
+  deletedAt: string | null
+}
+
+export type CreateWhatsappBusinessTemplatePayload = {
+  name: string
+  internalName: string
+  components: Record<string, unknown>[]
+  serviceId: string
+  messageType: WhatsappBusinessTemplateMessageType
+  language: WhatsappBusinessTemplateLanguage
+  category: WhatsappBusinessTemplateCategory
+}
+
+export type UpdateWhatsappBusinessTemplatePayload = {
+  name?: string
+  internalName?: string
+  components?: Record<string, unknown>[]
+  serviceId?: string
+  messageType?: WhatsappBusinessTemplateMessageType
+  language?: WhatsappBusinessTemplateLanguage
+  category?: WhatsappBusinessTemplateCategory
+}

package/src/core/ApiClient.ts

@@ -0,0 +1,31 @@
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'
+
+export interface ApiClient {
+  setAccessToken(accessToken: string): this
+  request<TResponse = unknown, TBody = unknown>(
+    method: HttpMethod,
+    endpoint: string,
+    body?: TBody,
+    headers?: Record<string, string>,
+  ): Promise<TResponse>
+  get<TResponse = unknown>(endpoint: string, headers?: Record<string, string>): Promise<TResponse>
+  post<TResponse = unknown, TBody = unknown>(
+    endpoint: string,
+    body?: TBody,
+    headers?: Record<string, string>,
+  ): Promise<TResponse>
+  put<TResponse = unknown, TBody = unknown>(
+    endpoint: string,
+    body?: TBody,
+    headers?: Record<string, string>,
+  ): Promise<TResponse>
+  patch<TResponse = unknown, TBody = unknown>(
+    endpoint: string,
+    body?: TBody,
+    headers?: Record<string, string>,
+  ): Promise<TResponse>
+  delete<TResponse = unknown>(
+    endpoint: string,
+    headers?: Record<string, string>,
+  ): Promise<TResponse>
+}

package/src/core/BaseApiClient.test.ts

@@ -0,0 +1,236 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { BaseApiClient, ApiError } from './BaseApiClient'
+
+function mockFetch(response: {
+  ok: boolean
+  status: number
+  statusText: string
+  headers?: Record<string, string>
+  body?: string
+  json?: unknown
+}) {
+  const headers = new Headers(response.headers)
+  return vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+    ok: response.ok,
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+    text: async () => response.body ?? '',
+    json: async () => response.json ?? JSON.parse(response.body ?? '{}'),
+  } as Response)
+}
+
+describe('BaseApiClient', () => {
+  let client: BaseApiClient
+
+  beforeEach(() => {
+    client = new BaseApiClient('https://api.example.com/')
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  // ── Constructor ──────────────────────────────────────────────────
+
+  it('strips trailing slash from baseUrl', async () => {
+    const spy = mockFetch({ ok: true, status: 200, statusText: 'OK', body: '{}' })
+    await client.get('/test')
+    expect(spy).toHaveBeenCalledWith('https://api.example.com/test', expect.anything())
+  })
+
+  // ── setAccessToken ───────────────────────────────────────────────
+
+  it('returns this for chaining', () => {
+    const result = client.setAccessToken('tok123')
+    expect(result).toBe(client)
+  })
+
+  it('includes Bearer token in Authorization header after setAccessToken', async () => {
+    client.setAccessToken('tok123')
+    const spy = mockFetch({ ok: true, status: 200, statusText: 'OK', body: '{}' })
+    await client.get('/test')
+    const headers = spy.mock.calls[0]?.[1]?.headers as Record<string, string>
+    expect(headers['Authorization']).toBe('Bearer tok123')
+  })
+
+  it('does not include Authorization header when no token is set', async () => {
+    const spy = mockFetch({ ok: true, status: 200, statusText: 'OK', body: '{}' })
+    await client.get('/test')
+    const headers = spy.mock.calls[0]?.[1]?.headers as Record<string, string>
+    expect(headers['Authorization']).toBeUndefined()
+  })
+
+  // ── URL construction ─────────────────────────────────────────────
+
+  it('strips leading slash from endpoint', async () => {
+    const spy = mockFetch({ ok: true, status: 200, statusText: 'OK', body: '{}' })
+    await client.get('/users')
+    expect(spy).toHaveBeenCalledWith('https://api.example.com/users', expect.anything())
+  })
+
+  it('handles endpoint without leading slash', async () => {
+    const spy = mockFetch({ ok: true, status: 200, statusText: 'OK', body: '{}' })
+    await client.get('users')
+    expect(spy).toHaveBeenCalledWith('https://api.example.com/users', expect.anything())
+  })
+
+  // ── HTTP methods ─────────────────────────────────────────────────
+
+  it.each(['GET', 'POST', 'PUT', 'PATCH', 'DELETE'] as const)(
+    '%s calls fetch with correct method',
+    async (method) => {
+      const spy = mockFetch({ ok: true, status: 200, statusText: 'OK', body: '{}' })
+      const fn = method.toLowerCase() as 'get' | 'post' | 'put' | 'patch' | 'delete'
+      await (client[fn] as (ep: string) => Promise<unknown>)('/test')
+      expect(spy.mock.calls[0]?.[1]?.method).toBe(method)
+    },
+  )
+
+  it('sends JSON body for POST', async () => {
+    const spy = mockFetch({ ok: true, status: 200, statusText: 'OK', body: '{}' })
+    await client.post('/items', { name: 'foo' })
+    expect(spy.mock.calls[0]?.[1]?.body).toBe(JSON.stringify({ name: 'foo' }))
+  })
+
+  it('does not send body for GET', async () => {
+    const spy = mockFetch({ ok: true, status: 200, statusText: 'OK', body: '{}' })
+    await client.get('/items')
+    expect(spy.mock.calls[0]?.[1]?.body).toBeUndefined()
+  })
+
+  it('does not send body for DELETE', async () => {
+    const spy = mockFetch({ ok: true, status: 200, statusText: 'OK', body: '{}' })
+    await client.delete('/items/1')
+    expect(spy.mock.calls[0]?.[1]?.body).toBeUndefined()
+  })
+
+  it('merges custom headers', async () => {
+    const spy = mockFetch({ ok: true, status: 200, statusText: 'OK', body: '{}' })
+    await client.get('/test', { 'X-Custom': 'hello' })
+    const headers = spy.mock.calls[0]?.[1]?.headers as Record<string, string>
+    expect(headers['X-Custom']).toBe('hello')
+    expect(headers['Content-Type']).toBe('application/json')
+  })
+
+  // ── Successful responses ─────────────────────────────────────────
+
+  it('parses JSON response body', async () => {
+    mockFetch({ ok: true, status: 200, statusText: 'OK', body: '{"id":1}' })
+    const result = await client.get<{ id: number }>('/test')
+    expect(result).toEqual({ id: 1 })
+  })
+
+  it('returns undefined for empty response body', async () => {
+    mockFetch({ ok: true, status: 204, statusText: 'No Content', body: '' })
+    const result = await client.delete('/items/1')
+    expect(result).toBeUndefined()
+  })
+
+  it('returns plain text when response is not JSON', async () => {
+    mockFetch({ ok: true, status: 200, statusText: 'OK', body: 'OK' })
+    const result = await client.post<string>('/action')
+    expect(result).toBe('OK')
+  })
+
+  it('parses JSON body even without Content-Type header', async () => {
+    mockFetch({ ok: true, status: 200, statusText: 'OK', body: '{"key":"value"}' })
+    const result = await client.get<{ key: string }>('/test')
+    expect(result).toEqual({ key: 'value' })
+  })
+
+  it('parses JSON response using Content-Type header when present', async () => {
+    mockFetch({
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      headers: { 'Content-Type': 'application/json; charset=utf-8' },
+      body: '{"id":42}',
+    })
+    const result = await client.get<{ id: number }>('/test')
+    expect(result).toEqual({ id: 42 })
+  })
+
+  it('returns plain text for text/plain Content-Type', async () => {
+    mockFetch({
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      headers: { 'Content-Type': 'text/plain' },
+      body: 'Created',
+    })
+    const result = await client.post<string>('/action')
+    expect(result).toBe('Created')
+  })
+
+  // ── Error handling ───────────────────────────────────────────────
+
+  it('throws ApiError with status for non-JSON error response', async () => {
+    mockFetch({ ok: false, status: 500, statusText: 'Internal Server Error' })
+    await expect(client.get('/fail')).rejects.toThrow(ApiError)
+    await expect(client.get('/fail')).rejects.toMatchObject({
+      message: 'HTTP Error 500: Internal Server Error',
+      status: 500,
+    })
+  })
+
+  it('throws ApiError with parsed message from JSON error', async () => {
+    mockFetch({
+      ok: false,
+      status: 422,
+      statusText: 'Unprocessable Entity',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ message: 'Validation failed', error: 'ValidationError' }),
+    })
+    await expect(client.get('/fail')).rejects.toMatchObject({
+      message: 'Validation failed',
+      errorClass: 'ValidationError',
+      status: 422,
+    })
+  })
+
+  it('includes validationErrors from JSON error response', async () => {
+    const validationErrors = [{ path: 'name', message: 'required', code: 'REQUIRED' }]
+    mockFetch({
+      ok: false,
+      status: 422,
+      statusText: 'Unprocessable Entity',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ message: 'Bad input', validationErrors }),
+    })
+    await expect(client.get('/fail')).rejects.toMatchObject({
+      validationErrors,
+    })
+  })
+
+  it('falls back to default message when JSON parsing fails', async () => {
+    mockFetch({
+      ok: false,
+      status: 400,
+      statusText: 'Bad Request',
+      headers: { 'Content-Type': 'application/json' },
+      body: 'not-json',
+      json: (() => {
+        throw new Error('parse error')
+      }) as unknown,
+    })
+    await expect(client.get('/fail')).rejects.toMatchObject({
+      message: 'HTTP Error 400: Bad Request',
+      status: 400,
+    })
+  })
+
+  it('uses error field as message when message is absent', async () => {
+    mockFetch({
+      ok: false,
+      status: 403,
+      statusText: 'Forbidden',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ error: 'AccessDenied' }),
+    })
+    await expect(client.get('/fail')).rejects.toMatchObject({
+      message: 'AccessDenied',
+      errorClass: 'AccessDenied',
+    })
+  })
+})

package/src/core/BaseApiClient.ts

@@ -0,0 +1,139 @@
+import type { ApiClient, HttpMethod } from './ApiClient'
+
+export interface ValidationError {
+  path: string
+  message: string
+  code: string
+}
+
+export class ApiError extends Error {
+  public readonly errorClass?: string | undefined
+  public readonly status?: number | undefined
+  public readonly validationErrors: ValidationError[] | null
+
+  constructor(
+    message: string,
+    errorClass?: string,
+    status?: number,
+    validationErrors: ValidationError[] | null = null,
+  ) {
+    super(message)
+    this.name = 'ApiError'
+    this.errorClass = errorClass
+    this.status = status
+    this.validationErrors = validationErrors
+  }
+}
+
+export class BaseApiClient implements ApiClient {
+  protected readonly baseUrl: string
+  protected accessToken: string | null = null
+
+  constructor(baseUrl: string, accessToken?: string) {
+    this.baseUrl = baseUrl.replace(/\/$/, '')
+    this.accessToken = accessToken || null
+  }
+
+  setAccessToken(accessToken: string): this {
+    this.accessToken = accessToken
+    return this
+  }
+
+  async request<TResponse = unknown, TBody = unknown>(
+    method: HttpMethod,
+    endpoint: string,
+    body?: TBody,
+    headers?: Record<string, string>,
+  ): Promise<TResponse> {
+    const url = `${this.baseUrl}/${endpoint.replace(/^\//, '')}`
+
+    const response = await fetch(url, {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...(this.accessToken && { Authorization: `Bearer ${this.accessToken}` }),
+        ...headers,
+      },
+      ...(body !== undefined && { body: JSON.stringify(body) }),
+    })
+
+    return this.handleResponse<TResponse>(response)
+  }
+
+  protected async handleResponse<TResponse>(response: Response): Promise<TResponse> {
+    if (!response.ok) {
+      const contentType = response.headers.get('Content-Type')
+      const isJson = contentType && contentType.includes('application/json')
+
+      let errorMessage = `HTTP Error ${response.status}: ${response.statusText}`
+      let errorClass: string | undefined
+      let validationErrors: ValidationError[] | null = null
+
+      if (isJson) {
+        try {
+          const errorData = await response.json()
+          errorMessage = errorData.message || errorData.error || errorMessage
+          errorClass = errorData.error
+          validationErrors = errorData.validationErrors ?? null
+        } catch {
+          // If JSON parsing fails, use the default error message
+        }
+      }
+
+      throw new ApiError(errorMessage, errorClass, response.status, validationErrors)
+    }
+
+    const contentType = response.headers.get('Content-Type')
+    const isJson = contentType && contentType.includes('application/json')
+
+    if (isJson) {
+      return (await response.json()) as TResponse
+    }
+
+    const text = await response.text()
+    if (text) {
+      try {
+        return JSON.parse(text) as TResponse
+      } catch {
+        return text as unknown as TResponse
+      }
+    }
+
+    return undefined as unknown as TResponse
+  }
+
+  get<TResponse = unknown>(endpoint: string, headers?: Record<string, string>): Promise<TResponse> {
+    return this.request<TResponse>('GET', endpoint, undefined, headers)
+  }
+
+  post<TResponse = unknown, TBody = unknown>(
+    endpoint: string,
+    body?: TBody,
+    headers?: Record<string, string>,
+  ): Promise<TResponse> {
+    return this.request<TResponse, TBody>('POST', endpoint, body, headers)
+  }
+
+  put<TResponse = unknown, TBody = unknown>(
+    endpoint: string,
+    body?: TBody,
+    headers?: Record<string, string>,
+  ): Promise<TResponse> {
+    return this.request<TResponse, TBody>('PUT', endpoint, body, headers)
+  }
+
+  patch<TResponse = unknown, TBody = unknown>(
+    endpoint: string,
+    body?: TBody,
+    headers?: Record<string, string>,
+  ): Promise<TResponse> {
+    return this.request<TResponse, TBody>('PATCH', endpoint, body, headers)
+  }
+
+  delete<TResponse = unknown>(
+    endpoint: string,
+    headers?: Record<string, string>,
+  ): Promise<TResponse> {
+    return this.request<TResponse>('DELETE', endpoint, undefined, headers)
+  }
+}