@webitel/api-services 26.8.17 → 26.8.18

package/package.json

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

package/src/validations/_shared/clearableNumber.validations.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+
+/**
+ * @description
+ * An optional number the user is allowed to clear.
+ *
+ * `wt-input-number` wraps PrimeVue's `InputNumber`, which emits `null` — not
+ * `undefined` — when its input is emptied. A plain `z.number().optional()`
+ * rejects that with "expected number, received null", which the form shows as
+ * a red field with a helper text indistinguishable from a required error, and
+ * which blocks saving. Worse, the failure is on the base object, so a
+ * `superRefine` carrying the real per-type rules never runs.
+ *
+ * Accepting `null` keeps an emptied optional field valid; whether the field may
+ * be empty at all stays with the required rules that run in `superRefine`.
+ *
+ * https://webitel.atlassian.net/browse/WTEL-10326
+ */
+export const clearableNumberSchema = z.number().nullable().optional();

package/src/validations/index.ts

@@ -1,3 +1,4 @@
+export * from './_shared/clearableNumber.validations';
 export * from './_shared/duration.validations';
 export * from './_shared/lookup.validations';
 export * from './_shared/variablePair.validations';

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

@@ -133,6 +133,47 @@ describe('queueSchema', () => {
 		expect(issuePaths(queueSchema.safeParse(queue))).not.toContain('team');
 	});
 
+	/**
+	 * `wt-input-number` wraps PrimeVue's `InputNumber`, which emits `null` when
+	 * its input is emptied. An optional number that rejects `null` fails on the
+	 * base object, so `superRefine` never runs and the field reads as required.
+	 * https://webitel.atlassian.net/browse/WTEL-10326
+	 */
+	it.each(
+		allQueueTypes,
+	)('accepts cleared optional numbers of type %i', (type) => {
+		const queue = validQueueFor(type);
+		const required = new Set(requiredPathsFor(type));
+		const payload = (queue.payload ?? {}) as AnyRecord;
+
+		for (const [key, value] of Object.entries(payload)) {
+			if (typeof value === 'number' && !required.has(`payload.${key}`)) {
+				payload[key] = null;
+			}
+		}
+		if (!required.has('priority')) queue.priority = null;
+
+		expect(issuePaths(queueSchema.safeParse(queue))).toEqual([]);
+	});
+
+	/** A cleared *required* number still fails — with the rule's message, not zod's. */
+	it('reports a cleared required number as required', () => {
+		const queue = validQueueFor(QueueType.OUTBOUND_IVR_QUEUE);
+		set(queue, 'payload.maxAttempts', null);
+
+		const result = queueSchema.safeParse(queue);
+
+		expect(issuePaths(result)).toEqual([
+			'payload.maxAttempts',
+		]);
+		expect(result.error?.issues[0]).toMatchObject({
+			code: 'custom',
+			params: {
+				i18nKey: 'required',
+			},
+		});
+	});
+
 	/**
 	 * Regle builds `$fields` from state keys, so anything the defaults seed must
 	 * survive the schema — a key the schema strips has no validation entry, and

package/src/validations/queue/queue.validations.ts

@@ -1,6 +1,7 @@
 import { get } from 'lodash-es';
 import { z } from 'zod';
 
+import { clearableNumberSchema } from '../_shared/clearableNumber.validations';
 import { i18nIssue } from '../_shared/i18nIssue';
 import { isFilled } from '../_shared/isFilled';
 import { flexibleLookupSchema } from '../_shared/lookup.validations';
@@ -30,7 +31,7 @@ export const queueSchemaBase = z.object({
 	description: z.string().optional(),
 	type: z.number(),
 	enabled: z.boolean().optional(),
-	priority: z.number().optional(),
+	priority: clearableNumberSchema,
 	tags: z
 		.array(
 			z.object({

package/src/validations/queue/queueAmd.validations.ts

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 
+import { clearableNumberSchema } from '../_shared/clearableNumber.validations';
+
 import { flexibleLookupSchema } from '../_shared/lookup.validations';
 
 /** Answering-machine detection, on the outbound IVR and the two auto-dialers. */
@@ -10,13 +12,13 @@ export const queueAmdSchema = z.object({
 	playback: flexibleLookupSchema.optional(),
 	allowNotSure: z.boolean().optional(),
 	silenceNotSure: z.boolean().optional(),
-	maxWordLength: z.number().optional(),
-	maxNumberOfWords: z.number().optional(),
-	betweenWordsSilence: z.number().optional(),
-	minWordLength: z.number().optional(),
-	totalAnalysisTime: z.number().optional(),
-	silenceThreshold: z.number().optional(),
-	afterGreetingSilence: z.number().optional(),
-	greeting: z.number().optional(),
-	initialSilence: z.number().optional(),
+	maxWordLength: clearableNumberSchema,
+	maxNumberOfWords: clearableNumberSchema,
+	betweenWordsSilence: clearableNumberSchema,
+	minWordLength: clearableNumberSchema,
+	totalAnalysisTime: clearableNumberSchema,
+	silenceThreshold: clearableNumberSchema,
+	afterGreetingSilence: clearableNumberSchema,
+	greeting: clearableNumberSchema,
+	initialSilence: clearableNumberSchema,
 });

