CCM-10547: add cmapaignid to template and implement client feature flag

Author: bhansell1

frontend/src/__tests__/app/request-proof-of-template/page.test.tsx

@@ -14,19 +14,25 @@ import {
   NHS_APP_TEMPLATE,
   SMS_TEMPLATE,
 } from '../../helpers';
+import { serverIsFeatureEnabled } from '@utils/server-features';
 import content from '@content/content';
 
 const { pageTitle } = content.components.requestProof;
 
 jest.mock('@utils/form-actions');
 jest.mock('next/navigation');
 jest.mock('@forms/RequestProof/RequestProof');
+jest.mock('@utils/server-features');
 
 const getTemplateMock = jest.mocked(getTemplate);
 const redirectMock = jest.mocked(redirect);
+const serverIsFeatureEnabledMock = jest.mocked(serverIsFeatureEnabled);
 
 describe('RequestProofPage', () => {
-  beforeEach(jest.resetAllMocks);
+  beforeEach(() => {
+    jest.resetAllMocks();
+    serverIsFeatureEnabledMock.mockResolvedValueOnce(true);
+  });
 
   test('should load page', async () => {
     const state = {
@@ -104,4 +110,17 @@ describe('RequestProofPage', () => {
       expect(redirectMock).toHaveBeenCalledWith('/invalid-template', 'replace');
     }
   );
+
+  test('should forbid user from requesting a proof when client does not have feature enabled', async () => {
+    serverIsFeatureEnabledMock.mockReset();
+    serverIsFeatureEnabledMock.mockResolvedValueOnce(false);
+
+    await RequestProofPage({
+      params: Promise.resolve({
+        templateId: 'template-id',
+      }),
+    });
+
+    expect(redirectMock).toHaveBeenCalledWith('/invalid-template', 'replace');
+  });
 });

frontend/src/__tests__/utils/server-features.test.ts

@@ -0,0 +1,86 @@
+import { serverIsFeatureEnabled } from '@utils/server-features';
+import { getSessionServer } from '@utils/amplify-utils';
+import { ClientConfiguration } from 'nhs-notify-backend-client';
+import { mock } from 'jest-mock-extended';
+
+jest.mock('@utils/amplify-utils');
+jest.mock('nhs-notify-backend-client');
+
+const getSessionServerMock = jest.mocked(getSessionServer);
+const clientConfigurationMock = jest.mocked(ClientConfiguration.fetch);
+
+describe('serverIsFeatureEnabled', () => {
+  beforeAll(() => {
+    jest.resetAllMocks();
+  });
+
+  it('should return false when no accessToken', async () => {
+    getSessionServerMock.mockResolvedValueOnce({
+      accessToken: undefined,
+      userSub: undefined,
+    });
+
+    const enabled = await serverIsFeatureEnabled('proofing');
+
+    expect(enabled).toEqual(false);
+  });
+
+  it('should return false when no client', async () => {
+    getSessionServerMock.mockResolvedValueOnce({
+      accessToken: 'token',
+      userSub: undefined,
+    });
+
+    const enabled = await serverIsFeatureEnabled('proofing');
+
+    expect(enabled).toEqual(false);
+
+    expect(clientConfigurationMock).toHaveBeenCalledWith('token');
+  });
+
+  it('should return false when feature is not enabled', async () => {
+    const featureEnabled = jest.fn(() => false);
+
+    clientConfigurationMock.mockResolvedValueOnce(
+      mock<ClientConfiguration>({
+        featureEnabled,
+      })
+    );
+
+    getSessionServerMock.mockResolvedValueOnce({
+      accessToken: 'token',
+      userSub: undefined,
+    });
+
+    const enabled = await serverIsFeatureEnabled('proofing');
+
+    expect(enabled).toEqual(false);
+
+    expect(clientConfigurationMock).toHaveBeenCalledWith('token');
+
+    expect(featureEnabled).toHaveBeenCalledWith('proofing');
+  });
+
+  it('should return true when feature is enabled', async () => {
+    const featureEnabled = jest.fn(() => true);
+
+    clientConfigurationMock.mockResolvedValueOnce(
+      mock<ClientConfiguration>({
+        featureEnabled,
+      })
+    );
+
+    getSessionServerMock.mockResolvedValueOnce({
+      accessToken: 'token',
+      userSub: undefined,
+    });
+
+    const enabled = await serverIsFeatureEnabled('proofing');
+
+    expect(enabled).toEqual(true);
+
+    expect(clientConfigurationMock).toHaveBeenCalledWith('token');
+
+    expect(featureEnabled).toHaveBeenCalledWith('proofing');
+  });
+});

frontend/src/app/request-proof-of-template/[templateId]/page.tsx

@@ -9,6 +9,8 @@ import {
 } from 'nhs-notify-web-template-management-utils';
 import { getTemplate } from '@utils/form-actions';
 import content from '@content/content';
+import { serverIsFeatureEnabled } from '@utils/server-features';
+
 const { pageTitle } = content.components.requestProof;
 
 export async function generateMetadata(): Promise<Metadata> {
@@ -20,6 +22,13 @@ export async function generateMetadata(): Promise<Metadata> {
 const RequestProofPage = async (props: PageProps) => {
   const { templateId } = await props.params;
 
+  const proofingEnabled = await serverIsFeatureEnabled('proofing');
+
+  if (!proofingEnabled) {
+    // Note: replace as part of CCM-?????
+    return redirect('/invalid-template', RedirectType.replace);
+  }
+
   const template = await getTemplate(templateId);
 
   const validatedTemplate = validateLetterTemplate(template);

frontend/src/hooks/use-text-input.hook.ts

@@ -3,9 +3,9 @@ import { useState } from 'react';
 type InputValue = HTMLTextAreaElement | HTMLInputElement | HTMLSelectElement;
 
 export const useTextInput = <T extends InputValue, S extends string = string>(
-  initialState: string
+  initialState: S
 ): [S, React.ChangeEventHandler<T>] => {
-  const [value, setValue] = useState<S>(initialState as S);
+  const [value, setValue] = useState<S>(initialState);
 
   const handleChange: React.ChangeEventHandler<T> = (e) => {
     setValue(e.target.value as S);

frontend/src/utils/server-features.ts

@@ -0,0 +1,31 @@
+'use server';
+
+import { cache } from 'react';
+import { ClientConfiguration, Features } from 'nhs-notify-backend-client';
+import { getSessionServer } from './amplify-utils';
+
+/*
+ * Caches at the request context level. Not a global cache.
+ */
+const fetchClient = cache(async (accessToken: string) =>
+  ClientConfiguration.fetch(accessToken)
+);
+
+/**
+ * Server-Side
+ *
+ * Fetches client configuration to check whether a specific feature is enabled
+ * @param {string} feature keyof Features
+ * @returns {Promise<Boolean>} boolean
+ */
+export async function serverIsFeatureEnabled(
+  feature: keyof Features
+): Promise<boolean> {
+  const { accessToken } = await getSessionServer();
+
+  if (!accessToken) return false;
+
+  const client = await fetchClient(accessToken);
+
+  return client?.featureEnabled(feature) || false;
+}

lambdas/backend-api/src/__tests__/templates/api/create-letter.test.ts

@@ -1,6 +1,10 @@
 import { createHandler } from '@backend-api/templates/api/create-letter';
 import { mock } from 'jest-mock-extended';
-import { CreateUpdateTemplate, TemplateDto } from 'nhs-notify-backend-client';
+import {
+  CreateUpdateTemplate,
+  ClientConfiguration,
+  TemplateDto,
+} from 'nhs-notify-backend-client';
 import {
   APIGatewayProxyEvent,
   APIGatewayProxyResult,
@@ -12,12 +16,16 @@ import {
 } from 'nhs-notify-web-template-management-test-helper-utils';
 import { TemplateClient } from '@backend-api/templates/app/template-client';
 
+jest.mock('nhs-notify-backend-client/src/client-configuration-client');
+
 const setup = () => {
   const templateClient = mock<TemplateClient>();
 
+  const clientConfigurationFetch = jest.mocked(ClientConfiguration.fetch);
+
   const handler = createHandler({ templateClient });
 
-  return { handler, mocks: { templateClient } };
+  return { handler, mocks: { templateClient, clientConfigurationFetch } };
 };
 
 const userId = '8B892046';
@@ -42,6 +50,12 @@ describe('create-letter', () => {
   test('successfully handles multipart form input and forwards PDF and CSV', async () => {
     const { handler, mocks } = setup();
 
+    mocks.clientConfigurationFetch.mockResolvedValueOnce(
+      mock<ClientConfiguration>({
+        campaignId: 'campaignId',
+      })
+    );
+
     const pdfFilename = 'template.pdf';
     const csvFilename = 'data.csv';
     const pdfType = 'application/pdf';
@@ -72,6 +86,7 @@ describe('create-letter', () => {
       body: multipart.toString('base64'),
       headers: {
         'Content-Type': contentType,
+        Authorization: 'example',
       },
       requestContext: { authorizer: { user: userId, clientId } },
     });
@@ -115,8 +130,11 @@ describe('create-letter', () => {
       initialTemplate,
       { userId, clientId },
       new File([pdf], pdfFilename, { type: pdfType }),
-      new File([csv], csvFilename, { type: csvType })
+      new File([csv], csvFilename, { type: csvType }),
+      'campaignId'
     );
+
+    expect(mocks.clientConfigurationFetch).toHaveBeenCalledWith('example');
   });
 
   test('successfully handles multipart form input without test data', async () => {
@@ -252,6 +270,7 @@ describe('create-letter', () => {
       initialTemplate,
       { userId, clientId: undefined },
       new File([pdf], pdfFilename, { type: pdfType }),
+      undefined,
       undefined
     );
   });
@@ -433,6 +452,7 @@ describe('create-letter', () => {
       initialTemplate,
       { userId, clientId },
       new File([pdf], pdfFilename, { type: pdfType }),
+      undefined,
       undefined
     );
   });

lambdas/backend-api/src/__tests__/templates/api/create.test.ts

@@ -1,15 +1,23 @@
 import type { APIGatewayProxyEvent, Context } from 'aws-lambda';
 import { mock } from 'jest-mock-extended';
-import { TemplateDto, CreateUpdateTemplate } from 'nhs-notify-backend-client';
+import {
+  TemplateDto,
+  CreateUpdateTemplate,
+  ClientConfiguration,
+} from 'nhs-notify-backend-client';
 import { createHandler } from '@backend-api/templates/api/create';
 import { TemplateClient } from '@backend-api/templates/app/template-client';
 
+jest.mock('nhs-notify-backend-client/src/client-configuration-client');
+
 const setup = () => {
   const templateClient = mock<TemplateClient>();
 
+  const clientConfigurationFetch = jest.mocked(ClientConfiguration.fetch);
+
   const handler = createHandler({ templateClient });
 
-  return { handler, mocks: { templateClient } };
+  return { handler, mocks: { templateClient, clientConfigurationFetch } };
 };
 
 describe('Template API - Create', () => {
@@ -112,6 +120,12 @@ describe('Template API - Create', () => {
   test('should return template', async () => {
     const { handler, mocks } = setup();
 
+    mocks.clientConfigurationFetch.mockResolvedValueOnce(
+      mock<ClientConfiguration>({
+        campaignId: 'campaignId',
+      })
+    );
+
     const create: CreateUpdateTemplate = {
       name: 'updated-name',
       message: 'message',