@webitel/api-services 26.8.7 → 26.8.9

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webitel/api-services",
-	"version": "26.8.7",
+	"version": "26.8.9",
 	"private": false,
 	"repository": {
 		"type": "git",

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

@@ -0,0 +1,84 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const readQueueHook = vi.fn();
+const readQueueSkill = vi.fn();
+
+vi.mock('../../../../gen-wire', () => ({
+	getQueueHookService: () => ({
+		readQueueHook,
+	}),
+	getQueueSkillService: () => ({
+		readQueueSkill,
+	}),
+}));
+
+const { QueueHooksAPI } = await import('../queueHooks');
+const { QueueSkillsAPI } = await import('../queueSkills');
+
+/**
+ * Protobuf omits `enabled` when it is false, so a disabled record reads back
+ * without the field. The card store seeds anything missing from the schema,
+ * where `enabled` defaults to `true` for newly added records — so `get` has to
+ * spell the false out, or an untouched save would re-enable the record.
+ */
+describe('reading a disabled queue hook / skill', () => {
+	beforeEach(() => {
+		readQueueHook.mockReset();
+		readQueueSkill.mockReset();
+	});
+
+	it('spells out enabled: false for a hook that omits it', async () => {
+		readQueueHook.mockResolvedValue({
+			data: {
+				id: 40,
+				event: 'bridged',
+			},
+		});
+
+		await expect(
+			QueueHooksAPI.get({
+				parentId: '208',
+				itemId: '40',
+			}),
+		).resolves.toMatchObject({
+			enabled: false,
+		});
+	});
+
+	it('spells out enabled: false for a skill that omits it', async () => {
+		readQueueSkill.mockResolvedValue({
+			data: {
+				id: 7,
+				lvl: 10,
+			},
+		});
+
+		await expect(
+			QueueSkillsAPI.get({
+				parentId: '208',
+				itemId: '7',
+			}),
+		).resolves.toMatchObject({
+			enabled: false,
+		});
+	});
+
+	it('keeps enabled: true as sent', async () => {
+		readQueueHook.mockResolvedValue({
+			data: {
+				id: 41,
+				event: 'missed',
+				enabled: true,
+			},
+		});
+
+		await expect(
+			QueueHooksAPI.get({
+				parentId: '208',
+				itemId: '41',
+			}),
+		).resolves.toMatchObject({
+			enabled: true,
+		});
+	});
+});

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

@@ -0,0 +1,75 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const searchQueueSkill = vi.fn();
+const readQueueSkill = vi.fn();
+
+vi.mock('../../../../gen-wire', () => ({
+	getQueueSkillService: () => ({
+		searchQueueSkill,
+		readQueueSkill,
+	}),
+}));
+
+const { QueueSkillsAPI } = await import('../queueSkills');
+
+/** live payload for a level-0 skill: `{id, skill, min_capacity: 0, max_capacity: 10}` */
+describe('QueueSkillsAPI reads a level-0 skill as level 0', () => {
+	beforeEach(() => {
+		searchQueueSkill.mockReset();
+		readQueueSkill.mockReset();
+	});
+
+	it('fills lvl in on get', async () => {
+		readQueueSkill.mockResolvedValue({
+			data: {
+				id: 339,
+				skill: {
+					id: '45',
+					name: 'Liza-test',
+				},
+				min_capacity: 0,
+				max_capacity: 10,
+			},
+		});
+
+		expect(
+			await QueueSkillsAPI.get({
+				parentId: '208',
+				itemId: '339',
+			}),
+		).toMatchObject({
+			id: 339,
+			lvl: 0,
+			minCapacity: 0,
+			maxCapacity: 10,
+		});
+	});
+
+	it('fills lvl in on every list row, without touching the rows that have one', async () => {
+		searchQueueSkill.mockResolvedValue({
+			data: {
+				items: [
+					{
+						id: 339,
+						max_capacity: 10,
+					},
+					{
+						id: 412,
+						lvl: 10,
+						max_capacity: 10,
+					},
+				],
+				next: false,
+			},
+		});
+
+		const { items } = await QueueSkillsAPI.getList({
+			parentId: '208',
+		});
+
+		expect(items.map((item: { lvl: number }) => item.lvl)).toEqual([
+			0,
+			10,
+		]);
+	});
+});

package/src/api/clients/queues/queueHooks.ts

@@ -77,6 +77,9 @@ const getQueueHook = async ({ parentId, itemId: id }: NestedGetItemParams) => {
 		);
 		return applyTransform(response.data, [
 			snakeToCamel(),
+			merge({
+				enabled: false,
+			}),
 		]);
 	} catch (err) {
 		throw applyTransform(err, [

package/src/api/clients/queues/queueSkills.ts

@@ -6,6 +6,7 @@ import {
 	applyTransform,
 	camelToSnake,
 	merge,
+	mergeEach,
 	notify,
 	sanitizeToWire,
 	snakeToCamel,
@@ -32,6 +33,12 @@ const preRequestHandler = (parentId: ApiId) => (item: ApiParams) => ({
 	queueId: parentId,
 });
 
+/** the wire drops a field at its proto3 default: `enabled` when false, `lvl` when 0 */
+const defaultObject = {
+	enabled: false,
+	lvl: 0,
+};
+
 const getQueueSkillsList = async (params: ApiParams) => {
 	const { page, size, search, sort, fields, id, parentId, skillId } =
 		applyTransform(params, [
@@ -58,7 +65,9 @@ const getQueueSkillsList = async (params: ApiParams) => {
 			merge(getDefaultGetListResponse()),
 		]);
 		return {
-			items,
+			items: applyTransform(items, [
+				mergeEach(defaultObject),
+			]),
 			next,
 		};
 	} catch (err) {
@@ -76,6 +85,7 @@ const getQueueSkill = async ({ parentId, itemId: id }: NestedGetItemParams) => {
 		);
 		return applyTransform(response.data, [
 			snakeToCamel(),
+			merge(defaultObject),
 		]);
 	} catch (err) {
 		throw applyTransform(err, [

package/src/validations/queueHook/__tests__/queueHook.validations.spec.ts

@@ -0,0 +1,31 @@
+import { getDefaultsFromZodSchema } from '@webitel/api-services/gen/utils';
+import { describe, expect, it } from 'vitest';
+
+import { queueHookSchema } from '../queueHook.validations';
+
+describe('queueHookSchema', () => {
+	/**
+	 * The card store seeds a new item from the schema defaults, so a hook added
+	 * from the queue card must come out enabled — as it did before the pinia
+	 * migration replaced the vuex `resettableItemState`.
+	 */
+	it('defaults a new hook to enabled', () => {
+		expect(getDefaultsFromZodSchema(queueHookSchema, {})).toMatchObject({
+			enabled: true,
+		});
+	});
+
+	it('keeps a disabled hook disabled', () => {
+		const result = queueHookSchema.safeParse({
+			event: 'joined',
+			schema: {
+				id: '1',
+				name: 'flow',
+			},
+			enabled: false,
+		});
+
+		expect(result.success).toBe(true);
+		expect(result.data?.enabled).toBe(false);
+	});
+});

package/src/validations/queueHook/queueHook.validations.ts

@@ -6,5 +6,5 @@ export const queueHookSchema = z.object({
 	event: z.string().min(1),
 	schema: filledLookupSchema,
 	properties: z.array(z.string()).optional(),
-	enabled: z.boolean().optional(),
+	enabled: z.boolean().default(true),
 });

package/src/validations/queueSkill/__tests__/queueSkill.validations.spec.ts

@@ -0,0 +1,98 @@
+import { getDefaultsFromZodSchema } from '@webitel/api-services/gen/utils';
+import { describe, expect, it } from 'vitest';
+
+import { queueSkillSchema } from '../queueSkill.validations';
+
+const filledSkill = {
+	id: '1',
+	name: 'English',
+};
+
+describe('queueSkillSchema', () => {
+	/** see the hook schema spec — same pre-migration default */
+	it('defaults a new skill to enabled', () => {
+		expect(getDefaultsFromZodSchema(queueSkillSchema, {})).toMatchObject({
+			enabled: true,
+		});
+	});
+
+	it('keeps a disabled skill disabled', () => {
+		const result = queueSkillSchema.safeParse({
+			skill: {
+				id: '1',
+				name: 'skill',
+			},
+			lvl: 1,
+			enabled: false,
+		});
+
+		expect(result.success).toBe(true);
+		expect(result.data?.enabled).toBe(false);
+	});
+
+	/** `skill` stays empty, and its error must not swallow the other defaults */
+	it('seeds a new skill with the defaults the form expects', () => {
+		expect(getDefaultsFromZodSchema(queueSkillSchema, {})).toMatchObject({
+			lvl: 0,
+			minCapacity: 0,
+			maxCapacity: 10,
+			buckets: [],
+		});
+	});
+
+	it('keeps values already on the draft', () => {
+		expect(
+			getDefaultsFromZodSchema(queueSkillSchema, {
+				skill: filledSkill,
+				lvl: 5,
+				minCapacity: 2,
+				maxCapacity: 8,
+			}),
+		).toMatchObject({
+			skill: filledSkill,
+			lvl: 5,
+			minCapacity: 2,
+			maxCapacity: 8,
+			buckets: [],
+		});
+	});
+
+	it('requires a skill', () => {
+		const result = queueSkillSchema.safeParse({
+			lvl: 0,
+			minCapacity: 0,
+			maxCapacity: 10,
+		});
+
+		expect(result.success).toBe(false);
+		expect(result.error?.issues.map((issue) => issue.path.join('.'))).toContain(
+			'skill',
+		);
+	});
+
+	it('reports both sides when minCapacity exceeds maxCapacity', () => {
+		const result = queueSkillSchema.safeParse({
+			skill: filledSkill,
+			lvl: 0,
+			minCapacity: 10,
+			maxCapacity: 5,
+		});
+
+		expect(result.success).toBe(false);
+		expect(result.error?.issues.map((issue) => issue.path.join('.'))).toEqual([
+			'minCapacity',
+			'maxCapacity',
+		]);
+	});
+
+	it('accepts the defaults as a valid pair', () => {
+		expect(
+			queueSkillSchema.safeParse({
+				skill: filledSkill,
+				lvl: 0,
+				minCapacity: 0,
+				maxCapacity: 10,
+			}).success,
+		).toBe(true);
+	});
+});

package/src/validations/queueSkill/queueSkill.validations.ts

@@ -7,11 +7,11 @@ import {
 
 export const queueSkillSchemaBase = z.object({
 	skill: filledLookupSchema,
-	lvl: z.number().min(0).max(1000),
-	minCapacity: z.number().min(0).max(100).optional(),
-	maxCapacity: z.number().min(0).max(100).optional(),
-	buckets: z.array(flexibleLookupSchema).optional(),
-	enabled: z.boolean().optional(),
+	lvl: z.number().min(0).max(1000).default(0),
+	minCapacity: z.number().min(0).max(100).optional().default(0),
+	maxCapacity: z.number().min(0).max(100).optional().default(10),
+	buckets: z.array(flexibleLookupSchema).optional().default([]),
+	enabled: z.boolean().default(true),
 });
 
 /**