@defra/forms-engine-plugin 0.0.1

package/src/server/plugins/engine/views/repeat-list-summary.html

@@ -0,0 +1,53 @@
+{% extends "layout.html" %}
+
+{% from "govuk/components/error-summary/macro.njk" import govukErrorSummary %}
+{% from "govuk/components/button/macro.njk" import govukButton %}
+{% from "govuk/components/summary-list/macro.njk" import govukSummaryList %}
+
+{% block content %}
+  <div class="govuk-grid-row">
+    <div class="govuk-grid-column-two-thirds">
+      {% if previewMode %}
+        {% include "partials/preview-banner.html" %}
+      {% endif %}
+
+      {% if errors %}
+        {{ govukErrorSummary({
+          titleText: "There is a problem",
+          errorList: errors
+        }) }}
+      {% endif %}
+
+      {% include "partials/heading.html" %}
+
+      {% for section in checkAnswers %}
+        {{ govukSummaryList(section.summaryList) }}
+      {% endfor %}
+
+      <div class="govuk-button-group">
+        <form method="post" novalidate>
+          <input type="hidden" name="crumb" value="{{ crumb }}">
+
+          {{ govukButton({
+            text: "Continue",
+            name: "action",
+            value: "continue",
+            preventDoubleClick: true
+          }) }}
+
+          {{ govukButton({
+            text: "Add another " + repeatTitle,
+            name: "action",
+            value: "add-another",
+            classes: "govuk-button--secondary",
+            preventDoubleClick: true
+          }) }}
+        </form>
+      </div>
+    </div>
+  </div>
+
+  {% if config.cdpEnvironment == 'local' and context | length and not context.isForceAccess %}
+    {% include "partials/debug.html" %}
+  {% endif %}
+{% endblock %}

package/src/server/plugins/errorPages.ts

@@ -0,0 +1,58 @@
+import {
+  type Request,
+  type ResponseToolkit,
+  type ServerRegisterPluginObject
+} from '@hapi/hapi'
+import { StatusCodes } from 'http-status-codes'
+
+/*
+ * Add an `onPreResponse` listener to return error pages
+ */
+export default {
+  plugin: {
+    name: 'error-pages',
+    register(server) {
+      server.ext('onPreResponse', (request: Request, h: ResponseToolkit) => {
+        const response = request.response
+
+        if ('isBoom' in response && response.isBoom) {
+          // An error was raised during
+          // processing the request
+          const statusCode = response.output.statusCode
+
+          // Check for a form model on the request
+          // and use it to set the correct service name
+          // and start page path. In the event of a error
+          // happening inside a "form" level request, the header
+          // then displays the contextual form text and href
+          const model = request.app.model
+          const viewModel = model
+            ? {
+                name: model.name,
+                serviceUrl: `/${model.basePath}`
+              }
+            : undefined
+
+          // In the event of 404
+          // return the `404` view
+          if (statusCode === StatusCodes.NOT_FOUND.valueOf()) {
+            return h.view('404', viewModel).code(statusCode)
+          }
+
+          request.log('error', {
+            statusCode,
+            data: response.data,
+            message: response.message,
+            stack: response.stack
+          })
+
+          request.logger.error(response.stack)
+
+          // The return the `500` view
+          return h.view('500', viewModel).code(statusCode)
+        }
+        return h.continue
+      })
+    }
+  }
+} satisfies ServerRegisterPluginObject<void>

package/src/server/plugins/nunjucks/context.js

