@defra/forms-engine-plugin 0.0.4 → 0.0.5

package/src/server/services/httpService.test.js

@@ -0,0 +1,491 @@
+import { getTraceId } from '@defra/hapi-tracing'
+import Boom from '@hapi/boom'
+import Wreck from '@hapi/wreck'
+import { StatusCodes } from 'http-status-codes'
+
+import {
+  get,
+  getJson,
+  post,
+  postJson,
+  put
+} from '~/src/server/services/httpService.js'
+
+jest.mock('@defra/hapi-tracing')
+
+describe('HTTP service', () => {
+  /** @type {RequestOptions} */
+  let authOptions
+  /** @type {RequestOptions} */
+  let blankOptions
+  /** @type {RequestOptions} */
+  let timeoutOptions
+
+  beforeEach(() => {
+    authOptions = {
+      headers: { Authorization: 'Bearer ey56yDSASDFfbgcbc' }
+    }
+    blankOptions = {}
+    timeoutOptions = {
+      timeout: 5000
+    }
+  })
+
+  describe('GET', () => {
+    beforeEach(() => {
+      jest.spyOn(Wreck, 'get').mockResolvedValue({
+        res: /** @type {IncomingMessage} */ ({
+          statusCode: StatusCodes.OK
+        }),
+        payload: undefined
+      })
+    })
+
+    it('passes headers', async () => {
+      jest.mocked(getTraceId).mockReturnValue('my-trace-id')
+      await expect(get('/test', blankOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.OK }
+      })
+
+      expect(Wreck.get).toHaveBeenCalledWith('/test', {
+        headers: { 'x-cdp-request-id': 'my-trace-id' }
+      })
+    })
+
+    it('passes additional headers', async () => {
+      jest.mocked(getTraceId).mockReturnValue('my-trace-id')
+      await expect(get('/test', authOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.OK }
+      })
+
+      expect(Wreck.get).toHaveBeenCalledWith('/test', {
+        headers: {
+          Authorization: 'Bearer ey56yDSASDFfbgcbc',
+          'x-cdp-request-id': 'my-trace-id'
+        }
+      })
+    })
+
+    it('passes non headers options', async () => {
+      jest.mocked(getTraceId).mockReturnValue('my-trace-id')
+      await expect(get('/test', timeoutOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.OK }
+      })
+
+      expect(Wreck.get).toHaveBeenCalledWith('/test', {
+        headers: {
+          'x-cdp-request-id': 'my-trace-id'
+        },
+        timeout: 5000
+      })
+    })
+
+    it('sends request', async () => {
+      await expect(get('/test', blankOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.OK }
+      })
+
+      expect(Wreck.get).toHaveBeenCalledWith('/test', {})
+    })
+
+    it('sends request as JSON', async () => {
+      await expect(getJson('/test')).resolves.toEqual({
+        res: { statusCode: StatusCodes.OK }
+      })
+
+      expect(Wreck.get).toHaveBeenCalledWith('/test', { json: true })
+    })
+  })
+
+  describe('GET (with error)', () => {
+    const error = Boom.notFound()
+
+    beforeEach(() => {
+      jest.spyOn(Wreck, 'get').mockResolvedValue({
+        res: /** @type {IncomingMessage} */ ({
+          statusCode: StatusCodes.NOT_FOUND
+        }),
+        payload: error
+      })
+    })
+
+    it('passes headers', async () => {
+      jest.mocked(getTraceId).mockReturnValue('my-trace-id')
+      await expect(get('/error', blankOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.NOT_FOUND },
+        error
+      })
+
+      expect(Wreck.get).toHaveBeenCalledWith('/error', {
+        headers: { 'x-cdp-request-id': 'my-trace-id' }
+      })
+    })
+
+    it('passes additional headers', async () => {
+      jest.mocked(getTraceId).mockReturnValue('my-trace-id')
+      await expect(get('/error', authOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.NOT_FOUND },
+        error
+      })
+
+      expect(Wreck.get).toHaveBeenCalledWith('/error', {
+        headers: {
+          Authorization: 'Bearer ey56yDSASDFfbgcbc',
+          'x-cdp-request-id': 'my-trace-id'
+        }
+      })
+    })
+
+    it('passes non headers options', async () => {
+      jest.mocked(getTraceId).mockReturnValue('my-trace-id')
+      await expect(get('/error', timeoutOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.NOT_FOUND },
+        error
+      })
+
+      expect(Wreck.get).toHaveBeenCalledWith('/error', {
+        headers: {
+          'x-cdp-request-id': 'my-trace-id'
+        },
+        timeout: 5000
+      })
+    })
+
+    it('sends request (with error)', async () => {
+      await expect(get('/error', blankOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.NOT_FOUND },
+        error
+      })
+
+      expect(Wreck.get).toHaveBeenCalledWith('/error', {})
+    })
+
+    it('sends request as JSON (with error)', async () => {
+      await expect(getJson('/error')).resolves.toEqual({
+        res: { statusCode: StatusCodes.NOT_FOUND },
+        error
+      })
+
+      expect(Wreck.get).toHaveBeenCalledWith('/error', { json: true })
+    })
+
+    it('sends request (unknown error)', async () => {
+      jest.spyOn(Wreck, 'get').mockResolvedValue({
+        res: /** @type {IncomingMessage} */ ({
+          statusCode: StatusCodes.NOT_FOUND
+        }),
+        payload: undefined
+      })
+
+      await expect(get('/error', blankOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.NOT_FOUND },
+        error: new Error('Unknown error')
+      })
+
+      expect(Wreck.get).toHaveBeenCalledWith('/error', {})
+    })
+  })
+
+  describe('POST', () => {
+    beforeEach(() => {
+      jest.spyOn(Wreck, 'post').mockResolvedValue({
+        res: /** @type {IncomingMessage} */ ({
+          statusCode: StatusCodes.OK
+        }),
+        payload: { reference: '1234' }
+      })
+    })
+
+    it('passes headers', async () => {
+      jest.mocked(getTraceId).mockReturnValue('my-trace-id')
+      await expect(post('/test', blankOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.OK },
+        payload: { reference: '1234' }
+      })
+
+      expect(Wreck.post).toHaveBeenCalledWith('/test', {
+        headers: { 'x-cdp-request-id': 'my-trace-id' }
+      })
+    })
+
+    it('passes additonal headers', async () => {
+      jest.mocked(getTraceId).mockReturnValue('my-trace-id')
+      await expect(post('/test', authOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.OK },
+        payload: { reference: '1234' }
+      })
+
+      expect(Wreck.post).toHaveBeenCalledWith('/test', {
+        headers: {
+          Authorization: 'Bearer ey56yDSASDFfbgcbc',
+          'x-cdp-request-id': 'my-trace-id'
+        }
+      })
+    })
+
+    it('passes non headers options', async () => {
+      jest.mocked(getTraceId).mockReturnValue('my-trace-id')
+      await expect(post('/test', timeoutOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.OK },
+        payload: { reference: '1234' }
+      })
+
+      expect(Wreck.post).toHaveBeenCalledWith('/test', {
+        headers: {
+          'x-cdp-request-id': 'my-trace-id'
+        },
+        timeout: 5000
+      })
+    })
+
+    it('sends request', async () => {
+      await expect(post('/test', blankOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.OK },
+        payload: { reference: '1234' }
+      })
+
+      expect(Wreck.post).toHaveBeenCalledWith('/test', {})
+    })
+
+    it('sends request as JSON', async () => {
+      await expect(postJson('/test', blankOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.OK },
+        payload: { reference: '1234' }
+      })
+
+      expect(Wreck.post).toHaveBeenCalledWith('/test', { json: true })
+    })
+  })
+
+  describe('POST (with error)', () => {
+    const error = Boom.notFound()
+
+    beforeEach(() => {
+      jest.spyOn(Wreck, 'post').mockResolvedValue({
+        res: /** @type {IncomingMessage} */ ({
+          statusCode: StatusCodes.NOT_FOUND
+        }),
+        payload: error
+      })
+    })
+
+    it('passes headers', async () => {
+      jest.mocked(getTraceId).mockReturnValue('my-trace-id')
+      await expect(post('/error', blankOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.NOT_FOUND },
+        error
+      })
+
+      expect(Wreck.post).toHaveBeenCalledWith('/error', {
+        headers: { 'x-cdp-request-id': 'my-trace-id' }
+      })
+    })
+
+    it('passes additional headers', async () => {
+      jest.mocked(getTraceId).mockReturnValue('my-trace-id')
+      await expect(post('/error', authOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.NOT_FOUND },
+        error
+      })
+
+      expect(Wreck.post).toHaveBeenCalledWith('/error', {
+        headers: {
+          Authorization: 'Bearer ey56yDSASDFfbgcbc',
+          'x-cdp-request-id': 'my-trace-id'
+        }
+      })
+    })
+
+    it('passes non headers options', async () => {
+      jest.mocked(getTraceId).mockReturnValue('my-trace-id')
+      await expect(post('/error', timeoutOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.NOT_FOUND },
+        error
+      })
+
+      expect(Wreck.post).toHaveBeenCalledWith('/error', {
+        headers: {
+          'x-cdp-request-id': 'my-trace-id'
+        },
+        timeout: 5000
+      })
+    })
+
+    it('sends request (with error)', async () => {
+      await expect(post('/error', blankOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.NOT_FOUND },
+        error
+      })
+
+      expect(Wreck.post).toHaveBeenCalledWith('/error', {})
+    })
+
+    it('sends request as JSON (with error)', async () => {
+      await expect(postJson('/error', blankOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.NOT_FOUND },
+        error
+      })
+
+      expect(Wreck.post).toHaveBeenCalledWith('/error', { json: true })
+    })
+
+    it('sends request (unknown error)', async () => {
+      jest.spyOn(Wreck, 'post').mockResolvedValue({
+        res: /** @type {IncomingMessage} */ ({
+          statusCode: StatusCodes.NOT_FOUND
+        }),
+        payload: undefined
+      })
+
+      await expect(post('/error', blankOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.NOT_FOUND },
+        error: new Error('Unknown error')
+      })
+
+      expect(Wreck.post).toHaveBeenCalledWith('/error', {})
+    })
+  })
+
+  describe('PUT', () => {
+    beforeEach(() => {
+      jest.spyOn(Wreck, 'put').mockResolvedValue({
+        res: /** @type {IncomingMessage} */ ({
+          statusCode: StatusCodes.OK
+        }),
+        payload: undefined
+      })
+    })
+
+    it('passes headers', async () => {
+      jest.mocked(getTraceId).mockReturnValue('my-trace-id')
+      await expect(put('/test', blankOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.OK }
+      })
+
+      expect(Wreck.put).toHaveBeenCalledWith('/test', {
+        headers: { 'x-cdp-request-id': 'my-trace-id' }
+      })
+    })
+
+    it('passes additional headers', async () => {
+      jest.mocked(getTraceId).mockReturnValue('my-trace-id')
+      await expect(put('/test', authOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.OK }
+      })
+
+      expect(Wreck.put).toHaveBeenCalledWith('/test', {
+        headers: {
+          Authorization: 'Bearer ey56yDSASDFfbgcbc',
+          'x-cdp-request-id': 'my-trace-id'
+        }
+      })
+    })
+
+    it('passes non headers options', async () => {
+      jest.mocked(getTraceId).mockReturnValue('my-trace-id')
+      await expect(put('/test', timeoutOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.OK }
+      })
+
+      expect(Wreck.put).toHaveBeenCalledWith('/test', {
+        headers: {
+          'x-cdp-request-id': 'my-trace-id'
+        },
+        timeout: 5000
+      })
+    })
+
+    it('sends request', async () => {
+      await expect(put('/test', blankOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.OK }
+      })
+
+      expect(Wreck.put).toHaveBeenCalledWith('/test', {})
+    })
+  })
+
+  describe('PUT (with error)', () => {
+    const error = Boom.notFound()
+
+    beforeEach(() => {
+      jest.spyOn(Wreck, 'put').mockResolvedValue({
+        res: /** @type {IncomingMessage} */ ({
+          statusCode: StatusCodes.NOT_FOUND
+        }),
+        payload: error
+      })
+    })
+
+    it('passes headers', async () => {
+      jest.mocked(getTraceId).mockReturnValue('my-trace-id')
+      await expect(put('/error', blankOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.NOT_FOUND },
+        error
+      })
+
+      expect(Wreck.put).toHaveBeenCalledWith('/error', {
+        headers: { 'x-cdp-request-id': 'my-trace-id' }
+      })
+    })
+
+    it('passes additional headers', async () => {
+      jest.mocked(getTraceId).mockReturnValue('my-trace-id')
+      await expect(put('/error', authOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.NOT_FOUND },
+        error
+      })
+
+      expect(Wreck.put).toHaveBeenCalledWith('/error', {
+        headers: {
+          Authorization: 'Bearer ey56yDSASDFfbgcbc',
+          'x-cdp-request-id': 'my-trace-id'
+        }
+      })
+    })
+
+    it('passes non headers options', async () => {
+      jest.mocked(getTraceId).mockReturnValue('my-trace-id')
+      await expect(put('/error', timeoutOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.NOT_FOUND },
+        error
+      })
+
+      expect(Wreck.put).toHaveBeenCalledWith('/error', {
+        headers: {
+          'x-cdp-request-id': 'my-trace-id'
+        },
+        timeout: 5000
+      })
+    })
+
+    it('sends request (with error)', async () => {
+      await expect(put('/error', blankOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.NOT_FOUND },
+        error
+      })
+
+      expect(Wreck.put).toHaveBeenCalledWith('/error', {})
+    })
+
+    it('sends request (unknown error)', async () => {
+      jest.spyOn(Wreck, 'put').mockResolvedValue({
+        res: /** @type {IncomingMessage} */ ({
+          statusCode: StatusCodes.NOT_FOUND
+        }),
+        payload: undefined
+      })
+
+      await expect(put('/error', blankOptions)).resolves.toEqual({
+        res: { statusCode: StatusCodes.NOT_FOUND },
+        error: new Error('Unknown error')
+      })
+
+      expect(Wreck.put).toHaveBeenCalledWith('/error', {})
+    })
+  })
+})
+
+/**
+ * @import { IncomingMessage } from 'node:http'
+ * @import { RequestOptions } from '~/src/server/services/httpService.js'
+ */

