@webitel/api-services 26.8.75 → 26.8.76

package/package.json

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

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

@@ -49,6 +49,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/shiftTemplate/__tests__/shiftTemplate.validations.spec.ts

@@ -0,0 +1,146 @@
+import { getDefaultsFromZodSchema } from '@webitel/api-services/gen/utils';
+import { describe, expect, it } from 'vitest';
+
+import {
+	getDefaultShiftTemplateTime,
+	getShiftTemplateTimeRangeErrors,
+	shiftTemplateSchema,
+} from '../shiftTemplate.validations';
+
+const valid = {
+	name: 'Day',
+	times: [
+		{
+			start: 540,
+			end: 1200,
+		},
+	],
+};
+
+describe('shiftTemplateSchema', () => {
+	it('accepts a template with a name and a time range', () => {
+		expect(shiftTemplateSchema.safeParse(valid).success).toBe(true);
+	});
+
+	it('fills a new template with one 9:00–18:00 row', () => {
+		expect(getDefaultShiftTemplateTime()).toEqual({
+			start: 540,
+			end: 1080,
+		});
+		expect(getDefaultsFromZodSchema(shiftTemplateSchema, {})).toEqual(
+			expect.objectContaining({
+				times: [
+					getDefaultShiftTemplateTime(),
+				],
+			}),
+		);
+	});
+
+	it('accepts a new template once the name is filled', () => {
+		const defaults = getDefaultsFromZodSchema(
+			shiftTemplateSchema,
+			{},
+		) as object;
+
+		expect(
+			shiftTemplateSchema.safeParse({
+				...defaults,
+				name: 'Day',
+			}).success,
+		).toBe(true);
+	});
+
+	it('requires a name', () => {
+		expect(
+			shiftTemplateSchema.safeParse({
+				...valid,
+				name: '',
+			}).success,
+		).toBe(false);
+	});
+
+	it('rejects a name longer than 250 symbols', () => {
+		expect(
+			shiftTemplateSchema.safeParse({
+				...valid,
+				name: 'a'.repeat(251),
+			}).success,
+		).toBe(false);
+	});
+
+	it('requires at least one time range', () => {
+		expect(
+			shiftTemplateSchema.safeParse({
+				...valid,
+				times: [],
+			}).success,
+		).toBe(false);
+	});
+
+	it.each([
+		[
+			'end before start',
+			{
+				start: 600,
+				end: 540,
+			},
+		],
+		[
+			'zero duration',
+			{
+				start: 600,
+				end: 600,
+			},
+		],
+		[
+			'end out of the day',
+			{
+				start: 600,
+				end: 1440,
+			},
+		],
+		[
+			'empty start',
+			{
+				end: 600,
+			},
+		],
+	])('rejects a row with %s', (_, time) => {
+		expect(
+			shiftTemplateSchema.safeParse({
+				...valid,
+				times: [
+					time,
+				],
+			}).success,
+		).toBe(false);
+	});
+});
+
+describe('getShiftTemplateTimeRangeErrors', () => {
+	it('marks both ends of a row whose start is not before its end', () => {
+		expect(
+			getShiftTemplateTimeRangeErrors([
+				{
+					start: 540,
+					end: 1200,
+				},
+				{
+					start: 600,
+					end: 540,
+				},
+			]),
+		).toEqual([
+			{
+				index: 1,
+				prop: 'start',
+				key: 'timerangeStartLessThanEnd',
+			},
+			{
+				index: 1,
+				prop: 'end',
+				key: 'timerangeStartLessThanEnd',
+			},
+		]);
+	});
+});

package/src/validations/shiftTemplate/shiftTemplate.validations.ts

@@ -0,0 +1,38 @@
+import type { WfmShiftTemplate } from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+
+import {
+	getTimeRangeErrors,
+	type TimeRange,
+	timeRangeSchema,
+} from '../_shared/timeRange.validations';
+import type { ZodShape } from '../types';
+
+/**
+ * [Claude] each row is a part of the shift within a day: start < end, both in minutes
+ */
+const shiftTemplateTimesSchema = z.array(timeRangeSchema).min(1);
+
+/**
+ * [Claude] row errors for `useTimeRangesValidation`: regle marks a row as a plain field,
+ * so the custom range issues are read from the schema directly
+ */
+export const getShiftTemplateTimeRangeErrors = (items: unknown) =>
+	getTimeRangeErrors(shiftTemplateTimesSchema, items);
+
+/**
+ * [Claude] a new template row: 9:00–18:00, 9 hours (minutes of the day).
+ * Shared by the schema default and the form's "add row" action.
+ */
+export const getDefaultShiftTemplateTime = (): TimeRange => ({
+	start: 9 * 60,
+	end: 18 * 60,
+});
+
+export const shiftTemplateSchema = z.object<ZodShape<WfmShiftTemplate>>({
+	name: z.string().min(1).max(250).default(''),
+	description: z.string().optional().default(''),
+	times: shiftTemplateTimesSchema.default(() => [
+		getDefaultShiftTemplateTime(),
+	]),
+});