@defra/forms-engine-plugin 0.0.2 → 0.0.4

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

@@ -1,491 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

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

package/src/server/types.ts

@@ -1,54 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,11 +0,0 @@
-/**
- * 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())