feat(FN-3163): MDM endpoints for automatically creating new DTFS customers in Salesforce

docker-compose.yml

@@ -41,6 +41,18 @@ services:
       COMPANIES_HOUSE_KEY:
       COMPANIES_HOUSE_MAX_REDIRECTS:
       COMPANIES_HOUSE_TIMEOUT:
+      DUN_AND_BRADSTREET_URL:
+      DUN_AND_BRADSTREET_KEY:
+      DUN_AND_BRADSTREET_MAX_REDIRECTS:
+      DUN_AND_BRADSTREET_TIMEOUT:
+      SF_CLIENT_ID:
+      SF_CLIENT_SECRET:
+      SF_USERNAME:
+      SF_PASSWORD:
+      SF_INSTANCE_URL:
+      SF_ACCESS_URL:
+      SF_MAX_REDIRECTS:
+      SF_TIMEOUT:
       API_KEY:
     healthcheck:
       test: ["CMD", "curl", "-f", "http://localhost:${PORT}"]

src/config/dun-and-bradstreet.config.ts

@@ -0,0 +1,20 @@
+import { registerAs } from '@nestjs/config';
+import { DUN_AND_BRADSTREET } from '@ukef/constants';
+import { getIntConfig } from '@ukef/helpers/get-int-config';
+
+export interface DunAndBradstreetConfig {
+  baseUrl: string;
+  key: string;
+  maxRedirects: number;
+  timeout: number;
+}
+
+export default registerAs(
+  DUN_AND_BRADSTREET.CONFIG.KEY,
+  (): DunAndBradstreetConfig => ({
+    baseUrl: process.env.DUN_AND_BRADSTREET_URL,
+    key: process.env.DUN_AND_BRADSTREET_KEY,
+    maxRedirects: getIntConfig(process.env.DUN_AND_BRADSTREET_MAX_REDIRECTS, 5),
+    timeout: getIntConfig(process.env.DUN_AND_BRADSTREET_TIMEOUT, 30000),
+  }),
+);

src/config/index.ts

@@ -2,7 +2,9 @@ import AppConfig from './app.config';
 import CompaniesHouseConfig from './companies-house.config';
 import DatabaseConfig from './database.config';
 import DocConfig from './doc.config';
+import DunAndBradstreetConfig from './dun-and-bradstreet.config';
 import InformaticaConfig from './informatica.config';
 import OrdnanceSurveyConfig from './ordnance-survey.config';
+import SalesforceConfig from './salesforce.config';
 
-export default [AppConfig, CompaniesHouseConfig, DocConfig, DatabaseConfig, InformaticaConfig, OrdnanceSurveyConfig];
+export default [AppConfig, CompaniesHouseConfig, DocConfig, DatabaseConfig, DunAndBradstreetConfig, InformaticaConfig, OrdnanceSurveyConfig, SalesforceConfig];

src/config/salesforce.config.test.ts

@@ -0,0 +1,56 @@
+import { withEnvironmentVariableParsingUnitTests } from '@ukef-test/common-tests/environment-variable-parsing-unit-tests';
+
+import salesforceConfig, { SalesforceConfig } from './salesforce.config';
+
+describe('salesforceConfig', () => {
+  const configDirectlyFromEnvironmentVariables: { configPropertyName: keyof SalesforceConfig; environmentVariableName: string }[] = [
+    {
+      configPropertyName: 'baseUrl',
+      environmentVariableName: 'SF_INSTANCE_URL',
+    },
+    {
+      configPropertyName: 'clientId',
+      environmentVariableName: 'SF_CLIENT_ID',
+    },
+
+    {
+      configPropertyName: 'clientSecret',
+      environmentVariableName: 'SF_CLIENT_SECRET',
+    },
+    {
+      configPropertyName: 'username',
+      environmentVariableName: 'SF_USERNAME',
+    },
+    {
+      configPropertyName: 'password',
+      environmentVariableName: 'SF_PASSWORD',
+    },
+    {
+      configPropertyName: 'accessUrl',
+      environmentVariableName: 'SF_ACCESS_URL',
+    },
+  ];
+
+  const configParsedAsIntFromEnvironmentVariablesWithDefault: {
+    configPropertyName: keyof SalesforceConfig;
+    environmentVariableName: string;
+    defaultConfigValue: number;
+  }[] = [
+    {
+      configPropertyName: 'maxRedirects',
+      environmentVariableName: 'SF_MAX_REDIRECTS',
+      defaultConfigValue: 5,
+    },
+    {
+      configPropertyName: 'timeout',
+      environmentVariableName: 'SF_TIMEOUT',
+      defaultConfigValue: 30000, // in milliseconds
+    },
+  ];
+
+  withEnvironmentVariableParsingUnitTests({
+    configDirectlyFromEnvironmentVariables,
+    configParsedAsIntFromEnvironmentVariablesWithDefault,
+    getConfig: () => salesforceConfig(),
+  });
+});

