@defra/forms-engine-plugin 4.0.9 → 4.0.11

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

package/src/server/plugins/engine/pageControllers/helpers/helpers.test.ts

@@ -11,7 +11,6 @@ import { PageController } from '~/src/server/plugins/engine/pageControllers/Page
 import { getProxyUrlForLocalDevelopment } from '~/src/server/plugins/engine/pageControllers/helpers/index.js'
 import {
   createPage,
-  isPageController,
   type PageControllerType
 } from '~/src/server/plugins/engine/pageControllers/helpers/pages.js'
 import {
@@ -26,7 +25,10 @@ import {
 import definition from '~/test/form/definitions/blank.js'
 
 describe('Page controller helpers', () => {
-  const examples = PageTypes.map((pageType) => {
+  const examples = PageTypes.filter(
+    (pageType) =>
+      pageType.controller !== ControllerType.SummaryWithConfirmationEmail
+  ).map((pageType) => {
     const pageDef = structuredClone(pageType)
 
     let controller: PageControllerType | undefined
@@ -67,10 +69,6 @@ describe('Page controller helpers', () => {
         controller = SummaryPageController
         break
 
-      case ControllerType.SummaryWithConfirmationEmail:
-        controller = SummaryPageController
-        break
-
       case ControllerType.Status:
         controller = StatusPageController
         break
@@ -155,24 +153,6 @@ describe('Page controller helpers', () => {
     })
   })
 
-  describe('Helper: isPageController', () => {
-    it.each([...examples])(
-      "allows valid page controller '$pageDef.controller'",
-      ({ pageDef }) => {
-        expect(isPageController(pageDef.controller)).toBe(true)
-      }
-    )
-
-    it.each([
-      { name: './pages/unknown.js' },
-      { name: 'UnknownPageController' },
-      { name: undefined },
-      { name: '' }
-    ])("rejects invalid page controller '$name'", ({ name }) => {
-      expect(isPageController(name)).toBe(false)
-    })
-  })
-
   describe('Helper: getProxyUrlForLocalDevelopment', () => {
     it('returns null if uploadUrl is undefined', () => {
       expect(getProxyUrlForLocalDevelopment(undefined)).toBeNull()

package/src/server/plugins/engine/pageControllers/helpers/pages.ts

@@ -1,23 +1,12 @@
 import {
   ControllerType,
   controllerNameFromPath,
-  isControllerName,
   type Page
 } from '@defra/forms-model'
 
 import { type FormModel } from '~/src/server/plugins/engine/models/index.js'
 import * as PageControllers from '~/src/server/plugins/engine/pageControllers/index.js'
 
-export function isPageController(
-  controllerName?: string | ControllerType
-): controllerName is keyof typeof PageControllers {
-  // Handle SummaryWithConfirmationEmail as it uses SummaryPageController
-  if (controllerName === ControllerType.SummaryWithConfirmationEmail) {
-    return true
-  }
-  return isControllerName(controllerName) && controllerName in PageControllers
-}
-
 export type PageControllerClass = InstanceType<PageControllerType>
 export type PageControllerType =
   (typeof PageControllers)[keyof typeof PageControllers]
@@ -56,10 +45,6 @@ export function createPage(model: FormModel, pageDef: Page) {
       controller = new PageControllers.SummaryPageController(model, pageDef)
       break
 
-    case ControllerType.SummaryWithConfirmationEmail:
-      controller = new PageControllers.SummaryPageController(model, pageDef)
-      break
-
     case ControllerType.Status:
       controller = new PageControllers.StatusPageController(model, pageDef)
       break