@webitel/api-services 26.8.44 → 26.8.46

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webitel/api-services",
-	"version": "26.8.44",
+	"version": "26.8.46",
 	"private": false,
 	"repository": {
 		"type": "git",

package/src/api/clients/logs/logs.ts

@@ -8,7 +8,7 @@ import {
 	snakeToCamel,
 	starToSearch,
 } from '../../transformers';
-import type { ApiParams } from '../_shared/types';
+import type { ApiParams, GetItemParams } from '../_shared/types';
 
 /**
  * The logger endpoints have no natural ordering, so both lists default to
@@ -146,6 +146,19 @@ const getLogsByConfigList = async (params: ApiParams) => {
 	}
 };
 
+const getLog = async ({ itemId: id }: GetItemParams) => {
+	try {
+		const response = await getLoggerService().loggerServiceGetLog(Number(id));
+		return applyTransform(response.data, [
+			snakeToCamel(),
+		]);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
 /** Audit log of everything one user did. */
 export const UserLogsAPI = {
 	getList: getLogsByUserList,
@@ -154,4 +167,5 @@ export const UserLogsAPI = {
 /** Audit log of everything done to one logger config's object. */
 export const ConfigLogsAPI = {
 	getList: getLogsByConfigList,
+	get: getLog,
 };

package/src/api/clients/wtTypes/sysTypes/__tests__/sysTypes.spec.ts

@@ -0,0 +1,101 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const get = vi.fn();
+
+vi.mock('../../../../defaults', async (importOriginal) => ({
+	...(await importOriginal<Record<string, unknown>>()),
+	getDefaultInstance: () => ({
+		get,
+	}),
+}));
+
+const { SysTypesAPI } = await import('../sysTypes');
+
+describe('SysTypesAPI.getLookup', () => {
+	beforeEach(() => get.mockReset());
+
+	it('queries the path with search, paging, preselected ids and schema filters', async () => {
+		get.mockResolvedValue({
+			data: {
+				items: [],
+			},
+		});
+
+		await SysTypesAPI.getLookup({
+			path: '/dictionary/cities',
+			display: 'name',
+			primary: 'id',
+			filters: [
+				'country=ua',
+			],
+			search: 'kyi',
+			id: [
+				7,
+			],
+			page: 2,
+		});
+
+		const url = get.mock.calls[0][0] as string;
+		expect(url.startsWith('/dictionary/cities?')).toBe(true);
+		expect(url).toContain('q=kyi%2A');
+		expect(url).toContain('page=2');
+		expect(url).toContain('ids=7');
+		expect(url).toContain('fields=id');
+		expect(url.endsWith('&country=ua')).toBe(true);
+	});
+
+	it('maps records to options by primary and a display template', async () => {
+		get.mockResolvedValue({
+			data: {
+				data: [
+					{
+						code: 7,
+						name: 'Kyiv',
+						region: {
+							name: 'Kyiv oblast',
+						},
+					},
+				],
+				next: true,
+			},
+		});
+
+		const response = await SysTypesAPI.getLookup({
+			path: '/dictionary/cities',
+			display: '{name} ({region.name}, {missing})',
+			primary: 'code',
+		});
+
+		expect(response.next).toBe(true);
+		expect(response.items[0]).toMatchObject({
+			id: 7,
+			name: 'Kyiv (Kyiv oblast, {missing})',
+		});
+	});
+
+	it('reads a plain dot-path display from `items` responses', async () => {
+		get.mockResolvedValue({
+			data: {
+				items: [
+					{
+						id: 'a',
+						profile: {
+							title: 'Alpha',
+						},
+					},
+				],
+			},
+		});
+
+		const response = await SysTypesAPI.getLookup({
+			path: '/objects',
+			display: 'profile.title',
+			primary: 'id',
+		});
+
+		expect(response.items[0]).toMatchObject({
+			id: 'a',
+			name: 'Alpha',
+		});
+	});
+});

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

@@ -4,6 +4,7 @@ import {
 	getDefaultInstance,
 } from '../../../defaults';
 import {
+	addQueryParamsToUrl,
 	applyTransform,
 	camelToSnake,
 	generateUrl,
@@ -16,15 +17,60 @@ import type { ApiParams } from '../../_shared/types';
 
 const instance = getDefaultInstance();
 
+type SysTypeRecord = Record<string, unknown>;
+
+// `{path.to.field}` placeholders in a display template
+const displayPlaceholder = /\{([^}]+)\}/g;
+
+const readPath = (record: SysTypeRecord, path: string): unknown =>
+	path
+		.split('.')
+		.reduce<unknown>(
+			(value, key) => (value as SysTypeRecord | undefined)?.[key],
+			record,
+		);
+
+/**
+ * A display is either a plain (dot-)path to one field, or a template such as
+ * `{name} ({code})`; an unresolved placeholder is left as written.
+ */
+const displayName = (display: string, record: SysTypeRecord): unknown => {
+	if (!display.match(displayPlaceholder)) return readPath(record, display);
+	return display.replace(displayPlaceholder, (_, key: string) => {
+		const value = readPath(record, key);
+		return value === undefined || value === null ? `{${key}}` : String(value);
+	});
+};
+
+/** Maps records to select options: `id` from `primary`, `name` from `display`. */
+const toSelectOptions =
+	({ display, primary }: { display?: string; primary?: string }) =>
+	(records: SysTypeRecord[]) =>
+		records.map((record) => ({
+			...record,
+			...(primary && {
+				id: record[primary],
+			}),
+			...(display && {
+				name: displayName(display, record),
+			}),
+		}));
+
+/**
+ * Records of a system type at `path`, for lookups. `filters` are pre-built
+ * `key=value` query conditions (as form schemas store them) appended as-is.
+ */
 const getSysTypeRecordsList = async ({
 	path,
 	display,
 	primary,
+	filters = [],
 	...params
 }: {
 	path: string;
 	display: string;
 	primary: string;
+	filters?: string[];
 } & ApiParams) => {
 	const fieldsToSend = [
 		'page',
@@ -50,6 +96,7 @@ const getSysTypeRecordsList = async ({
 		sanitize(fieldsToSend),
 		camelToSnake(),
 		generateUrl(path),
+		addQueryParamsToUrl(filters),
 	]);
 	try {
 		const response = await instance.get(url);
@@ -60,8 +107,11 @@ const getSysTypeRecordsList = async ({
 		return {
 			// Some endpoints return data, some return items so we need to check for both of them
 			items:
-				applyTransform(data || items, [
-					// transformItemsForSelect({ display, primary }),
+				applyTransform(data || items || [], [
+					toSelectOptions({
+						display,
+						primary,
+					}),
 				]) ?? [],
 			next,
 		};