@defra-fish/dynamics-lib 1.73.0-sales-api-refactor → 1.73.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra-fish/dynamics-lib",
-  "version": "1.73.0-sales-api-refactor",
+  "version": "1.73.0",
   "description": "Framework to support integration with dynamics",
   "type": "module",
   "engines": {
@@ -36,11 +36,12 @@
     "cache-manager": "3.6.0",
     "cache-manager-ioredis": "2.1.0",
     "debug": "4.3.3",
-    "dynamics-web-api": "1.7.3",
+    "dynamics-web-api": "2.4.0",
     "joi": "17.13.3",
     "moment": "2.29.1",
     "pluralize": "8.0.0",
     "simple-oauth2": "4.3.0",
     "uuid": "8.3.2"
-  }
+  },
+  "gitHead": "128d150e6bd30468bca4e39fb44dd11c5598eb43"
 }

package/src/__mocks__/dynamics-web-api-mock-helper.js

@@ -3,7 +3,7 @@ const { readFileSync } = jest.requireActual('fs')
 const Path = jest.requireActual('path')
 const optionSetDataPath = Path.join(Project.root, 'src', '__mocks__', 'option-set-data.json')
 
-export const configureDynamicsWebApiMock = (DynamicsWebApi = jest.genMockFromModule('dynamics-web-api')) => {
+export const configureDynamicsWebApiMock = DynamicsWebApi => {
   let expectedResponse = {}
   let nextResponses = {}
   let callError = {}
@@ -53,12 +53,12 @@ export const configureDynamicsWebApiMock = (DynamicsWebApi = jest.genMockFromMod
     }
   }
 
-  DynamicsWebApi.prototype.retrieveRequest = jest.fn(async () => responseCapableMethod('retrieveRequest'))
-  DynamicsWebApi.prototype.createRequest = jest.fn(async () => responseCapableMethod('createRequest'))
-  DynamicsWebApi.prototype.updateRequest = jest.fn(async () => responseCapableMethod('updateRequest'))
-  DynamicsWebApi.prototype.retrieveMultipleRequest = jest.fn(async () => responseCapableMethod('retrieveMultipleRequest'))
+  DynamicsWebApi.prototype.retrieve = jest.fn(async () => responseCapableMethod('retrieve'))
+  DynamicsWebApi.prototype.create = jest.fn(async () => responseCapableMethod('create'))
+  DynamicsWebApi.prototype.update = jest.fn(async () => responseCapableMethod('update'))
+  DynamicsWebApi.prototype.retrieveMultiple = jest.fn(async () => responseCapableMethod('retrieveMultiple'))
   DynamicsWebApi.prototype.retrieveGlobalOptionSets = jest.fn(async () => responseCapableMethod('retrieveGlobalOptionSets'))
-  DynamicsWebApi.prototype.executeUnboundFunction = jest.fn(async functionName => {
+  DynamicsWebApi.prototype.callFunction = jest.fn(async functionName => {
     let returnValue = null
     if (functionName === 'RetrieveVersion') {
       returnValue = {

package/src/__mocks__/dynamics-web-api.js

@@ -1,3 +1,5 @@
 import { configureDynamicsWebApiMock } from './dynamics-web-api-mock-helper.js'
-const DynamicsWebApi = jest.genMockFromModule('dynamics-web-api')
-export default configureDynamicsWebApiMock(DynamicsWebApi)
+const DynamicsWebApi = jest.fn()
+DynamicsWebApi.prototype = {}
+configureDynamicsWebApiMock(DynamicsWebApi)
+export { DynamicsWebApi }

package/src/client/__tests__/dynamics-client.spec.js

@@ -1,39 +1,145 @@
 import { config } from '../dynamics-client.js'
 import SimpleOAuth2 from 'simple-oauth2'
 
+const MOCK_SCOPE = 'https://resource/.default'
+const PREEMPTIVE_TOKEN_EXPIRY_SECONDS = 60
+
+const setRequiredEnv = () => {
+  process.env.DYNAMICS_API_PATH = 'https://test-server'
+  process.env.DYNAMICS_API_VERSION = '9.1'
+  process.env.DYNAMICS_API_TIMEOUT = 60000
+  process.env.OAUTH_AUTHORITY_HOST_URL = 'https://test-authority/'
+  process.env.OAUTH_TENANT = 'tenant'
+  process.env.OAUTH_CLIENT_ID = 'clientId'
+  process.env.OAUTH_CLIENT_SECRET = 'clientSecret'
+  process.env.OAUTH_SCOPE = MOCK_SCOPE
+}
+
+const createConfiguredClient = () => {
+  const dynamicsApiConfig = config()
+  const oauthClient = SimpleOAuth2.ClientCredentials.mock.results.at(-1).value
+  return { dynamicsApiConfig, oauthClient }
+}
+
+const seedCachedToken = async (dynamicsApiConfig, token = 'MOCK TOKEN') => {
+  SimpleOAuth2.__setMockTokenReturnValue(token)
+  await dynamicsApiConfig.onTokenRefresh()
+}
+
 describe('dynamics-client', () => {
-  it('is configured via environment variables', async () => {
-    process.env.DYNAMICS_API_PATH = 'https://test-server/api/data/v9.1/'
-    process.env.DYNAMICS_API_VERSION = '9.1'
-    process.env.DYNAMICS_API_TIMEOUT = 60000
-    process.env.OAUTH_AUTHORITY_HOST_URL = 'https://test-authority/'
-    process.env.OAUTH_TENANT = 'tenant'
-    process.env.OAUTH_CLIENT_ID = 'clientId'
-    process.env.OAUTH_CLIENT_SECRET = 'clientSecret'
-    process.env.OAUTH_RESOURCE = 'https://resource/.default'
-    const dynamicsApiConfig = config()
-
-    expect(dynamicsApiConfig).toMatchObject({
-      webApiUrl: process.env.DYNAMICS_API_PATH,
-      webApiVersion: process.env.DYNAMICS_API_VERSION,
-      timeout: `${process.env.DYNAMICS_API_TIMEOUT}`,
-      onTokenRefresh: expect.any(Function)
-    })
-    const testCallback = jest.fn()
-    await dynamicsApiConfig.onTokenRefresh(testCallback)
-    expect(testCallback).toHaveBeenCalledWith('MOCK TOKEN')
-  })
-
-  it('caches tokens until they expire', async () => {
-    const dynamicsApiConfig = config()
-    const testCallback = jest.fn()
-    await dynamicsApiConfig.onTokenRefresh(testCallback)
-    expect(testCallback).toHaveBeenLastCalledWith('MOCK TOKEN')
-    SimpleOAuth2.__setMockTokenReturnValue('NEW MOCK TOKEN')
-    await dynamicsApiConfig.onTokenRefresh(testCallback)
-    expect(testCallback).toHaveBeenLastCalledWith('MOCK TOKEN')
+  beforeEach(() => {
+    jest.clearAllMocks()
+    SimpleOAuth2.__setMockTokenReturnValue('MOCK TOKEN')
+    SimpleOAuth2.__setMockTokenExpired(false)
+    setRequiredEnv()
+  })
+
+  it('exposes serverUrl from DYNAMICS_API_PATH', () => {
+    const { dynamicsApiConfig } = createConfiguredClient()
+
+    expect(dynamicsApiConfig.serverUrl).toBe(process.env.DYNAMICS_API_PATH)
+  })
+
+  it('exposes dataApi.version from DYNAMICS_API_VERSION', () => {
+    const { dynamicsApiConfig } = createConfiguredClient()
+
+    expect(dynamicsApiConfig.dataApi.version).toBe(process.env.DYNAMICS_API_VERSION)
+  })
+
+  it('exposes timeout from DYNAMICS_API_TIMEOUT', () => {
+    const { dynamicsApiConfig } = createConfiguredClient()
+
+    expect(dynamicsApiConfig.timeout).toBe(`${process.env.DYNAMICS_API_TIMEOUT}`)
+  })
+
+  it('exposes onTokenRefresh as a function', () => {
+    const { dynamicsApiConfig } = createConfiguredClient()
+
+    expect(typeof dynamicsApiConfig.onTokenRefresh).toBe('function')
+  })
+
+  it('returns getToken access token when access token cache is empty', async () => {
+    SimpleOAuth2.__setMockTokenReturnValue('FIRST TOKEN')
+    const { dynamicsApiConfig } = createConfiguredClient()
+
+    const token = await dynamicsApiConfig.onTokenRefresh()
+
+    expect(token).toBe('FIRST TOKEN')
+  })
+
+  it('calls getToken once when access token cache is empty', async () => {
+    const { dynamicsApiConfig, oauthClient } = createConfiguredClient()
+
+    await dynamicsApiConfig.onTokenRefresh()
+
+    expect(oauthClient.getToken).toHaveBeenCalledTimes(1)
+  })
+
+  it('calls getToken with scope when access token cache is empty', async () => {
+    const { dynamicsApiConfig, oauthClient } = createConfiguredClient()
+
+    await dynamicsApiConfig.onTokenRefresh()
+
+    expect(oauthClient.getToken).toHaveBeenCalledWith({ scope: MOCK_SCOPE })
+  })
+
+  it('calls accessToken.expired with PREEMPTIVE_TOKEN_EXPIRY_SECONDS when token is cached', async () => {
+    const { dynamicsApiConfig, oauthClient } = createConfiguredClient()
+    await seedCachedToken(dynamicsApiConfig)
+    const cachedAccessToken = await oauthClient.getToken.mock.results[0].value
+
+    await dynamicsApiConfig.onTokenRefresh()
+
+    expect(cachedAccessToken.expired).toHaveBeenCalledWith(PREEMPTIVE_TOKEN_EXPIRY_SECONDS)
+  })
+
+  it('returns cached token when cached access token is not expired', async () => {
+    const { dynamicsApiConfig } = createConfiguredClient()
+    await seedCachedToken(dynamicsApiConfig, 'FIRST TOKEN')
+    SimpleOAuth2.__setMockTokenReturnValue('SECOND TOKEN')
+
+    const token = await dynamicsApiConfig.onTokenRefresh()
+
+    expect(token).toBe('FIRST TOKEN')
+  })
+
+  it('does not call getToken again when cached access token is not expired', async () => {
+    const { dynamicsApiConfig, oauthClient } = createConfiguredClient()
+    await seedCachedToken(dynamicsApiConfig)
+
+    await dynamicsApiConfig.onTokenRefresh()
+
+    expect(oauthClient.getToken).toHaveBeenCalledTimes(1)
+  })
+
+  it('returns refreshed token when cached access token is expired', async () => {
+    const { dynamicsApiConfig } = createConfiguredClient()
+    await seedCachedToken(dynamicsApiConfig, 'FIRST TOKEN')
+    SimpleOAuth2.__setMockTokenReturnValue('NEW TOKEN')
     SimpleOAuth2.__setMockTokenExpired(true)
-    await dynamicsApiConfig.onTokenRefresh(testCallback)
-    expect(testCallback).toHaveBeenLastCalledWith('NEW MOCK TOKEN')
+
+    const token = await dynamicsApiConfig.onTokenRefresh()
+
+    expect(token).toBe('NEW TOKEN')
+  })
+
+  it('calls getToken again when cached access token is expired', async () => {
+    const { dynamicsApiConfig, oauthClient } = createConfiguredClient()
+    await seedCachedToken(dynamicsApiConfig)
+    SimpleOAuth2.__setMockTokenExpired(true)
+
+    await dynamicsApiConfig.onTokenRefresh()
+
+    expect(oauthClient.getToken).toHaveBeenCalledTimes(2)
+  })
+
+  it('calls getToken with scope when cached access token is expired', async () => {
+    const { dynamicsApiConfig, oauthClient } = createConfiguredClient()
+    await seedCachedToken(dynamicsApiConfig)
+    SimpleOAuth2.__setMockTokenExpired(true)
+
+    await dynamicsApiConfig.onTokenRefresh()
+
+    expect(oauthClient.getToken).toHaveBeenLastCalledWith({ scope: MOCK_SCOPE })
   })
 })

package/src/client/__tests__/entity-manager.spec.js

@@ -13,7 +13,7 @@ import {
 } from '../../index.js'
 import TestEntity from '../../__mocks__/TestEntity.js'
 import { v4 as uuidv4 } from 'uuid'
-import MockDynamicsWebApi from 'dynamics-web-api'
+import { DynamicsWebApi as MockDynamicsWebApi } from 'dynamics-web-api'
 import { PredefinedQuery } from '../../queries/predefined-query.js'
 import { BaseEntity, EntityDefinition } from '../../entities/base.entity.js'
 
@@ -33,7 +33,7 @@ describe('entity manager', () => {
       t.boolVal = true
 
       const result = await persist([t])
-      expect(MockDynamicsWebApi.prototype.createRequest).toHaveBeenCalled()
+      expect(MockDynamicsWebApi.prototype.create).toHaveBeenCalled()
       expect(result).toHaveLength(1)
       expect(result[0]).toEqual(resultUuid)
     })
@@ -54,7 +54,7 @@ describe('entity manager', () => {
       )
 
       const result = await persist([t])
-      expect(MockDynamicsWebApi.prototype.updateRequest).toHaveBeenCalled()
+      expect(MockDynamicsWebApi.prototype.update).toHaveBeenCalled()
       expect(result).toHaveLength(1)
       expect(result[0]).toEqual(resultUuid)
     })
@@ -69,7 +69,7 @@ describe('entity manager', () => {
       t.boolVal = true
 
       const result = await persist([t], 'foo')
-      expect(MockDynamicsWebApi.prototype.createRequest).toHaveBeenCalled()
+      expect(MockDynamicsWebApi.prototype.create).toHaveBeenCalled()
       expect(MockDynamicsWebApi.prototype.executeBatch).toHaveBeenCalledWith(
         expect.objectContaining({
           impersonateAAD: 'foo'
@@ -94,10 +94,10 @@ describe('entity manager', () => {
         {}
       )
       await expect(persist([newEntity, existingEntity])).rejects.toThrow('Test error')
-      // Expect the console error to contain details of the batch data (one createRequest, one updateRequest plus the exception object)
+      // Expect the console error to contain details of the batch data (one create, one update plus the exception object)
       expect(consoleErrorSpy).toHaveBeenCalledWith(
         expect.stringMatching('Error persisting batch. Data: %j, Exception: %o'),
-        expect.arrayContaining([{ createRequest: expect.any(Object) }, { updateRequest: expect.any(Object) }]),
+        expect.arrayContaining([{ create: expect.any(Object) }, { update: expect.any(Object) }]),
         expect.any(Error)
       )
     })
@@ -332,14 +332,14 @@ describe('entity manager', () => {
 
   describe('findById', () => {
     it('finds by a primary key guid', async () => {
-      MockDynamicsWebApi.__setResponse('retrieveRequest', {
+      MockDynamicsWebApi.__setResponse('retrieve', {
         '@odata.etag': 'W/"202465000"',
         idval: '9f1b34a0-0c66-e611-80dc-c4346bad0190',
         strval: 'example'
       })
 
       const result = await findById(TestEntity, '9f1b34a0-0c66-e611-80dc-c4346bad0190')
-      expect(MockDynamicsWebApi.prototype.retrieveRequest).toBeCalledWith({
+      expect(MockDynamicsWebApi.prototype.retrieve).toBeCalledWith({
         key: '9f1b34a0-0c66-e611-80dc-c4346bad0190',
         collection: TestEntity.definition.dynamicsCollection,
         select: TestEntity.definition.select
@@ -350,13 +350,13 @@ describe('entity manager', () => {
     it('returns null if not found', async () => {
       const notFoundError = new Error('Not found')
       notFoundError.status = 404
-      MockDynamicsWebApi.__throwWithErrorOn('retrieveRequest', notFoundError)
+      MockDynamicsWebApi.__throwWithErrorOn('retrieve', notFoundError)
       const result = await findById(TestEntity, '9f1b34a0-0c66-e611-80dc-c4346bad0190')
       expect(result).toEqual(null)
     })
 
     it('throws an exception on general errors', async () => {
-      MockDynamicsWebApi.__throwWithErrorOn('retrieveRequest')
+      MockDynamicsWebApi.__throwWithErrorOn('retrieve')
       const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(jest.fn())
       await expect(findById(TestEntity, '9f1b34a0-0c66-e611-80dc-c4346bad0190')).rejects.toThrow('Test error')
       expect(consoleErrorSpy).toHaveBeenCalled()
@@ -365,13 +365,13 @@ describe('entity manager', () => {
 
   describe('findByAlternateKey', () => {
     it('finds by an alternate key', async () => {
-      MockDynamicsWebApi.__setResponse('retrieveRequest', {
+      MockDynamicsWebApi.__setResponse('retrieve', {
         '@odata.etag': 'W/"202465000"',
         idval: '9f1b34a0-0c66-e611-80dc-c4346bad0190',
         strval: 'example'
       })
       const result = await findByAlternateKey(TestEntity, 'example')
-      expect(MockDynamicsWebApi.prototype.retrieveRequest).toBeCalledWith({
+      expect(MockDynamicsWebApi.prototype.retrieve).toBeCalledWith({
         key: "strval='example'",
         collection: TestEntity.definition.dynamicsCollection,
         select: TestEntity.definition.select
@@ -381,13 +381,13 @@ describe('entity manager', () => {
     })
 
     it('escapes special characters in the key', async () => {
-      MockDynamicsWebApi.__setResponse('retrieveRequest', {
+      MockDynamicsWebApi.__setResponse('retrieve', {
         '@odata.etag': 'W/"202465000"',
         idval: '9f1b34a0-0c66-e611-80dc-c4346bad0190',
         strval: 'example'
       })
       const result = await findByAlternateKey(TestEntity, "test & example'")
-      expect(MockDynamicsWebApi.prototype.retrieveRequest).toBeCalledWith({
+      expect(MockDynamicsWebApi.prototype.retrieve).toBeCalledWith({
         key: "strval='test %26 example'''",
         collection: TestEntity.definition.dynamicsCollection,
         select: TestEntity.definition.select
@@ -399,7 +399,7 @@ describe('entity manager', () => {
 
   describe('findByExample', () => {
     it('builds a select statement appropriate to the type definition for each field', async () => {
-      MockDynamicsWebApi.__setResponse('retrieveMultipleRequest', { value: [{}] })
+      MockDynamicsWebApi.__setResponse('retrieveMultiple', { value: [{}] })
 
       const lookup = new TestEntity()
       lookup.strVal = 'StringData'
@@ -412,7 +412,7 @@ describe('entity manager', () => {
       const expectedLookupSelect =
         "strval eq 'StringData' and intval eq 123 and decval eq 123.45 and boolval eq true and dateval eq 1946-01-01 and datetimeval eq 1946-01-01T01:02:03Z and optionsetval eq 910400000"
       const result = await findByExample(lookup)
-      expect(MockDynamicsWebApi.prototype.retrieveMultipleRequest).toBeCalledWith({
+      expect(MockDynamicsWebApi.prototype.retrieveMultiple).toBeCalledWith({
         collection: TestEntity.definition.dynamicsCollection,
         select: TestEntity.definition.select,
         filter: expect.stringMatching(`${TestEntity.definition.defaultFilter} and ${expectedLookupSelect}`)
@@ -422,7 +422,7 @@ describe('entity manager', () => {
     })
 
     it('does not require the entity to define a default filter', async () => {
-      MockDynamicsWebApi.__setResponse('retrieveMultipleRequest', { value: [{}] })
+      MockDynamicsWebApi.__setResponse('retrieveMultiple', { value: [{}] })
 
       class SameEntity extends BaseEntity {
         static _definition = new EntityDefinition(() => ({
@@ -458,7 +458,7 @@ describe('entity manager', () => {
       lookup.testVal = 'StringData'
       const expectedLookupSelect = "testval eq 'StringData'"
       const result = await findByExample(lookup)
-      expect(MockDynamicsWebApi.prototype.retrieveMultipleRequest).toBeCalledWith({
+      expect(MockDynamicsWebApi.prototype.retrieveMultiple).toBeCalledWith({
         collection: SameEntity.definition.dynamicsCollection,
         select: SameEntity.definition.select,
         filter: expect.stringMatching(`${expectedLookupSelect}`)
@@ -468,13 +468,13 @@ describe('entity manager', () => {
     })
 
     it('only serializes fields into the select statement if they are set', async () => {
-      MockDynamicsWebApi.__setResponse('retrieveMultipleRequest', { value: [{}] })
+      MockDynamicsWebApi.__setResponse('retrieveMultiple', { value: [{}] })
 
       const lookup = new TestEntity()
       lookup.strVal = 'StringData'
       const expectedLookupSelect = "strval eq 'StringData'"
       const result = await findByExample(lookup)
-      expect(MockDynamicsWebApi.prototype.retrieveMultipleRequest).toBeCalledWith({
+      expect(MockDynamicsWebApi.prototype.retrieveMultiple).toBeCalledWith({
         collection: TestEntity.definition.dynamicsCollection,
         select: TestEntity.definition.select,
         filter: expect.stringMatching(`${TestEntity.definition.defaultFilter} and ${expectedLookupSelect}`)
@@ -484,7 +484,7 @@ describe('entity manager', () => {
     })
 
     it('throws an error object on failure', async () => {
-      MockDynamicsWebApi.__throwWithErrorOn('retrieveMultipleRequest')
+      MockDynamicsWebApi.__throwWithErrorOn('retrieveMultiple')
       const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(jest.fn())
       await expect(findByExample(new TestEntity())).rejects.toThrow('Test error')
       expect(consoleErrorSpy).toHaveBeenCalled()
@@ -492,8 +492,8 @@ describe('entity manager', () => {
   })
 
   describe('executeQuery', () => {
-    it('calls retrieveMultipleRequest on the Dynamics API with the request data', async () => {
-      MockDynamicsWebApi.__setResponse('retrieveMultipleRequest', {
+    it('calls retrieveMultiple on the Dynamics API with the request data', async () => {
+      MockDynamicsWebApi.__setResponse('retrieveMultiple', {
         value: [
           {
             '@odata.etag': 'W/"202465000"',
@@ -504,7 +504,7 @@ describe('entity manager', () => {
       })
 
       const result = await executeQuery(new PredefinedQuery({ root: TestEntity, filter: "strval eq 'example'" }))
-      expect(MockDynamicsWebApi.prototype.retrieveMultipleRequest).toBeCalledWith({
+      expect(MockDynamicsWebApi.prototype.retrieveMultiple).toBeCalledWith({
         collection: TestEntity.definition.dynamicsCollection,
         filter: "strval eq 'example'",
         select: TestEntity.definition.select
@@ -516,7 +516,7 @@ describe('entity manager', () => {
     })
 
     it('throws an error object on failure', async () => {
-      MockDynamicsWebApi.__throwWithErrorOn('retrieveMultipleRequest')
+      MockDynamicsWebApi.__throwWithErrorOn('retrieveMultiple')
       const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(jest.fn())
       await expect(executeQuery(new PredefinedQuery({ root: TestEntity, filter: "strval eq 'example'" }))).rejects.toThrow('Test error')
       expect(consoleErrorSpy).toHaveBeenCalled()
@@ -527,7 +527,7 @@ describe('entity manager', () => {
     beforeEach(async () => {
       MockDynamicsWebApi.__reset()
       MockDynamicsWebApi.__setNextResponses(
-        'retrieveMultipleRequest',
+        'retrieveMultiple',
         {
           value: [
             {
@@ -592,7 +592,7 @@ describe('entity manager', () => {
     })
 
     it('throws an error object on failure', async () => {
-      MockDynamicsWebApi.__throwWithErrorOn('retrieveMultipleRequest')
+      MockDynamicsWebApi.__throwWithErrorOn('retrieveMultiple')
       const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(jest.fn())
       await expect(
         executePagedQuery(new PredefinedQuery({ root: TestEntity, filter: "strval eq 'example'" }), () => {}, 1)

package/src/client/dynamics-client.js

@@ -1,4 +1,4 @@
-import DynamicsWebApi from 'dynamics-web-api'
+import { DynamicsWebApi } from 'dynamics-web-api'
 import SimpleOAuth2 from 'simple-oauth2'
 const PREEMPTIVE_TOKEN_EXPIRY_SECONDS = 60
 
@@ -21,14 +21,16 @@ export function config () {
 
   let accessToken = null
   return {
-    webApiUrl: process.env.DYNAMICS_API_PATH,
-    webApiVersion: process.env.DYNAMICS_API_VERSION,
+    serverUrl: process.env.DYNAMICS_API_PATH,
+    dataApi: {
+      version: process.env.DYNAMICS_API_VERSION
+    },
     timeout: process.env.DYNAMICS_API_TIMEOUT || 90000,
-    onTokenRefresh: async dynamicsWebApiCallback => {
+    onTokenRefresh: async () => {
       if (!accessToken || accessToken.expired(PREEMPTIVE_TOKEN_EXPIRY_SECONDS)) {
         accessToken = await oauthClient.getToken({ scope: process.env.OAUTH_SCOPE })
       }
-      dynamicsWebApiCallback(accessToken.token.access_token)
+      return accessToken.token.access_token
     }
   }
 }

package/src/client/entity-manager.js

@@ -14,9 +14,9 @@ export async function persist (entities, createdBy) {
     dynamicsClient.startBatch()
     entities.forEach(entity => {
       if (entity.isNew()) {
-        dynamicsClient.createRequest(entity.toPersistRequest())
+        dynamicsClient.create(entity.toPersistRequest())
       } else {
-        dynamicsClient.updateRequest(entity.toPersistRequest())
+        dynamicsClient.update(entity.toPersistRequest())
       }
     })
     return await dynamicsClient.executeBatch({
@@ -24,7 +24,7 @@ export async function persist (entities, createdBy) {
     })
   } catch (e) {
     const error = e.length ? e[0] : e
-    const requestDetails = entities.map(entity => ({ [entity.isNew() ? 'createRequest' : 'updateRequest']: entity.toPersistRequest() }))
+    const requestDetails = entities.map(entity => ({ [entity.isNew() ? 'create' : 'update']: entity.toPersistRequest() }))
     console.error('Error persisting batch. Data: %j, Exception: %o', requestDetails, error)
     throw error
   }
@@ -33,7 +33,7 @@ export async function persist (entities, createdBy) {
 const retrieveMultipleFetchOperation = async entityClasses => {
   try {
     dynamicsClient.startBatch()
-    entityClasses.forEach(cls => dynamicsClient.retrieveMultipleRequest(cls.definition.toRetrieveRequest()))
+    entityClasses.forEach(cls => dynamicsClient.retrieveMultiple(cls.definition.toRetrieveRequest()))
     return await dynamicsClient.executeBatch()
   } catch (e) {
     const error = e.length ? e[0] : e
@@ -98,7 +98,10 @@ export function retrieveGlobalOptionSets () {
     'dynamics_optionsetmap',
     async () => {
       try {
-        const data = await dynamicsClient.retrieveGlobalOptionSets('Microsoft.Dynamics.CRM.OptionSetMetadata', ['Name', 'Options'])
+        const data = await dynamicsClient.retrieveGlobalOptionSets({
+          castType: 'Microsoft.Dynamics.CRM.OptionSetMetadata',
+          select: ['Name', 'Options']
+        })
         return data.value.reduce((acc, { Name: name, Options: options }) => {
           acc[name] = {
             name,
@@ -132,7 +135,7 @@ export function retrieveGlobalOptionSets () {
  */
 export async function findById (entityType, key) {
   try {
-    const record = await dynamicsClient.retrieveRequest({ key: key, ...entityType.definition.toRetrieveRequest(null) })
+    const record = await dynamicsClient.retrieve({ key: key, ...entityType.definition.toRetrieveRequest(null) })
     const optionSetData = await retrieveGlobalOptionSets().cached()
     return entityType.fromResponse(record, optionSetData)
   } catch (e) {
@@ -180,7 +183,7 @@ export async function findByExample (entity) {
         return acc
       }, [])
     ].join(' and ')
-    const results = await dynamicsClient.retrieveMultipleRequest(entity.constructor.definition.toRetrieveRequest(filter))
+    const results = await dynamicsClient.retrieveMultiple(entity.constructor.definition.toRetrieveRequest(filter))
     const optionSetData = await retrieveGlobalOptionSets().cached()
     return results.value.map(result => entity.constructor.fromResponse(result, optionSetData))
   } catch (e) {
@@ -200,7 +203,7 @@ export async function findByExample (entity) {
  */
 export async function executeQuery (query) {
   try {
-    const response = await dynamicsClient.retrieveMultipleRequest(query.toRetrieveRequest())
+    const response = await dynamicsClient.retrieveMultiple(query.toRetrieveRequest())
     const optionSetData = await retrieveGlobalOptionSets().cached()
     return query.fromResponse(response.value, optionSetData)
   } catch (e) {
@@ -227,7 +230,7 @@ export async function executePagedQuery (query, onPageReceived, maxPages) {
     const optionSetData = await retrieveGlobalOptionSets().cached()
     let nextLink = null
     do {
-      const response = await dynamicsClient.retrieveMultipleRequest(query.toRetrieveRequest(), nextLink)
+      const response = await dynamicsClient.retrieveMultiple(query.toRetrieveRequest(), nextLink)
       nextLink = response.oDataNextLink
       await onPageReceived(query.fromResponse(response.value, optionSetData))
       processed += response.value.length

package/src/entities/base.entity.js

@@ -308,7 +308,7 @@ export class BaseEntity {
       ...(!this.isNew() && { key: this.id }),
       collection: this.constructor.definition.dynamicsCollection,
       contentId: this.uniqueContentId,
-      entity: this.toRequestBody()
+      data: this.toRequestBody()
     }
   }
 

package/src/queries/__tests__/contact.queries.spec.js

@@ -4,11 +4,13 @@ import { Permission } from '../../entities/permission.entity.js'
 import { PredefinedQuery } from '../predefined-query.js'
 
 jest.mock('dynamics-web-api', () => {
-  return jest.fn().mockImplementation(() => {
-    return {
-      executeUnboundAction: jest.fn()
-    }
-  })
+  return {
+    DynamicsWebApi: jest.fn().mockImplementation(() => {
+      return {
+        callAction: jest.fn()
+      }
+    })
+  }
 })
 
 describe('Contact Queries', () => {

package/src/queries/__tests__/recurring-payments-queries.spec.js

@@ -1,10 +1,8 @@
 import {
   findDueRecurringPayments,
   findRecurringPaymentsByAgreementId,
-  findRecurringPaymentByPermissionId,
-  findPermissionByRecurringPaymentId
+  findRecurringPaymentByPermissionId
 } from '../recurring-payments.queries.js'
-import { RecurringPayment } from '../../entities/recurring-payment.entity.js'
 
 describe('Recurring Payment Queries', () => {
   const baseSelection = () => [
@@ -21,7 +19,7 @@ describe('Recurring Payment Queries', () => {
   ]
 
   describe('findDueRecurringPayments', () => {
-    it('builds retrieve request with due date filter, active-state checks and contact/permission expands', () => {
+    it('builds a query to retrieve active recurring payments', () => {
       const date = new Date('2023-11-08')
 
       const query = findDueRecurringPayments(date)
@@ -37,7 +35,7 @@ describe('Recurring Payment Queries', () => {
   })
 
   describe('findRecurringPaymentsByAgreementId', () => {
-    it('builds retrieve request filtered by agreement id and active state', () => {
+    it('builds a query to retrieve active recurring payments', () => {
       const agreementId = 'abc123'
 
       const query = findRecurringPaymentsByAgreementId(agreementId)
@@ -51,7 +49,7 @@ describe('Recurring Payment Queries', () => {
   })
 
   describe('findRecurringPaymentByPermissionId', () => {
-    it('builds retrieve request filtered by active permission id and active state', () => {
+    it('builds a query to retrieve recurring payments by permissionId', () => {
       const permissionId = 'perm-123'
 
       const query = findRecurringPaymentByPermissionId(permissionId)
@@ -64,43 +62,4 @@ describe('Recurring Payment Queries', () => {
       })
     })
   })
-
-  describe('findPermissionByRecurringPaymentId', () => {
-    const createMockDefinition = defaultFilter => ({
-      defaultFilter,
-      relationships: {
-        activePermission: { property: 'defra_ActivePermission' }
-      },
-      toRetrieveRequest: filter => ({
-        collection: 'defra_recurringpayments',
-        select: baseSelection(),
-        filter
-      })
-    })
-
-    it.each(['rcp-456', 'rcp-789'])('builds full filter with conjunctions when recurring payment id is %s', recurringPaymentId => {
-      const mockDefaultFilter = 'mock_default_filter'
-      const definitionSpy = jest.spyOn(RecurringPayment, 'definition', 'get').mockReturnValue(createMockDefinition(mockDefaultFilter))
-
-      try {
-        const request = findPermissionByRecurringPaymentId(recurringPaymentId).toRetrieveRequest()
-        expect(request.filter).toBe(
-          `_defra_activepermission_value ne null and defra_recurringpaymentid eq ${recurringPaymentId} and ${mockDefaultFilter}`
-        )
-      } finally {
-        definitionSpy.mockRestore()
-      }
-    })
-
-    it('expands active permission relationship', () => {
-      const definitionSpy = jest.spyOn(RecurringPayment, 'definition', 'get').mockReturnValue(createMockDefinition('mock_default_filter'))
-
-      try {
-        const request = findPermissionByRecurringPaymentId('rcp-456').toRetrieveRequest()
-        expect(request.expand).toContainEqual({ property: 'defra_ActivePermission' })
-      } finally {
-        definitionSpy.mockRestore()
-      }
-    })
-  })
 })

package/src/queries/recurring-payments.queries.js

@@ -59,20 +59,3 @@ export const findRecurringPaymentByPermissionId = permissionId => {
     expand: [activePermission]
   })
 }
-
-/**
- * Builds a query to retrieve the active permission linked to a recurring payment
- *
- * @param recurringPaymentId the id of the recurring payment
- * @returns {PredefinedQuery}
- */
-export const findPermissionByRecurringPaymentId = recurringPaymentId => {
-  const { activePermission } = RecurringPayment.definition.relationships
-  const filter = `_defra_activepermission_value ne null and defra_recurringpaymentid eq ${recurringPaymentId} and ${RecurringPayment.definition.defaultFilter}`
-
-  return new PredefinedQuery({
-    root: RecurringPayment,
-    filter,
-    expand: [activePermission]
-  })
-}