@ikatec/digisac-api-sdk 4.4.0 → 4.5.0

package/src/apis/messages/MessagesApi.test.ts

@@ -45,6 +45,17 @@ const message: Message = {
   obfuscated: false,
   reactionParentMessageId: null,
   hsmId: null,
+  isFromBot: false,
+  accountId: 'acc-1',
+  serviceId: 'svc-1',
+  contactId: 'ctt-1',
+  fromId: null,
+  toId: 'ctt-1',
+  userId: 'usr-1',
+  ticketId: 'tkt-1',
+  ticketUserId: 'usr-1',
+  ticketDepartmentId: 'dep-1',
+  quotedMessageId: null,
   createdAt: '2024-01-01T00:00:00Z',
   updatedAt: '2024-01-01T00:00:00Z',
   deletedAt: null,

package/src/apis/messages/MessagesApi.ts

@@ -101,9 +101,12 @@ export class MessagesApi extends BaseCrudApi<Message, CreateMessagePayload, Upda
     )
   }
 
-  /** Triggers an AI-generated summary for the conversation associated with the given message. */
-  summarize(id: string, headers?: Record<string, string>): Promise<void> {
-    return this.client.post<void>(`${this.basePath}/${id}/summarize`, undefined, headers)
+  /**
+   * Triggers an AI-generated summary for the conversation associated with the given message.
+   * Resolves to `'OK'`.
+   */
+  summarize(id: string, headers?: Record<string, string>): Promise<string> {
+    return this.client.post<string>(`${this.basePath}/${id}/summarize`, undefined, headers)
   }
 
   /** Checks whether a message is out of the visible range (i.e. there are more than `limit` messages after it). */

package/src/apis/messages/types.ts

@@ -113,6 +113,19 @@ export type Message = {
   transcribeError?: boolean
   reactionParentMessageId: string | null
   hsmId: string | null
+  isFromBot: boolean
+  accountId: string
+  serviceId: string
+  contactId: string
+  /** The contact that sent the message; `null` when it is from the account. */
+  fromId: string | null
+  toId: string | null
+  /** The user that sent the message; `null` for a received one. */
+  userId: string | null
+  ticketId: string | null
+  ticketUserId: string | null
+  ticketDepartmentId: string | null
+  quotedMessageId: string | null
   createdAt: string
   updatedAt: string
   deletedAt: string | null

package/src/apis/payloads.test-d.ts

@@ -1,6 +1,9 @@
 import { expectError } from 'tsd'
 import type { ApiClient } from '../core/ApiClient'
+import { CardsApi } from './cards/CardsApi'
 import { ContactsApi } from './contacts/ContactsApi'
+import { KanbanColumnsApi } from './kanbanColumns/KanbanColumnsApi'
+import { PipelineApi } from './pipeline/PipelineApi'
 import { PersonalAccessTokensApi } from './personalAccessTokens/PersonalAccessTokensApi'
 import { RolesApi } from './roles/RolesApi'
 import { TagsApi } from './tags/TagsApi'
@@ -63,3 +66,30 @@ const tags = new TagsApi(client)
 tags.attachContacts('t-1', { where: { id: { $in: ['c-1', 'c-2'] } } })
 expectError(tags.attachContacts('t-1', {}))
 expectError(tags.detachContacts('t-1', { include: ['tags'] }))
+
+// ── pipelines: moving the cards of a deleted status needs the target ─
+
+const pipelines = new PipelineApi(client)
+pipelines.deleteStatus('st-1', { action: 'move-to-another', newStatusId: 'st-2' })
+pipelines.deleteStatus('st-1', { action: 'keep-without-status' })
+expectError(pipelines.deleteStatus('st-1', { action: 'move-to-another' }))
+expectError(pipelines.createAutomation({ pipelineId: 'p-1', type: 'email' }))
+expectError(pipelines.deleteStage('s-1', { typeAction: 'archive' }))
+
+// ── cards: getCards is not scoped by the backend and only answers the attributes asked ─
+
+const cards = new CardsApi(client)
+cards.getCards({
+  where: { accountId: 'a-1', pipelineId: 'p-1' },
+  attributes: ['id', 'title'],
+  order: [['contact.name', 'ASC']],
+})
+expectError(cards.getCards({ where: { pipelineId: 'p-1' }, attributes: ['id'] }))
+expectError(cards.getCards({ where: { accountId: 'a-1' } }))
+expectError(cards.saveComment({ comment: 'no card nor id' }))
+
+// ── kanban columns: the backend computes the position ───────────────
+
+const columns = new KanbanColumnsApi(client)
+columns.reorder('col-1', { beforeColumnId: 'col-0', afterColumnId: 'col-2' })
+expectError(columns.reorder('col-1', { position: 'M' }))

package/src/apis/pipeline/PipelineApi.test.ts

@@ -0,0 +1,193 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { ApiClient } from '../../core/ApiClient'
+import { PipelineApi } from './PipelineApi'
+
+// ── Mock client factory ──────────────────────────────────────────────
+
+function createMockClient(): ApiClient {
+  return {
+    setAccessToken: vi.fn().mockReturnThis(),
+    request: vi.fn(),
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+    patch: vi.fn(),
+    delete: vi.fn(),
+  }
+}
+
+const headers = { 'X-Custom': 'value' }
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe('PipelineApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: PipelineApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new PipelineApi(client)
+  })
+
+  describe('stages', () => {
+    const stage = { name: 'Proposta', pipelineId: 'p1', position: 2 }
+
+    it('createStage calls client.post with /pipelines/stage and body', async () => {
+      vi.mocked(client.post).mockResolvedValue({ id: 's1', ...stage })
+      const result = await api.createStage(stage)
+      expect(client.post).toHaveBeenCalledWith('/pipelines/stage', stage, undefined)
+      expect(result).toEqual({ id: 's1', ...stage })
+    })
+
+    it('createStage resolves to the refusal code the backend answers with 200', async () => {
+      vi.mocked(client.post).mockResolvedValue('STAGES_LIMIT')
+      await expect(api.createStage(stage)).resolves.toBe('STAGES_LIMIT')
+    })
+
+    it('updateStage calls client.put with /pipelines/stage/:id and body', async () => {
+      const body = { ...stage, id: 's1', statuses: [{ id: 'st1', name: 'Novo', position: 1 }] }
+      await api.updateStage('s1', body, headers)
+      expect(client.put).toHaveBeenCalledWith('/pipelines/stage/s1', body, headers)
+    })
+
+    it('deleteStage calls client.request with DELETE and the destination of the cards', async () => {
+      vi.mocked(client.request).mockResolvedValue('MESSAGE_STAGE_DELETED')
+      const body = { typeAction: 'move' as const, idNewStage: 's2', user: { id: 'u1' } }
+      const result = await api.deleteStage('s1', body)
+      expect(client.request).toHaveBeenCalledWith('DELETE', '/pipelines/stage/s1', body, undefined)
+      expect(result).toBe('MESSAGE_STAGE_DELETED')
+    })
+
+    it('deleteStage sends an empty body by default', async () => {
+      await api.deleteStage('s1')
+      expect(client.request).toHaveBeenCalledWith('DELETE', '/pipelines/stage/s1', {}, undefined)
+    })
+
+    it('getStageTotals calls client.post with /pipelines/stage-totals/:id and the filters', async () => {
+      const filters = { nameTitle: 'Acme', createdFrom: '01/09/2026' }
+      await api.getStageTotals('s1', filters)
+      expect(client.post).toHaveBeenCalledWith('/pipelines/stage-totals/s1', filters, undefined)
+    })
+
+    it('getStageTotals sends no filter by default', async () => {
+      await api.getStageTotals('s1')
+      expect(client.post).toHaveBeenCalledWith('/pipelines/stage-totals/s1', {}, undefined)
+    })
+  })
+
+  describe('statuses', () => {
+    it('getStatuses calls client.get with /pipelines/statuses/:pipelineId', async () => {
+      vi.mocked(client.get).mockResolvedValue([{ id: 'st1', name: 'Novo' }])
+      const result = await api.getStatuses('p1', headers)
+      expect(client.get).toHaveBeenCalledWith('/pipelines/statuses/p1', headers)
+      expect(result).toEqual([{ id: 'st1', name: 'Novo' }])
+    })
+
+    it('getStatus calls client.get with /pipelines/status/:id', async () => {
+      await api.getStatus('st1')
+      expect(client.get).toHaveBeenCalledWith('/pipelines/status/st1', undefined)
+    })
+
+    it('deleteStatus calls client.post with /pipelines/delete-status/:id and the action', async () => {
+      vi.mocked(client.post).mockResolvedValue('MESSAGE_STATUS_DELETED')
+      const body = { action: 'move-to-another' as const, newStatusId: 'st2' }
+      const result = await api.deleteStatus('st1', body)
+      expect(client.post).toHaveBeenCalledWith('/pipelines/delete-status/st1', body, undefined)
+      expect(result).toBe('MESSAGE_STATUS_DELETED')
+    })
+
+    it('renameStatus posts only newStatusName to the delete-status route', async () => {
+      vi.mocked(client.post).mockResolvedValue('MESSAGE_STATUS_RENAMED')
+      const result = await api.renameStatus('st1', 'Qualificado', headers)
+      expect(client.post).toHaveBeenCalledWith(
+        '/pipelines/delete-status/st1',
+        { newStatusName: 'Qualificado' },
+        headers,
+      )
+      expect(result).toBe('MESSAGE_STATUS_RENAMED')
+    })
+  })
+
+  describe('automations', () => {
+    const body = {
+      pipelineId: 'p1',
+      type: 'notification' as const,
+      config: { notify: 'high' as const },
+    }
+
+    it('createAutomation calls client.post with /pipelines/automations and body', async () => {
+      await api.createAutomation(body)
+      expect(client.post).toHaveBeenCalledWith('/pipelines/automations', body, undefined)
+    })
+
+    it('updateAutomation calls client.put with /pipelines/automations/:id and body', async () => {
+      await api.updateAutomation('a1', body, headers)
+      expect(client.put).toHaveBeenCalledWith('/pipelines/automations/a1', body, headers)
+    })
+
+    it('deleteAutomation calls client.delete with /pipelines/automations/:id', async () => {
+      await api.deleteAutomation('a1')
+      expect(client.delete).toHaveBeenCalledWith('/pipelines/automations/a1', undefined)
+    })
+
+    it('getAutomation calls client.get with /pipelines/automations/:pipelineId', async () => {
+      vi.mocked(client.get).mockResolvedValue([])
+      const result = await api.getAutomation('p1')
+      expect(client.get).toHaveBeenCalledWith('/pipelines/automations/p1', undefined)
+      expect(result).toEqual([])
+    })
+  })
+
+  describe('pipeline actions', () => {
+    it('duplicate calls client.post with /pipelines/duplicate/:pipelineId and no body', async () => {
+      await api.duplicate('p1', headers)
+      expect(client.post).toHaveBeenCalledWith('/pipelines/duplicate/p1', undefined, headers)
+    })
+
+    it('archive posts archive: true to /pipelines/:id/archive', async () => {
+      await api.archive('p1')
+      expect(client.post).toHaveBeenCalledWith(
+        '/pipelines/p1/archive',
+        { archive: true },
+        undefined,
+      )
+    })
+
+    it('unarchive posts archive: false to /pipelines/:id/archive', async () => {
+      await api.unarchive('p1')
+      expect(client.post).toHaveBeenCalledWith(
+        '/pipelines/p1/archive',
+        { archive: false },
+        undefined,
+      )
+    })
+
+    it('exportCsv calls client.post with /pipelines/:id/export and resolves to the CSV text', async () => {
+      vi.mocked(client.post).mockResolvedValue('Funil;\n')
+      const body = { createdAtInit: '2026-09-01 00:00:00', createdAtFinal: '2026-09-30 23:59:59' }
+      const result = await api.exportCsv('p1', body)
+      expect(client.post).toHaveBeenCalledWith('/pipelines/p1/export', body, undefined)
+      expect(result).toBe('Funil;\n')
+    })
+
+    it('getManyWithTotals serializes the query on /pipelines/withTotals', async () => {
+      await api.getManyWithTotals({ archive: true })
+      const expected = `/pipelines/withTotals?query=${encodeURIComponent(JSON.stringify({ archive: true }))}`
+      expect(client.get).toHaveBeenCalledWith(expected, undefined)
+    })
+
+    it('getManyWithTotals sends no query string without a query', async () => {
+      await api.getManyWithTotals()
+      expect(client.get).toHaveBeenCalledWith('/pipelines/withTotals', undefined)
+    })
+  })
+
+  describe('error propagation', () => {
+    it('propagates errors from createStage', async () => {
+      vi.mocked(client.post).mockRejectedValue(new Error('Validation failed'))
+      await expect(api.createStage({ name: 'x', pipelineId: 'p1', position: 1 })).rejects.toThrow(
+        'Validation failed',
+      )
+    })
+  })
+})

