@webitel/api-services 0.1.68 → 0.1.70

package/src/api/clients/queues/__tests__/queueLogs.spec.ts

@@ -0,0 +1,132 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const searchAttemptsHistory = vi.fn();
+
+vi.mock('@webitel/api-services/gen', () => ({
+	getMemberService: () => ({
+		searchAttemptsHistory,
+	}),
+}));
+
+const { QueueLogsAPI } = await import('../queueLogs');
+
+const paramsSent = () => searchAttemptsHistory.mock.calls[0][0];
+
+describe('QueueLogsAPI.getList', () => {
+	beforeEach(() => {
+		searchAttemptsHistory.mockReset().mockResolvedValue({
+			data: {
+				items: [],
+				next: false,
+			},
+		});
+	});
+
+	/**
+	 * The range filters are protobuf nested messages, so they only bind as
+	 * `joined_at.from`. The generated params type calls them `joinedAtFrom`,
+	 * which the backend would ignore — the request would succeed and quietly
+	 * return unfiltered rows. That is how the duration filter was broken before
+	 * this migration, so it is worth pinning.
+	 *
+	 * Verified live: `joined_at`, `leaving_at` and `offering_at` all filter with
+	 * this shape. `duration` does not — the backend accepts and ignores it (see
+	 * the note in `queueLogs.ts`), so this pins the wire format only, not that
+	 * the duration filter actually works.
+	 */
+	it('sends range bounds as dotted keys', async () => {
+		await QueueLogsAPI.getList({
+			parentId: '7',
+			joinedAt: {
+				from: 100,
+				to: 200,
+			},
+			duration: {
+				from: 5,
+				to: 30,
+			},
+		});
+
+		expect(paramsSent()).toMatchObject({
+			'joined_at.from': 100,
+			'joined_at.to': 200,
+			'duration.from': 5,
+			'duration.to': 30,
+		});
+	});
+
+	it('does not send the flattened names the generated type declares', async () => {
+		await QueueLogsAPI.getList({
+			parentId: '7',
+			joinedAt: {
+				from: 100,
+				to: 200,
+			},
+		});
+
+		expect(paramsSent()).not.toHaveProperty('joinedAtFrom');
+		expect(paramsSent()).not.toHaveProperty('joinedAtTo');
+	});
+
+	it('maps the filter names onto the service params', async () => {
+		await QueueLogsAPI.getList({
+			parentId: '7',
+			bucket: [
+				1,
+			],
+			agent: [
+				2,
+			],
+			leavingAt: {
+				from: 10,
+				to: 20,
+			},
+			offeringAt: {
+				from: 30,
+				to: 40,
+			},
+		});
+
+		expect(paramsSent()).toMatchObject({
+			bucketId: [
+				1,
+			],
+			agentId: [
+				2,
+			],
+			'leaving_at.from': 10,
+			'leaving_at.to': 20,
+			'offering_at.from': 30,
+			'offering_at.to': 40,
+		});
+	});
+
+	it('scopes the query to its queue and maps search onto q', async () => {
+		await QueueLogsAPI.getList({
+			parentId: '7',
+			search: 'joe',
+		});
+
+		// `starToSearch` makes it a prefix search, as everywhere else
+		expect(paramsSent()).toMatchObject({
+			queueId: [
+				'7',
+			],
+			q: 'joe*',
+		});
+	});
+
+	it('sorts by join time unless told otherwise', async () => {
+		await QueueLogsAPI.getList({
+			parentId: '7',
+		});
+		expect(paramsSent().sort).toBe('+joined_at');
+
+		searchAttemptsHistory.mockClear();
+		await QueueLogsAPI.getList({
+			parentId: '7',
+			sort: '-duration',
+		});
+		expect(paramsSent().sort).toBe('-duration');
+	});
+});

package/src/api/clients/queues/__tests__/queueMembers.spec.ts

