@webitel/api-services 26.8.45 → 26.8.47

package/package.json

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

package/src/api/clients/wtTypes/sysTypes/__tests__/sysTypes.spec.ts

@@ -0,0 +1,101 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const get = vi.fn();
+
+vi.mock('../../../../defaults', async (importOriginal) => ({
+	...(await importOriginal<Record<string, unknown>>()),
+	getDefaultInstance: () => ({
+		get,
+	}),
+}));
+
+const { SysTypesAPI } = await import('../sysTypes');
+
+describe('SysTypesAPI.getLookup', () => {
+	beforeEach(() => get.mockReset());
+
+	it('queries the path with search, paging, preselected ids and schema filters', async () => {
+		get.mockResolvedValue({
+			data: {
+				items: [],
+			},
+		});
+
+		await SysTypesAPI.getLookup({
+			path: '/dictionary/cities',
+			display: 'name',
+			primary: 'id',
+			filters: [
+				'country=ua',
+			],
+			search: 'kyi',
+			id: [
+				7,
+			],
+			page: 2,
+		});
+
+		const url = get.mock.calls[0][0] as string;
+		expect(url.startsWith('/dictionary/cities?')).toBe(true);
+		expect(url).toContain('q=kyi%2A');
+		expect(url).toContain('page=2');
+		expect(url).toContain('ids=7');
+		expect(url).toContain('fields=id');
+		expect(url.endsWith('&country=ua')).toBe(true);
+	});
+
+	it('maps records to options by primary and a display template', async () => {
+		get.mockResolvedValue({
+			data: {
+				data: [
+					{
+						code: 7,
+						name: 'Kyiv',
+						region: {
+							name: 'Kyiv oblast',
+						},
+					},
+				],
+				next: true,
+			},
+		});
+
+		const response = await SysTypesAPI.getLookup({
+			path: '/dictionary/cities',
+			display: '{name} ({region.name}, {missing})',
+			primary: 'code',
+		});
+
+		expect(response.next).toBe(true);
+		expect(response.items[0]).toMatchObject({
+			id: 7,
+			name: 'Kyiv (Kyiv oblast, {missing})',
+		});
+	});
+
+	it('reads a plain dot-path display from `items` responses', async () => {
+		get.mockResolvedValue({
+			data: {
+				items: [
+					{
+						id: 'a',
+						profile: {
+							title: 'Alpha',
+						},
+					},
+				],
+			},
+		});
+
+		const response = await SysTypesAPI.getLookup({
+			path: '/objects',
+			display: 'profile.title',
+			primary: 'id',
+		});
+
+		expect(response.items[0]).toMatchObject({
+			id: 'a',
+			name: 'Alpha',
+		});
+	});
+});

package/src/api/clients/wtTypes/sysTypes/sysTypes.ts