package/src/apis/pipeline/PipelineApi.ts

@@ -1,6 +1,28 @@
 import type { ApiClient } from '../../core/ApiClient'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
-import type { Pipeline, CreatePipelinePayload, UpdatePipelinePayload } from './types'
+import type {
+  CreatePipelineAutomationPayload,
+  CreatePipelinePayload,
+  CreatePipelineStagePayload,
+  DeletePipelineStagePayload,
+  DeletePipelineStageResult,
+  DeletePipelineStatusPayload,
+  ExportPipelinePayload,
+  Pipeline,
+  PipelineAutomation,
+  PipelineRecord,
+  PipelineStage,
+  PipelineStageRefusal,
+  PipelineStageStatusWithCount,
+  PipelineStageTotals,
+  PipelineStageTotalsFilters,
+  PipelineStatusRef,
+  PipelinesWithTotals,
+  PipelinesWithTotalsQuery,
+  UpdatePipelineAutomationPayload,
+  UpdatePipelinePayload,
+  UpdatePipelineStagePayload,
+} from './types'
 
 export class PipelineApi extends BaseCrudApi<
   Pipeline,
@@ -10,4 +32,255 @@ export class PipelineApi extends BaseCrudApi<
   constructor(client: ApiClient) {
     super(client, '/pipelines')
   }
