@webitel/api-services 1.0.9 → 1.0.11

package/src/api/clients/outboundResources/outboundResources.ts

@@ -0,0 +1,225 @@
+import deepCopy from 'deep-copy';
+import { getOutboundResourceService } from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	camelToSnake,
+	merge,
+	mergeEach,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers';
+import type {
+	AddItemParams,
+	ApiParams,
+	DeleteItemParams,
+	GetItemParams,
+	PatchItemParams,
+	UpdateItemParams,
+} from '../_shared/types';
+
+const fieldsToSend = [
+	'limit',
+	'enabled',
+	'rps',
+	'maxSuccessivelyErrors',
+	'name',
+	'errorIds',
+	'display',
+	'description',
+	'resourceId',
+	'gateway',
+	'patterns',
+	'failureDialDelay',
+	'parameters',
+];
+
+/*
+ * The form binds `maxErrors` / `cps`, the API expects
+ * `maxSuccessivelyErrors` / `rps`. `getResource` maps them back.
+ */
+const preRequestHandler = (item: ApiParams) => {
+	const copy = deepCopy(item);
+	copy.maxSuccessivelyErrors = copy.maxErrors;
+	copy.rps = copy.cps;
+	return copy;
+};
+
+const getResourcesList = async (params: ApiParams) => {
+	const defaultObject = {
+		gateway: null,
+		enabled: false,
+	};
+
+	const { page, size, search, sort, fields, id } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+	]);
+
+	try {
+		const response = await getOutboundResourceService().searchOutboundResource({
+			page,
+			size,
+			// the generated param is `q`; `search` is what the datalist store sends
+			q: search,
+			sort,
+			fields,
+			id,
+		});
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [
+				mergeEach(defaultObject),
+			]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getResource = async ({ itemId: id }: GetItemParams) => {
+	const defaultObject = {
+		name: '',
+		gateway: {},
+		rps: 0,
+		limit: 0,
+		description: '',
+		maxSuccessivelyErrors: 0,
+		errorIds: [],
+		patterns: [],
+		failureDialDelay: 0,
+		parameters: {
+			cidType: '',
+			ignoreEarlyMedia: '',
+		},
+	};
+
+	const responseHandler = (response: ApiParams) => {
+		const copy = deepCopy(response);
+		copy.maxErrors = copy.maxSuccessivelyErrors;
+		copy.cps = copy.rps;
+		copy.parameters = {
+			...defaultObject.parameters,
+			...copy.parameters,
+		};
+		return copy;
+	};
+
+	try {
+		const response = await getOutboundResourceService().readOutboundResource(
+			String(id),
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			merge(defaultObject),
+			responseHandler,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const addResource = async ({ itemInstance }: AddItemParams) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response =
+			await getOutboundResourceService().createOutboundResource(item);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const updateResource = async ({
+	itemInstance,
+	itemId: id,
+}: UpdateItemParams) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await getOutboundResourceService().updateOutboundResource(
+			String(id),
+			item,
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const patchResource = async ({ changes, id }: PatchItemParams) => {
+	const body = applyTransform(changes, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await getOutboundResourceService().patchOutboundResource(
+			String(id),
+			body,
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const deleteResource = async ({ id }: DeleteItemParams) => {
+	try {
+		const response = await getOutboundResourceService().deleteOutboundResource(
+			String(id),
+		);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getResourcesLookup = (params: Parameters<typeof getResourcesList>[0]) =>
+	getResourcesList({
+		...params,
+		fields: params.fields || [
+			'id',
+			'name',
+		],
+	});
+
+export const OutboundResourcesAPI = {
+	getList: getResourcesList,
+	get: getResource,
+	add: addResource,
+	patch: patchResource,
+	update: updateResource,
+	delete: deleteResource,
+	getLookup: getResourcesLookup,
+};

package/src/api/clients/outboundResources/resourceDisplays.ts

@@ -0,0 +1,165 @@
+import { getOutboundResourceService } from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers';
+import type {
+	ApiId,
+	ApiParams,
+	NestedAddItemParams,
+	NestedDeleteItemParams,
+	NestedGetItemParams,
+	NestedUpdateItemParams,
+} from '../_shared/types';
+
+const fieldsToSend = [
+	'display',
+	'resourceId',
+];
+
+const preRequestHandler = (parentId: ApiId) => (item: ApiParams) => ({
+	...item,
+	resourceId: parentId,
+});
+
+const getResourceDisplaysList = async (params: ApiParams) => {
+	const { page, size, search, sort, fields, id, parentId } = applyTransform(
+		params,
+		[
+			merge(getDefaultGetParams()),
+			starToSearch('search'),
+		],
+	);
+
+	try {
+		const response =
+			await getOutboundResourceService().searchOutboundResourceDisplay(
+				String(parentId),
+				{
+					page,
+					size,
+					// the generated param is `q`; `search` is what the datalist store sends
+					q: search,
+					sort,
+					fields,
+					id,
+				},
+			);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getResourceDisplay = async ({
+	parentId,
+	itemId: id,
+}: NestedGetItemParams) => {
+	try {
+		const response =
+			await getOutboundResourceService().readOutboundResourceDisplay(
+				String(parentId),
+				String(id),
+			);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const addResourceDisplay = async ({
+	parentId,
+	itemInstance,
+}: NestedAddItemParams) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler(parentId),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response =
+			await getOutboundResourceService().createOutboundResourceDisplay(
+				String(parentId),
+				item,
+			);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const updateResourceDisplay = async ({
+	parentId,
+	itemInstance,
+	itemId: id,
+}: NestedUpdateItemParams) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler(parentId),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response =
+			await getOutboundResourceService().updateOutboundResourceDisplay(
+				String(parentId),
+				String(id),
+				item,
+			);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const deleteResourceDisplay = async ({
+	parentId,
+	id,
+}: NestedDeleteItemParams) => {
+	try {
+		const response =
+			await getOutboundResourceService().deleteOutboundResourceDisplay(
+				String(parentId),
+				String(id),
+			);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+export const ResourceDisplaysAPI = {
+	getList: getResourceDisplaysList,
+	get: getResourceDisplay,
+	add: addResourceDisplay,
+	update: updateResourceDisplay,
+	delete: deleteResourceDisplay,
+};

package/src/api/clients/pauseTemplates/pauseTemplates.ts

@@ -0,0 +1,203 @@
+import deepCopy from 'deep-copy';
+import { getPauseTemplateService } from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+} from '../../transformers';
+import type {
+	AddItemParams,
+	ApiParams,
+	DeleteItemParams,
+	GetItemParams,
+	UpdateItemParams,
+} from '../_shared/types';
+
+const fieldsToSend = [
+	'name',
+	'description',
+	'causes',
+	'domainId',
+	'createdAt',
+	'createdBy',
+	'updatedAt',
+	'updatedBy',
+];
+
+/**
+ * WFM services wrap both request and response payloads in an `item` envelope,
+ * and nest each pause cause under a `cause` key. The form binds a flat
+ * `{ id, name, duration }`.
+ */
+const itemResponseHandler = (response: ApiParams) => {
+	const item = {
+		...response.item,
+	};
+
+	item.causes = item.causes?.map((cause: ApiParams) => ({
+		id: cause.cause?.id,
+		name: cause.cause?.name,
+		duration: cause?.duration,
+	}));
+
+	return item;
+};
+
+const preRequestHandler = (item: ApiParams) => {
+	const copy = deepCopy(item);
+	copy.causes = copy.causes.map((cause: ApiParams) => {
+		if (!cause.name && !cause.id) return cause;
+		return {
+			cause: {
+				id: cause?.id,
+				name: cause?.name,
+			},
+			duration: cause.duration,
+		};
+	});
+	return copy;
+};
+
+const getPauseTemplatesList = async (params: ApiParams) => {
+	const {
+		search: q,
+		page,
+		size,
+		sort,
+		fields,
+	} = applyTransform(params, [
+		merge(getDefaultGetParams()),
+	]);
+
+	try {
+		const response =
+			await getPauseTemplateService().pauseTemplateServiceSearchPauseTemplate({
+				q,
+				page,
+				size,
+				sort,
+				fields,
+			});
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getPauseTemplate = async ({ itemId: id }: GetItemParams) => {
+	try {
+		const response =
+			await getPauseTemplateService().pauseTemplateServiceReadPauseTemplate(
+				String(id),
+			);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			itemResponseHandler,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const addPauseTemplate = async ({ itemInstance }: AddItemParams) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+		preRequestHandler,
+	]);
+	try {
+		const response =
+			await getPauseTemplateService().pauseTemplateServiceCreatePauseTemplate({
+				item: {
+					...item,
+				},
+			});
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			itemResponseHandler,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const updatePauseTemplate = async ({
+	itemInstance,
+	itemId: id,
+}: UpdateItemParams) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+		preRequestHandler,
+	]);
+	try {
+		const response =
+			await getPauseTemplateService().pauseTemplateServiceUpdatePauseTemplate(
+				String(id),
+				{
+					item: {
+						...item,
+					},
+				},
+			);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			itemResponseHandler,
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const deletePauseTemplate = async ({ id }: DeleteItemParams) => {
+	try {
+		const response =
+			await getPauseTemplateService().pauseTemplateServiceDeletePauseTemplate(
+				String(id),
+			);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getPauseTemplatesLookup = (
+	params: Parameters<typeof getPauseTemplatesList>[0],
+) =>
+	getPauseTemplatesList({
+		...params,
+		fields: params.fields || [
+			'id',
+			'name',
+		],
+	});
+
+export const PauseTemplatesAPI = {
+	getList: getPauseTemplatesList,
+	get: getPauseTemplate,
+	add: addPauseTemplate,
+	update: updatePauseTemplate,
+	delete: deletePauseTemplate,
+	getLookup: getPauseTemplatesLookup,
+};

package/src/api/clients/queues/__tests__/queueLogs.spec.ts

@@ -88,10 +88,10 @@ describe('QueueLogsAPI.getList', () => {
 		});
 
 		expect(paramsSent()).toMatchObject({
-			bucketId: [
+			bucket_id: [
 				1,
 			],
-			agentId: [
+			agent_id: [
 				2,
 			],
 			'leaving_at.from': 10,
@@ -109,7 +109,7 @@ describe('QueueLogsAPI.getList', () => {
 
 		// `starToSearch` makes it a prefix search, as everywhere else
 		expect(paramsSent()).toMatchObject({
-			queueId: [
+			queue_id: [
 				'7',
 			],
 			q: 'joe*',

package/src/api/clients/queues/__tests__/queueMembers.spec.ts

@@ -91,13 +91,13 @@ describe('QueueMembersAPI.getList', () => {
 
 		expect(paramsSent()).toMatchObject({
 			q: 'joe*',
-			bucketId: [
+			bucket_id: [
 				1,
 			],
-			agentId: [
+			agent_id: [
 				2,
 			],
-			stopCause: [
+			stop_cause: [
 				'cancel',
 			],
 			'offering_at.from': 300,
@@ -123,7 +123,7 @@ describe('QueueMembersAPI.getList', () => {
 		expect(paramsSent()).toMatchObject({
 			'created_at.from': 100,
 			'created_at.to': 200,
-			stopCause: [
+			stop_cause: [
 				'cancel',
 			],
 		});

package/src/api/clients/queues/queueLogs.ts

@@ -43,6 +43,11 @@ const getQueueLogs = async (params: ApiParams) => {
 		 keys (`joined_at.from`); the generated type's `joinedAtFrom` is ignored
 		 by the backend. Kept as a variable, not an inline literal, so TS's
 		 excess-property check doesn't flag the dotted keys against that type.
+
+		 That cast also hides every *other* key from the check, which is how
+		 `queueId` / `agentId` / `bucketId` sat here unnoticed: the endpoint
+		 declares them snake_case, so all three filters were silently ignored.
+		 `wireParamsCoverage.spec.ts` now checks this object against the schema.
 		 */
 		const requestParams = {
 			page,
@@ -52,11 +57,11 @@ const getQueueLogs = async (params: ApiParams) => {
 			sort,
 			fields,
 			// repeated params, even for the single queue this tab shows
-			queueId: [
+			queue_id: [
 				String(parentId),
 			],
-			agentId: agent,
-			bucketId: bucket,
+			agent_id: agent,
+			bucket_id: bucket,
 			result,
 			'joined_at.from': joinedAt?.from,
 			'joined_at.to': joinedAt?.to,

package/src/api/clients/queues/queueMembers.ts

@@ -145,9 +145,9 @@ const getMembersList = async (params: ApiParams) => {
 			sort,
 			fields,
 			id,
-			bucketId: bucket,
-			stopCause,
-			agentId: agent,
+			bucket_id: bucket,
+			stop_cause: stopCause,
+			agent_id: agent,
 			'created_at.from': createdAt?.from,
 			'created_at.to': createdAt?.to,
 			'offering_at.from': offeringAt?.from,