@webitel/api-services 26.8.76 → 26.8.77

package/package.json

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

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

@@ -0,0 +1,144 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const wireItem = {
+	id: '1',
+	name: 'lunch',
+	description: 'desc',
+	causes: [
+		{
+			cause: {
+				id: '7',
+				name: 'Coffee',
+			},
+			duration: '15',
+		},
+	],
+	domain_id: '1',
+};
+
+const service = {
+	pauseTemplateServiceSearchPauseTemplate: vi.fn(() =>
+		Promise.resolve({
+			data: {
+				items: [
+					wireItem,
+				],
+				next: true,
+			},
+		}),
+	),
+	pauseTemplateServiceReadPauseTemplate: vi.fn(() =>
+		Promise.resolve({
+			data: {
+				item: wireItem,
+			},
+		}),
+	),
+	pauseTemplateServiceCreatePauseTemplate: vi.fn(() =>
+		Promise.resolve({
+			data: {
+				item: wireItem,
+			},
+		}),
+	),
+	pauseTemplateServiceUpdatePauseTemplate: vi.fn(() =>
+		Promise.resolve({
+			data: {
+				item: wireItem,
+			},
+		}),
+	),
+};
+
+vi.mock('../../../../gen-wire', async (importOriginal) => ({
+	...(await importOriginal<Record<string, unknown>>()),
+	getPauseTemplateService: () => service,
+}));
+
+const { PauseTemplatesAPI } = await import('../pauseTemplates');
+
+const formItem = {
+	id: '1',
+	name: 'lunch',
+	description: 'desc',
+	causes: [
+		{
+			cause: {
+				id: '7',
+				name: 'Coffee',
+			},
+			duration: 15,
+		},
+		{
+			duration: 30,
+		},
+	],
+	domainId: '1',
+	_dirty: true,
+};
+
+describe('PauseTemplatesAPI', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('getList sends the search as `q`', async () => {
+		const { items, next } = await PauseTemplatesAPI.getList({
+			search: 'lun',
+			page: 2,
+			size: 10,
+		});
+
+		expect(
+			service.pauseTemplateServiceSearchPauseTemplate,
+		).toHaveBeenCalledWith(
+			expect.objectContaining({
+				q: 'lun*',
+				page: 2,
+				size: 10,
+			}),
+		);
+		expect(items[0].domainId).toBe('1');
+		expect(next).toBe(true);
+	});
+
+	it('get unwraps the `item` envelope and keeps causes nested', async () => {
+		const item = await PauseTemplatesAPI.get({
+			itemId: '1',
+		});
+
+		expect(item.name).toBe('lunch');
+		expect(item.causes).toEqual(wireItem.causes);
+	});
+
+	it('add wraps the item and sends only the form fields', async () => {
+		await PauseTemplatesAPI.add({
+			itemInstance: formItem,
+		});
+
+		const [body] =
+			service.pauseTemplateServiceCreatePauseTemplate.mock.calls[0];
+		expect(body).toEqual({
+			item: {
+				name: 'lunch',
+				description: 'desc',
+				causes: formItem.causes,
+			},
+		});
+	});
+
+	it('update sends the id separately and drops it from the item', async () => {
+		await PauseTemplatesAPI.update({
+			itemId: '1',
+			itemInstance: formItem,
+		});
+
+		const [id, body] =
+			service.pauseTemplateServiceUpdatePauseTemplate.mock.calls[0];
+		expect(id).toBe('1');
+		expect(body.item).not.toHaveProperty('id');
+		expect(body.item).not.toHaveProperty('domain_id');
+		expect(body.item).not.toHaveProperty('_dirty');
+		expect(body.item.causes).toEqual(formItem.causes);
+	});
+});

package/src/api/clients/pauseTemplates/pauseTemplates.ts

