@webitel/api-services 1.0.6 → 1.0.8

package/src/api/clients/emails/emails.ts

@@ -62,6 +62,13 @@ const getList = async ({
 	}
 };
 
+const emailFieldsToSend = [
+	'email',
+	'primary',
+	'etag',
+	'type',
+];
+
 const get = async ({
 	itemId,
 	parentId,
@@ -69,18 +76,12 @@ const get = async ({
 	itemId: ApiId;
 	parentId: ApiId;
 }) => {
-	const fields = [
-		'email',
-		'primary',
-		'etag',
-		'type',
-	];
 	try {
 		const response = await getEmails().locateEmail(
 			String(parentId),
 			String(itemId),
 			{
-				fields,
+				fields: emailFieldsToSend,
 			},
 		);
 		return applyTransform(response.data, [
@@ -142,6 +143,9 @@ const update = async ({
 			String(parentId),
 			itemInstance.etag,
 			item,
+			{
+				fields: emailFieldsToSend,
+			},
 		);
 		const { data } = applyTransform(response.data, [
 			snakeToCamel(),

package/src/api/clients/index.ts

@@ -8,18 +8,25 @@ export * from './calendars/calendars';
 export * from './callHistory/callHistory';
 export * from './caseCloseReasonGroups/caseCloseReasonGroups';
 export * from './caseCloseReasons/caseCloseReasons';
+export * from './caseComments/caseComments';
+export * from './caseFiles/caseFiles';
+export * from './caseLinks/caseLinks';
 export * from './casePriorities/casePriorities';
+export * from './caseRelatedCases/caseRelatedCases';
 export * from './caseServiceCatalogs/serviceCatalogs';
 export * from './caseServices/services';
 export * from './caseSources/caseSources';
 export * from './caseStatusConditions/caseStatusConditions';
 export * from './caseStatuses/caseStatuses';
+export * from './cases/cases';
 export * from './catalog/catalog';
 export * from './changelogs/changelogs';
 export * from './chatDialogs/chatDialogs';
 export * from './chatGateways/chatGateways';
+export * from './chatMessagesHistory/chatMessagesHistory';
 export * from './communications/communications';
 export * from './configurations/configurations';
+export * from './contactCases/contactCases';
 export * from './contactGroups/contactGroups';
 export * from './dynamicConditions/dynamicConditions';
 export * from './dynamicGroups/dynamicGroups';
@@ -51,8 +58,10 @@ export * from './quickReplies/quickReplies';
 export * from './regions/regions';
 // export * from './roles/roles'; fixme: ApplicationAccess import
 export * from './skills/skills';
+export * from './slaConditions/slaConditions';
 export * from './slas/slas';
 export * from './teams/teams';
+export * from './timeline/timeline';
 export * from './userSettings/userSettings';
 export * from './users/users';
 export * from './variables/variables';

package/src/api/clients/labels/labels.ts

@@ -1,42 +1,38 @@
-import { LabelsApiFactory } from 'webitel-sdk';
-import {
-	getDefaultGetParams,
-	getDefaultInstance,
-	getDefaultOpenAPIConfig,
-} from '../../defaults';
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
+import { GetLabelsQueryParams, getLabels } from '../../../gen-wire';
+import { getDefaultGetParams } from '../../defaults';
 import {
 	applyTransform,
 	camelToSnake,
 	merge,
 	notify,
-	sanitize,
+	sanitizeToWire,
 	snakeToCamel,
 	starToSearch,
 } from '../../transformers';
 import type { ApiParams } from '../_shared/types';
 
-const instance = getDefaultInstance();
-const configuration = getDefaultOpenAPIConfig();
-
-const service = LabelsApiFactory(configuration, '', instance);
+const getLabelsList = async (params: ApiParams) => {
+	const listFieldsToSend =
+		getShallowFieldsToSendFromZodSchema(GetLabelsQueryParams);
 
-const getList = async (params: ApiParams) => {
-	const fieldsToSend = [
-		'page',
-		'size',
-		'search',
-		'sort',
-		'fields',
-		'id',
-	];
-	const { page, size, search } = applyTransform(params, [
-		sanitize(fieldsToSend),
+	const { page, size, q, fields } = applyTransform(params, [
 		merge(getDefaultGetParams()),
-		starToSearch('search'),
+		merge({
+			q: params.search,
+		}),
+		sanitizeToWire(listFieldsToSend),
+		starToSearch('q'),
 		camelToSnake(),
 	]);
+
 	try {
-		const response = await service.getLabels(page, size, search);
+		const response = await getLabels().getLabels({
+			page,
+			size,
+			q,
+			fields,
+		});
 		const { labels, next } = applyTransform(response.data, [
 			snakeToCamel(),
 			merge({
@@ -55,16 +51,15 @@ const getList = async (params: ApiParams) => {
 	}
 };
 
-const getLabelsLookup = (params: Parameters<typeof getList>[0]) =>
-	getList({
+const getLabelsLookup = (params: Parameters<typeof getLabelsList>[0]) =>
+	getLabelsList({
 		...params,
 		fields: params.fields || [
-			'id',
-			'name',
+			'label',
 		],
 	});
 
 export const LabelsAPI = {
-	getList,
+	getList: getLabelsList,
 	getLookup: getLabelsLookup,
 };

package/src/api/clients/phones/phones.ts

@@ -63,6 +63,13 @@ const getPhonesList = async ({
 	}
 };
 
+const phoneFieldsToSend = [
+	'number',
+	'primary',
+	'etag',
+	'type',
+];
+
 const getPhone = async ({
 	itemId,
 	parentId,
@@ -70,18 +77,12 @@ const getPhone = async ({
 	itemId: ApiId;
 	parentId: ApiId;
 }) => {
-	const fields = [
-		'number',
-		'primary',
-		'etag',
-		'type',
-	];
 	try {
 		const response = await getPhones().locatePhone(
 			String(parentId),
 			String(itemId),
 			{
-				fields,
+				fields: phoneFieldsToSend,
 			},
 		);
 		return applyTransform(response.data, [
@@ -143,6 +144,9 @@ const updatePhone = async ({
 			String(parentId),
 			itemInstance.etag,
 			item,
+			{
+				fields: phoneFieldsToSend,
+			},
 		);
 		const { data } = applyTransform(response.data, [
 			snakeToCamel(),

package/src/api/clients/timeline/timeline.ts

@@ -0,0 +1,124 @@
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
+import {
+	GetTimelineQueryParams,
+	GetTimelineTimelineQueryParams,
+	getCaseTimeline,
+	getTimeline,
+} from '../../../gen-wire';
+
+import { getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	merge,
+	notify,
+	sanitizeToWire,
+	snakeToCamel,
+} from '../../transformers';
+import type { ApiId, ApiParams } from '../_shared/types';
+
+type TimelineEntity = 'case' | 'contact';
+
+const clients = {
+	case: {
+		getTimeline: (parentId, params) =>
+			getCaseTimeline().getTimeline(parentId, params),
+		getTimelineCounter: (parentId) =>
+			getCaseTimeline().getTimelineCounter(parentId),
+		queryParamsSchema: GetTimelineQueryParams,
+	},
+	contact: {
+		getTimeline: (parentId, params) =>
+			getTimeline().getTimelineTimeline(parentId, params),
+		getTimelineCounter: (parentId) =>
+			getTimeline().getTimelineCounterTimeline(parentId),
+		queryParamsSchema: GetTimelineTimelineQueryParams,
+	},
+} satisfies Record<
+	TimelineEntity,
+	{
+		getTimeline: (
+			parentId: string,
+			params: ApiParams,
+		) => Promise<{
+			data: unknown;
+		}>;
+		getTimelineCounter: (parentId: string) => Promise<{
+			data: unknown;
+		}>;
+		queryParamsSchema: unknown;
+	}
+>;
+
+const getList = async ({
+	entity,
+	parentId,
+	...rest
+}: {
+	entity: TimelineEntity;
+	parentId: ApiId;
+} & ApiParams) => {
+	const { getTimeline, queryParamsSchema } = clients[entity];
+	const fieldsToSend = getShallowFieldsToSendFromZodSchema(queryParamsSchema);
+
+	const { dateFrom, dateTo, type, page, size } = applyTransform(rest, [
+		merge(getDefaultGetParams()),
+		sanitizeToWire(fieldsToSend),
+	]);
+
+	try {
+		const response = await getTimeline(String(parentId), {
+			page,
+			size,
+			dateFrom,
+			dateTo,
+			type,
+		});
+		// `days` can be a large, deeply-nested tree — merge() would recursively
+		// clone the whole thing via deepmerge just to add unused `items`/`next`
+		// defaults, which risks a stack overflow on large histories.
+		const data = applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+		return {
+			days: data?.days ?? [],
+			next: data?.next ?? false,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getCounters = async ({
+	entity,
+	parentId,
+}: {
+	entity: TimelineEntity;
+	parentId: ApiId;
+}) => {
+	const { getTimelineCounter } = clients[entity];
+	const defaultObject = {
+		callsCount: 0,
+		chatsCount: 0,
+		emailsCount: 0,
+		dateFrom: Date.now(),
+		dateTo: Date.now(),
+	};
+	try {
+		const response = await getTimelineCounter(String(parentId));
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			merge(defaultObject),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+export const TimelineAPI = {
+	getList,
+	getCounters,
+};

package/src/api/clients/variables/variables.ts

@@ -61,6 +61,12 @@ const getVariablesList = async ({
 	}
 };
 
+const variableFieldsToSend = [
+	'key',
+	'value',
+	'etag',
+];
+
 // no dedicated "locate one" endpoint exists for variables — reuse the list
 // endpoint filtered to a single id, matching what the crm-local adapter did
 const getVariable = async ({
@@ -74,11 +80,7 @@ const getVariable = async ({
 		const response = await getVariables().listVariables(parentId, {
 			page: 1,
 			size: 1,
-			fields: [
-				'key',
-				'value',
-				'etag',
-			],
+			fields: variableFieldsToSend,
 			id: [
 				itemId,
 			],
@@ -145,6 +147,9 @@ const updateVariable = async ({
 			parentId,
 			itemInstance.etag,
 			item,
+			{
+				fields: variableFieldsToSend,
+			},
 		);
 		const { data } = applyTransform(response.data, [
 			snakeToCamel(),

package/src/api/clients/wtTypes/_shared/utils/assignFieldPositions.ts

@@ -0,0 +1,28 @@
+import type {
+	DataField,
+	ProtoDataStruct,
+} from '@webitel/api-services/gen/models';
+
+type PositionableDataField = DataField & {
+	position?: number;
+};
+
+// readonly (system) fields never get a position; every other field is
+// numbered in the order the backend returns it, 1-based.
+export const assignFieldPositions = (
+	item: ProtoDataStruct,
+): ProtoDataStruct => {
+	let position = 1;
+
+	const fields = ((item.fields ?? []) as PositionableDataField[]).map(
+		(field) => ({
+			...field,
+			position: field.readonly ? undefined : position++,
+		}),
+	);
+
+	return {
+		...item,
+		fields,
+	};
+};

package/src/api/clients/wtTypes/_shared/utils/sortDynamicFields.ts

@@ -1,18 +1,16 @@
-import deepCopy from 'deep-copy';
 import type {
-	WebitelProtoDataField,
-	WebitelProtoDataStruct,
-} from 'webitel-sdk';
+	DataField,
+	ProtoDataStruct,
+} from '@webitel/api-services/gen/models';
+import deepCopy from 'deep-copy';
 
-// The generated webitel-sdk type omits `position`, but the backend returns it
+// The generated type omits `position`, but the backend returns it
 // and it drives ordering of dynamic fields.
-type SortableDataField = WebitelProtoDataField & {
+type SortableDataField = DataField & {
 	position?: number;
 };
 
-export const sortDynamicFields = (
-	item: WebitelProtoDataStruct,
-): WebitelProtoDataStruct => {
+export const sortDynamicFields = (item: ProtoDataStruct): ProtoDataStruct => {
 	const allFields = (item.fields ?? []) as SortableDataField[];
 
 	const unSortableFields = allFields.filter((field) => !field.position);

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

@@ -20,10 +20,10 @@ import type { ApiId, ApiParams } from '../../_shared/types';
 const instance = getDefaultInstance();
 
 const getAdjunctTypeRecordsList = async ({
-	repo,
+	parentId,
 	...params
 }: {
-	repo: string;
+	parentId: string;
 } & ApiParams) => {
 	const fieldsToSend = [
 		'page',
@@ -45,7 +45,7 @@ const getAdjunctTypeRecordsList = async ({
 		camelToSnake(),
 	]);
 	try {
-		const response = await getDictionaries().searchData(repo, {
+		const response = await getDictionaries().searchData(parentId, {
 			size,
 			page,
 			sort,
@@ -69,13 +69,13 @@ const getAdjunctTypeRecordsList = async ({
 
 const getAdjunctTypeRecord = async ({
 	itemId: id,
-	repo,
+	parentId,
 }: {
 	itemId: ApiId;
-	repo: string;
+	parentId: string;
 }) => {
 	try {
-		const response = await getDictionaries().locateData(repo, String(id));
+		const response = await getDictionaries().locateData(parentId, String(id));
 		return response.data;
 	} catch (err) {
 		throw applyTransform(err, [
@@ -87,18 +87,18 @@ const getAdjunctTypeRecord = async ({
 const addAdjunctTypeRecord = async ({
 	itemInstance,
 	fieldsToSend,
-	repo,
+	parentId,
 }: {
 	itemInstance: ApiParams;
 	fieldsToSend: string[];
-	repo: string;
+	parentId: string;
 }) => {
 	const item = applyTransform(itemInstance, [
 		camelToSnake(),
 		sanitize(fieldsToSend),
 	]);
 	try {
-		const response = await getDictionaries().createData(repo, item);
+		const response = await getDictionaries().createData(parentId, item);
 		return applyTransform(response.data, [
 			snakeToCamel(),
 		]);
@@ -113,19 +113,23 @@ const updateAdjunctTypeRecord = async ({
 	itemInstance,
 	fieldsToSend,
 	itemId: id,
-	repo,
+	parentId,
 }: {
 	itemInstance: ApiParams;
 	fieldsToSend: string[];
 	itemId: ApiId;
-	repo: string;
+	parentId: string;
 }) => {
 	const item = applyTransform(itemInstance, [
 		camelToSnake(),
 		sanitize(fieldsToSend),
 	]);
 	try {
-		const response = await getDictionaries().updateData(repo, String(id), item);
+		const response = await getDictionaries().updateData(
+			parentId,
+			String(id),
+			item,
+		);
 		return applyTransform(response.data, [
 			snakeToCamel(),
 		]);
@@ -137,10 +141,10 @@ const updateAdjunctTypeRecord = async ({
 };
 
 const deleteAdjunctTypeRecord = async ({
-	repo,
+	parentId,
 	id,
 }: {
-	repo: string;
+	parentId: string;
 	id: ApiId | ApiId[];
 }) => {
 	const ids = (
@@ -151,8 +155,7 @@ const deleteAdjunctTypeRecord = async ({
 				]
 	).map(String);
 	try {
-		const response = await getDictionaries().deleteData2(repo, ids);
-		return response.data;
+		await getDictionaries().deleteData2(parentId, ids);
 	} catch (err) {
 		throw applyTransform(err, [
 			notify,

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

@@ -18,6 +18,8 @@ import type {
 	ApiParams,
 	UpdateItemParams,
 } from '../../_shared/types';
+import { assignFieldPositions } from '../_shared/utils/assignFieldPositions';
+import { sortDynamicFields } from '../_shared/utils/sortDynamicFields';
 
 const fieldsToSend = [
 	'name',
@@ -102,6 +104,7 @@ const getAdjunctType = async ({ itemId: itemRepo }: { itemId: string }) => {
 		return applyTransform(response.data, [
 			snakeToCamel(),
 			itemResponseHandler,
+			assignFieldPositions,
 		]);
 	} catch (err) {
 		throw applyTransform(err, [
@@ -134,6 +137,7 @@ const updateAdjunctType = async ({
 	itemId: id,
 }: UpdateItemParams) => {
 	const item = applyTransform(itemInstance, [
+		sortDynamicFields,
 		camelToSnake(),
 		sanitize(fieldsToSend),
 	]);

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

@@ -1,19 +1,17 @@
-import { ExtensionsApiFactory, type WebitelProtoDataStruct } from 'webitel-sdk';
-import { getDefaultInstance, getDefaultOpenAPIConfig } from '../../../defaults';
+import type { ProtoDataStruct } from '@webitel/api-services/gen/models';
+import { getExtensions } from '../../../../gen-wire';
 import {
 	applyTransform,
 	camelToSnake,
 	notify,
-	sanitize,
+	sanitizeToWire,
 	snakeToCamel,
 } from '../../../transformers';
 import type { ApiId, ApiParams } from '../../_shared/types';
+import { assignFieldPositions } from '../_shared/utils/assignFieldPositions';
 import { sortDynamicFields } from '../_shared/utils/sortDynamicFields';
 
-const instance = getDefaultInstance();
-const configuration = getDefaultOpenAPIConfig();
-
-const typeExtensionsService = ExtensionsApiFactory(configuration, '', instance);
+const typeExtensionsService = getExtensions();
 
 const fieldsToSend = [
 	'fields',
@@ -21,33 +19,19 @@ const fieldsToSend = [
 	'path',
 ];
 
-const generateIdsFromRepos = (item: WebitelProtoDataStruct) => ({
+const generateIdsFromRepos = (item: ProtoDataStruct) => ({
 	...item,
 	id: item.repo,
 });
 
 const getTypeExtension = async ({ itemId: typeRepo }: { itemId: string }) => {
-	const createPositionGenerator = () => {
-		let position = 1;
-		return (item: ApiParams) => (item.readonly ? null : position++);
-	};
-	const getPosition = createPositionGenerator();
-
-	const itemResponseHandler = (item: ApiParams) => ({
-		...item,
-		fields: item.fields.map((field: ApiParams) => ({
-			...field,
-			position: getPosition(field),
-		})),
-	});
-
 	try {
-		const response = await typeExtensionsService.locateType(typeRepo);
+		const response = await typeExtensionsService.locateTypeExtensions(typeRepo);
 
 		return applyTransform(response.data, [
 			snakeToCamel(),
 			generateIdsFromRepos,
-			itemResponseHandler,
+			assignFieldPositions,
 		]);
 	} catch {
 		return {
@@ -67,11 +51,11 @@ const addTypeExtension = async ({
 }) => {
 	const item = applyTransform(itemInstance, [
 		sortDynamicFields,
+		sanitizeToWire(fieldsToSend),
 		camelToSnake(),
-		sanitize(fieldsToSend),
 	]);
 	try {
-		const response = await typeExtensionsService.createType(
+		const response = await typeExtensionsService.createTypeExtensions(
 			String(typeRepo),
 			item,
 		);
@@ -88,7 +72,7 @@ const addTypeExtension = async ({
 
 const deleteTypeExtension = async ({ itemId: typeRepo }: { itemId: ApiId }) => {
 	try {
-		await typeExtensionsService.deleteType([
+		await typeExtensionsService.deleteTypeExtensions([
 			String(typeRepo),
 		]);
 	} catch (err) {
@@ -116,18 +100,24 @@ const updateTypeExtension = async ({
 	}
 
 	if (!itemInstance.fields.length && !itemInstance.isNew) {
-		return deleteTypeExtension({
+		await deleteTypeExtension({
 			itemId: typeRepo,
 		});
+
+		return {
+			id: typeRepo,
+			fields: [],
+			isNew: true,
+		};
 	}
 
 	const item = applyTransform(itemInstance, [
 		sortDynamicFields,
+		sanitizeToWire(fieldsToSend),
 		camelToSnake(),
-		sanitize(fieldsToSend),
 	]);
 	try {
-		const response = await typeExtensionsService.updateType(
+		const response = await typeExtensionsService.updateTypeExtensions(
 			String(typeRepo),
 			item,
 		);
@@ -143,7 +133,7 @@ const updateTypeExtension = async ({
 };
 
 export const WtTypeExtensionAPI = {
-	getList: getTypeExtension,
+	get: getTypeExtension,
 	add: addTypeExtension,
 	update: updateTypeExtension,
 	delete: deleteTypeExtension,