@webitel/api-services 0.0.24 → 0.0.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webitel/api-services",
-  "version": "0.0.24",
+  "version": "0.0.27",
   "private": false,
   "scripts": {
     "make-all": "npm run gen:api && npm version patch && npm run publish-lib",
@@ -11,27 +11,32 @@
     "gen:api:typedoc": "npx typedoc",
     "gen:api:cleanup": "rm swagger.yaml formatted-openapi.yaml",
     "build:types": "vue-tsc -p ./tsconfig.build.json",
+    "format:all": "npx biome check --write --unsafe ./src",
     "orval": "orval",
     "lint:package": "publint",
     "utils:i": "npm i"
   },
   "type": "module",
   "exports": {
+    "./api": {
+      "types": "./types/api/index.d.ts",
+      "import": "./src/api/index.ts"
+    },
     "./gen": {
-      "import": "./src/gen/index.ts",
-      "types": "./types/gen/index.d.ts"
+      "types": "./types/gen/index.d.ts",
+      "import": "./src/gen/index.ts"
     },
     "./utils": {
-      "import": "./src/utils/index.ts",
-      "types": "./types/utils/index.d.ts"
+      "types": "./types/utils/index.d.ts",
+      "import": "./src/utils/index.ts"
     },
     "./gen/utils": {
-      "import": "./src/utils/gen/index.ts",
-      "types": "./types/utils/gen/index.d.ts"
+      "types": "./types/utils/gen/index.d.ts",
+      "import": "./src/utils/gen/index.ts"
     },
     "./gen/models": {
-      "import": "./src/gen/_models/index.ts",
-      "types": "./types/gen/_models/index.d.ts"
+      "types": "./types/gen/_models/index.d.ts",
+      "import": "./src/gen/_models/index.ts"
     }
   },
   "files": [
@@ -48,7 +53,7 @@
     "zod": "^3.25.55"
   },
   "devDependencies": {
-    "@biomejs/biome": "1.9.4",
+    "@biomejs/biome": "2.0.4",
     "@tsconfig/node22": "^22.0.0",
     "@types/node": "^22.13.10",
     "axios": "^1.10.0",

package/src/api/axios/generateInstance.ts

@@ -0,0 +1,35 @@
+import axios from 'axios';
+
+/**
+ * Generates an Axios instance with custom configuration
+ * @param options - Configuration options
+ * @param options.interceptors - Request and response interceptors
+ * @param options.baseURL - Base URL for the instance
+ * @param options.rest - Additional Axios configuration options
+ * @returns Configured Axios instance
+ */
+export const generateInstance = ({ interceptors, baseURL, ...rest } = {}) => {
+	const instance = axios.create({
+		baseURL,
+		headers: {
+			'X-Webitel-Access': localStorage.getItem('access-token') || '',
+		},
+		...rest,
+	});
+
+	if (interceptors) {
+		const { request, response } = interceptors;
+		if (request) {
+			for (const interceptor of request) {
+				instance.interceptors.request.use(...interceptor);
+			}
+		}
+		if (response) {
+			for (const interceptor of response) {
+				instance.interceptors.response.use(...interceptor);
+			}
+		}
+	}
+
+	return instance;
+};

package/src/api/axios/index.ts

@@ -0,0 +1,2 @@
+// Export axios directory contents
+export * from './generateInstance';

package/src/api/clients/_shared/generatePermissionsApi.ts

@@ -0,0 +1,97 @@
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	generateUrl,
+	merge,
+	mergeEach,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers/index';
+
+const permissionsUrl = 'acl';
+
+const handlePermissionsList = (items) => {
+	return items.map((item) => ({
+		...item,
+		access: {
+			x: {
+				id: (item.granted.match(/x/g) || []).length + 1,
+				rule: 'x'.repeat((item.granted.match(/x/g) || []).length),
+			},
+			r: {
+				id: (item.granted.match(/r/g) || []).length + 1,
+				rule: 'r'.repeat((item.granted.match(/r/g) || []).length),
+			},
+			w: {
+				id: (item.granted.match(/w/g) || []).length + 1,
+				rule: 'w'.repeat((item.granted.match(/w/g) || []).length),
+			},
+			d: {
+				id: (item.granted.match(/d/g) || []).length + 1,
+				rule: 'd'.repeat((item.granted.match(/d/g) || []).length),
+			},
+		},
+	}));
+};
+
+export const generatePermissionsApi = (baseUrl) => {
+	const instance = getDefaultInstance();
+
+	const getList = async ({ parentId, ...params }) => {
+		const fieldsToSend = ['page', 'size', 'q', 'sort', 'fields', 'id'];
+
+		const defaultObject = {
+			user: false,
+		};
+
+		const url = applyTransform(params, [
+			merge(getDefaultGetParams()),
+			starToSearch('search'),
+			(params) => ({
+				...params,
+				q: params.search,
+			}),
+			sanitize(fieldsToSend),
+			camelToSnake(),
+			generateUrl(`${baseUrl}/${parentId}/${permissionsUrl}`),
+		]);
+		try {
+			const response = await instance.get(url);
+			const { items, next } = applyTransform(response.data, [
+				snakeToCamel(),
+				merge(getDefaultGetListResponse()),
+			]);
+			return {
+				items: applyTransform(items, [
+					mergeEach(defaultObject),
+					handlePermissionsList,
+				]),
+				next,
+			};
+		} catch (err) {
+			throw applyTransform(err, [notify]);
+		}
+	};
+
+	const patch = async ({ changes, id }) => {
+		const body = applyTransform(changes, [camelToSnake()]);
+		const url = `${baseUrl}/${id}/${permissionsUrl}`;
+		try {
+			const response = await instance.patch(url, body);
+			return applyTransform(response.data, [snakeToCamel()]);
+		} catch (err) {
+			throw applyTransform(err, [notify]);
+		}
+	};
+
+	return {
+		getPermissionsList: getList,
+		patchPermissions: patch,
+	};
+};

package/src/api/clients/agents/agentChats.ts

@@ -0,0 +1,71 @@
+import { AgentChatServiceApiFactory } from 'webitel-sdk';
+
+import i18n from '../../../locale/i18n';
+import {
+	getDefaultGetParams,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+	merge,
+	notify,
+	snakeToCamel,
+} from '../../transformers/index';
+
+const { t } = i18n.global;
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const agentChatsService = AgentChatServiceApiFactory(
+	configuration,
+	'',
+	instance,
+);
+
+const getChatsList = async (params) => {
+	const { size, page, onlyClosed, onlyUnprocessed } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+	]);
+
+	try {
+		const response = await agentChatsService.getAgentChats(
+			size,
+			page,
+			undefined,
+			undefined,
+			undefined,
+			onlyClosed,
+			onlyUnprocessed,
+		);
+		const { items, next } = applyTransform(response.data, [snakeToCamel()]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const markChatProcessed = async (chatId) => {
+	// add to chat unprocessedClose: true
+	try {
+		const response = await agentChatsService.markChatProcessed(chatId);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify(({ callback }) =>
+				callback({
+					type: 'error',
+					text: t('errorNotifications.markChatProcessed'),
+				}),
+			),
+		]);
+	}
+};
+
+export const AgentChatsAPI = {
+	getList: getChatsList,
+	markChatProcessed,
+};

