@webitel/api-services 26.8.8 → 26.8.9

package/package.json

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

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/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,9 +85,7 @@ const getQueueSkill = async ({ parentId, itemId: id }: NestedGetItemParams) => {
 		);
 		return applyTransform(response.data, [
 			snakeToCamel(),
-			merge({
-				enabled: false,
-			}),
+			merge(defaultObject),
 		]);
 	} catch (err) {
 		throw applyTransform(err, [

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

@@ -3,6 +3,11 @@ 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', () => {
@@ -24,4 +29,70 @@ describe('queueSkillSchema', () => {
 		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,10 +7,10 @@ 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(),
+	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),
 });