package/src/validations/queue/queuePayload.validations.ts

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 
+import { clearableNumberSchema } from '../_shared/clearableNumber.validations';
+
 import { queueAmdSchema } from './queueAmd.validations';
 
 /**
@@ -16,15 +18,15 @@ import { queueAmdSchema } from './queueAmd.validations';
  */
 export const queuePayloadSchema = z.object({
 	// dialing and retries
-	maxAttempts: z.number().optional(),
-	minAttempts: z.number().optional(),
-	originateTimeout: z.number().optional(),
-	waitBetweenRetries: z.number().optional(),
+	maxAttempts: clearableNumberSchema,
+	minAttempts: clearableNumberSchema,
+	originateTimeout: clearableNumberSchema,
+	waitBetweenRetries: clearableNumberSchema,
 	waitBetweenRetriesDesc: z.boolean().optional(),
-	minDuration: z.number().optional(),
-	maxCalls: z.number().optional(),
-	progressiveCount: z.number().optional(),
-	dialingRate: z.number().optional(),
+	minDuration: clearableNumberSchema,
+	maxCalls: clearableNumberSchema,
+	progressiveCount: clearableNumberSchema,
+	dialingRate: clearableNumberSchema,
 	resourceStrategy: z.string().optional(),
 	strictCircuit: z.boolean().optional(),
 	perNumbers: z.boolean().optional(),
@@ -32,33 +34,33 @@ export const queuePayloadSchema = z.object({
 	retryAbandoned: z.boolean().optional(),
 
 	// predictive dialer only
-	maxAgentLine: z.number().optional(),
-	maxAgentLose: z.number().optional(),
-	maxAbandonedRate: z.number().optional(),
-	targetAbandonedRate: z.number().optional(),
-	abandonRateAdjustment: z.number().optional(),
-	loadFactor: z.number().optional(),
-	playbackSilence: z.number().optional(),
-	statisticTime: z.number().optional(),
+	maxAgentLine: clearableNumberSchema,
+	maxAgentLose: clearableNumberSchema,
+	maxAbandonedRate: clearableNumberSchema,
+	targetAbandonedRate: clearableNumberSchema,
+	abandonRateAdjustment: clearableNumberSchema,
+	loadFactor: clearableNumberSchema,
+	playbackSilence: clearableNumberSchema,
+	statisticTime: clearableNumberSchema,
 
 	// waiting and distribution
 	timeBaseScore: z.string().optional(),
-	maxWaitTime: z.number().optional(),
-	maxWaitingSize: z.number().optional(),
-	discardAbandonedAfter: z.number().optional(),
+	maxWaitTime: clearableNumberSchema,
+	maxWaitingSize: clearableNumberSchema,
+	discardAbandonedAfter: clearableNumberSchema,
 	manualDistribution: z.boolean().optional(),
-	minOnlineAgents: z.number().optional(),
-	maxMemberLimit: z.number().optional(),
+	minOnlineAgents: clearableNumberSchema,
+	maxMemberLimit: clearableNumberSchema,
 	ignoreCalendar: z.boolean().optional(),
 
 	// sticky agent
-	stickyAgentSec: z.number().optional(),
+	stickyAgentSec: clearableNumberSchema,
 	stickyIgnoreStatus: z.boolean().optional(),
 
 	// chat queues only
-	maxIdleAgent: z.number().optional(),
-	maxIdleClient: z.number().optional(),
-	maxIdleDialog: z.number().optional(),
+	maxIdleAgent: clearableNumberSchema,
+	maxIdleClient: clearableNumberSchema,
+	maxIdleDialog: clearableNumberSchema,
 	lastMessageTimeout: z.boolean().optional(),
 
 	// media

package/src/validations/queue/taskProcessing.validations.ts

@@ -1,19 +1,21 @@
 import { z } from 'zod';
 
+import { clearableNumberSchema } from '../_shared/clearableNumber.validations';
+
 import { flexibleLookupSchema } from '../_shared/lookup.validations';
 
 export const prolongationOptionsSchema = z.object({
 	enabled: z.boolean().optional(),
 	isTimeoutRetry: z.boolean().optional(),
-	prolongationTimeSec: z.number().optional(),
-	repeatsNumber: z.number().optional(),
+	prolongationTimeSec: clearableNumberSchema,
+	repeatsNumber: clearableNumberSchema,
 });
 
 export const taskProcessingSchema = z.object({
 	enabled: z.boolean().optional(),
 	formSchema: flexibleLookupSchema.optional(),
-	sec: z.number().optional(),
-	renewalSec: z.number().optional(),
+	sec: clearableNumberSchema,
+	renewalSec: clearableNumberSchema,
 	// `.prefault`, not `.default`: zod 4's `.default({})` does not recurse, so
 	// the nested keys would be missing and Regle would build no `$fields` for
 	// them — the prolongation block would lose its validation silently.