@webitel/api-services 1.0.5 → 1.0.7

package/src/api/clients/configurations/configurations.ts

@@ -1,16 +1,17 @@
-import { SystemSettingServiceApiFactory } from 'webitel-sdk';
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
 import {
-	getDefaultGetListResponse,
-	getDefaultGetParams,
-	getDefaultInstance,
-	getDefaultOpenAPIConfig,
-} from '../../defaults';
+	CreateSystemSettingBody,
+	getSystemSettingService,
+	SearchAvailableSystemSettingQueryParams,
+	SearchSystemSettingQueryParams,
+} from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
 import {
 	applyTransform,
 	camelToSnake,
 	merge,
 	notify,
-	sanitize,
+	sanitizeToWire,
 	snakeToCamel,
 	starToSearch,
 } from '../../transformers';
@@ -22,30 +23,30 @@ import type {
 	UpdateItemParams,
 } from '../_shared/types';
 
-const instance = getDefaultInstance();
-const configuration = getDefaultOpenAPIConfig();
-
-const configurationService = SystemSettingServiceApiFactory(
-	configuration,
-	'',
-	instance,
-);
-
 const getList = async (params: ApiParams) => {
-	const { page, size, search, sort, fields, name } = applyTransform(params, [
+	const listFieldsToSend = getShallowFieldsToSendFromZodSchema(
+		SearchSystemSettingQueryParams,
+	);
+
+	const { page, size, fields, sort, name, q } = applyTransform(params, [
 		merge(getDefaultGetParams()),
-		starToSearch('search'),
+		merge({
+			q: params.search,
+		}),
+		sanitizeToWire(listFieldsToSend),
+		starToSearch('q'),
+		camelToSnake(),
 	]);
 
 	try {
-		const response = await configurationService.searchSystemSetting(
+		const response = await getSystemSettingService().searchSystemSetting({
 			page,
 			size,
-			search,
-			sort,
 			fields,
+			sort,
 			name,
-		);
+			q,
+		});
 		const { items, next } = applyTransform(response.data, [
 			snakeToCamel(),
 			merge(getDefaultGetListResponse()),
@@ -63,7 +64,9 @@ const getList = async (params: ApiParams) => {
 
 const get = async ({ itemId: id }: GetItemParams) => {
 	try {
-		const response = await configurationService.readSystemSetting(Number(id));
+		const response = await getSystemSettingService().readSystemSetting(
+			Number(id),
+		);
 		return applyTransform(response.data, [
 			snakeToCamel(),
 		]);
@@ -74,19 +77,21 @@ const get = async ({ itemId: id }: GetItemParams) => {
 	}
 };
 
+// `value` is a free-form `google.protobuf.Value` on the backend and has no
+// fixed shape, so it's not part of the generated body schema — kept on the
+// allowlist by hand alongside it (mirrors `custom` on contacts).
 const fieldsToSend = [
-	'id',
-	'name',
+	...getShallowFieldsToSendFromZodSchema(CreateSystemSettingBody),
 	'value',
 ];
 
 const add = async ({ itemInstance }: AddItemParams) => {
 	const item = applyTransform(itemInstance, [
-		sanitize(fieldsToSend),
+		sanitizeToWire(fieldsToSend),
 		camelToSnake(),
 	]);
 	try {
-		const response = await configurationService.createSystemSetting(item);
+		const response = await getSystemSettingService().createSystemSetting(item);
 		return applyTransform(response.data, [
 			snakeToCamel(),
 		]);
@@ -99,11 +104,11 @@ const add = async ({ itemInstance }: AddItemParams) => {
 
 const update = async ({ itemInstance, itemId: id }: UpdateItemParams) => {
 	const item = applyTransform(itemInstance, [
-		sanitize(fieldsToSend),
+		sanitizeToWire(fieldsToSend),
 		camelToSnake(),
 	]);
 	try {
-		const response = await configurationService.updateSystemSetting(
+		const response = await getSystemSettingService().updateSystemSetting(
 			Number(id),
 			item,
 		);
@@ -127,7 +132,9 @@ const getLookup = (params: Parameters<typeof getList>[0]) =>
 
 const deleteItem = async ({ id }: DeleteItemParams) => {
 	try {
-		const response = await configurationService.deleteSystemSetting(Number(id));
+		const response = await getSystemSettingService().deleteSystemSetting(
+			Number(id),
+		);
 		return applyTransform(response.data, []);
 	} catch (err) {
 		throw applyTransform(err, [
@@ -137,19 +144,29 @@ const deleteItem = async ({ id }: DeleteItemParams) => {
 };
 
 const getObjectsList = async (params: ApiParams) => {
-	const { page, size, search, sort, fields } = applyTransform(params, [
+	const listFieldsToSend = getShallowFieldsToSendFromZodSchema(
+		SearchAvailableSystemSettingQueryParams,
+	);
+
+	const { page, size, fields, sort, q } = applyTransform(params, [
 		merge(getDefaultGetParams()),
-		starToSearch('search'),
+		merge({
+			q: params.search,
+		}),
+		sanitizeToWire(listFieldsToSend),
+		starToSearch('q'),
+		camelToSnake(),
 	]);
 
 	try {
-		const response = await configurationService.searchAvailableSystemSetting(
-			page,
-			size,
-			search,
-			sort,
-			fields,
-		);
+		const response =
+			await getSystemSettingService().searchAvailableSystemSetting({
+				page,
+				size,
+				fields,
+				sort,
+				q,
+			});
 		const { items, next } = applyTransform(response.data, [
 			snakeToCamel(),
 			merge(getDefaultGetListResponse()),

package/src/api/clients/contactCases/contactCases.ts

@@ -0,0 +1,109 @@
+import { snakeToKebab } from '@webitel/api-services/utils';
+import { getCases } from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	merge,
+	notify,
+	snakeToCamel,
+} from '../../transformers';
+import type { ApiId, ApiParams } from '../_shared/types';
+import { FTSServiceAPI } from '../cases/_internals/ftsService';
+import { stringifyCaseFilters } from '../cases/_internals/stringifyCaseFilters';
+
+function transformSourceType(data: ApiParams) {
+	if (Array.isArray(data)) {
+		return data.map((item) => {
+			if (item.source?.type) {
+				item.source.type = snakeToKebab(item.source.type.toLowerCase());
+			}
+			return item;
+		});
+	}
+
+	if (data.source?.type) {
+		data.source.type = snakeToKebab(data.source.type.toLowerCase());
+	}
+	return data;
+}
+
+const getContactCasesList = async ({
+	parentId,
+	...params
+}: {
+	parentId: ApiId;
+} & ApiParams) => {
+	let ftsIds: Array<string | number> | undefined;
+	const { fts } = params;
+	if (fts) {
+		try {
+			const { items } = await FTSServiceAPI.getList({
+				page: params.page,
+				size: params.size,
+				fts: params.fts,
+				sort: params.sort,
+				objectName: [
+					'cases',
+					'case_comments',
+				],
+			});
+			ftsIds = items.map(({ id }: ApiParams) => id);
+		} catch {
+			// skip error, load cases without fts
+		}
+	}
+
+	/* everything left over after pulling out the technical query params is a
+	 * filter, keyed by the (camelCase) filter names stringifyCaseFilters expects */
+	const { page, size, q, ids, sort, fields, ...filters } = applyTransform(
+		{
+			...params,
+			ids: params.ids || ftsIds,
+		},
+		[
+			merge(getDefaultGetParams()),
+			(params) => ({
+				...params,
+				q: params.search,
+			}),
+		],
+	);
+
+	try {
+		const response = await getCases().searchCases2(String(parentId), {
+			page,
+			size,
+			q,
+			ids,
+			sort,
+			fields: [
+				...(fields || []),
+				'etag',
+				'id',
+				'custom',
+			],
+			filters: stringifyCaseFilters(filters),
+		});
+
+		const { items, next } = applyTransform(response.data, [
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [
+				snakeToCamel([
+					'custom',
+				]),
+				transformSourceType,
+			]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+export const ContactCasesAPI = {
+	getList: getContactCasesList,
+};

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);