package/src/server/services/httpService.ts

@@ -0,0 +1,50 @@
+import Wreck from '@hapi/wreck'
+
+import { applyTraceHeaders } from '~/src/server/utils/utils.js'
+
+export type Method = keyof Pick<typeof Wreck, 'get' | 'post' | 'put' | 'delete'>
+export type RequestOptions = Parameters<typeof Wreck.defaults>[0]
+
+export const request = async <BodyType = Buffer>(
+  method: Method,
+  url: string,
+  options?: RequestOptions
+) => {
+  const headers = applyTraceHeaders(options?.headers)
+
+  const mergedOptions = { ...options, headers }
+
+  const { res, payload } = await Wreck[method]<BodyType>(url, mergedOptions)
+
+  if (!res.statusCode || res.statusCode < 200 || res.statusCode > 299) {
+    return { res, error: payload || new Error('Unknown error') }
+  }
+
+  return { res, payload }
+}
+
+export const get = <BodyType>(url: string, options?: RequestOptions) => {
+  return request<BodyType>('get', url, options)
+}
+
+export const getJson = <BodyType extends object>(url: string) => {
+  return get<BodyType>(url, { json: true })
+}
+
+export const post = <BodyType>(url: string, options: RequestOptions) => {
+  return request<BodyType>('post', url, options)
+}
+
+export const postJson = <BodyType extends object>(
+  url: string,
+  options: RequestOptions
+) => {
+  return post<BodyType>(url, {
+    ...options,
+    json: true
+  })
+}
+
+export const put = <BodyType>(url: string, options: RequestOptions) => {
+  return request<BodyType>('put', url, options)
+}