package/src/api/clients/agents/agents.ts

@@ -0,0 +1,263 @@
+import { AgentServiceApiFactory } from 'webitel-sdk';
+
+import convertDuration from '../../../scripts/convertDuration';
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const agentService = AgentServiceApiFactory(configuration, '', instance);
+
+const convertStatusDuration = (value) => {
+	if (value > 60 * 60 * 24) return '>24:00:00';
+	return convertDuration(value);
+};
+
+const getAgentsList = async (params) => {
+	const listResponseHandler = (items) => {
+		return items.map((item) => ({
+			...item,
+			statusDuration: convertStatusDuration(item.statusDuration),
+		}));
+	};
+
+	const {
+		page,
+		size,
+		search,
+		sort,
+		fields,
+		id,
+		team,
+		skill,
+		isSupervisor,
+		isNotSupervisor,
+		notTeamId,
+		supervisorId,
+		notSkillId,
+	} = applyTransform(params, [merge(getDefaultGetParams())]);
+
+	try {
+		const response = await agentService.searchAgent(
+			page,
+			size,
+			search,
+			sort,
+			fields,
+			id,
+			undefined,
+			supervisorId,
+			team,
+			undefined,
+			undefined,
+			isSupervisor,
+			skill,
+			undefined,
+			isNotSupervisor,
+			undefined,
+			undefined,
+			notTeamId,
+			notSkillId,
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items: applyTransform(items, [listResponseHandler]),
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getAgent = async ({ itemId: id }) => {
+	const defaultObject = {
+		user: {},
+		team: {},
+		supervisor: [],
+		auditor: [],
+		region: {},
+		progressiveCount: 0,
+		chatCount: 0,
+		taskCount: 0,
+		isSupervisor: false,
+		description: '',
+		greetingMedia: {},
+	};
+
+	try {
+		const response = await agentService.readAgent(id);
+		return applyTransform(response.data, [
+			snakeToCamel(),
+			merge(defaultObject),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const fieldsToSend = [
+	'user',
+	'team',
+	'supervisor',
+	'auditor',
+	'region',
+	'greetingMedia',
+	'progressiveCount',
+	'chatCount',
+	'taskCount',
+	'isSupervisor',
+];
+
+const addAgent = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await agentService.createAgent(item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const patchAgent = async ({ changes, id }) => {
+	const body = applyTransform(changes, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await agentService.patchAgent(id, body);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateAgent = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await agentService.updateAgent(id, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteAgent = async ({ id }) => {
+	try {
+		const response = await agentService.deleteAgent(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getAgentsLookup = (params) =>
+	getAgentsList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+const getAgentHistory = async (params) => {
+	const {
+		parentId,
+		from,
+		to,
+		page,
+		size,
+		sort = '-joined_at',
+	} = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+	]);
+
+	try {
+		const response = await agentService.searchAgentStateHistory(
+			page,
+			size,
+			from,
+			to,
+			parentId,
+			sort,
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getAgentUsersOptions = async (params) => {
+	const { page, size, search, sort, fields, id } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+	]);
+
+	try {
+		const response = await agentService.searchLookupUsersAgentNotExists(
+			page,
+			size,
+			search,
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+const getSupervisorOptions = async (params) => {
+	const isSupervisor = true;
+	return getAgentsList({ ...params, isSupervisor });
+};
+
+const getRegularAgentsOptions = async (params) => {
+	const isNotSupervisor = true;
+	return getAgentsList({ ...params, isNotSupervisor });
+};
+
+export const AgentsAPI = {
+	getList: getAgentsList,
+	get: getAgent,
+	add: addAgent,
+	patch: patchAgent,
+	update: updateAgent,
+	delete: deleteAgent,
+	getLookup: getAgentsLookup,
+
+	getAgentHistory,
+	getRegularAgentsOptions,
+	getAgentUsersOptions,
+	getSupervisorOptions,
+};

package/src/api/clients/buckets/buckets.ts

@@ -0,0 +1,110 @@
+import { BucketServiceApiFactory } from 'webitel-sdk';
+
+import {
+	getDefaultGetListResponse,
+	getDefaultGetParams,
+	getDefaultInstance,
+	getDefaultOpenAPIConfig,
+} from '../../defaults/index';
+import applyTransform, {
+	camelToSnake,
+	merge,
+	notify,
+	sanitize,
+	snakeToCamel,
+	starToSearch,
+} from '../../transformers/index';
+
+const instance = getDefaultInstance();
+const configuration = getDefaultOpenAPIConfig();
+
+const bucketService = BucketServiceApiFactory(configuration, '', instance);
+
+const getBucketsList = async (params) => {
+	const { page, size, search, sort, fields, id } = applyTransform(params, [
+		merge(getDefaultGetParams()),
+		starToSearch('search'),
+	]);
+
+	try {
+		const response = await bucketService.searchBucket(
+			page,
+			size,
+			search,
+			sort,
+			fields,
+			id,
+		);
+		const { items, next } = applyTransform(response.data, [
+			snakeToCamel(),
+			merge(getDefaultGetListResponse()),
+		]);
+		return {
+			items,
+			next,
+		};
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getBucket = async ({ itemId: id }) => {
+	try {
+		const response = await bucketService.readBucket(id);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const fieldsToSend = ['name', 'description'];
+
+const addBucket = async ({ itemInstance }) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await bucketService.createBucket(item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const updateBucket = async ({ itemInstance, itemId: id }) => {
+	const item = applyTransform(itemInstance, [
+		sanitize(fieldsToSend),
+		camelToSnake(),
+	]);
+	try {
+		const response = await bucketService.updateBucket(id, item);
+		return applyTransform(response.data, [snakeToCamel()]);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const deleteBucket = async ({ id }) => {
+	try {
+		const response = await bucketService.deleteBucket(id);
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [notify]);
+	}
+};
+
+const getBucketsLookup = (params) =>
+	getBucketsList({
+		...params,
+		fields: params.fields || ['id', 'name'],
+	});
+
+export const BucketsAPI = {
+	getList: getBucketsList,
+	get: getBucket,
+	add: addBucket,
+	update: updateBucket,
+	delete: deleteBucket,
+	getLookup: getBucketsLookup,
+};