@webitel/api-services 26.8.70 → 26.8.72

package/src/validations/_shared/timeRange.validations.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+
+import { i18nIssue } from './i18nIssue';
+
+export const dayMinuteSchema = z
+	.number()
+	.int()
+	.refine((value) => value >= 0 && value < 24 * 60, i18nIssue('hourRange'));
+
+export type TimeRange = {
+	start: number;
+	end: number;
+};
+
+export type TimeRangeError = {
+	index: number;
+	prop: string;
+	key: string;
+};
+
+const RANGE_PROPS = [
+	'start',
+	'end',
+] as const;
+
+const addRangeIssue = (
+	ctx: z.RefinementCtx,
+	key: string,
+	...path: number[]
+) => {
+	RANGE_PROPS.forEach((prop) => {
+		ctx.addIssue({
+			code: 'custom',
+			path: [
+				...path,
+				prop,
+			],
+			...i18nIssue(key),
+		});
+	});
+};
+
+export const refineTimeRangeStartLessThanEnd = (
+	item: TimeRange,
+	ctx: z.RefinementCtx,
+) => {
+	if (item.start >= item.end) addRangeIssue(ctx, 'timerangeStartLessThanEnd');
+};
+
+export const timeRangeSchema = z
+	.object({
+		start: dayMinuteSchema,
+		end: dayMinuteSchema,
+	})
+	.superRefine(refineTimeRangeStartLessThanEnd);
+
+const isIntersecting = (a: TimeRange, b: TimeRange) =>
+	a.start <= b.end && b.start <= a.end;
+
+export const refineTimeRangesNotIntersect =
+	<T extends TimeRange>(groupBy?: (item: T) => unknown) =>
+	(items: T[], ctx: z.RefinementCtx) => {
+		items.forEach((item, index) => {
+			const hasIntersection = items.some(
+				(other, otherIndex) =>
+					otherIndex !== index &&
+					groupBy?.(item) === groupBy?.(other) &&
+					isIntersecting(item, other),
+			);
+
+			if (hasIntersection) addRangeIssue(ctx, 'timerangeNotIntersect', index);
+		});
+	};
+
+export const getTimeRangeErrors = (
+	schema: z.ZodType,
+	items: unknown,
+): TimeRangeError[] => {
+	const result = schema.safeParse(items);
+
+	if (result.success) return [];
+
+	return result.error.issues.flatMap((issue) => {
+		const [index, prop] = issue.path;
+		const key = issue.code === 'custom' ? issue.params?.i18nKey : undefined;
+
+		if (
+			typeof index !== 'number' ||
+			typeof prop !== 'string' ||
+			typeof key !== 'string'
+		) {
+			return [];
+		}
+
+		return [
+			{
+				index,
+				prop,
+				key,
+			},
+		];
+	});
+};

package/src/validations/calendar/__tests__/calendar.validations.spec.ts

@@ -4,7 +4,7 @@ import type { z } from 'zod';
 import * as validationsIndex from '../../index';
 import {
 	calendarSchema,
-	getCalendarDayRangeIssues,
+	getCalendarDayRangeErrors,
 } from '../calendar.validations';
 
 /** custom rules carry their message key in params, see `i18nIssue` */
@@ -668,7 +668,7 @@ describe('validations barrel export', () => {
 	});
 });
 