package/src/server/services/index.ts

@@ -0,0 +1 @@
+export { CacheService } from '~/src/server/services/cacheService.js'

package/src/server/types.ts

@@ -0,0 +1,54 @@
+import {
+  type FormDefinition,
+  type FormMetadata,
+  type SubmitPayload,
+  type SubmitResponsePayload
+} from '@defra/forms-model'
+
+import { type FormModel } from '~/src/server/plugins/engine/models/index.js'
+import { type DetailItem } from '~/src/server/plugins/engine/models/types.js'
+import { type PageController } from '~/src/server/plugins/engine/pageControllers/PageController.js'
+import {
+  type FormRequestPayload,
+  type FormStatus
+} from '~/src/server/routes/types.js'
+
+export interface FormsService {
+  getFormMetadata: (slug: string) => Promise<FormMetadata>
+  getFormDefinition: (
+    id: string,
+    state: FormStatus
+  ) => Promise<FormDefinition | undefined>
+}
+
+export interface FormSubmissionService {
+  persistFiles: (
+    files: { fileId: string; initiatedRetrievalKey: string }[],
+    persistedRetrievalKey: string
+  ) => Promise<object>
+  submit: (data: SubmitPayload) => Promise<SubmitResponsePayload | undefined>
+}
+
+export interface Services {
+  formsService: FormsService
+  formSubmissionService: FormSubmissionService
+  outputService: OutputService
+}
+
+export interface RouteConfig {
+  formFileName?: string
+  formFilePath?: string
+  enforceCsrf?: boolean
+  services?: Services
+  controllers?: Record<string, typeof PageController>
+}
+
+export interface OutputService {
+  submit: (
+    request: FormRequestPayload,
+    model: FormModel,
+    emailAddress: string,
+    items: DetailItem[],
+    submitResponse: SubmitResponsePayload
+  ) => Promise<void>
+}