@@ -0,0 +1,175 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const searchMemberInQueue = vi.fn();
+const resetMembersCount = vi.fn();
+const resetMembers = vi.fn();
+
+vi.mock('@webitel/api-services/gen', () => ({
+	getMemberService: () => ({
+		searchMemberInQueue,
+		resetMembersCount,
+		resetMembers,
+	}),
+}));
+
+const { QueueMembersAPI } = await import('../queueMembers');
+
+describe('QueueMembersAPI.getList', () => {
+	beforeEach(() => {
+		searchMemberInQueue.mockReset().mockResolvedValue({
+			data: {
+				items: [],
+				next: false,
+			},
+		});
+	});
+
+	const paramsSent = () => searchMemberInQueue.mock.calls[0][1];
+
+	/**
+	 * `created_at` and `priority` are protobuf nested messages, so they only
+	 * bind as dotted keys. The generated params type calls them `createdAtFrom`
+	 * and `priorityFrom`, which the backend ignores — the request succeeds and
+	 * returns unfiltered rows.
+	 */
+	it('sends range bounds as dotted keys', async () => {
+		await QueueMembersAPI.getList({
+			parentId: '7',
+			createdAt: {
+				from: 100,
+				to: 200,
+			},
+			memberPriority: {
+				from: 1,
+				to: 9,
+			},
+		});
+
+		expect(paramsSent()).toMatchObject({
+			'created_at.from': 100,
+			'created_at.to': 200,
+			'priority.from': 1,
+			'priority.to': 9,
+		});
+		expect(paramsSent()).not.toHaveProperty('createdAtFrom');
+		expect(paramsSent()).not.toHaveProperty('priorityFrom');
+	});
+
+	it('passes the queue id positionally, as a number', async () => {
+		await QueueMembersAPI.getList({
+			parentId: '7',
+		});
+
+		expect(searchMemberInQueue.mock.calls[0][0]).toBe(7);
+	});
+
+	/** the datalist names differ from the service's, so the mapping is explicit */
+	it('maps the filter names onto the service params', async () => {
+		await QueueMembersAPI.getList({
+			parentId: '7',
+			search: 'joe',
+			bucket: [
+				1,
+			],
+			agent: [
+				2,
+			],
+			stopCause: [
+				'cancel',
+			],
+			offeringAt: {
+				from: 300,
+				to: 400,
+			},
+			attempts: {
+				from: 2,
+				to: 5,
+			},
+			name: 'alice',
+			destination: '380',
+		});
+
+		expect(paramsSent()).toMatchObject({
+			q: 'joe*',
+			bucketId: [
+				1,
+			],
+			agentId: [
+				2,
+			],
+			stopCause: [
+				'cancel',
+			],
+			'offering_at.from': 300,
+			'offering_at.to': 400,
+			'attempts.from': 2,
+			'attempts.to': 5,
+			name: 'alice',
+			destination: '380',
+		});
+	});
+
+	/** the pre-migration spellings still work, so both can coexist */
+	it('still accepts the legacy filter names', async () => {
+		await QueueMembersAPI.getList({
+			parentId: '7',
+			from: 100,
+			to: 200,
+			cause: [
+				'cancel',
+			],
+		});
+
+		expect(paramsSent()).toMatchObject({
+			'created_at.from': 100,
+			'created_at.to': 200,
+			stopCause: [
+				'cancel',
+			],
+		});
+	});
+});
+
+describe('QueueMembersAPI.getQuantity', () => {
+	beforeEach(() => {
+		resetMembersCount.mockReset().mockResolvedValue({
+			data: {
+				count: 12,
+			},
+		});
+	});
+
+	/** was a hand-built url; the generated call must keep the dotted keys */
+	it('counts through the service with dotted range keys', async () => {
+		const count = await QueueMembersAPI.getQuantity({
+			parentId: '7',
+			filters: {
+				createdAt: {
+					from: 100,
+					to: 200,
+				},
+			},
+		});
+
+		expect(count).toBe(12);
+		expect(resetMembersCount).toHaveBeenCalledWith(
+			'7',
+			expect.objectContaining({
+				'created_at.from': 100,
+				'created_at.to': 200,
+			}),
+		);
+	});
+
+	it('reports zero when the service returns no count', async () => {
+		resetMembersCount.mockResolvedValue({
+			data: {},
+		});
+
+		await expect(
+			QueueMembersAPI.getQuantity({
+				parentId: '7',
+			}),
+		).resolves.toBe(0);
+	});
+});

package/src/api/clients/queues/__tests__/queues.spec.ts