@@ -0,0 +1,88 @@
+import { readFileSync } from 'node:fs'
+import { basename, join } from 'node:path'
+
+import Boom from '@hapi/boom'
+import { StatusCodes } from 'http-status-codes'
+
+import pkg from '~/package.json' with { type: 'json' }
+import { parseCookieConsent } from '~/src/common/cookies.js'
+import { config } from '~/src/config/index.js'
+import { createLogger } from '~/src/server/common/helpers/logging/logger.js'
+import { PREVIEW_PATH_PREFIX } from '~/src/server/constants.js'
+import {
+  encodeUrl,
+  safeGenerateCrumb
+} from '~/src/server/plugins/engine/helpers.js'
+
+const logger = createLogger()
+
+/** @type {Record<string, string> | undefined} */
+let webpackManifest
+
+/**
+ * @param {FormRequest | FormRequestPayload | null} request
+ */
+export function context(request) {
+  const manifestPath = join(config.get('publicDir'), 'assets-manifest.json')
+
+  if (!webpackManifest) {
+    try {
+      // eslint-disable-next-line -- Allow JSON type 'any'
+      webpackManifest = JSON.parse(readFileSync(manifestPath, 'utf-8'))
+    } catch {
+      logger.error(`Webpack ${basename(manifestPath)} not found`)
+    }
+  }
+
+  const { params, path, query = {}, response, state } = request ?? {}
+
+  const isForceAccess = 'force' in query
+  const isPreviewMode = path?.startsWith(PREVIEW_PATH_PREFIX)
+
+  // Only add the slug in to the context if the response is OK.
+  // Footer meta links are not rendered when the slug is missing.
+  const isResponseOK =
+    !Boom.isBoom(response) && response?.statusCode === StatusCodes.OK
+
+  /** @type {ViewContext} */
+  const ctx = {
+    appVersion: pkg.version,
+    assetPath: '/assets',
+    config: {
+      cdpEnvironment: config.get('cdpEnvironment'),
+      designerUrl: config.get('designerUrl'),
+      feedbackLink: encodeUrl(config.get('feedbackLink')),
+      phaseTag: config.get('phaseTag'),
+      serviceBannerText: config.get('serviceBannerText'),
+      serviceName: config.get('serviceName'),
+      serviceVersion: config.get('serviceVersion')
+    },
+    crumb: safeGenerateCrumb(request),
+    cspNonce: request?.plugins.blankie?.nonces?.script,
+    currentPath: request ? `${request.path}${request.url.search}` : undefined,
+    previewMode: isPreviewMode ? params?.state : undefined,
+    slug: isResponseOK ? params?.slug : undefined,
+
+    getAssetPath: (asset = '') => {
+      return `/${webpackManifest?.[asset] ?? asset}`
+    }
+  }
+
+  if (!isForceAccess) {
+    ctx.config.googleAnalyticsTrackingId = config.get(
+      'googleAnalyticsTrackingId'
+    )
+
+    if (typeof state?.cookieConsent === 'string') {
+      ctx.cookieConsent = parseCookieConsent(state.cookieConsent)
+    }
+  }
+
+  return ctx
+}
+
+/**
+ * @import { CookieConsent } from '~/src/common/types.js'
+ * @import { ViewContext } from '~/src/server/plugins/nunjucks/types.js'
+ * @import { FormRequest, FormRequestPayload } from '~/src/server/routes/types.js'
+ */

package/src/server/plugins/nunjucks/context.test.js