@@ -1,13 +1,18 @@
-import deepCopy from 'deep-copy';
-import { getPauseTemplateService } from '../../../gen-wire';
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
+import { pauseTemplateSchema } from '@webitel/api-services/validations';
+import {
+	getPauseTemplateService,
+	PauseTemplateServiceSearchPauseTemplateQueryParams,
+} from '../../../gen-wire';
 import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
 import {
 	applyTransform,
 	camelToSnake,
 	merge,
 	notify,
-	sanitize,
+	sanitizeToWire,
 	snakeToCamel,
+	starToSearch,
 } from '../../transformers';
 import type {
 	AddItemParams,
@@ -17,71 +22,36 @@ import type {
 	UpdateItemParams,
 } from '../_shared/types';
 
-const fieldsToSend = [
-	'name',
-	'description',
-	'causes',
-	'domainId',
-	'createdAt',
-	'createdBy',
-	'updatedAt',
-	'updatedBy',
-];
+const fieldsToSend = getShallowFieldsToSendFromZodSchema(pauseTemplateSchema);
 
 /**
- * WFM services wrap both request and response payloads in an `item` envelope,
- * and nest each pause cause under a `cause` key. The form binds a flat
- * `{ id, name, duration }`.
+ * [Claude] WFM services wrap both request and response payloads in an `item` envelope.
  */
-const itemResponseHandler = (response: ApiParams) => {
-	const item = {
-		...response.item,
-	};
-
-	item.causes = item.causes?.map((cause: ApiParams) => ({
-		id: cause.cause?.id,
-		name: cause.cause?.name,
-		duration: cause?.duration,
-	}));
-
-	return item;
-};
-
-const preRequestHandler = (item: ApiParams) => {
-	const copy = deepCopy(item);
-	copy.causes = copy.causes.map((cause: ApiParams) => {
-		if (!cause.name && !cause.id) return cause;
-		return {
-			cause: {
-				id: cause?.id,
-				name: cause?.name,
-			},
-			duration: cause.duration,
-		};
-	});
-	return copy;
-};
+const itemResponseHandler = (response: ApiParams) => ({
+	...response.item,
+});
 
 const getPauseTemplatesList = async (params: ApiParams) => {
-	const {
-		search: q,
-		page,
-		size,
-		sort,
-		fields,
-	} = applyTransform(params, [
+	const requestParams = applyTransform(params, [
 		merge(getDefaultGetParams()),
+		starToSearch('search'),
+		(params: ApiParams) => ({
+			...params,
+			q: params.q ?? params.search,
+		}),
+		sanitizeToWire(
+			getShallowFieldsToSendFromZodSchema(
+				PauseTemplateServiceSearchPauseTemplateQueryParams,
+			),
+		),
+		camelToSnake(),
 	]);
 
 	try {
 		const response =
-			await getPauseTemplateService().pauseTemplateServiceSearchPauseTemplate({
-				q,
-				page,
-				size,
-				sort,
-				fields,
-			});
+			await getPauseTemplateService().pauseTemplateServiceSearchPauseTemplate(
+				requestParams,
+			);
 		const { items, next } = applyTransform(response.data, [
 			snakeToCamel(),
 			merge(getDefaultGetListResponse()),
@@ -116,16 +86,13 @@ const getPauseTemplate = async ({ itemId: id }: GetItemParams) => {
 
 const addPauseTemplate = async ({ itemInstance }: AddItemParams) => {
 	const item = applyTransform(itemInstance, [
-		sanitize(fieldsToSend),
+		sanitizeToWire(fieldsToSend),
 		camelToSnake(),
-		preRequestHandler,
 	]);
 	try {
 		const response =
 			await getPauseTemplateService().pauseTemplateServiceCreatePauseTemplate({
-				item: {
-					...item,
-				},
+				item,
 			});
 		return applyTransform(response.data, [
 			snakeToCamel(),
@@ -143,18 +110,15 @@ const updatePauseTemplate = async ({
 	itemId: id,
 }: UpdateItemParams) => {
 	const item = applyTransform(itemInstance, [
-		sanitize(fieldsToSend),
+		sanitizeToWire(fieldsToSend),
 		camelToSnake(),
-		preRequestHandler,
 	]);
 	try {
 		const response =
 			await getPauseTemplateService().pauseTemplateServiceUpdatePauseTemplate(
 				String(id),
 				{
-					item: {
-						...item,
-					},
+					item,
 				},
 			);
 		return applyTransform(response.data, [
@@ -182,9 +146,7 @@ const deletePauseTemplate = async ({ id }: DeleteItemParams) => {
 	}
 };
 
-const getPauseTemplatesLookup = (
-	params: Parameters<typeof getPauseTemplatesList>[0],
-) =>
+const getPauseTemplatesLookup = (params: ApiParams) =>
 	getPauseTemplatesList({
 		...params,
 		fields: params.fields || [

package/src/validations/index.ts

@@ -34,6 +34,7 @@ export * from './device/device.validations';
 export * from './license/licenseImport.validations';
 export * from './OAuth/OAuth.validations';
 export * from './onlineSkill/onlineSkill.validations';
+export * from './pauseTemplate/pauseTemplate.validations';
 export * from './queue/queue.rules';
 export * from './queue/queue.validations';
 export * from './queue/queueAmd.validations';

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

@@ -0,0 +1,85 @@
+import { describe, expect, it } from 'vitest';
+
+import { pauseTemplateSchema } from '../pauseTemplate.validations';
+
+describe('pauseTemplateSchema', () => {
+	it('fills a new template with one 30 min row and no cause', () => {
+		expect(pauseTemplateSchema.parse({}).causes).toEqual([
+			{
+				duration: 30,
+			},
+		]);
+	});
+
+	it('accepts a row without a pause cause', () => {
+		const result = pauseTemplateSchema.safeParse({
+			name: 'lunch',
+			causes: [
+				{
+					duration: 15,
+				},
+			],
+		});
+		expect(result.success).toBe(true);
+	});
+
+	it('rejects an empty name', () => {
+		expect(
+			pauseTemplateSchema.safeParse({
+				name: '',
+			}).success,
+		).toBe(false);
+	});
+
+	it('rejects a name longer than 250 symbols', () => {
+		expect(
+			pauseTemplateSchema.safeParse({
+				name: 'a'.repeat(251),
+			}).success,
+		).toBe(false);
+	});
+
+	it('rejects a template without rows', () => {
+		expect(
+			pauseTemplateSchema.safeParse({
+				name: 'lunch',
+				causes: [],
+			}).success,
+		).toBe(false);
+	});
+
+	it('accepts a duration the API returns as a string', () => {
+		expect(
+			pauseTemplateSchema.safeParse({
+				name: 'lunch',
+				causes: [
+					{
+						cause: null,
+						duration: '15',
+					},
+				],
+			}).success,
+		).toBe(true);
+	});
+
+	it.each([
+		0,
+		'0',
+		null,
+	])('rejects a row duration of %j', (duration) => {
+		expect(
+			pauseTemplateSchema.safeParse({
+				name: 'lunch',
+				causes: [
+					{
+						cause: {
+							id: '1',
+							name: 'Coffee',
+						},
+						duration,
+					},
+				],
+			}).success,
+		).toBe(false);
+	});
+});

package/src/validations/pauseTemplate/pauseTemplate.validations.ts

@@ -0,0 +1,51 @@
+import type {
+	WfmPauseTemplate,
+	WfmPauseTemplateCause,
+} from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+
+import { flexibleLookupSchema } from '../_shared/lookup.validations';
+import type { ZodShape } from '../types';
+
+/**
+ * [Claude] the API returns the duration (minutes) as an int64 string. An emptied
+ * field becomes `undefined` (not `NaN` as with `z.coerce`), so the form shows
+ * "required" instead of zod's raw "expected number, received NaN".
+ */
+const durationMinutesSchema = z.preprocess(
+	(value) =>
+		value === '' || value === null || value === undefined
+			? undefined
+			: Number(value),
+	z.number().int().min(1),
+);
+
+/**
+ * [Claude] the pause cause is optional ("Not selected"), the duration is not.
+ */
+export const pauseTemplateCauseSchema = z.object({
+	cause: flexibleLookupSchema.nullish(),
+	duration: durationMinutesSchema,
+});
+
+/**
+ * [Claude] a new template row: no pause cause ("Not selected"), 30 minutes.
+ * Shared by the schema default and the form's "add row" action.
+ */
+export const getDefaultPauseTemplateCause = (): WfmPauseTemplateCause & {
+	duration: string;
+} => ({
+	duration: '30',
+});
+
+export const pauseTemplateSchema = z.object<ZodShape<WfmPauseTemplate>>({
+	name: z.string().min(1).max(250).default(''),
+	description: z.string().optional().default(''),
+	causes: z
+		.array(pauseTemplateCauseSchema)
+		.min(1)
+		// [Claude] `.prefault`, not `.default`: the API-shaped row (duration as a string) goes through the schema
+		.prefault(() => [
+			getDefaultPauseTemplateCause(),
+		]),
+});