@@ -0,0 +1,130 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { QueueType } from '../../../../enums';
+
+const readQueue = vi.fn();
+const searchQueue = vi.fn();
+
+vi.mock('@webitel/api-services/gen', () => ({
+	getQueueService: () => ({
+		readQueue,
+		searchQueue,
+	}),
+}));
+
+const { QueuesAPI } = await import('../queues');
+
+/**
+ * proto3 omits zero values, so an OFFLINE_QUEUE (type `0`) arrives with no
+ * `type` key at all. Legacy restored it with a `defaultObject`; these tests
+ * pin that the restore survived the migration.
+ *
+ * The failure mode is silent and severe: without `type`, `getQueueDefaults`
+ * falls back to the type-agnostic base, the Params tab renders none of the
+ * offline-specific controls, and `queueSchema`'s `superRefine` skips the
+ * per-type branch — the form just quietly loses half its behaviour.
+ */
+describe('QueuesAPI.get, on a type-less (offline) response', () => {
+	beforeEach(() => {
+		readQueue.mockReset();
+	});
+
+	it('restores type 0 and seeds the offline defaults', async () => {
+		readQueue.mockResolvedValue({
+			data: {
+				id: 239,
+				name: 'offline',
+				payload: {},
+			},
+		});
+
+		const item = await QueuesAPI.get({
+			itemId: 239,
+		});
+
+		expect(item.type).toBe(QueueType.OFFLINE_QUEUE);
+		// seeded from offlineQueue(), not from the base defaults
+		expect(item.payload).toMatchObject({
+			maxAttempts: 3,
+			originateTimeout: 60,
+			minOnlineAgents: 0,
+		});
+		expect(item.taskProcessing).toBeDefined();
+	});
+
+	it('never overwrites a type the backend did send', async () => {
+		readQueue.mockResolvedValue({
+			data: {
+				id: 15,
+				type: QueueType.CHAT_INBOUND_QUEUE,
+				payload: {},
+			},
+		});
+
+		const item = await QueuesAPI.get({
+			itemId: 15,
+		});
+
+		expect(item.type).toBe(QueueType.CHAT_INBOUND_QUEUE);
+	});
+});
+
+describe('QueuesAPI.getList, on type-less rows', () => {
+	beforeEach(() => {
+		searchQueue.mockReset();
+	});
+
+	/**
+	 * The table renders `type`, `active` and `waiting` straight into cells, so
+	 * an omitted zero shows up as a blank column rather than "Offline queue"/0.
+	 */
+	it('restores the zero values the table renders', async () => {
+		searchQueue.mockResolvedValue({
+			data: {
+				items: [
+					{
+						id: 239,
+						name: 'offline',
+					},
+				],
+				next: false,
+			},
+		});
+
+		const { items } = await QueuesAPI.getList({});
+
+		expect(items[0]).toMatchObject({
+			type: QueueType.OFFLINE_QUEUE,
+			enabled: false,
+			active: 0,
+			waiting: 0,
+		});
+	});
+
+	it('leaves non-zero values alone', async () => {
+		searchQueue.mockResolvedValue({
+			data: {
+				items: [
+					{
+						id: 15,
+						type: QueueType.CHAT_INBOUND_QUEUE,
+						enabled: true,
+						active: 4,
+						priority: 1000,
+					},
+				],
+				next: false,
+			},
+		});
+
+		const { items } = await QueuesAPI.getList({});
+
+		expect(items[0]).toMatchObject({
+			type: QueueType.CHAT_INBOUND_QUEUE,
+			enabled: true,
+			active: 4,
+			priority: 1000,
+			waiting: 0,
+		});
+	});
+});

package/src/api/clients/queues/defaults/__tests__/queueTypeDefaults.spec.ts