@@ -0,0 +1,142 @@
+import { tmpdir } from 'node:os'
+
+import { config } from '~/src/config/index.js'
+import { encodeUrl } from '~/src/server/plugins/engine/helpers.js'
+import { context } from '~/src/server/plugins/nunjucks/context.js'
+
+describe('Nunjucks context', () => {
+  beforeEach(() => jest.resetModules())
+
+  describe('Asset path', () => {
+    it("should include 'assetPath' for GOV.UK Frontend icons", () => {
+      const { assetPath } = context(null)
+      expect(assetPath).toBe('/assets')
+    })
+  })
+
+  describe('Asset helper', () => {
+    it("should locate 'assets-manifest.json' assets", () => {
+      const { getAssetPath } = context(null)
+
+      expect(getAssetPath('example.scss')).toBe(
+        '/stylesheets/example.xxxxxxx.min.css'
+      )
+
+      expect(getAssetPath('example.mjs')).toBe(
+        '/javascripts/example.xxxxxxx.min.js'
+      )
+    })
+
+    it("should return path when 'assets-manifest.json' is missing", async () => {
+      await jest.isolateModulesAsync(async () => {
+        const { config } = await import('~/src/config/index.js')
+
+        // Import when isolated to avoid cache
+        const { context } = await import(
+          '~/src/server/plugins/nunjucks/context.js'
+        )
+
+        // Update config for missing manifest
+        config.set('publicDir', tmpdir())
+        const { getAssetPath } = context(null)
+
+        // Uses original paths when missing
+        expect(getAssetPath('example.scss')).toBe('/example.scss')
+        expect(getAssetPath('example.mjs')).toBe('/example.mjs')
+      })
+    })
+
+    it('should return path to unknown assets', () => {
+      const { getAssetPath } = context(null)
+
+      expect(getAssetPath()).toBe('/')
+      expect(getAssetPath('example.jpg')).toBe('/example.jpg')
+      expect(getAssetPath('example.gif')).toBe('/example.gif')
+    })
+  })
+
+  describe('Config', () => {
+    it('should include environment, phase tag and service info', () => {
+      const ctx = context(null)
+
+      expect(ctx.config).toEqual(
+        expect.objectContaining({
+          cdpEnvironment: config.get('cdpEnvironment'),
+          feedbackLink: encodeUrl(config.get('feedbackLink')),
+          googleAnalyticsTrackingId: config.get('googleAnalyticsTrackingId'),
+          phaseTag: config.get('phaseTag'),
+          serviceBannerText: config.get('serviceBannerText'),
+          serviceName: config.get('serviceName'),
+          serviceVersion: config.get('serviceVersion')
+        })
+      )
+    })
+  })
+
+  describe('Crumb', () => {
+    it('should handle malformed requests with missing state', () => {
+      // While state should always exist in a valid Hapi request (it holds cookies),
+      // we've seen malformed requests in production where it's missing
+      const malformedRequest = /** @type {FormRequest} */ (
+        /** @type {unknown} */ ({
+          server: {
+            plugins: {
+              crumb: {
+                generate: jest.fn()
+              }
+            }
+          },
+          plugins: {},
+          route: {
+            settings: {
+              plugins: {}
+            }
+          },
+          path: '/test',
+          url: { search: '' }
+          // state intentionally omitted to test real malformed requests
+        })
+      )
+
+      const { crumb } = context(malformedRequest)
+      expect(crumb).toBeUndefined()
+      expect(
+        malformedRequest.server.plugins.crumb.generate
+      ).not.toHaveBeenCalled()
+    })
+
+    it('should generate crumb when state exists', () => {
+      const mockCrumb = 'generated-crumb-value'
+      const validRequest = /** @type {FormRequest} */ (
+        /** @type {unknown} */ ({
+          server: {
+            plugins: {
+              crumb: {
+                generate: jest.fn().mockReturnValue(mockCrumb)
+              }
+            }
+          },
+          plugins: {},
+          route: {
+            settings: {
+              plugins: {}
+            }
+          },
+          path: '/test',
+          url: { search: '' },
+          state: {}
+        })
+      )
+
+      const { crumb } = context(validRequest)
+      expect(crumb).toBe(mockCrumb)
+      expect(validRequest.server.plugins.crumb.generate).toHaveBeenCalledWith(
+        validRequest
+      )
+    })
+  })
+})
+
+/**
+ * @import { FormRequest } from '~/src/server/routes/types.js'
+ */

package/src/server/plugins/nunjucks/enviroment.test.js