-describe('getCalendarDayRangeIssues', () => {
+describe('getCalendarDayRangeErrors', () => {
 	const row = (day: number, start: number, end: number) => ({
 		day,
 		disabled: false,
@@ -678,7 +678,7 @@ describe('getCalendarDayRangeIssues', () => {
 
 	it('reports nothing for valid rows', () => {
 		expect(
-			getCalendarDayRangeIssues([
+			getCalendarDayRangeErrors([
 				row(0, 540, 541),
 				row(0, 600, 660),
 				row(1, 540, 1200),
@@ -688,7 +688,7 @@ describe('getCalendarDayRangeIssues', () => {
 
 	it('reports both ends of a row whose start is not before its end', () => {
 		expect(
-			getCalendarDayRangeIssues([
+			getCalendarDayRangeErrors([
 				row(0, 600, 540),
 			]),
 		).toEqual([
@@ -706,15 +706,15 @@ describe('getCalendarDayRangeIssues', () => {
 	});
 
 	it('reports every row of an overlap on the same day', () => {
-		const issues = getCalendarDayRangeIssues([
+		const errors = getCalendarDayRangeErrors([
 			row(0, 540, 720),
 			row(0, 600, 780),
 		]);
 
-		expect(issues.every(({ key }) => key === 'timerangeNotIntersect')).toBe(
+		expect(errors.every(({ key }) => key === 'timerangeNotIntersect')).toBe(
 			true,
 		);
-		expect(issues.map(({ index, prop }) => `${index}.${prop}`).sort()).toEqual([
+		expect(errors.map(({ index, prop }) => `${index}.${prop}`).sort()).toEqual([
 			'0.end',
 			'0.start',
 			'1.end',
@@ -724,7 +724,7 @@ describe('getCalendarDayRangeIssues', () => {
 
 	it('does not treat the same hours on different days as an overlap', () => {
 		expect(
-			getCalendarDayRangeIssues([
+			getCalendarDayRangeErrors([
 				row(0, 540, 720),
 				row(2, 540, 720),
 			]),
@@ -733,7 +733,7 @@ describe('getCalendarDayRangeIssues', () => {
 
 	it('reports a minute outside the day', () => {
 		expect(
-			getCalendarDayRangeIssues([
+			getCalendarDayRangeErrors([
 				row(0, 0, 24 * 60),
 			]),
 		).toEqual([

package/src/validations/calendar/calendar.validations.ts

@@ -1,67 +1,14 @@
 import type { EngineCalendar } from '@webitel/api-services/gen/models';
 import { z } from 'zod';
-import { i18nIssue } from '../_shared/i18nIssue';
 import { requiredLookupSchema } from '../_shared/lookup.validations';
+import {
+	dayMinuteSchema,
+	getTimeRangeErrors,
+	refineTimeRangeStartLessThanEnd,
+	refineTimeRangesNotIntersect,
+} from '../_shared/timeRange.validations';
 import type { ZodShape } from '../types';
 
-const HOUR_RANGE_KEY = 'hourRange';
-const TIMERANGE_START_LESS_THAN_END_KEY = 'timerangeStartLessThanEnd';
-const TIMERANGE_NOT_INTERSECT_KEY = 'timerangeNotIntersect';
-
-/** Legacy hourRange: value >= 0 && value < 1440 */
-const dayMinuteSchema = z
-	.number()
-	.int()
-	.refine((value) => value >= 0 && value < 24 * 60, i18nIssue(HOUR_RANGE_KEY));
-
-type AcceptOfDayUi = {
-	day: number;
-	start: number;
-	end: number;
-};
-
-const getIntersectingIndices = (items: AcceptOfDayUi[]) => {
-	const indices = new Set<number>();
-	const indicesByDay = new Map<number, number[]>();
-
-	items.forEach((item, index) => {
-		const dayIndices = indicesByDay.get(item.day) ?? [];
-		dayIndices.push(index);
-		indicesByDay.set(item.day, dayIndices);
-	});
-
-	indicesByDay.forEach((dayIndices) => {
-		const ranges: Array<{
-			start: number;
-			end: number;
-			index: number;
-		}> = [];
-
-		dayIndices.forEach((index) => {
-			const current = items[index];
-
-			ranges.forEach((range) => {
-				if (
-					(current.start >= range.start && current.end <= range.end) ||
-					(current.start <= range.start && current.end >= range.start) ||
-					(current.start <= range.end && current.end >= range.end)
-				) {
-					indices.add(index);
-					indices.add(range.index);
-				}
-			});
-
-			ranges.push({
-				start: current.start,
-				end: current.end,
-				index,
-			});
-		});
-	});
-
-	return indices;
-};
-
 /** UI shape: minutes as `start`/`end` (API maps to startTimeOfDay/endTimeOfDay). */
 const acceptOfDayUiSchema = z
 	.object({
@@ -70,54 +17,11 @@ const acceptOfDayUiSchema = z
 		start: dayMinuteSchema,
 		end: dayMinuteSchema,
 	})
-	.superRefine((item, ctx) => {
-		if (item.start >= item.end) {
-			ctx.addIssue({
-				code: 'custom',
-				path: [
-					'start',
-				],
-				...i18nIssue(TIMERANGE_START_LESS_THAN_END_KEY),
-			});
-			ctx.addIssue({
-				code: 'custom',
-				path: [
-					'end',
-				],
-				...i18nIssue(TIMERANGE_START_LESS_THAN_END_KEY),
-			});
-		}
-	});
+	.superRefine(refineTimeRangeStartLessThanEnd);
 
 const acceptsOfDayUiArraySchema = z
 	.array(acceptOfDayUiSchema)
-	.superRefine((items, ctx) => {
-		getIntersectingIndices(items).forEach((index) => {
-			ctx.addIssue({
-				code: 'custom',
-				path: [
-					index,
-					'start',
-				],
-				...i18nIssue(TIMERANGE_NOT_INTERSECT_KEY),
-			});
-			ctx.addIssue({
-				code: 'custom',
-				path: [
-					index,
-					'end',
-				],
-				...i18nIssue(TIMERANGE_NOT_INTERSECT_KEY),
-			});
-		});
-	});
-
-export type CalendarDayRangeIssue = {
-	index: number;
-	prop: string;
-	/** message key, resolve as `validation.<key>` */
-	key: string;
-};
+	.superRefine(refineTimeRangesNotIntersect((item) => item.day));
 
 /**
  * The same rules as the card schema, reported per row so a form can mark the
@@ -127,33 +31,8 @@ export type CalendarDayRangeIssue = {
  * verdicts (overlapping ranges) are only re-derived by a full `$validate()`,
  * so a row the user has not touched keeps a message that is no longer true.
  */
-export const getCalendarDayRangeIssues = (
-	items: unknown,
-): CalendarDayRangeIssue[] => {
-	const result = acceptsOfDayUiArraySchema.safeParse(items);
-
-	if (result.success) return [];
-
-	return result.error.issues.flatMap((issue) => {
-		const [index, prop] = issue.path;
-		const key =
-			issue.code === 'custom' && typeof issue.params?.i18nKey === 'string'
-				? issue.params.i18nKey
-				: undefined;
-
-		if (typeof index !== 'number' || typeof prop !== 'string' || !key) {
-			return [];
-		}
-
-		return [
-			{
-				index,
-				prop,
-				key,
-			},
-		];
-	});
-};
+export const getCalendarDayRangeErrors = (items: unknown) =>
+	getTimeRangeErrors(acceptsOfDayUiArraySchema, items);
 
 export const calendarExceptSchema = z.object({
 	name: z.string().min(1),

package/src/validations/index.ts

@@ -3,6 +3,7 @@ export * from './_shared/duration.validations';
 export * from './_shared/i18nIssue';
 export * from './_shared/lookup.validations';
 export * from './_shared/phoneNumber.validations';
+export * from './_shared/timeRange.validations';
 export * from './_shared/variablePair.validations';
 export * from './adjunctType/adjunctType.validations';
 export * from './agent/agent.validations';
@@ -44,6 +45,10 @@ export * from './queueMember/memberCommunication.validations';
 export * from './queueMember/queueMember.validations';
 export * from './queueResGroup/queueResGroup.validations';
 export * from './queueSkill/queueSkill.validations';
+export * from './resource/resource.validations';
+export * from './resourceDisplay/resourceDisplay.validations';
+export * from './resourceGroup/resourceGroup.validations';
+export * from './resourceInGroup/resourceInGroup.validations';
 export * from './sla/sla.validations';
 export * from './slaCondition/slaCondition.validations';
 export * from './team/team.validations';

package/src/validations/resource/__tests__/resource.validations.spec.ts

@@ -0,0 +1,102 @@
+import { getDefaultsFromZodSchema } from '@webitel/api-services/gen/utils';
+import { describe, expect, it } from 'vitest';
+
+import { resourceSchema } from '../resource.validations';
+
+const filledResource = {
+	name: 'Resource',
+	gateway: {
+		id: 1,
+		name: 'Gateway',
+	},
+	rps: 10,
+	limit: 10,
+	maxSuccessivelyErrors: 2,
+};
+
+const issuePaths = (value: Record<string, unknown>) =>
+	resourceSchema
+		.safeParse(value)
+		.error?.issues.map((issue) => issue.path.join('.')) ?? [];
+
+describe('resourceSchema', () => {
+	it('seeds a new resource with the defaults the form expects', () => {
+		expect(getDefaultsFromZodSchema(resourceSchema, {})).toMatchObject({
+			name: '',
+			rps: 10,
+			limit: 10,
+			description: '',
+			maxSuccessivelyErrors: 2,
+			errorIds: [],
+			patterns: [],
+			failureDialDelay: 0,
+			parameters: {
+				cidType: '',
+				ignoreEarlyMedia: '',
+			},
+		});
+	});
+
+	it('accepts a filled resource', () => {
+		expect(resourceSchema.safeParse(filledResource).success).toBe(true);
+	});
+
+	it('requires a name, a gateway, rps, limit and max successive errors', () => {
+		const paths = issuePaths({
+			name: '',
+			gateway: {},
+			rps: null,
+			limit: null,
+			maxSuccessivelyErrors: null,
+		});
+
+		expect(paths).toEqual(
+			expect.arrayContaining([
+				'name',
+				'gateway',
+				'rps',
+				'limit',
+				'maxSuccessivelyErrors',
+			]),
+		);
+	});
+
+	it('keeps rps and limit within their ranges', () => {
+		expect(
+			issuePaths({
+				...filledResource,
+				rps: 1001,
+				limit: 5001,
+			}),
+		).toEqual([
+			'rps',
+			'limit',
+		]);
+		expect(
+			issuePaths({
+				...filledResource,
+				rps: -2,
+				limit: -2,
+			}),
+		).toEqual([
+			'rps',
+			'limit',
+		]);
+		expect(
+			issuePaths({
+				...filledResource,
+				rps: -1,
+				limit: -1,
+			}),
+		).toEqual([]);
+	});
+
+	it('lets the failure dial delay be cleared', () => {
+		expect(
+			resourceSchema.safeParse({
+				...filledResource,
+				failureDialDelay: null,
+			}).success,
+		).toBe(true);
+	});
+});

package/src/validations/resource/resource.validations.ts

@@ -0,0 +1,28 @@
+import type { EngineOutboundResource } from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+
+import { clearableNumberSchema } from '../_shared/clearableNumber.validations';
+import { filledLookupSchema } from '../_shared/lookup.validations';
+import type { ZodShape } from '../types';
+
+export const resourceSchema = z.object<ZodShape<EngineOutboundResource>>({
+	name: z.string().min(1).default(''),
+	gateway: filledLookupSchema,
+	rps: z.number().min(-1).max(1000).default(10),
+	limit: z.number().min(-1).max(5000).default(10),
+	description: z.string().optional().default(''),
+	maxSuccessivelyErrors: z.number().default(2),
+	errorIds: z.array(z.string()).optional().default([]),
+	patterns: z.array(z.string()).optional().default([]),
+	failureDialDelay: clearableNumberSchema.default(0),
+	parameters: z
+		.object({
+			cidType: z.string().optional().default(''),
+			ignoreEarlyMedia: z.string().optional().default(''),
+		})
+		.optional()
+		.default({
+			cidType: '',
+			ignoreEarlyMedia: '',
+		}),
+});

package/src/validations/resourceDisplay/__tests__/resourceDisplay.validations.spec.ts

@@ -0,0 +1,45 @@
+import { getDefaultsFromZodSchema } from '@webitel/api-services/gen/utils';
+import { describe, expect, it } from 'vitest';
+
+import { resourceDisplaySchema } from '../resourceDisplay.validations';
+
+const issuePaths = (value: Record<string, unknown>) =>
+	resourceDisplaySchema
+		.safeParse(value)
+		.error?.issues.map((issue) => issue.path.join('.')) ?? [];
+
+describe('resourceDisplaySchema', () => {
+	it('seeds a new number with an empty display', () => {
+		expect(getDefaultsFromZodSchema(resourceDisplaySchema, {})).toMatchObject({
+			display: '',
+		});
+	});
+
+	it('requires a number', () => {
+		expect(
+			issuePaths({
+				display: '',
+			}),
+		).toEqual([
+			'display',
+		]);
+	});
+
+	it('rejects symbols a number cannot dial', () => {
+		expect(
+			issuePaths({
+				display: '380 44 123',
+			}),
+		).toEqual([
+			'display',
+		]);
+	});
+
+	it('accepts a dialable number', () => {
+		expect(
+			resourceDisplaySchema.safeParse({
+				display: '+380441234567',
+			}).success,
+		).toBe(true);
+	});
+});

package/src/validations/resourceDisplay/resourceDisplay.validations.ts

@@ -0,0 +1,9 @@
+import type { EngineResourceDisplay } from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+
+import { phoneNumberSchema } from '../_shared/phoneNumber.validations';
+import type { ZodShape } from '../types';
+
+export const resourceDisplaySchema = z.object<ZodShape<EngineResourceDisplay>>({
+	display: phoneNumberSchema.default(''),
+});