@ikatec/digisac-api-sdk 4.10.0 → 4.11.0

package/src/apis/distribution/DistributionApi.ts

@@ -1,19 +1,57 @@
 import type { ApiClient } from '../../core/ApiClient'
 import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
+import type { Department } from '../departments/types'
 import type { Distribution, CreateDistributionPayload, UpdateDistributionPayload } from './types'
 
+/**
+ * Ticket distribution rules. `getById` answers `null` for an unknown id and always includes `departments` and
+ * `roles` (the query is ignored).
+ */
 export class DistributionApi extends BaseCrudApi<
   Distribution,
   CreateDistributionPayload,
   UpdateDistributionPayload,
   ListQuery<Distribution>,
-  void
+  void,
+  Distribution | undefined,
+  Distribution | Department[]
 > {
   constructor(client: ApiClient) {
     super(client, '/distribution')
   }
 
+  /**
+   * Creates a distribution. Resolves the distribution (without `departments`/`roles`), or no body
+   * (`undefined`) when `departments` is sent — find it by name with `getMany` in that case.
+   * @permissions distribution.create
+   */
+  override create(
+    body: CreateDistributionPayload,
+    headers?: Record<string, string>,
+  ): Promise<Distribution | undefined> {
+    return super.create(body, headers)
+  }
+
+  /**
+   * Updates a distribution. The backend reads the id from the body, so it is sent there too. It replaces
+   * the links: omitting `roles` or `departments` clears them. Resolves the stored distribution (with
+   * `deletedAt`, without the links) or, when `departments` is sent, the updated departments. An unknown id
+   * answers 500.
+   * @permissions distribution.view OR distribution.update
+   */
+  override updateById(
+    id: string,
+    body: UpdateDistributionPayload,
+    headers?: Record<string, string>,
+  ): Promise<Distribution | Department[]> {
+    return this.client.put<Distribution | Department[], UpdateDistributionPayload & { id: string }>(
+      `${this.basePath}/${id}`,
+      { ...body, id },
+      headers,
+    )
+  }
+
   /**
    * Deletes a distribution. Resolves with no body, also for an unknown id (200).
    * @permissions distribution.view OR distribution.destroy

package/src/apis/distribution/types.ts

@@ -11,7 +11,8 @@ export type Distribution = {
   distributeQueue: boolean
   accountId: string
   archivedAt: string | null
-  deletedAt: string | null
+  /** Only in the answer of `updateById` (the stored model, not transformed). */
+  deletedAt?: string | null
   createdAt: string
   updatedAt: string
   // relationships
@@ -21,6 +22,9 @@ export type Distribution = {
 
 export type DistributionRelationships = 'departments' | 'roles'
 
+/** A department or a role linked to a distribution (only the id is read). */
+export type DistributionLink = { id: string }
+
 export type CreateDistributionPayload = {
   name: string
   maxNum: number
@@ -28,8 +32,17 @@ export type CreateDistributionPayload = {
   timeToRedistribute?: number
   redistributeAssignedTickets?: boolean
   distributeQueue?: boolean
+  /** An archived distribution is skipped by the distribution crons. */
+  archivedAt?: string | null
+  /** Departments to distribute; a department has at most one distribution. */
+  departments?: DistributionLink[]
+  roles?: DistributionLink[]
 }
 
+/**
+ * The update replaces the links: send `departments` and `roles` again to keep them — omitting them
+ * clears them.
+ */
 export type UpdateDistributionPayload = {
   name?: string
   maxNum?: number
@@ -37,4 +50,7 @@ export type UpdateDistributionPayload = {
   timeToRedistribute?: number
   redistributeAssignedTickets?: boolean
   distributeQueue?: boolean
+  archivedAt?: string | null
+  departments?: DistributionLink[]
+  roles?: DistributionLink[]
 }

package/src/apis/integrations/IntegrationsApi.test.ts

@@ -0,0 +1,42 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { IntegrationsApi } from './IntegrationsApi'
+import type { ApiClient } from '../../core/ApiClient'
+
+// ── 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(),
+  }
+}
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe('IntegrationsApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: IntegrationsApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new IntegrationsApi(client)
+  })
+
+  it('create posts to /integrations and resolves the empty object the route answers', async () => {
+    vi.mocked(client.post).mockResolvedValue({})
+    const body = { type: 'menu_button', url: 'https://example.com', icon: '', text: 'QA' }
+    await expect(api.create(body)).resolves.toEqual({})
+    expect(client.post).toHaveBeenCalledWith('/integrations', body, undefined)
+  })
+
+  it('updateById puts to /integrations/:id and resolves the empty object', async () => {
+    vi.mocked(client.put).mockResolvedValue({})
+    await expect(api.updateById('int-1', { text: 'QA 2' })).resolves.toEqual({})
+    expect(client.put).toHaveBeenCalledWith('/integrations/int-1', { text: 'QA 2' }, undefined)
+  })
+})

