@webitel/api-services 26.8.76 → 26.8.78

package/package.json

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

@@ -0,0 +1,162 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const wireItem = {
+	id: '1',
+	name: 'FTE 1',
+	description: 'desc',
+	workday_hours: 9,
+	workdays_per_month: 20,
+	vacation: 24,
+	sick_leaves: 10,
+	days_off: 5,
+	pause_duration: 60,
+	pause_template: {
+		id: '7',
+		name: '30-15-15',
+	},
+	shift_template: {
+		id: '3',
+		name: 'Full time',
+	},
+	domain_id: '1',
+};
+
+const service = {
+	workingConditionServiceSearchWorkingCondition: vi.fn(() =>
+		Promise.resolve({
+			data: {
+				items: [
+					wireItem,
+				],
+				next: true,
+			},
+		}),
+	),
+	workingConditionServiceReadWorkingCondition: vi.fn(() =>
+		Promise.resolve({
+			data: {
+				item: wireItem,
+			},
+		}),
+	),
+	workingConditionServiceCreateWorkingCondition: vi.fn(() =>
+		Promise.resolve({
+			data: {
+				item: wireItem,
+			},
+		}),
+	),
+	workingConditionServiceUpdateWorkingCondition: vi.fn(() =>
+		Promise.resolve({
+			data: {
+				item: wireItem,
+			},
+		}),
+	),
+};
+
+vi.mock('../../../../gen-wire', async (importOriginal) => ({
+	...(await importOriginal<Record<string, unknown>>()),
+	getWorkingConditionService: () => service,
+}));
+
+const { WorkingConditionsAPI } = await import('../workingConditions');
+
+const formItem = {
+	id: '1',
+	name: 'FTE 1',
+	description: 'desc',
+	workdayHours: 9,
+	workdaysPerMonth: 20,
+	vacation: 24,
+	sickLeaves: 10,
+	daysOff: 5,
+	pauseDuration: 60,
+	pauseTemplate: {
+		id: '7',
+		name: '30-15-15',
+	},
+	shiftTemplate: null,
+	domainId: '1',
+	createdAt: '1',
+	_dirty: true,
+};
+
+describe('WorkingConditionsAPI', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('getList sends the search as `q`', async () => {
+		const { items, next } = await WorkingConditionsAPI.getList({
+			search: 'fte',
+			page: 2,
+			size: 10,
+		});
+
+		expect(
+			service.workingConditionServiceSearchWorkingCondition,
+		).toHaveBeenCalledWith(
+			expect.objectContaining({
+				q: 'fte*',
+				page: 2,
+				size: 10,
+			}),
+		);
+		expect(items[0].workdaysPerMonth).toBe(20);
+		expect(next).toBe(true);
+	});
+
+	it('get and update unwrap the `item` envelope', async () => {
+		const item = await WorkingConditionsAPI.get({
+			itemId: '1',
+		});
+		expect(item.pauseTemplate).toEqual(wireItem.pause_template);
+
+		const updated = await WorkingConditionsAPI.update({
+			itemId: '1',
+			itemInstance: formItem,
+		});
+		expect(updated.name).toBe('FTE 1');
+	});
+
+	it('add wraps the item and sends only the form fields', async () => {
+		await WorkingConditionsAPI.add({
+			itemInstance: formItem,
+		});
+
+		const [body] =
+			service.workingConditionServiceCreateWorkingCondition.mock.calls[0];
+		expect(body).toEqual({
+			item: {
+				name: 'FTE 1',
+				description: 'desc',
+				workday_hours: 9,
+				workdays_per_month: 20,
+				vacation: 24,
+				sick_leaves: 10,
+				days_off: 5,
+				pause_duration: 60,
+				pause_template: {
+					id: '7',
+					name: '30-15-15',
+				},
+				shift_template: null,
+			},
+		});
+	});
+
+	it('update sends the id separately and drops it from the item', async () => {
+		await WorkingConditionsAPI.update({
+			itemId: '1',
+			itemInstance: formItem,
+		});
+
+		const [id, body] =
+			service.workingConditionServiceUpdateWorkingCondition.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/workingConditions/workingConditions.ts

@@ -1,12 +1,18 @@
-import { getWorkingConditionService } from '../../../gen-wire';
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
+import { workingConditionSchema } from '@webitel/api-services/validations';
+import {
+	getWorkingConditionService,
+	WorkingConditionServiceSearchWorkingConditionQueryParams,
+} from '../../../gen-wire';
 import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
 import {
 	applyTransform,
 	camelToSnake,
 	merge,
 	notify,
-	sanitize,
+	sanitizeToWire,
 	snakeToCamel,
+	starToSearch,
 } from '../../transformers';
 import type {
 	AddItemParams,
@@ -16,53 +22,37 @@ import type {
 	UpdateItemParams,
 } from '../_shared/types';
 
-const fieldsToSend = [
-	'name',
-	'description',
-	'workdayHours',
-	'workdayPerMonth',
-	'pauseDuration',
-	'vacation',
-	'pauseTemplate',
-	'sickLeaves',
-	'shiftTemplate',
-	'daysOff',
-	'createdAt',
-	'createdBy',
-	'domainId',
-	'id',
-	'updatedAt',
-	'updatedBy',
-];
+const fieldsToSend = getShallowFieldsToSendFromZodSchema(
+	workingConditionSchema,
+);
 
 /**
- * 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) => ({
 	...response.item,
 });
 
 const getWorkingConditionsList = 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(
+				WorkingConditionServiceSearchWorkingConditionQueryParams,
+			),
+		),
+		camelToSnake(),
 	]);
 
 	try {
 		const response =
 			await getWorkingConditionService().workingConditionServiceSearchWorkingCondition(
-				{
-					page,
-					size,
-					q,
-					sort,
-					fields,
-				},
+				requestParams,
 			);
 		const { items, next } = applyTransform(response.data, [
 			snakeToCamel(),
@@ -98,16 +88,14 @@ const getWorkingCondition = async ({ itemId: id }: GetItemParams) => {
 
 const addWorkingCondition = async ({ itemInstance }: AddItemParams) => {
 	const item = applyTransform(itemInstance, [
-		sanitize(fieldsToSend),
+		sanitizeToWire(fieldsToSend),
 		camelToSnake(),
 	]);
 	try {
 		const response =
 			await getWorkingConditionService().workingConditionServiceCreateWorkingCondition(
 				{
-					item: {
-						...item,
-					},
+					item,
 				},
 			);
 		return applyTransform(response.data, [
@@ -126,7 +114,7 @@ const updateWorkingCondition = async ({
 	itemId: id,
 }: UpdateItemParams) => {
 	const item = applyTransform(itemInstance, [
-		sanitize(fieldsToSend),
+		sanitizeToWire(fieldsToSend),
 		camelToSnake(),
 	]);
 	try {
@@ -134,13 +122,12 @@ const updateWorkingCondition = async ({
 			await getWorkingConditionService().workingConditionServiceUpdateWorkingCondition(
 				String(id),
 				{
-					item: {
-						...item,
-					},
+					item,
 				},
 			);
 		return applyTransform(response.data, [
 			snakeToCamel(),
+			itemResponseHandler,
 		]);
 	} catch (err) {
 		throw applyTransform(err, [
@@ -163,9 +150,7 @@ const deleteWorkingCondition = async ({ id }: DeleteItemParams) => {
 	}
 };
 
-const getWorkingConditionsLookup = (
-	params: Parameters<typeof getWorkingConditionsList>[0],
-) =>
+const getWorkingConditionsLookup = (params: ApiParams) =>
 	getWorkingConditionsList({
 		...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';
@@ -61,3 +62,4 @@ export * from './types';
 export * from './user/user.validations';
 export * from './userToken/userToken.validations';
 export * from './variable/variable.validations';
+export * from './workingCondition/workingCondition.validations';