@@ -0,0 +1,201 @@
+import * as helpers from '~/src/server/plugins/engine/helpers.js'
+import { environment } from '~/src/server/plugins/nunjucks/environment.js'
+
+describe('Nunjucks environment', () => {
+  describe('checkErrorTemplates function', () => {
+    /** @type {Function} */
+    let checkErrorTemplates
+
+    beforeEach(() => {
+      checkErrorTemplates = environment.getGlobal('checkErrorTemplates')
+
+      jest
+        .spyOn(helpers, 'evaluateTemplate')
+        .mockImplementation((text) => `evaluated-${text}`)
+    })
+
+    afterEach(() => {
+      jest.restoreAllMocks()
+    })
+
+    test('returns errors unchanged when context is not present', () => {
+      const nunjucksCtx = {
+        ctx: {}
+      }
+
+      const errors = [{ text: 'Error 1' }, { text: 'Error 2' }]
+
+      const result = checkErrorTemplates.call(nunjucksCtx, errors)
+
+      expect(result).toBe(errors)
+      expect(helpers.evaluateTemplate).not.toHaveBeenCalled()
+    })
+
+    test('evaluates error texts when context is present', () => {
+      const formContext = { someData: 'some-text' }
+      const nunjucksCtx = {
+        ctx: { context: formContext }
+      }
+
+      const errors = [{ text: 'Error 1' }, { text: 'Error 2' }]
+
+      const result = checkErrorTemplates.call(nunjucksCtx, errors)
+
+      expect(helpers.evaluateTemplate).toHaveBeenCalledTimes(2)
+      expect(helpers.evaluateTemplate).toHaveBeenCalledWith(
+        'Error 1',
+        formContext
+      )
+      expect(helpers.evaluateTemplate).toHaveBeenCalledWith(
+        'Error 2',
+        formContext
+      )
+
+      expect(result).toEqual([
+        { text: 'evaluated-Error 1' },
+        { text: 'evaluated-Error 2' }
+      ])
+    })
+  })
+
+  describe('checkComponentTemplates function', () => {
+    /** @type {Function} */
+    let checkComponentTemplates
+
+    beforeEach(() => {
+      checkComponentTemplates = environment.getGlobal('checkComponentTemplates')
+
+      jest
+        .spyOn(helpers, 'evaluateTemplate')
+        .mockImplementation((text) => `evaluated-${text}`)
+    })
+
+    afterEach(() => {
+      jest.restoreAllMocks()
+    })
+
+    test('evaluates string content for Html components', () => {
+      const formContext = { someData: 'some-text' }
+      const nunjucksCtx = {
+        ctx: { context: formContext }
+      }
+
+      const component = {
+        type: 'Html',
+        isFormComponent: false,
+        model: {
+          content: 'Some {{ context.someData }} content'
+        }
+      }
+
+      const result = checkComponentTemplates.call(nunjucksCtx, component)
+
+      expect(helpers.evaluateTemplate).toHaveBeenCalledWith(
+        'Some {{ context.someData }} content',
+        formContext
+      )
+      expect(result.model.content).toBe(
+        'evaluated-Some {{ context.someData }} content'
+      )
+    })
+
+    test('does not evaluate non-string content for Html components', () => {
+      const formContext = { someData: 'some-text' }
+      const nunjucksCtx = {
+        ctx: { context: formContext }
+      }
+
+      const nonStringContent = { some: 'object' }
+      const component = {
+        type: 'Html',
+        isFormComponent: false,
+        model: {
+          content: nonStringContent
+        }
+      }
+
+      const result = checkComponentTemplates.call(nunjucksCtx, component)
+
+      expect(helpers.evaluateTemplate).not.toHaveBeenCalled()
+
+      expect(result.model.content).toBe(nonStringContent)
+    })
+
+    test('evaluates label text for form components', () => {
+      const formContext = { someData: 'some-text' }
+      const nunjucksCtx = {
+        ctx: { context: formContext }
+      }
+
+      const component = {
+        isFormComponent: true,
+        model: {
+          label: {
+            text: 'Label with {{ context.someData }}'
+          }
+        }
+      }
+
+      const result = checkComponentTemplates.call(nunjucksCtx, component)
+
+      expect(helpers.evaluateTemplate).toHaveBeenCalledWith(
+        'Label with {{ context.someData }}',
+        formContext
+      )
+
+      expect(result.model.label?.text).toBe(
+        'evaluated-Label with {{ context.someData }}'
+      )
+    })
+  })
+
+  describe('evaluate function', () => {
+    /** @type {Function} */
+    let evaluateFunc
+
+    beforeEach(() => {
+      evaluateFunc = environment.getGlobal('evaluate')
+
+      jest
+        .spyOn(helpers, 'evaluateTemplate')
+        .mockImplementation((text) => `evaluated-${text}`)
+    })
+
+    afterEach(() => {
+      jest.restoreAllMocks()
+    })
+
+    test('evaluates template when context is present', () => {
+      const formContext = { someData: 'some-text' }
+      const nunjucksCtx = {
+        ctx: { context: formContext }
+      }
+
+      const template = 'Template with {{ context.someData }}'
+      const result = evaluateFunc.call(nunjucksCtx, template)
+
+      expect(helpers.evaluateTemplate).toHaveBeenCalledWith(
+        template,
+        formContext
+      )
+      expect(result).toBe('evaluated-Template with {{ context.someData }}')
+    })
+
+    test('returns template unchanged when context is not present', () => {
+      const nunjucksCtx = {
+        ctx: {}
+      }
+
+      const template = 'Template with {{ context.someData }}'
+      const result = evaluateFunc.call(nunjucksCtx, template)
+
+      expect(helpers.evaluateTemplate).not.toHaveBeenCalled()
+
+      expect(result).toBe(template)
+    })
+  })
+})
+
+/*
+ * @import { ComponentViewModel } from '~/src/server/plugins/engine/components/types.js'
+ */