src/config/salesforce.config.ts

@@ -0,0 +1,29 @@
+import { registerAs } from '@nestjs/config';
+import { getIntConfig } from '@ukef/helpers/get-int-config';
+
+export const KEY = 'salesforce';
+
+export interface SalesforceConfig {
+  baseUrl: string;
+  clientId: string;
+  clientSecret: string;
+  username: string;
+  password: string;
+  accessUrl: string;
+  maxRedirects: number;
+  timeout: number;
+}
+
+export default registerAs(
+  KEY,
+  (): SalesforceConfig => ({
+    baseUrl: process.env.SF_INSTANCE_URL,
+    clientId: process.env.SF_CLIENT_ID,
+    clientSecret: process.env.SF_CLIENT_SECRET,
+    username: process.env.SF_USERNAME,
+    password: process.env.SF_PASSWORD,
+    accessUrl: process.env.SF_ACCESS_URL,
+    maxRedirects: getIntConfig(process.env.SF_MAX_REDIRECTS, 5),
+    timeout: getIntConfig(process.env.SF_TIMEOUT, 30000), // in milliseconds
+  }),
+);

src/constants/dun-and-bradstreet.constant.ts

@@ -0,0 +1,5 @@
+export const DUN_AND_BRADSTREET = {
+  CONFIG: {
+    KEY: 'dunAndBradstreet',
+  },
+};

src/constants/index.ts

@@ -21,6 +21,7 @@ export * from './companies-house.constant';
 export * from './customers.constant';
 export * from './database-name.constant';
 export * from './date.constant';
+export * from './dun-and-bradstreet.constant';
 export * from './enums';
 export * from './geospatial.constant';
 export * from './govuk-notify.constant';

src/helper-modules/dun-and-bradstreet/dun-and-bradstreet.module.ts

@@ -0,0 +1,27 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { DunAndBradstreetConfig } from '@ukef/config/dun-and-bradstreet.config';
+import { DUN_AND_BRADSTREET } from '@ukef/constants';
+import { HttpModule } from '@ukef/modules/http/http.module';
+
+import { DunAndBradstreetService } from './dun-and-bradstreet.service';
+
+@Module({
+  imports: [
+    HttpModule.registerAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: (configService: ConfigService) => {
+        const { baseUrl, maxRedirects, timeout } = configService.get<DunAndBradstreetConfig>(DUN_AND_BRADSTREET.CONFIG.KEY);
+        return {
+          baseURL: baseUrl,
+          maxRedirects,
+          timeout,
+        };
+      },
+    }),
+  ],
+  providers: [DunAndBradstreetService],
+  exports: [DunAndBradstreetService],
+})
+export class DunAndBradstreetModule {}

src/helper-modules/dun-and-bradstreet/dun-and-bradstreet.service.test.ts

