@defra/forms-engine-plugin 4.0.9 → 4.0.10

package/src/server/plugins/engine/components/NumberField.ts

@@ -1,5 +1,9 @@
 import { type NumberFieldComponent } from '@defra/forms-model'
-import joi, { type CustomValidator, type NumberSchema } from 'joi'
+import joi, {
+  type CustomHelpers,
+  type CustomValidator,
+  type NumberSchema
+} from 'joi'
 
 import {
   FormComponent,
@@ -161,29 +165,154 @@ export class NumberField extends FormComponent {
   }
 }
 
+/**
+ * Validates string length of a numeric value
+ * @param value - The numeric value to validate
+ * @param minLength - Minimum required string length
+ * @param maxLength - Maximum allowed string length
+ * @returns Object with validation result
+ */
+export function validateStringLength(
+  value: number,
+  minLength?: number,
+  maxLength?: number
+): { isValid: boolean; error?: 'minLength' | 'maxLength' } {
+  if (typeof minLength !== 'number' && typeof maxLength !== 'number') {
+    return { isValid: true }
+  }
+
+  const valueStr = String(value)
+
+  if (typeof minLength === 'number' && valueStr.length < minLength) {
+    return { isValid: false, error: 'minLength' }
+  }
+
+  if (typeof maxLength === 'number' && valueStr.length > maxLength) {
+    return { isValid: false, error: 'maxLength' }
+  }
+
+  return { isValid: true }
+}
+
+/**
+ * Validates minimum decimal precision
+ * @param value - The numeric value to validate
+ * @param minPrecision - Minimum required decimal places
+ * @returns true if valid, false if invalid
+ */
+export function validateMinimumPrecision(
+  value: number,
+  minPrecision: number
+): boolean {
+  if (Number.isInteger(value)) {
+    return false
+  }
+
+  const valueStr = String(value)
+  const decimalIndex = valueStr.indexOf('.')
+
+  if (decimalIndex !== -1) {
+    const decimalPlaces = valueStr.length - decimalIndex - 1
+    return decimalPlaces >= minPrecision
+  }
+
+  return false
+}
+
+/**
+ * Helper function to handle length validation errors
+ * Returns the appropriate error response based on the validation result
+ */
+function handleLengthValidationError(
+  lengthCheck: ReturnType<typeof validateStringLength>,
+  helpers: CustomHelpers,
+  custom: string | undefined,
+  minLength: number | undefined,
+  maxLength: number | undefined
+) {
+  if (!lengthCheck.isValid && lengthCheck.error) {
+    const errorType = `number.${lengthCheck.error}`
+
+    if (custom) {
+      // Only pass the relevant length value in context
+      const contextData =
+        lengthCheck.error === 'minLength'
+          ? { minLength: minLength ?? 0 }
+          : { maxLength: maxLength ?? 0 }
+      return helpers.message({ custom }, contextData)
+    }
+
+    const context =
+      lengthCheck.error === 'minLength'
+        ? { minLength: minLength ?? 0 }
+        : { maxLength: maxLength ?? 0 }
+    return helpers.error(errorType, context)
+  }
+  return null
+}
+
 export function getValidatorPrecision(component: NumberField) {
   const validator: CustomValidator = (value: number, helpers) => {
     const { options, schema } = component
-
     const { customValidationMessage: custom } = options
-    const { precision: limit } = schema
+    const {
+      precision: limit,
+      minPrecision,
+      minLength,
+      maxLength
+    } = schema as {
+      precision?: number
+      minPrecision?: number
+      minLength?: number
+      maxLength?: number
+    }
 
     if (!limit || limit <= 0) {
+      const lengthCheck = validateStringLength(value, minLength, maxLength)
+      const error = handleLengthValidationError(
+        lengthCheck,
+        helpers,
+        custom,
+        minLength,
+        maxLength
+      )
+      if (error) return error
       return value
     }
 
+    // Validate precision (max decimal places)
     const validationSchema = joi
       .number()
       .precision(limit)
       .prefs({ convert: false })
 
     try {
-      return joi.attempt(value, validationSchema)
+      joi.attempt(value, validationSchema)
     } catch {
       return custom
         ? helpers.message({ custom }, { limit })
         : helpers.error('number.precision', { limit })
     }
+
+    // Validate minimum precision (min decimal places)
+    if (typeof minPrecision === 'number' && minPrecision > 0) {
+      if (!validateMinimumPrecision(value, minPrecision)) {
+        return helpers.error('number.minPrecision', { minPrecision })
+      }
+    }
+
+    // Check string length validation after precision checks
+    const lengthCheck = validateStringLength(value, minLength, maxLength)
+    const error = handleLengthValidationError(
+      lengthCheck,
+      helpers,
+      custom,
+      minLength,
+      maxLength
+    )
+    if (error) return error
+
+    return value
   }
 
   return validator