package/src/server/utils/notify.test.ts

@@ -0,0 +1,37 @@
+import { postJson } from '~/src/server/services/httpService.js'
+import { sendNotification } from '~/src/server/utils/notify.js'
+
+jest.mock('~/src/server/services/httpService')
+
+describe('Utils: Notify', () => {
+  const templateId = 'example-template-id'
+  const emailAddress = 'enrique.chase@defra.gov.uk'
+  const personalisation = {
+    subject: 'Hello',
+    body: 'World'
+  }
+
+  describe('sendNotification', () => {
+    it('calls postJson with personalised email payload', async () => {
+      await sendNotification({
+        templateId,
+        emailAddress,
+        personalisation
+      })
+
+      expect(postJson).toHaveBeenCalledWith(
+        'https://api.notifications.service.gov.uk/v2/notifications/email',
+        {
+          payload: {
+            template_id: templateId,
+            email_address: emailAddress,
+            personalisation
+          },
+          headers: {
+            Authorization: expect.stringMatching(/^Bearer /)
+          }
+        }
+      )
+    })
+  })
+})

package/src/server/utils/notify.ts

@@ -0,0 +1,50 @@
+import { token } from '@hapi/jwt'
+
+import { config } from '~/src/config/index.js'
+import { postJson } from '~/src/server/services/httpService.js'
+
+const notifyAPIKey = config.get('notifyAPIKey')
+
+// Extract the two uuids from the notifyApiKey
+// See https://github.com/alphagov/notifications-node-client/blob/main/client/api_client.js#L17
+// Needed until `https://github.com/alphagov/notifications-node-client/pull/200` is published
+const apiKeyId: string = notifyAPIKey.substring(
+  notifyAPIKey.length - 36,
+  notifyAPIKey.length
+)
+const serviceId: string = notifyAPIKey.substring(
+  notifyAPIKey.length - 73,
+  notifyAPIKey.length - 37
+)
+
+export interface SendNotificationArgs {
+  templateId: string
+  emailAddress: string
+  personalisation: { subject: string; body: string }
+}
+
+function createToken(iss: string, secret: string) {
+  const iat = Math.round(Date.now() / 1000)
+
+  return token.generate({ iss, iat }, secret, {
+    header: { typ: 'JWT', alg: 'HS256' }
+  })
+}
+
+export async function sendNotification(args: SendNotificationArgs) {
+  const { templateId, emailAddress, personalisation } = args
+
+  return postJson(
+    'https://api.notifications.service.gov.uk/v2/notifications/email',
+    {
+      payload: {
+        template_id: templateId,
+        email_address: emailAddress,
+        personalisation
+      },
+      headers: {
+        Authorization: 'Bearer ' + createToken(serviceId, apiKeyId)
+      }
+    }
+  )
+}

package/src/server/utils/secure-context/get-trust-store-certs.js

@@ -0,0 +1,11 @@
+/**
+ * Get base64 certs from all environment variables starting with TRUSTSTORE_
+ * @param {NodeJS.ProcessEnv} envs - environment variables
+ */
+export const getTrustStoreCerts = (envs) =>
+  Object.entries(envs)
+    .filter(
+      /** @type { (env: [string, string?]) => env is [string, string] } */
+      (([key, value]) => key.startsWith('TRUSTSTORE_') && !!value)
+    )
+    .map(([, value]) => Buffer.from(value, 'base64').toString().trim())