package/src/server/plugins/nunjucks/environment.js

@@ -0,0 +1,116 @@
+import { dirname, join } from 'node:path'
+
+import { ComponentType } from '@defra/forms-model'
+import nunjucks from 'nunjucks'
+import resolvePkg from 'resolve'
+
+import { config } from '~/src/config/index.js'
+import { evaluateTemplate } from '~/src/server/plugins/engine/helpers.js'
+import * as filters from '~/src/server/plugins/nunjucks/filters/index.js'
+
+const govukFrontendPath = dirname(
+  resolvePkg.sync('govuk-frontend/package.json')
+)
+
+export const paths = [
+  join(config.get('appDir'), 'plugins/engine/views'),
+  join(config.get('appDir'), 'views')
+]
+
+export const environment = nunjucks.configure(
+  [...paths, join(govukFrontendPath, 'dist')],
+  {
+    trimBlocks: true,
+    lstripBlocks: true,
+    watch: config.get('isDevelopment'),
+    noCache: config.get('isDevelopment')
+  }
+)
+
+for (const [name, nunjucksFilter] of Object.entries(filters)) {
+  environment.addFilter(name, nunjucksFilter)
+}
+
+/**
+ * @this {NunjucksContext}
+ * @param {FormSubmissionError[]} errors
+ */
+function checkErrorTemplates(errors) {
+  const { context } = this.ctx
+
+  if (!context) {
+    return errors
+  }
+
+  errors.forEach((error) => {
+    error.text = evaluateTemplate(error.text, context)
+  })
+
+  return errors
+}
+
+environment.addGlobal('checkErrorTemplates', checkErrorTemplates)
+
+/**
+ * @this {NunjucksContext}
+ * @param {ComponentViewModel} component
+ */
+function checkComponentTemplates(component) {
+  const { context } = this.ctx
+
+  if (!context) {
+    return component
+  }
+
+  if (component.isFormComponent) {
+    // Evaluate label/legend text
+    if (component.model.fieldset?.legend?.text) {
+      const legend = component.model.fieldset.legend
+
+      legend.text = evaluateTemplate(legend.text, context)
+    } else if (component.model.label?.text) {
+      const label = component.model.label
+
+      label.text = evaluateTemplate(label.text, context)
+    } else {
+      // No template evaluation needed for other component types
+    }
+
+    // Evaluate error message
+    if (component.model.errorMessage?.text) {
+      const message = component.model.errorMessage
+
+      message.text = evaluateTemplate(message.text, context)
+    }
+  } else if (component.type === ComponentType.Html) {
+    const content = component.model.content
+
+    if (typeof content === 'string') {
+      component.model.content = evaluateTemplate(content, context)
+    }
+  } else {
+    // No template evaluation needed for other component types
+  }
+
+  return component
+}
+
+environment.addGlobal('checkComponentTemplates', checkComponentTemplates)
+
+/**
+ * @this {NunjucksContext}
+ * @param {string} template
+ */
+function evaluate(template) {
+  const { context } = this.ctx
+
+  return context ? evaluateTemplate(template, context) : template
+}
+
+environment.addGlobal('evaluate', evaluate)
+
+/**
+ * @import { NunjucksContext } from '~/src/server/plugins/nunjucks/types.js'
+ * @import { FormSubmissionError } from '~/src/server/plugins/engine/types.js'
+ * @import { ComponentViewModel } from '~/src/server/plugins/engine/components/types.js'
+ */

package/src/server/plugins/nunjucks/filters/answer.js

@@ -0,0 +1,27 @@
+import { getAnswer } from '~/src/server/plugins/engine/components/helpers.js'
+
+/**
+ * Nunjucks filter to get the answer for a component
+ * @this {NunjucksContext}
+ * @param {string} name - The name of the component to check
+ */
+export function answer(name) {
+  const { context } = this.ctx
+
+  if (!context) {
+    return undefined
+  }
+
+  const component = context.componentMap.get(name)
+
+  if (!component?.isFormComponent) {
+    return undefined
+  }
+
+  return getAnswer(/** @type {Field} */ (component), context.relevantState)
+}
+
+/**
+ * @import { NunjucksContext } from '~/src/server/plugins/nunjucks/types.js'
+ * @import { Field } from '~/src/server/plugins/engine/components/helpers.js'
+ */