@@ -0,0 +1,143 @@
+import { describe, expect, it } from 'vitest';
+
+import { QueueType } from '../../../../../enums';
+import { processing } from '../processing';
+import {
+	getQueueDefaults,
+	hasQueueTypeDefaults,
+	QueueTypeDefaults,
+} from '../queueTypeDefaults';
+
+const allQueueTypes = Object.values(QueueType);
+
+/** The two types whose legacy schema deliberately has no `taskProcessing`. */
+const typesWithoutTaskProcessing = [
+	QueueType.OUTBOUND_IVR_QUEUE,
+	QueueType.OUTBOUND_JOB_QUEUE,
+];
+
+/** The three types whose legacy schema carries `payload.amd`. */
+const typesWithAmd = [
+	QueueType.OUTBOUND_IVR_QUEUE,
+	QueueType.PROGRESSIVE_DIALER,
+	QueueType.PREDICTIVE_DIALER,
+];
+
+describe('queue type defaults', () => {
+	it('has a factory for every QueueType', () => {
+		for (const type of allQueueTypes) {
+			expect(QueueTypeDefaults[type], `missing factory for ${type}`).toBeTypeOf(
+				'function',
+			);
+		}
+		expect(Object.keys(QueueTypeDefaults)).toHaveLength(allQueueTypes.length);
+	});
+
+	it('stamps each factory with its own type', () => {
+		for (const type of allQueueTypes) {
+			expect(QueueTypeDefaults[type]().type).toBe(type);
+		}
+	});
+
+	/**
+	 * The legacy code used factories precisely so two queues never shared a
+	 * nested object. A plain object export would let edits on one new queue
+	 * leak into the next one opened.
+	 */
+	it('returns a fresh deep object on every call', () => {
+		for (const type of allQueueTypes) {
+			const a = QueueTypeDefaults[type]();
+			const b = QueueTypeDefaults[type]();
+
+			expect(a).not.toBe(b);
+			expect(a).toEqual(b);
+			expect(a.payload).not.toBe(b.payload);
+			expect(a.variables).not.toBe(b.variables);
+		}
+	});
+
+	it('keeps taskProcessing exactly where the legacy schema had it', () => {
+		for (const type of allQueueTypes) {
+			const defaults = QueueTypeDefaults[type]();
+
+			if (typesWithoutTaskProcessing.includes(type)) {
+				expect(defaults.taskProcessing, `${type}`).toBeUndefined();
+			} else {
+				expect(defaults.taskProcessing, `${type}`).toBeDefined();
+			}
+		}
+	});
+
+	it('keeps payload.amd exactly where the legacy schema had it', () => {
+		for (const type of allQueueTypes) {
+			const { payload } = QueueTypeDefaults[type]();
+
+			expect(Boolean(payload.amd), `${type}`).toBe(typesWithAmd.includes(type));
+		}
+	});
+
+	/**
+	 * Regression guard: api-services' `processing()` used to omit
+	 * `prolongationOptions`, which left the Processing tab's prolongation block
+	 * without Regle `$fields` — no required markers, no error text.
+	 */
+	it('seeds taskProcessing.prolongationOptions', () => {
+		expect(processing().prolongationOptions).toEqual({
+			enabled: false,
+			isTimeoutRetry: false,
+			prolongationTimeSec: 30,
+			repeatsNumber: 1,
+		});
+
+		const defaults = QueueTypeDefaults[QueueType.INBOUND_QUEUE]();
+
+		expect(defaults.taskProcessing).toMatchObject({
+			prolongationOptions: {
+				repeatsNumber: 1,
+			},
+		});
+	});
+
+	it('treats IM_CHAT_QUEUE as CHAT_INBOUND_QUEUE apart from the type', () => {
+		const chat = QueueTypeDefaults[QueueType.CHAT_INBOUND_QUEUE]();
+		const imChat = QueueTypeDefaults[QueueType.IM_CHAT_QUEUE]();
+
+		expect({
+			...imChat,
+			type: chat.type,
+		}).toEqual(chat);
+	});
+});
+
+describe('getQueueDefaults', () => {
+	it('resolves a numeric type', () => {
+		expect(getQueueDefaults(QueueType.PREVIEW_DIALER).type).toBe(
+			QueueType.PREVIEW_DIALER,
+		);
+	});
+
+	/** The card page reads `?type=` off the route, so it arrives as a string. */
+	it('resolves a stringified type from the route query', () => {
+		expect(getQueueDefaults(String(QueueType.PREDICTIVE_DIALER)).type).toBe(
+			QueueType.PREDICTIVE_DIALER,
+		);
+	});
+
+	it('falls back to the base queue shape for an unknown type', () => {
+		const defaults = getQueueDefaults(undefined);
+
+		expect(defaults.type).toBeUndefined();
+		expect(defaults).toMatchObject({
+			name: '',
+			priority: 0,
+			variables: [],
+		});
+	});
+
+	it('reports whether a type has defaults', () => {
+		expect(hasQueueTypeDefaults(QueueType.OFFLINE_QUEUE)).toBe(true);
+		expect(hasQueueTypeDefaults('4')).toBe(true);
+		expect(hasQueueTypeDefaults(42)).toBe(false);
+		expect(hasQueueTypeDefaults(undefined)).toBe(false);
+	});
+});

package/src/api/clients/queues/defaults/amd.ts

@@ -0,0 +1,17 @@
+export const amd = () => ({
+	enabled: false,
+	ai: false,
+	positive: [],
+	playback: {},
+	allowNotSure: false,
+	silenceNotSure: false,
+	maxWordLength: 5000,
+	maxNumberOfWords: 3,
+	betweenWordsSilence: 50,
+	minWordLength: 100,
+	totalAnalysisTime: 5000,
+	silenceThreshold: 256,
+	afterGreetingSilence: 800,
+	greeting: 1500,
+	initialSilence: 2500,
+});

package/src/api/clients/queues/defaults/defaultQueue.ts

@@ -0,0 +1,9 @@
+export const defaultQueue = () => ({
+	name: '',
+	description: '',
+	priority: 0,
+	tags: [],
+	dncList: {},
+	calendar: {},
+	variables: [],
+});

package/src/api/clients/queues/defaults/processing.ts

@@ -1,14 +1,18 @@
 import deepmerge from 'deepmerge';
 
-const processing = (processing = {}) =>
+export const processing = (overrides = {}) =>
 	deepmerge(
 		{
 			enabled: false,
 			formSchema: {},
 			sec: 30,
 			renewalSec: 15,
+			prolongationOptions: {
+				enabled: false,
+				isTimeoutRetry: false,
+				prolongationTimeSec: 30,
+				repeatsNumber: 1,
+			},
 		},
-		processing,
+		overrides,
 	);
-
-export default processing;