@webitel/api-services 26.8.65 → 26.8.67

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

@@ -0,0 +1,85 @@
+import { getDefaultsFromZodSchema } from '@webitel/api-services/gen/utils';
+import { describe, expect, it } from 'vitest';
+
+import { teamSchema } from '../team.validations';
+
+const filledTeam = {
+	name: 'Support',
+	strategy: 'random',
+	maxNoAnswer: 3,
+	wrapUpTime: 15,
+	noAnswerDelayTime: 30,
+	taskAcceptTimeout: 30,
+	callTimeout: 60,
+	inviteChatTimeout: 30,
+};
+
+const issuePaths = (value: Record<string, unknown>) =>
+	teamSchema
+		.safeParse(value)
+		.error?.issues.map((issue) => issue.path.join('.')) ?? [];
+
+describe('teamSchema', () => {
+	it('seeds a new team with the defaults the form expects', () => {
+		expect(getDefaultsFromZodSchema(teamSchema, {})).toMatchObject({
+			name: '',
+			description: '',
+			strategy: '',
+			admin: [],
+			screenControl: false,
+			maxNoAnswer: 3,
+			wrapUpTime: 15,
+			noAnswerDelayTime: 30,
+			taskAcceptTimeout: 30,
+			callTimeout: 60,
+			inviteChatTimeout: 30,
+		});
+	});
+
+	it('requires a name and a strategy', () => {
+		const paths = issuePaths({
+			...filledTeam,
+			name: '',
+			strategy: '',
+		});
+
+		expect(paths).toContain('name');
+		expect(paths).toContain('strategy');
+	});
+
+	it('requires every timing parameter', () => {
+		const paths = issuePaths({
+			...filledTeam,
+			maxNoAnswer: null,
+			wrapUpTime: null,
+			noAnswerDelayTime: null,
+			taskAcceptTimeout: null,
+			callTimeout: null,
+			inviteChatTimeout: null,
+		});
+
+		expect(paths).toEqual(
+			expect.arrayContaining([
+				'maxNoAnswer',
+				'wrapUpTime',
+				'noAnswerDelayTime',
+				'taskAcceptTimeout',
+				'callTimeout',
+				'inviteChatTimeout',
+			]),
+		);
+	});
+
+	it('accepts a zero timing parameter', () => {
+		expect(
+			teamSchema.safeParse({
+				...filledTeam,
+				wrapUpTime: 0,
+			}).success,
+		).toBe(true);
+	});
+
+	it('accepts a filled team', () => {
+		expect(teamSchema.safeParse(filledTeam).success).toBe(true);
+	});
+});

package/src/validations/team/team.validations.ts

@@ -0,0 +1,20 @@
+import type { EngineAgentTeam } from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+
+import { flexibleLookupSchema } from '../_shared/lookup.validations';
+import type { ZodShape } from '../types';
+
+export const teamSchema = z.object<ZodShape<EngineAgentTeam>>({
+	id: z.string().optional(),
+	name: z.string().min(1).default(''),
+	description: z.string().optional().default(''),
+	strategy: z.string().min(1).default(''),
+	admin: z.array(flexibleLookupSchema).optional().default([]),
+	screenControl: z.boolean().optional().default(false),
+	maxNoAnswer: z.number().default(3),
+	wrapUpTime: z.number().default(15),
+	noAnswerDelayTime: z.number().default(30),
+	taskAcceptTimeout: z.number().default(30),
+	callTimeout: z.number().default(60),
+	inviteChatTimeout: z.number().default(30),
+});

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

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+
+import { teamAgentSchema } from '../teamAgent.validations';
+
+describe('teamAgentSchema', () => {
+	it('requires an agent', () => {
+		expect(
+			teamAgentSchema.safeParse({
+				agent: {},
+			}).success,
+		).toBe(false);
+	});
+
+	it('accepts a picked agent', () => {
+		expect(
+			teamAgentSchema.safeParse({
+				agent: {
+					id: '1',
+					name: 'John',
+				},
+			}).success,
+		).toBe(true);
+	});
+});

package/src/validations/teamAgent/teamAgent.validations.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+import { filledLookupSchema } from '../_shared/lookup.validations';
+
+export const teamAgentSchema = z.object({
+	agent: filledLookupSchema,
+});

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

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+
+import { teamFlowSchema } from '../teamFlow.validations';
+
+const issuePaths = (value: Record<string, unknown>) =>
+	teamFlowSchema
+		.safeParse(value)
+		.error?.issues.map((issue) => issue.path.join('.')) ?? [];
+
+describe('teamFlowSchema', () => {
+	it('requires a name and a flow schema', () => {
+		const paths = issuePaths({
+			name: '',
+			schema: {},
+		});
+
+		expect(paths).toContain('name');
+		expect(paths).toContain('schema');
+	});
+
+	it('accepts a filled flow', () => {
+		expect(
+			teamFlowSchema.safeParse({
+				name: 'Service',
+				schema: {
+					id: 1,
+					name: 'Flow',
+				},
+			}).success,
+		).toBe(true);
+	});
+});

package/src/validations/teamFlow/teamFlow.validations.ts

@@ -0,0 +1,12 @@
+import type { EngineTeamTrigger } from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+
+import { filledLookupSchema } from '../_shared/lookup.validations';
+import type { ZodShape } from '../types';
+
+export const teamFlowSchema = z.object<ZodShape<EngineTeamTrigger>>({
+	name: z.string().min(1),
+	description: z.string().optional(),
+	schema: filledLookupSchema,
+	enabled: z.boolean().default(true),
+});

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

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+
+import { teamHookSchema } from '../teamHook.validations';
+
+const issuePaths = (value: Record<string, unknown>) =>
+	teamHookSchema
+		.safeParse(value)
+		.error?.issues.map((issue) => issue.path.join('.')) ?? [];
+
+describe('teamHookSchema', () => {
+	it('requires an event and a flow schema', () => {
+		const paths = issuePaths({
+			event: '',
+			schema: {},
+		});
+
+		expect(paths).toContain('event');
+		expect(paths).toContain('schema');
+	});
+
+	it('accepts a filled hook', () => {
+		expect(
+			teamHookSchema.safeParse({
+				event: 'agent_status',
+				schema: {
+					id: 1,
+					name: 'Flow',
+				},
+			}).success,
+		).toBe(true);
+	});
+});

package/src/validations/teamHook/teamHook.validations.ts

@@ -0,0 +1,12 @@
+import type { EngineTeamHook } from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+
+import { filledLookupSchema } from '../_shared/lookup.validations';
+import type { ZodShape } from '../types';
+
+export const teamHookSchema = z.object<ZodShape<EngineTeamHook>>({
+	event: z.string().min(1),
+	schema: filledLookupSchema,
+	properties: z.array(z.string()).optional(),
+	enabled: z.boolean().default(true),
+});