@@ -0,0 +1,112 @@
+import { HttpService } from '@nestjs/axios';
+import { ConfigService } from '@nestjs/config';
+import { resetAllWhenMocks, when } from 'jest-when';
+import { of, throwError } from 'rxjs';
+
+import { DunAndBradstreetService } from './dun-and-bradstreet.service';
+import { DunAndBradstreetException } from './exception/dun-and-bradstreet.exception';
+import { RandomValueGenerator } from '@ukef-test/support/generator/random-value-generator';
+import { AxiosError } from 'axios';
+
+describe('CompaniesHouseService', () => {
+  let httpServiceGet: jest.Mock;
+  let configServiceGet: jest.Mock;
+  let service: DunAndBradstreetService;
+
+  const valueGenerator = new RandomValueGenerator();
+
+  const testRegistrationNumber = '0' + valueGenerator.stringOfNumericCharacters({ length: 7 });
+  const expectedAccessToken = 'TEST_ACCESS_TOKEN';
+  const getAccessTokenMethodMock = jest
+  .spyOn(DunAndBradstreetService.prototype as any, 'getAccessToken')
+  .mockImplementation(() => Promise.resolve(expectedAccessToken))
+
+  const dunAndBradstreetpath = `/v1/match/cleanseMatch?countryISOAlpha2Code=GB&registrationNumber=${testRegistrationNumber}`;
+  const expectedDunsNumber = "123456789"
+  const getDunsNumberDunAndBradstreetResponse = {
+    "matchCandidates": [
+      {
+        "organization": {
+          "duns": expectedDunsNumber
+        }
+      }
+    ]
+  }
+
+
+  const expectedHttpServiceGetArguments: [string, object] = [
+    dunAndBradstreetpath,
+    {
+      headers: {
+        Authorization: `Bearer ${expectedAccessToken}`,
+      },
+    },
+  ];
+
+  const expectedHttpServiceGetResponse = of({
+    data: getDunsNumberDunAndBradstreetResponse,
+    status: 200,
+    statusText: 'OK',
+    config: undefined,
+    headers: undefined,
+  });
+
+  beforeAll(() => {
+    const httpService = new HttpService();
+    httpServiceGet = jest.fn();
+    httpService.get = httpServiceGet;
+
+    const configService = new ConfigService();
+    configServiceGet = jest.fn().mockReturnValue({ key: "TEST API_KEY" });
+    configService.get = configServiceGet;
+
+    service = new DunAndBradstreetService(httpService, configService);
+  });
+
+  beforeEach(() => {
+    resetAllWhenMocks();
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('getDunAndBradstreetNumberByRegistrationNumber', () => {
+    it('calls the Dun and Bradstreet API with the correct arguments', async () => {
+      when(httpServiceGet)
+        .calledWith(...expectedHttpServiceGetArguments)
+        .mockReturnValueOnce(expectedHttpServiceGetResponse);
+
+      await service.getDunAndBradstreetNumberByRegistrationNumber(testRegistrationNumber);
+
+      expect(getAccessTokenMethodMock).toHaveBeenCalledTimes(1);
+      expect(httpServiceGet).toHaveBeenCalledTimes(1);
+      expect(httpServiceGet).toHaveBeenCalledWith(...expectedHttpServiceGetArguments);
+    });
+
+    it('returns the results when the Dun and Bradstreet API returns a 200 response with results', async () => {
+      when(httpServiceGet)
+        .calledWith(...expectedHttpServiceGetArguments)
+        .mockReturnValueOnce(expectedHttpServiceGetResponse);
+
+      const response = await service.getDunAndBradstreetNumberByRegistrationNumber(testRegistrationNumber);
+
+      expect(getAccessTokenMethodMock).toHaveBeenCalledTimes(1);
+      expect(response).toBe(expectedDunsNumber);
+    });
+
+    it('throws a DunAndBradstreetException if the Dun and Bradstreet API returns an unknown error response', async () => {
+      const axiosError = new AxiosError();
+      when(httpServiceGet)
+        .calledWith(...expectedHttpServiceGetArguments)
+        .mockReturnValueOnce(throwError(() => axiosError));
+
+      const getDunsNumberPromise = service.getDunAndBradstreetNumberByRegistrationNumber(testRegistrationNumber);
+
+      expect(getAccessTokenMethodMock).toHaveBeenCalledTimes(1);
+      await expect(getDunsNumberPromise).rejects.toBeInstanceOf(DunAndBradstreetException);
+      await expect(getDunsNumberPromise).rejects.toThrow('Failed to get response from Dun and Bradstreet API');
+      await expect(getDunsNumberPromise).rejects.toHaveProperty('innerError', axiosError);
+    });
+  });
+});

src/helper-modules/dun-and-bradstreet/dun-and-bradstreet.service.ts

@@ -0,0 +1,57 @@
+import { HttpService } from '@nestjs/axios';
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { DUN_AND_BRADSTREET } from '@ukef/constants';
+import { HttpClient } from '@ukef/modules/http/http.client';
+
+import { DunAndBradstreetConfig } from '@ukef/config/dun-and-bradstreet.config';
+import { createWrapDunAndBradstreetHttpGetErrorCallback } from './wrap-dun-and-bradstreet-http-error-callback';
+
+@Injectable()
+export class DunAndBradstreetService {
+  private readonly httpClient: HttpClient;
+  private readonly encoded_key: string;
+
+
+  constructor(httpService: HttpService, configService: ConfigService) {
+    this.httpClient = new HttpClient(httpService);
+    const { key } = configService.get<DunAndBradstreetConfig>(DUN_AND_BRADSTREET.CONFIG.KEY);
+    this.encoded_key = key;
+  }
+
+  async getDunAndBradstreetNumberByRegistrationNumber(registrationNumber: string): Promise<string> {
+    const path = `/v1/match/cleanseMatch?countryISOAlpha2Code=GB&registrationNumber=${registrationNumber}`;
+    const access_token = await this.getAccessToken();    
+
+    const { data } = await this.httpClient.get<any>({
+      path,
+      headers: {
+        'Authorization': 'Bearer ' + access_token,
+      },
+      onError: createWrapDunAndBradstreetHttpGetErrorCallback({
+        messageForUnknownError: 'Failed to get response from Dun and Bradstreet API',
+        knownErrors: [],
+      }),
+    });
+    return data?.matchCandidates[0]?.organization?.duns;
+  }
+
+  private async getAccessToken(): Promise<string> {
+    const path = '/v3/token'
+    const response = await this.httpClient.post<any, any>({
+      path,
+      body: {
+        'grant_type': 'client_credentials',
+      },
+      headers: {
+        'Authorization': 'Basic ' + this.encoded_key,
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      onError: createWrapDunAndBradstreetHttpGetErrorCallback({
+        messageForUnknownError: 'Failed to get access token',
+        knownErrors: [],
+      }),
+    })
+    return response.data.access_token
+  }
+}

src/helper-modules/dun-and-bradstreet/exception/dun-and-bradstreet.exception.test.ts

@@ -0,0 +1,28 @@
+import { RandomValueGenerator } from '@ukef-test/support/generator/random-value-generator';
+
+import { DunAndBradstreetException } from './dun-and-bradstreet.exception';
+
+describe('CompaniesHouseException', () => {
+  const valueGenerator = new RandomValueGenerator();
+  const message = valueGenerator.string();
+
+  it('exposes the message it was created with', () => {
+    const exception = new DunAndBradstreetException(message);
+
+    expect(exception.message).toBe(message);
+  });
+
+  it('exposes the name of the exception', () => {
+    const exception = new DunAndBradstreetException(message);
+
+    expect(exception.name).toBe('DunAndBradstreetException');
+  });
+
+  it('exposes the inner error it was created with', () => {
+    const innerError = new Error();
+
+    const exception = new DunAndBradstreetException(message, innerError);
+
+    expect(exception.innerError).toBe(innerError);
+  });
+});

src/helper-modules/dun-and-bradstreet/exception/dun-and-bradstreet.exception.ts

@@ -0,0 +1,9 @@
+export class DunAndBradstreetException extends Error {
+  constructor(
+    message: string,
+    public readonly innerError?: Error,
+  ) {
+    super(message);
+    this.name = this.constructor.name;
+  }
+}

src/helper-modules/dun-and-bradstreet/known-errors.ts

@@ -0,0 +1,5 @@
+import { AxiosError } from 'axios';
+
+export type KnownErrors = KnownError[];
+
+type KnownError = { checkHasError: (error: Error) => boolean; throwError: (error: AxiosError) => never };