package/src/apis/integrations/IntegrationsApi.ts

@@ -1,19 +1,52 @@
 import type { ApiClient } from '../../core/ApiClient'
 import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
-import type { Integration, CreateIntegrationPayload, UpdateIntegrationPayload } from './types'
+import type {
+  Integration,
+  CreateIntegrationPayload,
+  UpdateIntegrationPayload,
+  IntegrationWriteResponse,
+} from './types'
 
+/** Integrations of the account (buttons and events of the UI). `getById` answers `null` for an unknown id. */
 export class IntegrationsApi extends BaseCrudApi<
   Integration,
   CreateIntegrationPayload,
   UpdateIntegrationPayload,
   ListQuery<Integration>,
-  'OK'
+  'OK',
+  IntegrationWriteResponse,
+  IntegrationWriteResponse
 > {
   constructor(client: ApiClient) {
     super(client, '/integrations')
   }
 
+  /**
+   * Creates an integration. Resolves `{}` — also when the type is unique (`event_ticket_transfer`,
+   * `event_ticket_closed`), already exists in the account and nothing is created. Find the integration with
+   * `getMany` (e.g. by `text`).
+   * @permissions integrations.create
+   */
+  override create(
+    body: CreateIntegrationPayload,
+    headers?: Record<string, string>,
+  ): Promise<IntegrationWriteResponse> {
+    return super.create(body, headers)
+  }
+
+  /**
+   * Updates an integration. Resolves `{}`; read it again with `getById`. An unknown id answers 500.
+   * @permissions integrations.view OR integrations.update
+   */
+  override updateById(
+    id: string,
+    body: UpdateIntegrationPayload,
+    headers?: Record<string, string>,
+  ): Promise<IntegrationWriteResponse> {
+    return super.updateById(id, body, headers)
+  }
+
   /**
    * Deletes an integration. Resolves the text `'OK'`; an unknown id answers 500.
    * @permissions integrations.view OR integrations.destroy

package/src/apis/integrations/types.ts

@@ -1,27 +1,46 @@
+/**
+ * The types the UI shows: buttons (`menu_button` in the header, `context_menu_button_*` in the contact and
+ * message menus) and events that open the integration when a ticket is transferred or closed (unique per
+ * account). The backend accepts any string.
+ */
+export type IntegrationType =
+  | 'menu_button'
+  | 'context_menu_button_contact_modal'
+  | 'context_menu_button_contact_side_list'
+  | 'context_menu_button_message'
+  | 'event_ticket_transfer'
+  | 'event_ticket_closed'
+  | (string & {})
+
+export type IntegrationSize = 'sm' | 'md' | 'lg' | (string & {})
+
 export type Integration = {
   id: string
-  type: string
+  type: IntegrationType
   url: string | null
   icon: string | null
   text: string | null
-  size: string | null
+  size: IntegrationSize | null
   accountId: string
   createdAt: string
   updatedAt: string
 }
 
+/** What `create` and `updateById` resolve to: an empty object. */
+export type IntegrationWriteResponse = Record<string, never>
+
 export type CreateIntegrationPayload = {
-  type: string
+  type: IntegrationType
   url?: string
   icon?: string
   text?: string
-  size?: string
+  size?: IntegrationSize
 }
 
 export type UpdateIntegrationPayload = {
-  type?: string
+  type?: IntegrationType
   url?: string | null
   icon?: string | null
   text?: string | null
-  size?: string | null
+  size?: IntegrationSize | null
 }

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

@@ -54,6 +54,8 @@ import type { SummarizeTicketResult } from './contacts/types'
 import { CustomFieldsApi } from './customFields/CustomFieldsApi'
 import { DepartmentsApi } from './departments/DepartmentsApi'
 import type { Department } from './departments/types'
+import type { Distribution } from './distribution/types'
+import type { ContactBlockList } from './contactBlockLists/types'
 import { DistributionApi } from './distribution/DistributionApi'
 import { FilesApi } from './files/FilesApi'
 import type { CreateToUploadResult, DeleteFileResult, File } from './files/types'
@@ -545,6 +547,62 @@ expectType<Promise<'OK'>>(new ContactBlockListsControlsApi(client).deleteById('c
 expectType<Promise<boolean>>(new RolesApi(client).deleteById('r-1'))
 expectType<Promise<void>>(new AcceptanceTermsApi(client).deleteById('t-1'))
 expectType<Promise<void>>(new DistributionApi(client).deleteById('d-1'))
+
+// ── create/updateById: what each route really answers (QARC-1008) ─────
+
+expectType<Promise<Distribution | undefined>>(
+  new DistributionApi(client).create({
+    name: 'd',
+    maxNum: 1,
+    redistributeAll: false,
+    departments: [{ id: 'dep-1' }],
+  }),
+)
+expectType<Promise<Distribution | Department[]>>(
+  new DistributionApi(client).updateById('d-1', {
+    name: 'd',
+    roles: [{ id: 'r-1' }],
+    departments: [],
+  }),
+)
+expectType<Promise<Record<string, never>>>(
+  new IntegrationsApi(client).create({ type: 'menu_button', text: 'x' }),
+)
+expectType<Promise<Record<string, never>>>(
+  new IntegrationsApi(client).updateById('i-1', { text: 'x' }),
+)
+expectType<Promise<void>>(
+  new ContactBlockListsControlsApi(client).create({
+    reason: 'r',
+    servicesIds: ['s-1'],
+    contactBlockListsIds: ['l-1'],
+    action: 'block',
+    revertExceptions: false,
+  }),
+)
+expectType<Promise<{ count: number }>>(
+  new ContactBlockListsApi(client).count({ where: { name: 'x' } }),
+)
+expectType<Promise<{ count: number }>>(new ContactBlockListsControlsApi(client).count())
+expectType<Promise<Paginated<ContactBlockList>>>(
+  new ContactBlockListsApi(client).getMany({ include: ['importFile'] }),
+)
+expectError(
+  new DistributionApi(client).create({
+    name: 'd',
+    maxNum: 1,
+    redistributeAll: false,
+    departments: ['dep-1'],
+  }),
+)
+expectError(
+  new ContactBlockListsControlsApi(client).create({
+    reason: 'r',
+    servicesIds: [],
+    contactBlockListsIds: [],
+    action: 'remove',
+  }),
+)
 expectType<Promise<false>>(new KnowledgeBaseApi(client).deleteById('k-1'))
 expectType<Promise<false>>(new KnowledgeBaseItemApi(client).deleteById('k-1'))
 expectType<Promise<DeleteFileResult>>(new FilesApi(client).deleteById('f-1'))

package/src/core/BaseCrudApi.test-d.ts

@@ -1,7 +1,7 @@
 import { expectError, expectType } from 'tsd'
 import type { ApiClient } from './ApiClient'
 import { BaseCrudApi } from './BaseCrudApi'
-import type { Paginated } from './types'
+import type { ListQuery, Paginated } from './types'
 
 // ── Test model ──────────────────────────────────────────────────────
 
@@ -40,6 +40,16 @@ expectType<Promise<Item>>(api.create({ name: 'x' }))
 expectType<Promise<Item>>(api.updateById('1', {}))
 expectType<Promise<Item>>(api.deleteById('1'))
 
+// Routes that do not answer the resource on create/update (TCreateResponse, TUpdateResponse)
+const writes = new BaseCrudApi<Item, CreateItem, UpdateItem, ListQuery<Item>, 'OK', void, Item[]>(
+  client,
+  '/items',
+)
+expectType<Promise<void>>(writes.create({ name: 'x' }))
+expectType<Promise<Item[]>>(writes.updateById('1', {}))
+expectType<Promise<'OK'>>(writes.deleteById('1'))
+expectType<Promise<Item>>(writes.getById('1'))
+
 expectError(api.create({}))
 expectError(api.create({ name: 1 }))
 expectError(api.updateById('1', { name: 1 }))

package/src/core/BaseCrudApi.ts

@@ -16,7 +16,9 @@ export type {
 
 /**
  * Generic CRUD resource: the reads of `BaseReadApi` plus `create`, `updateById` and `deleteById`.
- * `TDeleteResponse` is what `deleteById` resolves to (most routes answer the text `'OK'`).
+ * `TDeleteResponse` is what `deleteById` resolves to (most routes answer the text `'OK'`);
+ * `TCreateResponse` and `TUpdateResponse` are what `create` and `updateById` resolve to, for the routes
+ * that do not answer the resource (an empty body, `{}`, another model).
  */
 export class BaseCrudApi<
   TResponse,
@@ -24,24 +26,31 @@ export class BaseCrudApi<
   TUpdate = TCreate,
   TQuery extends ListQuery<TResponse> = ListQuery<TResponse>,
   TDeleteResponse = TResponse,
+  TCreateResponse = TResponse,
+  TUpdateResponse = TResponse,
 >
   extends BaseReadApi<TResponse, TQuery>
-  implements CrudApi<TResponse, TCreate, TUpdate, TQuery, TDeleteResponse>
+  implements
+    CrudApi<TResponse, TCreate, TUpdate, TQuery, TDeleteResponse, TCreateResponse, TUpdateResponse>
 {
   /**
    * Creates a new resource.
    * @permissions $resourceName.create
    */
-  create(body: TCreate, headers?: Record<string, string>): Promise<TResponse> {
-    return this.client.post<TResponse, TCreate>(this.basePath, body, headers)
+  create(body: TCreate, headers?: Record<string, string>): Promise<TCreateResponse> {
+    return this.client.post<TCreateResponse, TCreate>(this.basePath, body, headers)
   }
 
   /**
    * Updates an existing resource by ID.
    * @permissions $resourceName.update
    */
-  updateById(id: string, body: TUpdate, headers?: Record<string, string>): Promise<TResponse> {
-    return this.client.put<TResponse, TUpdate>(`${this.basePath}/${id}`, body, headers)
+  updateById(
+    id: string,
+    body: TUpdate,
+    headers?: Record<string, string>,
+  ): Promise<TUpdateResponse> {
+    return this.client.put<TUpdateResponse, TUpdate>(`${this.basePath}/${id}`, body, headers)
   }
 
   /**

package/src/core/types.ts

@@ -160,8 +160,10 @@ export type CrudApi<
   TUpdate = TCreate,
   TQuery extends ListQuery<TResponse> = ListQuery<TResponse>,
   TDeleteResponse = TResponse,
+  TCreateResponse = TResponse,
+  TUpdateResponse = TResponse,
 > = HasGetMany<TResponse, TQuery> &
   HasGetById<TResponse> &
-  HasCreate<TResponse, TCreate> &
-  HasUpdateById<TResponse, TUpdate> &
+  HasCreate<TCreateResponse, TCreate> &
+  HasUpdateById<TUpdateResponse, TUpdate> &
   HasDeleteById<TDeleteResponse>