@webitel/api-services 26.8.75 → 26.8.77

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webitel/api-services",
-	"version": "26.8.75",
+	"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/api/clients/shiftTemplates/__tests__/shiftTemplates.spec.ts

@@ -0,0 +1,145 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const wireItem = {
+	id: '1',
+	name: 'Day',
+	description: 'desc',
+	times: [
+		{
+			start: 540,
+			end: 1200,
+		},
+	],
+	domain_id: '1',
+	created_at: '1',
+};
+
+const service = {
+	shiftTemplateServiceSearchShiftTemplate: vi.fn(() =>
+		Promise.resolve({
+			data: {
+				items: [
+					wireItem,
+				],
+				next: true,
+			},
+		}),
+	),
+	shiftTemplateServiceReadShiftTemplate: vi.fn(() =>
+		Promise.resolve({
+			data: {
+				item: wireItem,
+			},
+		}),
+	),
+	shiftTemplateServiceCreateShiftTemplate: vi.fn(() =>
+		Promise.resolve({
+			data: {
+				item: wireItem,
+			},
+		}),
+	),
+	shiftTemplateServiceUpdateShiftTemplate: vi.fn(() =>
+		Promise.resolve({
+			data: {
+				item: wireItem,
+			},
+		}),
+	),
+};
+
+vi.mock('../../../../gen-wire', async (importOriginal) => ({
+	...(await importOriginal<Record<string, unknown>>()),
+	getShiftTemplateService: () => service,
+}));
+
+const { ShiftTemplatesAPI } = await import('../shiftTemplates');
+
+const formItem = {
+	id: '1',
+	name: 'Day',
+	description: 'desc',
+	times: [
+		{
+			start: 540,
+			end: 1200,
+		},
+	],
+	domainId: '1',
+	createdAt: '1',
+	_dirty: true,
+};
+
+describe('ShiftTemplatesAPI', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('getList sends the search as `q`', async () => {
+		const { items, next } = await ShiftTemplatesAPI.getList({
+			search: 'day',
+			page: 2,
+			size: 10,
+		});
+
+		expect(
+			service.shiftTemplateServiceSearchShiftTemplate,
+		).toHaveBeenCalledWith(
+			expect.objectContaining({
+				q: 'day*',
+				page: 2,
+				size: 10,
+			}),
+		);
+		expect(items[0].name).toBe('Day');
+		expect(next).toBe(true);
+	});
+
+	it('get and update unwrap the `item` envelope', async () => {
+		const item = await ShiftTemplatesAPI.get({
+			itemId: '1',
+		});
+		expect(item.times).toEqual(wireItem.times);
+
+		const updated = await ShiftTemplatesAPI.update({
+			itemId: '1',
+			itemInstance: formItem,
+		});
+		expect(updated.name).toBe('Day');
+	});
+
+	it('add wraps the item and sends only the form fields', async () => {
+		await ShiftTemplatesAPI.add({
+			itemInstance: formItem,
+		});
+
+		const [body] =
+			service.shiftTemplateServiceCreateShiftTemplate.mock.calls[0];
+		expect(body).toEqual({
+			item: {
+				name: 'Day',
+				description: 'desc',
+				times: [
+					{
+						start: 540,
+						end: 1200,
+					},
+				],
+			},
+		});
+	});
+
+	it('update sends the id separately and drops it from the item', async () => {
+		await ShiftTemplatesAPI.update({
+			itemId: '1',
+			itemInstance: formItem,
+		});
+
+		const [id, body] =
+			service.shiftTemplateServiceUpdateShiftTemplate.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');
+	});
+});

package/src/api/clients/shiftTemplates/shiftTemplates.ts