@@ -4,6 +4,7 @@ import {
 	getDefaultInstance,
 } from '../../../defaults';
 import {
+	addQueryParamsToUrl,
 	applyTransform,
 	camelToSnake,
 	generateUrl,
@@ -16,15 +17,60 @@ import type { ApiParams } from '../../_shared/types';
 
 const instance = getDefaultInstance();
 
+type SysTypeRecord = Record<string, unknown>;
+
+// `{path.to.field}` placeholders in a display template
+const displayPlaceholder = /\{([^}]+)\}/g;
+
+const readPath = (record: SysTypeRecord, path: string): unknown =>
+	path
+		.split('.')
+		.reduce<unknown>(
+			(value, key) => (value as SysTypeRecord | undefined)?.[key],
+			record,
+		);
+
+/**
+ * A display is either a plain (dot-)path to one field, or a template such as
+ * `{name} ({code})`; an unresolved placeholder is left as written.
+ */
+const displayName = (display: string, record: SysTypeRecord): unknown => {
+	if (!display.match(displayPlaceholder)) return readPath(record, display);
+	return display.replace(displayPlaceholder, (_, key: string) => {
+		const value = readPath(record, key);
+		return value === undefined || value === null ? `{${key}}` : String(value);
+	});
+};
+
+/** Maps records to select options: `id` from `primary`, `name` from `display`. */
+const toSelectOptions =
+	({ display, primary }: { display?: string; primary?: string }) =>
+	(records: SysTypeRecord[]) =>
+		records.map((record) => ({
+			...record,
+			...(primary && {
+				id: record[primary],
+			}),
+			...(display && {
+				name: displayName(display, record),
+			}),
+		}));
+
+/**
+ * Records of a system type at `path`, for lookups. `filters` are pre-built
+ * `key=value` query conditions (as form schemas store them) appended as-is.
+ */
 const getSysTypeRecordsList = async ({
 	path,
 	display,
 	primary,
+	filters = [],
 	...params
 }: {
 	path: string;
 	display: string;
 	primary: string;
+	filters?: string[];
 } & ApiParams) => {
 	const fieldsToSend = [
 		'page',
@@ -50,6 +96,7 @@ const getSysTypeRecordsList = async ({
 		sanitize(fieldsToSend),
 		camelToSnake(),
 		generateUrl(path),
+		addQueryParamsToUrl(filters),
 	]);
 	try {
 		const response = await instance.get(url);
@@ -60,8 +107,11 @@ const getSysTypeRecordsList = async ({
 		return {
 			// Some endpoints return data, some return items so we need to check for both of them
 			items:
-				applyTransform(data || items, [
-					// transformItemsForSelect({ display, primary }),
+				applyTransform(data || items || [], [
+					toSelectOptions({
+						display,
+						primary,
+					}),
 				]) ?? [],
 			next,
 		};

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

@@ -0,0 +1,67 @@
+import { getDefaultsFromZodSchema } from '@webitel/api-services/gen/utils';
+import { describe, expect, it } from 'vitest';
+
+import { agentSkillSchema } from '../agentSkill.validations';
+
+const filledSkill = {
+	id: '1',
+	name: 'English',
+};
+
+describe('agentSkillSchema', () => {
+	it('seeds a new skill with the defaults the form expects', () => {
+		expect(getDefaultsFromZodSchema(agentSkillSchema, {})).toMatchObject({
+			capacity: 10,
+			enabled: true,
+		});
+	});
+
+	it('keeps values already on the draft', () => {
+		expect(
+			getDefaultsFromZodSchema(agentSkillSchema, {
+				skill: filledSkill,
+				capacity: 42,
+				enabled: false,
+			}),
+		).toMatchObject({
+			skill: filledSkill,
+			capacity: 42,
+			enabled: false,
+		});
+	});
+
+	it('requires a skill', () => {
+		const result = agentSkillSchema.safeParse({
+			capacity: 10,
+		});
+
+		expect(result.success).toBe(false);
+		expect(result.error?.issues.map((issue) => issue.path.join('.'))).toContain(
+			'skill',
+		);
+	});
+
+	it('rejects capacity outside 0-100', () => {
+		const tooHigh = agentSkillSchema.safeParse({
+			skill: filledSkill,
+			capacity: 101,
+		});
+		const tooLow = agentSkillSchema.safeParse({
+			skill: filledSkill,
+			capacity: -1,
+		});
+
+		expect(tooHigh.success).toBe(false);
+		expect(tooLow.success).toBe(false);
+	});
+
+	it('accepts a valid skill', () => {
+		expect(
+			agentSkillSchema.safeParse({
+				skill: filledSkill,
+				capacity: 50,
+				enabled: true,
+			}).success,
+		).toBe(true);
+	});
+});

package/src/validations/agentSkill/agentSkill.validations.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+import { filledLookupSchema } from '../_shared/lookup.validations';
+
+export const agentSkillSchema = z.object({
+	skill: filledLookupSchema,
+	capacity: z.number().min(0).max(100).default(10),
+	enabled: z.boolean().default(true),
+});

package/src/validations/index.ts

@@ -5,6 +5,7 @@ export * from './_shared/lookup.validations';
 export * from './_shared/phoneNumber.validations';
 export * from './_shared/variablePair.validations';
 export * from './adjunctType/adjunctType.validations';
+export * from './agentSkill/agentSkill.validations';
 export * from './auditForm/auditForm.validations';
 export * from './bucket/bucket.validations';
 export * from './calendar/calendar.validations';