@webitel/api-services 1.0.6 → 1.0.8

package/src/api/clients//321/201ontacts/contacts.ts

@@ -1,17 +1,16 @@
-import deepCopy from 'deep-copy';
-import { ContactsApiFactory } from 'webitel-sdk';
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
 import {
-	getDefaultGetListResponse,
-	getDefaultGetParams,
-	getDefaultInstance,
-	getDefaultOpenAPIConfig,
-} from '../../defaults';
+	CreateContactBody,
+	getContacts,
+	SearchContactsQueryParams,
+	UpdateContactBody,
+} from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
 import {
 	applyTransform,
-	camelToSnake,
 	merge,
 	notify,
-	sanitize,
+	sanitizeToWire,
 	snakeToCamel,
 } from '../../transformers';
 import { generatePermissionsApi } from '../_shared/generatePermissionsApi';
@@ -23,37 +22,13 @@ import type {
 } from '../_shared/types';
 import { ContactsSearchMode } from './enums/ContactsSearchMode';
 
-const instance = getDefaultInstance();
-const configuration = getDefaultOpenAPIConfig();
-
-const contactService = ContactsApiFactory(configuration, '', instance);
-
 const baseUrl = '/contacts';
 
-const formatAccessMode = (item: ApiParams) => ({
-	...item,
-	access: {
-		edit: item.mode.includes('w'),
-		delete: item.mode.includes('d'),
-	},
-});
+const searchFieldsToSend = getShallowFieldsToSendFromZodSchema(
+	SearchContactsQueryParams,
+);
 
 const getList = async (params: ApiParams) => {
-	const fieldsToSend = [
-		'page',
-		'size',
-		'q',
-		'sort',
-		'fields',
-		'id',
-		'qin',
-		'notIdGroup',
-		'group',
-		'owner',
-		'label',
-		'user',
-	];
-
 	if (!params.fields) {
 		params.fields = [
 			'id',
@@ -70,44 +45,7 @@ const getList = async (params: ApiParams) => {
 		];
 	}
 
-	const listResponseHandler = (items: ApiParams[]) =>
-		items?.map((item) => ({
-			...item,
-			name: item.name.commonName,
-			managers: item.managers
-				? [
-						...item.managers.data,
-					]
-				: [],
-			labels: item.labels
-				? [
-						...item.labels.data,
-					]
-				: [],
-			groups: getGroupsFromResponse(item),
-			variables: item.variables
-				? [
-						...item.variables.data,
-					]
-				: [],
-			timezones: item.timezones
-				? [
-						...item.timezones.data,
-					]
-				: [],
-			phones: item.phones
-				? [
-						...item.phones.data,
-					]
-				: [],
-			emails: item.emails
-				? [
-						...item.emails.data,
-					]
-				: [],
-		}));
-
-	let changedParams: Record<string, unknown> = {};
+	let changedParams: ApiParams;
 
 	if (params?.search) {
 		changedParams = {
@@ -139,34 +77,29 @@ const getList = async (params: ApiParams) => {
 			searchKey = 'emails,phones,imclients{user{name}}';
 		}
 
-		// This code needed for adding starToSearch method to applyTransform while searchKey !== SearchMode.VARIABLES because '*' in variables search mode brokes backend logic.
-		// if (searchKey !== ContactsSearchMode.VARIABLES) {
-		//   transformations.push(starToSearch('q')); WTEL-4265
-		// }
-
 		changedParams = {
 			...params,
 			q: searchValue || '',
 			qin: searchKey || '',
 		};
-	}
 
-	if (params.hasUser != null) {
-		changedParams.user = params.hasUser;
-	}
+		if (params.hasUser != null) {
+			changedParams.user = params.hasUser;
+		}
 
-	if (params.contactGroup) {
-		changedParams.group = [
-			...params.contactGroup.list,
-		];
-	}
-	if (params.contactLabel) {
-		changedParams.label = params.contactLabel.map(
-			(item: ApiParams) => item.label,
-		);
-	}
-	if (params.contactOwner) {
-		changedParams.owner = params.contactOwner;
+		if (params.contactGroup) {
+			changedParams.group = [
+				...params.contactGroup.list,
+			];
+		}
+		if (params.contactLabel) {
+			changedParams.label = params.contactLabel.map(
+				(item: ApiParams) => item.label,
+			);
+		}
+		if (params.contactOwner) {
+			changedParams.owner = params.contactOwner;
+		}
 	}
 
 	if (params.parentId) {
@@ -175,47 +108,30 @@ const getList = async (params: ApiParams) => {
 		];
 	}
 
-	const transformations = [
-		sanitize(fieldsToSend),
+	// `notIdGroup`/`qin`/`group`/`owner`/`label`/`user` are the field names the
+	// generated `SearchContactsParams` type declares for this endpoint — unlike
+	// the old `ContactsApiFactory`-based client, no camelCase->snake_case
+	// conversion is applied on the way out here.
+	const searchParams = applyTransform(changedParams, [
+		sanitizeToWire(searchFieldsToSend),
 		merge(getDefaultGetParams()),
-		camelToSnake(),
-	];
-
-	const {
-		page,
-		size,
-		q,
-		sort,
-		fields,
-		id,
-		qin,
-		mode,
-		group,
-		not_id_group,
-		owner,
-		label,
-		user,
-	} = applyTransform(changedParams, transformations);
+	]);
 
 	try {
-		const response = await contactService.searchContacts(
-			page,
-			size,
-			q,
-			sort || '+name',
-			[
+		const response = await getContacts().searchContacts({
+			...searchParams,
+			sort: searchParams.sort
+				? [
+						searchParams.sort,
+					]
+				: [
+						'+name',
+					],
+			fields: [
 				'mode',
-				...fields,
+				...(searchParams.fields || []),
 			],
-			id,
-			qin,
-			mode,
-			not_id_group,
-			group,
-			owner,
-			label,
-			user,
-		);
+		});
 
 		const { items, next } = applyTransform(
 			{
@@ -231,10 +147,7 @@ const getList = async (params: ApiParams) => {
 		);
 
 		return {
-			items: applyTransform(items, [
-				(items: ApiParams[]) => items?.map((item) => formatAccessMode(item)),
-				listResponseHandler,
-			]),
+			items,
 			next,
 		};
 	} catch (err) {
@@ -244,71 +157,32 @@ const getList = async (params: ApiParams) => {
 	}
 };
 
-const get = async ({ itemId: id }: GetItemParams) => {
-	const fields = [
-		'name',
-		'about',
-		'labels',
-		'groups',
-		'etag',
-		'mode',
-		'managers',
-		'timezones',
-		'variables',
-		'phones',
-		'emails',
-		'imclients',
-		'user',
-		'custom',
-	];
+const contactFieldsToSend = [
+	'name',
+	'about',
+	'labels',
+	'groups',
+	'etag',
+	'mode',
+	'managers',
+	'timezones',
+	'variables',
+	'phones',
+	'emails',
+	'imclients',
+	'user',
+	'custom',
+];
 
-	const defaultObject = {};
-	const itemResponseHandler = (item: ApiParams) => {
-		return {
-			...item,
-			name: item.name.commonName,
-			labels: item.labels
-				? [
-						...item.labels.data,
-					]
-				: [],
-			groups: getGroupsFromResponse(item),
-			managers: item.managers
-				? [
-						...item.managers.data,
-					]
-				: [],
-			timezones: item.timezones
-				? [
-						...item.timezones.data,
-					]
-				: [],
-			variables: item.variables
-				? [
-						...item.variables.data,
-					]
-				: [],
-			phones: item.phones
-				? [
-						...item.phones.data,
-					]
-				: [],
-			emails: item.emails
-				? [
-						...item.emails.data,
-					]
-				: [],
-		};
-	};
+const get = async ({ itemId: id }: GetItemParams) => {
 	try {
-		const response = await contactService.locateContact(String(id), fields);
+		const response = await getContacts().locateContact(String(id), {
+			fields: contactFieldsToSend,
+		});
 		return applyTransform(response.data, [
 			snakeToCamel([
 				'custom',
 			]),
-			merge(defaultObject),
-			itemResponseHandler,
-			formatAccessMode,
 		]);
 	} catch (err) {
 		throw applyTransform(err, [
@@ -317,16 +191,15 @@ const get = async ({ itemId: id }: GetItemParams) => {
 	}
 };
 
-const fieldsToSend = [
-	'name',
-	'labels',
-	'about',
-	'managers',
-	'timezones',
-	'groups',
+// `custom` is tenant-defined and has no fixed shape, so it's not part of the
+// generated body schemas — kept on the allowlist by hand alongside them.
+const createFieldsToSend = [
+	...getShallowFieldsToSendFromZodSchema(CreateContactBody),
+	'custom',
+];
+const updateFieldsToSend = [
+	...getShallowFieldsToSendFromZodSchema(UpdateContactBody),
 	'custom',
-	'emails',
-	'phones',
 ];
 
 const sanitizeManagers = (itemInstance: ApiParams) => {
@@ -374,35 +247,20 @@ const sanitizeGroups = (itemInstance: ApiParams) => {
 	};
 };
 
-const preRequestHandler = (item: ApiParams) => {
-	const copy = deepCopy(item);
-	copy.name = {
-		commonName: copy.name,
-	};
-	return copy;
-};
-
-const getGroupsFromResponse = (item: ApiParams) => {
-	return item.groups
-		? [
-				...item.groups.data.map((el: ApiParams) => el.group),
-			]
-		: [];
-};
-
 const add = async ({ itemInstance }: AddItemParams) => {
+	// `name`/`managers[].user`/`timezones[].timezone`/`groups[].group` are
+	// expected already in the shape `ContactsInputContact` declares (e.g.
+	// `name: { commonName }`, not a plain string) — callers build the draft
+	// against the raw `Contact` type now, so no request-side wrapping happens
+	// here anymore.
 	const item = applyTransform(itemInstance, [
-		preRequestHandler,
 		sanitizeManagers,
 		sanitizeTimezones,
 		sanitizeGroups,
-		sanitize(fieldsToSend),
-		camelToSnake([
-			'custom',
-		]),
+		sanitizeToWire(createFieldsToSend),
 	]);
 	try {
-		const response = await contactService.createContact(item);
+		const response = await getContacts().createContact(item);
 		return applyTransform(response.data, [
 			snakeToCamel([
 				'custom',
@@ -418,17 +276,15 @@ const add = async ({ itemInstance }: AddItemParams) => {
 const update = async ({ itemInstance }: AddItemParams) => {
 	const { etag } = itemInstance;
 	const item = applyTransform(itemInstance, [
-		preRequestHandler,
 		sanitizeManagers,
 		sanitizeTimezones,
 		sanitizeGroups,
-		sanitize(fieldsToSend),
-		camelToSnake([
-			'custom',
-		]),
+		sanitizeToWire(updateFieldsToSend),
 	]);
 	try {
-		const response = await contactService.updateContact(etag, item);
+		const response = await getContacts().updateContact(etag, item, {
+			fields: contactFieldsToSend,
+		});
 		return applyTransform(response.data, [
 			snakeToCamel([
 				'custom',
@@ -443,7 +299,7 @@ const update = async ({ itemInstance }: AddItemParams) => {
 
 const deleteContact = async ({ id }: DeleteItemParams) => {
 	try {
-		const response = await contactService.deleteContact(String(id));
+		const response = await getContacts().deleteContact(String(id));
 		return applyTransform(response.data, []);
 	} catch (err) {
 		throw applyTransform(err, [
@@ -452,14 +308,27 @@ const deleteContact = async ({ id }: DeleteItemParams) => {
 	}
 };
 
-const getContactsLookup = (params: Parameters<typeof getList>[0]) =>
-	getList({
+const getContactsLookup = async (params: Parameters<typeof getList>[0]) => {
+	// Every other entity's lookup returns a flat `{id, name: string}` shape,
+	// and generic search/select components across the app rely on that
+	// convention for their default option rendering — so `name` is flattened
+	// here (unlike `getList`/`get`, which return the raw `Contact` shape with
+	// `name: { commonName }`) to keep lookups a drop-in for those components.
+	const { items, next } = await getList({
 		...params,
 		fields: params.fields || [
 			'id',
 			'name',
 		],
 	});
+	return {
+		items: items.map((item: ApiParams) => ({
+			...item,
+			name: item.name?.commonName,
+		})),
+		next,
+	};
+};
 
 export const ContactsAPI = {
 	getList,

package/src/api/clients//321/201ontacts/getContactAccessFromMode.ts

@@ -0,0 +1,9 @@
+export interface ContactAccess {
+	edit: boolean;
+	delete: boolean;
+}
+
+export const getContactAccessFromMode = (mode?: string): ContactAccess => ({
+	edit: !!mode?.includes('w'),
+	delete: !!mode?.includes('d'),
+});

package/src/api/clients//321/201ontacts/index.ts

@@ -1,4 +1,4 @@
 export * from './contactChatMessagesHistory';
 export * from './contacts';
 export * from './enums/ContactsSearchMode';
-export * from './types/ContactEntity.types';
+export * from './getContactAccessFromMode';

package/src/validations/adjunctType/adjunctType.validations.ts

@@ -0,0 +1,18 @@
+import type { DataInputDictionary } from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+
+import type { ZodShape } from '../types';
+
+export const adjunctTypeSchema = z.object<ZodShape<DataInputDictionary>>({
+	name: z.string().min(1),
+	repo: z
+		.string()
+		.min(1)
+		.regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/),
+	about: z.string().optional(),
+	administered: z.boolean().optional(),
+	primary: z.string().optional(),
+	display: z.string().optional(),
+	fields: z.array(z.any()).optional(),
+	indexes: z.any().optional(),
+});

package/src/validations/case/case.validations.ts

@@ -0,0 +1,33 @@
+import type { WebitelCasesCase } from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+
+import { lookupSchema } from '../_shared/lookup.validations';
+
+const lookupShape = () => lookupSchema.passthrough().default({});
+
+const statusConditionShape = () =>
+	z
+		.object({
+			id: z
+				.union([
+					z.string(),
+					z.number(),
+				])
+				.optional(),
+			name: z.string().optional(),
+			final: z.boolean().optional(),
+			initial: z.boolean().optional(),
+		})
+		.passthrough()
+		.default({});
+
+export const caseSchema = z.object({
+	subject: z.string().default(''),
+	source: lookupShape(),
+	priority: lookupShape(),
+	reporter: lookupShape(),
+	service: lookupShape(),
+	statusCondition: statusConditionShape(),
+	closeReason: lookupShape(),
+	closeResult: z.string().default(''),
+} satisfies Partial<Record<keyof WebitelCasesCase, z.ZodType>>);

package/src/validations/caseClose/caseClose.validations.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+
+export const caseCloseSchema = z
+	.object({
+		reason: z
+			.object({
+				id: z.union([
+					z.string(),
+					z.number(),
+				]),
+			})
+			.passthrough()
+			.nullable(),
+		result: z.string().nullable(),
+	})
+	.superRefine((data, ctx) => {
+		if (!data.reason?.id) {
+			ctx.addIssue({
+				code: 'custom',
+			});
+		}
+
+		if (!data.result) {
+			ctx.addIssue({
+				code: 'custom',
+			});
+		}
+	});
+
+export type CaseClose = z.infer<typeof caseCloseSchema>;

package/src/validations/caseExportOptions/caseExportOptions.validations.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+
+export const caseExportOptionsSchema = z
+	.object({
+		type: z
+			.object({
+				name: z.string(),
+				value: z.string(),
+			})
+			.nullable(),
+		separator: z.string().nullable(),
+	})
+	.superRefine((data, ctx) => {
+		if (!data.type) {
+			ctx.addIssue({
+				code: 'custom',
+			});
+		}
+
+		if (data.type?.value === 'csv' && !data.separator) {
+			ctx.addIssue({
+				code: 'custom',
+			});
+		}
+	});
+
+export type CaseExportOptions = z.infer<typeof caseExportOptionsSchema>;

package/src/validations/contact/contact.validations.ts

@@ -1,13 +1,18 @@
+import type { WebitelContactsContact } from '@webitel/api-services/gen/models';
 import { z } from 'zod';
-import type { ContactEntity } from '../../api/clients/сontacts/types/ContactEntity.types';
 import type { ZodShape } from '../types';
 
-export const contactSchema = z.object<ZodShape<ContactEntity>>({
-	name: z.string().optional(),
-	timezones: z.array(z.any()).optional(),
-	managers: z.array(z.any()).optional(),
-	groups: z.array(z.any()).optional(),
-	labels: z.array(z.any()).optional(),
+export const contactSchema = z.object<ZodShape<WebitelContactsContact>>({
+	name: z
+		.object({
+			commonName: z.string().optional(),
+		})
+		.passthrough()
+		.optional(),
+	timezones: z.any().optional(),
+	managers: z.any().optional(),
+	groups: z.any().optional(),
+	labels: z.any().optional(),
 	about: z.string().nullish(),
 	user: z.any().nullish(),
 });

package/src/validations/index.ts

@@ -1,11 +1,15 @@
 export * from './_shared/duration.validations';
 export * from './_shared/lookup.validations';
 export * from './_shared/variablePair.validations';
+export * from './adjunctType/adjunctType.validations';
 export * from './auditForm/auditForm.validations';
 export * from './bucket/bucket.validations';
 export * from './calendar/calendar.validations';
+export * from './case/case.validations';
+export * from './caseClose/caseClose.validations';
 export * from './caseCloseReason/caseCloseReason.validations';
 export * from './caseCloseReasonGroup/caseCloseReasonGroup.validations';
+export * from './caseExportOptions/caseExportOptions.validations';
 export * from './casePriority/casePriority.validations';
 export * from './caseService/caseService.validations';
 export * from './caseServiceCatalog/caseServiceCatalog.validations';
@@ -32,5 +36,6 @@ export * from './queueResGroup/queueResGroup.validations';
 export * from './queueSkill/queueSkill.validations';
 export * from './sla/sla.validations';
 export * from './slaCondition/slaCondition.validations';
+export * from './typeExtension/typeExtension.validations';
 export * from './types';
 export * from './variable/variable.validations';

package/src/validations/typeExtension/typeExtension.validations.ts

@@ -0,0 +1,8 @@
+import type { ProtoDataStruct } from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+
+import type { ZodShape } from '../types';
+
+export const typeExtensionSchema = z.object<ZodShape<ProtoDataStruct>>({
+	fields: z.array(z.any()).optional(),
+});