+
+  /**
+   * Adds a stage (with its statuses and reasons) to a pipeline. Resolves to the stage as stored,
+   * without the statuses/reasons, or to a refusal code with 200: `'STAGES_LIMIT'` (the pipeline
+   * already has 10 stages) or `'STAGE_ALREADY_EXIST'` (same name).
+   * @permissions pipelines.update
+   */
+  createStage(
+    body: CreatePipelineStagePayload,
+    headers?: Record<string, string>,
+  ): Promise<PipelineStage | PipelineStageRefusal> {
+    return this.client.post<PipelineStage | PipelineStageRefusal, CreatePipelineStagePayload>(
+      `${this.basePath}/stage`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Updates a stage. `statuses` and `reasons` replace the whole set: items with `id` are kept
+   * and updated, items without it are created and the missing ones are deleted — omitting the
+   * lists deletes every status and reason of the stage. Resolves to the stage as stored, or to
+   * `'STAGE_ALREADY_EXIST'`.
+   * @permissions pipelines.update
+   */
+  updateStage(
+    id: string,
+    body: UpdatePipelineStagePayload,
+    headers?: Record<string, string>,
+  ): Promise<PipelineStage | 'STAGE_ALREADY_EXIST'> {
+    return this.client.put<PipelineStage | 'STAGE_ALREADY_EXIST', UpdatePipelineStagePayload>(
+      `${this.basePath}/stage/${id}`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Deletes a stage and moves its cards (see {@link DeletePipelineStagePayload}). Resolves to
+   * `'MESSAGE_STAGE_DELETED'`, or to `'PIPELINES_MIN_STAGES'` (nothing deleted) when the pipeline
+   * has only 2 stages. The backend also serves this under `PUT /pipelines/delete-stage/{id}`.
+   * @permissions pipelines.update
+   */
+  deleteStage(
+    id: string,
+    body: DeletePipelineStagePayload = {},
+    headers?: Record<string, string>,
+  ): Promise<DeletePipelineStageResult> {
+    return this.client.request<DeletePipelineStageResult, DeletePipelineStagePayload>(
+      'DELETE',
+      `${this.basePath}/stage/${id}`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Lists the statuses of every stage of a pipeline (`[]` for an unknown pipeline).
+   * @permissions pipelines.view
+   */
+  getStatuses(pipelineId: string, headers?: Record<string, string>): Promise<PipelineStatusRef[]> {
+    return this.client.get<PipelineStatusRef[]>(`${this.basePath}/statuses/${pipelineId}`, headers)
+  }
+
+  /**
+   * Gets a stage status with the number of cards using it. An unknown id resolves to
+   * `{ cardsCount: 0 }` with 200, not to an error.
+   * @permissions pipelines.view
+   */
+  getStatus(
+    id: string,
+    headers?: Record<string, string>,
+  ): Promise<PipelineStageStatusWithCount | { cardsCount: 0 }> {
+    return this.client.get<PipelineStageStatusWithCount | { cardsCount: 0 }>(
+      `${this.basePath}/status/${id}`,
+      headers,
+    )
+  }
+
+  /**
+   * Deletes a stage status, keeping its cards without status or moving them to another one.
+   * Resolves to `'MESSAGE_STATUS_DELETED'`.
+   * @permissions pipelines.view
+   */
+  deleteStatus(
+    id: string,
+    body: DeletePipelineStatusPayload,
+    headers?: Record<string, string>,
+  ): Promise<'MESSAGE_STATUS_DELETED'> {
+    return this.client.post<'MESSAGE_STATUS_DELETED', DeletePipelineStatusPayload>(
+      `${this.basePath}/delete-status/${id}`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Renames a stage status — same route as {@link deleteStatus}, without an `action`.
+   * Resolves to `'MESSAGE_STATUS_RENAMED'`; an empty name fails with 500.
+   * @permissions pipelines.view
+   */
+  renameStatus(
+    id: string,
+    newStatusName: string,
+    headers?: Record<string, string>,
+  ): Promise<'MESSAGE_STATUS_RENAMED'> {
+    return this.client.post<'MESSAGE_STATUS_RENAMED', { newStatusName: string }>(
+      `${this.basePath}/delete-status/${id}`,
+      { newStatusName },
+      headers,
+    )
+  }
+
+  /**
+   * Creates an automation of a pipeline. Resolves to the automation as stored.
+   * @permissions pipelines.update
+   */
+  createAutomation(
+    body: CreatePipelineAutomationPayload,
+    headers?: Record<string, string>,
+  ): Promise<PipelineAutomation> {
+    return this.client.post<PipelineAutomation, CreatePipelineAutomationPayload>(
+      `${this.basePath}/automations`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Updates an automation. Resolves to the automation as stored.
+   * @permissions pipelines.update
+   */
+  updateAutomation(
+    id: string,
+    body: UpdatePipelineAutomationPayload,
+    headers?: Record<string, string>,
+  ): Promise<PipelineAutomation> {
+    return this.client.put<PipelineAutomation, UpdatePipelineAutomationPayload>(
+      `${this.basePath}/automations/${id}`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Deletes an automation. Resolves with no content; an unknown id fails with 500.
+   * @permissions pipelines.update
+   */
+  deleteAutomation(id: string, headers?: Record<string, string>): Promise<void> {
+    return this.client.delete<void>(`${this.basePath}/automations/${id}`, headers)
+  }
+
+  /**
+   * Gets the automation of a pipeline — a single object (the first one found), or `[]` when
+   * the pipeline has none.
+   * @permissions pipelines.view
+   */
+  getAutomation(
+    pipelineId: string,
+    headers?: Record<string, string>,
+  ): Promise<PipelineAutomation | []> {
+    return this.client.get<PipelineAutomation | []>(
+      `${this.basePath}/automations/${pipelineId}`,
+      headers,
+    )
+  }
+
+  /**
+   * Copies a pipeline as `"<name> (copy)"`, with its stages, statuses, reasons and automations
+   * (not its departments). Resolves to the new pipeline as stored, without the stages.
+   * @permissions pipelines.view
+   */
+  duplicate(pipelineId: string, headers?: Record<string, string>): Promise<PipelineRecord> {
+    return this.client.post<PipelineRecord>(
+      `${this.basePath}/duplicate/${pipelineId}`,
+      undefined,
+      headers,
+    )
+  }
+
+  /**
+   * Archives a pipeline. Resolves to the pipeline with its stages and their card totals.
+   * @permissions pipelines.update
+   */
+  archive(id: string, headers?: Record<string, string>): Promise<Pipeline> {
+    return this.client.post<Pipeline, { archive: boolean }>(
+      `${this.basePath}/${id}/archive`,
+      { archive: true },
+      headers,
+    )
+  }
+
+  /**
+   * Restores an archived pipeline. Resolves to the pipeline with its stages and their totals.
+   * @permissions pipelines.update
+   */
+  unarchive(id: string, headers?: Record<string, string>): Promise<Pipeline> {
+    return this.client.post<Pipeline, { archive: boolean }>(
+      `${this.basePath}/${id}/archive`,
+      { archive: false },
+      headers,
+    )
+  }
+
+  /**
+   * Exports the cards of a pipeline as CSV text (`;` as the delimiter): a summary block
+   * followed by one row per card.
+   * @permissions pipelines.view
+   */
+  exportCsv(
+    id: string,
+    body: ExportPipelinePayload = {},
+    headers?: Record<string, string>,
+  ): Promise<string> {
+    return this.client.post<string, ExportPipelinePayload>(
+      `${this.basePath}/${id}/export`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Lists the pipelines of the account with their stages and card totals. Not paginated.
+   * @permissions pipelines.view
+   */
+  getManyWithTotals(
+    query?: PipelinesWithTotalsQuery,
+    headers?: Record<string, string>,
+  ): Promise<PipelinesWithTotals> {
+    return this.client.get<PipelinesWithTotals>(
+      `${this.basePath}/withTotals${this.toQueryString(query)}`,
+      headers,
+    )
+  }
+
+  /**
+   * Gets the card totals of a stage, optionally filtered like the board. Resolves to `null`
+   * for an unknown stage.
+   * @permissions pipelines.update OR pipelines.opportunity.update
+   */
+  getStageTotals(
+    stageId: string,
+    filters: PipelineStageTotalsFilters = {},
+    headers?: Record<string, string>,
+  ): Promise<PipelineStageTotals | null> {
+    return this.client.post<PipelineStageTotals | null, PipelineStageTotalsFilters>(
+      `${this.basePath}/stage-totals/${stageId}`,
+      filters,
+      headers,
+    )
+  }
 }