@webitel/api-services 1.0.9 → 1.0.11

package/src/api/clients/skills/skills.ts

@@ -1,10 +1,5 @@
-import { SkillServiceApiFactory } from 'webitel-sdk';
-import {
-	getDefaultGetListResponse,
-	getDefaultGetParams,
-	getDefaultInstance,
-	getDefaultOpenAPIConfig,
-} from '../../defaults';
+import { getSkillService } from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
 import {
 	applyTransform,
 	camelToSnake,
@@ -22,26 +17,27 @@ import type {
 	UpdateItemParams,
 } from '../_shared/types';
 
-const instance = getDefaultInstance();
-const configuration = getDefaultOpenAPIConfig();
-
-const skillService = SkillServiceApiFactory(configuration, '', instance);
-
 const getSkillsList = async (params: ApiParams) => {
-	const { page, size, search, sort, fields, id } = applyTransform(params, [
+	const requestParams = applyTransform(params, [
 		merge(getDefaultGetParams()),
 		starToSearch('search'),
+		camelToSnake(),
+		(params) => ({
+			...params,
+			q: params.search,
+		}),
+		sanitize([
+			'page',
+			'size',
+			'q',
+			'sort',
+			'fields',
+			'id',
+		]),
 	]);
 
 	try {
-		const response = await skillService.searchSkill(
-			page,
-			size,
-			search,
-			sort,
-			fields,
-			id,
-		);
+		const response = await getSkillService().searchSkill(requestParams);
 		const { items, next } = applyTransform(response.data, [
 			snakeToCamel(),
 			merge(getDefaultGetListResponse()),
@@ -59,7 +55,7 @@ const getSkillsList = async (params: ApiParams) => {
 
 const getSkill = async ({ itemId: id }: GetItemParams) => {
 	try {
-		const response = await skillService.readSkill(String(id));
+		const response = await getSkillService().readSkill(String(id));
 		return applyTransform(response.data, [
 			snakeToCamel(),
 		]);
@@ -81,7 +77,7 @@ const addSkill = async ({ itemInstance }: AddItemParams) => {
 		camelToSnake(),
 	]);
 	try {
-		const response = await skillService.createSkill(item);
+		const response = await getSkillService().createSkill(item);
 		return applyTransform(response.data, [
 			snakeToCamel(),
 		]);
@@ -98,7 +94,7 @@ const updateSkill = async ({ itemInstance, itemId: id }: UpdateItemParams) => {
 		camelToSnake(),
 	]);
 	try {
-		const response = await skillService.updateSkill(String(id), item);
+		const response = await getSkillService().updateSkill(String(id), item);
 		return applyTransform(response.data, [
 			snakeToCamel(),
 		]);
@@ -111,7 +107,7 @@ const updateSkill = async ({ itemInstance, itemId: id }: UpdateItemParams) => {
 
 const deleteSkill = async ({ id }: DeleteItemParams) => {
 	try {
-		const response = await skillService.deleteSkill(String(id));
+		const response = await getSkillService().deleteSkill(String(id));
 		return applyTransform(response.data, []);
 	} catch (err) {
 		throw applyTransform(err, [

package/src/api/clients/storagePolicies/storagePolicies.ts

@@ -0,0 +1,270 @@
+import deepCopy from 'deep-copy';
+import { getFilePoliciesService } from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	camelToSnake,
+	merge,
+	mergeEach,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers';
+import type {
+	AddItemParams,
+	ApiId,
+	ApiParams,
+	DeleteItemParams,
+	GetItemParams,
+	PatchItemParams,
+	UpdateItemParams,
+} from '../_shared/types';
+
+const fieldsToSend = [
+	'name',
+	'description',
+	'channels',
+	'mimeTypes',
+	'retentionDays',
+	'speedDownload',
+	'speedUpload',
+	'maxUploadSize',
+	'enabled',
+	'encrypt',
+];
+
+/**
+ * The list endpoint returns nothing useful without an explicit field list, so
+ * this client always asks for the full row.
+ */
+const listFields = [
+	'id',
+	'name',
+	'description',
+	'channels',
+	'mime_types',
+	'retention_days',
+	'speed_download',
+	'speed_upload',
+	'max_upload_size',
+	'position',
+	'enabled',
+	'encrypt',
+];
+
+const defaultObject = {
+	name: '',
+	description: '',
+	channels: [],
+	mimeTypes: [],
+	retentionDays: 0,
+	speedDownload: 0,
+	speedUpload: 0,
+	maxUploadSize: 0,
+	position: 0,
+	enabled: false,
+};
+
+const preRequestHandler = (item: ApiParams) => {
+	const copy = deepCopy(item);
+	return {
+		...copy,
+		channels: item.channels.map(
+			(channel: ApiParams) => channel.value || channel,
+		),
+	};
+};
+
+const getStoragePoliciesList = async (params: ApiParams) => {
+	const { page, size, search, sort, id } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+	]);
+
+	try {
+		const response = await getFilePoliciesService().searchFilePolicies({
+			page,
+			size,
+			// the generated param is `q`; `search` is what the datalist store sends
+			q: search,
+			sort,
+			fields: listFields,
+			id,
+		});
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [
+				mergeEach(defaultObject),
+			]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getStoragePolicy = async ({ itemId: id }: GetItemParams) => {
+	try {
+		const response = await getFilePoliciesService().readFilePolicy(Number(id));
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			merge(defaultObject),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const addStoragePolicy = async ({ itemInstance }: AddItemParams) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitize(fieldsToSend),
+		// `channels` values mirror the StorageUploadFileChannel enum and stay camelCase
+		camelToSnake([
+			'channels',
+		]),
+	]);
+	try {
+		const response = await getFilePoliciesService().createFilePolicy(item);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const updateStoragePolicy = async ({
+	itemInstance,
+	itemId: id,
+}: UpdateItemParams) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler,
+		sanitize(fieldsToSend),
+		// `channels` values mirror the StorageUploadFileChannel enum and stay camelCase
+		camelToSnake([
+			'channels',
+		]),
+	]);
+	try {
+		const response = await getFilePoliciesService().updateFilePolicy(
+			Number(id),
+			item,
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const patchStoragePolicy = async ({ changes, id }: PatchItemParams) => {
+	const body = applyTransform(changes, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await getFilePoliciesService().patchFilePolicy(
+			Number(id),
+			body,
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const deleteStoragePolicy = async ({ id }: DeleteItemParams) => {
+	try {
+		const response = await getFilePoliciesService().deleteFilePolicy(
+			Number(id),
+		);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const movePositionStoragePolicy = async ({
+	fromId,
+	toId,
+}: {
+	fromId: ApiId;
+	toId: ApiId;
+}) => {
+	try {
+		const response = await getFilePoliciesService().movePositionFilePolicy(
+			Number(fromId),
+			Number(toId),
+			{},
+		);
+		return applyTransform(response.data, [
+			notify(({ callback }) =>
+				callback({
+					type: 'success',
+					text: 'Successfully saved',
+				}),
+			),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const applyStoragePolicies = async (id: ApiId) => {
+	try {
+		const response = await getFilePoliciesService().filePolicyApply(
+			Number(id),
+			{},
+		);
+		return response.data;
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getStoragePoliciesLookup = (
+	params: Parameters<typeof getStoragePoliciesList>[0],
+) =>
+	getStoragePoliciesList({
+		...params,
+		fields: params.fields || [
+			'id',
+			'name',
+		],
+	});
+
+export const StoragePoliciesAPI = {
+	getList: getStoragePoliciesList,
+	get: getStoragePolicy,
+	add: addStoragePolicy,
+	patch: patchStoragePolicy,
+	update: updateStoragePolicy,
+	delete: deleteStoragePolicy,
+	movePosition: movePositionStoragePolicy,
+	applyPolicies: applyStoragePolicies,
+	getLookup: getStoragePoliciesLookup,
+};

package/src/api/clients/teamHooks/teamHooks.ts

@@ -0,0 +1,195 @@
+import { getTeamHookService } from '../../../gen-wire';
+import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
+import {
+	applyTransform,
+	camelToSnake,
+	merge,
+	mergeEach,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers';
+import type {
+	ApiId,
+	ApiParams,
+	NestedAddItemParams,
+	NestedDeleteItemParams,
+	NestedGetItemParams,
+	NestedPatchItemParams,
+	NestedUpdateItemParams,
+} from '../_shared/types';
+
+const fieldsToSend = [
+	'event',
+	'properties',
+	'schema',
+	'enabled',
+];
+
+const preRequestHandler = (parentId: ApiId) => (item: ApiParams) => ({
+	...item,
+	teamId: parentId,
+});
+
+const getTeamHooksList = async (params: ApiParams) => {
+	const defaultObject = {
+		enabled: false,
+	};
+
+	const { page, size, search, sort, fields, id, parentId } = applyTransform(
+		params,
+		[
+			merge(getDefaultGetParams()),
+			starToSearch('search'),
+		],
+	);
+
+	try {
+		const response = await getTeamHookService().searchTeamHook(
+			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: applyTransform(items, [
+				mergeEach(defaultObject),
+			]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const getTeamHook = async ({ parentId, itemId: id }: NestedGetItemParams) => {
+	const defaultObject = {
+		event: '',
+		properties: [],
+		schema: {},
+		enabled: false,
+	};
+
+	try {
+		const response = await getTeamHookService().readTeamHook(
+			String(parentId),
+			Number(id),
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			merge(defaultObject),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const addTeamHook = async ({ parentId, itemInstance }: NestedAddItemParams) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler(parentId),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await getTeamHookService().createTeamHook(
+			String(parentId),
+			item,
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const patchTeamHook = async ({
+	parentId,
+	changes,
+	id,
+}: NestedPatchItemParams) => {
+	const body = applyTransform(changes, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await getTeamHookService().patchTeamHook(
+			String(parentId),
+			Number(id),
+			body,
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const updateTeamHook = async ({
+	parentId,
+	itemInstance,
+	itemId: id,
+}: NestedUpdateItemParams) => {
+	const item = applyTransform(itemInstance, [
+		preRequestHandler(parentId),
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await getTeamHookService().updateTeamHook(
+			String(parentId),
+			Number(id),
+			item,
+		);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+const deleteTeamHook = async ({ parentId, id }: NestedDeleteItemParams) => {
+	try {
+		const response = await getTeamHookService().deleteTeamHook(
+			String(parentId),
+			Number(id),
+		);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
+export const TeamHooksAPI = {
+	getList: getTeamHooksList,
+	get: getTeamHook,
+	add: addTeamHook,
+	patch: patchTeamHook,
+	update: updateTeamHook,
+	delete: deleteTeamHook,
+};

package/src/api/clients/teamTriggers/agentTriggers.ts

@@ -0,0 +1,77 @@
+import { getTeamTriggerService } from '../../../gen-wire';
+import { getDefaultGetListResponse } from '../../defaults';
+import {
+	applyTransform,
+	merge,
+	mergeEach,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers';
+import type { ApiId, ApiParams } from '../_shared/types';
+
+/**
+ * Triggers visible to the signed-in agent, across every team they belong to.
+ * `TeamFlowsAPI` is the admin-side view of the same entity, scoped to one team.
+ */
+const getAgentTriggersList = async (params: ApiParams) => {
+	const defaultObject = {
+		enabled: false,
+	};
+
+	const { page, size, search, sort, fields, id, enabled } = applyTransform(
+		params,
+		[
+			starToSearch('search'),
+		],
+	);
+
+	const response = await getTeamTriggerService().searchAgentTrigger({
+		page,
+		size,
+		// the generated param is `q`; `search` is what the datalist store sends
+		q: search,
+		sort,
+		fields,
+		enabled,
+		id,
+	});
+	const { items, next } = applyTransform(response.data, [
+		snakeToCamel(),
+		merge(getDefaultGetListResponse()),
+	]);
+	return {
+		items: applyTransform(items, [
+			mergeEach(defaultObject),
+		]),
+		next,
+	};
+};
+
+/**
+ * Deliberately does not notify: callers word the success and failure toasts
+ * themselves, and a notify here would double them.
+ */
+const runAgentTrigger = async ({ id }: { id: ApiId }) => {
+	const response = await getTeamTriggerService().runTeamTrigger(Number(id), {});
+	return applyTransform(response.data, [
+		snakeToCamel(),
+	]);
+};
+
+const getAgentTriggersLookup = (
+	params: Parameters<typeof getAgentTriggersList>[0],
+) =>
+	getAgentTriggersList({
+		...params,
+		fields: params.fields || [
+			'id',
+			'name',
+			'enabled',
+		],
+	});
+
+export const AgentTriggersAPI = {
+	getList: getAgentTriggersList,
+	run: runAgentTrigger,
+	getLookup: getAgentTriggersLookup,
+};