@@ -1,12 +1,18 @@
-import { getShiftTemplateService } from '../../../gen-wire';
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
+import { shiftTemplateSchema } from '@webitel/api-services/validations';
+import {
+	getShiftTemplateService,
+	ShiftTemplateServiceSearchShiftTemplateQueryParams,
+} from '../../../gen-wire';
 import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
 import {
 	applyTransform,
 	camelToSnake,
 	merge,
 	notify,
-	sanitize,
+	sanitizeToWire,
 	snakeToCamel,
+	starToSearch,
 } from '../../transformers';
 import type {
 	AddItemParams,
@@ -16,48 +22,36 @@ import type {
 	UpdateItemParams,
 } from '../_shared/types';
 
-const fieldsToSend = [
-	'name',
-	'description',
-	'times',
-];
+const fieldsToSend = getShallowFieldsToSendFromZodSchema(shiftTemplateSchema);
 
 /**
- * WFM services wrap both request and response payloads in an `item` envelope.
+ * [Claude] WFM services wrap both request and response payloads in an `item` envelope.
  */
-const itemResponseHandler = (response: ApiParams) => {
-	const copy = {
-		...response.item,
-	};
-
-	copy.times = copy.times?.map((time: ApiParams) => ({
-		...time,
-		duration: time.end - time.start,
-	}));
-
-	return copy;
-};
+const itemResponseHandler = (response: ApiParams) => ({
+	...response.item,
+});
 
 const getShiftTemplatesList = 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(
+				ShiftTemplateServiceSearchShiftTemplateQueryParams,
+			),
+		),
+		camelToSnake(),
 	]);
 
 	try {
 		const response =
-			await getShiftTemplateService().shiftTemplateServiceSearchShiftTemplate({
-				q,
-				page,
-				size,
-				sort,
-				fields,
-			});
+			await getShiftTemplateService().shiftTemplateServiceSearchShiftTemplate(
+				requestParams,
+			);
 		const { items, next } = applyTransform(response.data, [
 			snakeToCamel(),
 			merge(getDefaultGetListResponse()),
@@ -92,15 +86,13 @@ const getShiftTemplate = async ({ itemId: id }: GetItemParams) => {
 
 const addShiftTemplate = async ({ itemInstance }: AddItemParams) => {
 	const item = applyTransform(itemInstance, [
-		sanitize(fieldsToSend),
+		sanitizeToWire(fieldsToSend),
 		camelToSnake(),
 	]);
 	try {
 		const response =
 			await getShiftTemplateService().shiftTemplateServiceCreateShiftTemplate({
-				item: {
-					...item,
-				},
+				item,
 			});
 		return applyTransform(response.data, [
 			snakeToCamel(),
@@ -118,7 +110,7 @@ const updateShiftTemplate = async ({
 	itemId: id,
 }: UpdateItemParams) => {
 	const item = applyTransform(itemInstance, [
-		sanitize(fieldsToSend),
+		sanitizeToWire(fieldsToSend),
 		camelToSnake(),
 	]);
 	try {
@@ -126,13 +118,12 @@ const updateShiftTemplate = async ({
 			await getShiftTemplateService().shiftTemplateServiceUpdateShiftTemplate(
 				String(id),
 				{
-					item: {
-						...item,
-					},
+					item,
 				},
 			);
 		return applyTransform(response.data, [
 			snakeToCamel(),
+			itemResponseHandler,
 		]);
 	} catch (err) {
 		throw applyTransform(err, [
@@ -155,9 +146,7 @@ const deleteShiftTemplate = async ({ id }: DeleteItemParams) => {
 	}
 };
 
-const getShiftTemplatesLookup = (
-	params: Parameters<typeof getShiftTemplatesList>[0],
-) =>
+const getShiftTemplatesLookup = (params: ApiParams) =>
 	getShiftTemplatesList({
 		...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';
@@ -49,6 +50,7 @@ export * from './resource/resource.validations';
 export * from './resourceDisplay/resourceDisplay.validations';
 export * from './resourceGroup/resourceGroup.validations';
 export * from './resourceInGroup/resourceInGroup.validations';
+export * from './shiftTemplate/shiftTemplate.validations';
 export * from './sla/sla.validations';
 export * from './slaCondition/slaCondition.validations';
 export * from './team/team.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);
+	});
+});