@webitel/api-services 26.8.76 → 26.8.78

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

@@ -0,0 +1,85 @@
+import { describe, expect, it } from 'vitest';
+
+import { pauseTemplateSchema } from '../pauseTemplate.validations';
+
+describe('pauseTemplateSchema', () => {
+	it('fills a new template with one 30 min row and no cause', () => {
+		expect(pauseTemplateSchema.parse({}).causes).toEqual([
+			{
+				duration: 30,
+			},
+		]);
+	});
+
+	it('accepts a row without a pause cause', () => {
+		const result = pauseTemplateSchema.safeParse({
+			name: 'lunch',
+			causes: [
+				{
+					duration: 15,
+				},
+			],
+		});
+		expect(result.success).toBe(true);
+	});
+
+	it('rejects an empty name', () => {
+		expect(
+			pauseTemplateSchema.safeParse({
+				name: '',
+			}).success,
+		).toBe(false);
+	});
+
+	it('rejects a name longer than 250 symbols', () => {
+		expect(
+			pauseTemplateSchema.safeParse({
+				name: 'a'.repeat(251),
+			}).success,
+		).toBe(false);
+	});
+
+	it('rejects a template without rows', () => {
+		expect(
+			pauseTemplateSchema.safeParse({
+				name: 'lunch',
+				causes: [],
+			}).success,
+		).toBe(false);
+	});
+
+	it('accepts a duration the API returns as a string', () => {
+		expect(
+			pauseTemplateSchema.safeParse({
+				name: 'lunch',
+				causes: [
+					{
+						cause: null,
+						duration: '15',
+					},
+				],
+			}).success,
+		).toBe(true);
+	});
+
+	it.each([
+		0,
+		'0',
+		null,
+	])('rejects a row duration of %j', (duration) => {
+		expect(
+			pauseTemplateSchema.safeParse({
+				name: 'lunch',
+				causes: [
+					{
+						cause: {
+							id: '1',
+							name: 'Coffee',
+						},
+						duration,
+					},
+				],
+			}).success,
+		).toBe(false);
+	});
+});

package/src/validations/pauseTemplate/pauseTemplate.validations.ts

@@ -0,0 +1,51 @@
+import type {
+	WfmPauseTemplate,
+	WfmPauseTemplateCause,
+} from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+
+import { flexibleLookupSchema } from '../_shared/lookup.validations';
+import type { ZodShape } from '../types';
+
+/**
+ * [Claude] the API returns the duration (minutes) as an int64 string. An emptied
+ * field becomes `undefined` (not `NaN` as with `z.coerce`), so the form shows
+ * "required" instead of zod's raw "expected number, received NaN".
+ */
+const durationMinutesSchema = z.preprocess(
+	(value) =>
+		value === '' || value === null || value === undefined
+			? undefined
+			: Number(value),
+	z.number().int().min(1),
+);
+
+/**
+ * [Claude] the pause cause is optional ("Not selected"), the duration is not.
+ */
+export const pauseTemplateCauseSchema = z.object({
+	cause: flexibleLookupSchema.nullish(),
+	duration: durationMinutesSchema,
+});
+
+/**
+ * [Claude] a new template row: no pause cause ("Not selected"), 30 minutes.
+ * Shared by the schema default and the form's "add row" action.
+ */
+export const getDefaultPauseTemplateCause = (): WfmPauseTemplateCause & {
+	duration: string;
+} => ({
+	duration: '30',
+});
+
+export const pauseTemplateSchema = z.object<ZodShape<WfmPauseTemplate>>({
+	name: z.string().min(1).max(250).default(''),
+	description: z.string().optional().default(''),
+	causes: z
+		.array(pauseTemplateCauseSchema)
+		.min(1)
+		// [Claude] `.prefault`, not `.default`: the API-shaped row (duration as a string) goes through the schema
+		.prefault(() => [
+			getDefaultPauseTemplateCause(),
+		]),
+});

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

@@ -0,0 +1,81 @@
+import { describe, expect, it } from 'vitest';
+
+import { workingConditionSchema } from '../workingCondition.validations';
+
+const valid = {
+	name: 'FTE 1',
+	pauseTemplate: {
+		id: '1',
+		name: '30-15-15',
+	},
+};
+
+describe('workingConditionSchema', () => {
+	it('accepts a condition with only a name and a pause template', () => {
+		expect(workingConditionSchema.safeParse(valid).success).toBe(true);
+	});
+
+	it('requires a pause template', () => {
+		expect(
+			workingConditionSchema.safeParse({
+				name: 'FTE 1',
+			}).success,
+		).toBe(false);
+	});
+
+	it('keeps the workday duration optional and clearable', () => {
+		expect(
+			workingConditionSchema.safeParse({
+				...valid,
+				workdayHours: null,
+			}).success,
+		).toBe(true);
+	});
+
+	it('rejects a name longer than 250 symbols', () => {
+		expect(
+			workingConditionSchema.safeParse({
+				...valid,
+				name: 'a'.repeat(251),
+			}).success,
+		).toBe(false);
+	});
+
+	it.each([
+		[
+			'workdayHours',
+			25,
+		],
+		[
+			'workdaysPerMonth',
+			32,
+		],
+		[
+			'vacation',
+			366,
+		],
+		[
+			'sickLeaves',
+			366,
+		],
+		[
+			'daysOff',
+			366,
+		],
+		[
+			'pauseDuration',
+			1441,
+		],
+		[
+			'workdayHours',
+			-1,
+		],
+	])('rejects %s = %j', (field, value) => {
+		expect(
+			workingConditionSchema.safeParse({
+				...valid,
+				[field]: value,
+			}).success,
+		).toBe(false);
+	});
+});

package/src/validations/workingCondition/workingCondition.validations.ts

@@ -0,0 +1,25 @@
+import type { WfmWorkingCondition } from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+
+import {
+	filledLookupSchema,
+	flexibleLookupSchema,
+} from '../_shared/lookup.validations';
+import type { ZodShape } from '../types';
+
+/** [Claude] an optional whole number the user may clear (`wt-input-number` emits `null`) */
+const optionalCountSchema = (max: number) =>
+	z.number().int().min(0).max(max).nullish();
+
+export const workingConditionSchema = z.object<ZodShape<WfmWorkingCondition>>({
+	name: z.string().min(1).max(250),
+	description: z.string().optional().default(''),
+	workdayHours: optionalCountSchema(24),
+	workdaysPerMonth: optionalCountSchema(31),
+	vacation: optionalCountSchema(365),
+	sickLeaves: optionalCountSchema(365),
+	daysOff: optionalCountSchema(365),
+	pauseDuration: optionalCountSchema(1440),
+	pauseTemplate: filledLookupSchema,
+	shiftTemplate: flexibleLookupSchema.nullish(),
+});