feat: app action call returning response[EXT-4402] (#1777)

* feat: app action call returning response

* fix: changed types to fix build

* refactor: function separated for polling

* fix: error changed according to app action

* refactor: return type changed, retry params removed from public

* fix: return types fixed

* test: test cases skeleton

* refactor: more tests added

* fix: test cases

* test: fixed unit test cases

* test: create app action call test modified

* refactor: removed unnecessary code

* test: included test for checking response for get app action call

* refactor: new method called createAppActionCall

* fix: test cases, lint types

* refactor: function name changed

Author: vikaskumr

lib/adapters/REST/endpoints/app-action-call.ts

@@ -1,6 +1,10 @@
 import type { AxiosInstance } from 'contentful-sdk-core'
-import { CreateAppActionCallProps, AppActionCallProps } from '../../../entities/app-action-call'
-import { WebhookCallDetailsProps } from '../../../entities/webhook'
+import {
+  AppActionCallProps,
+  AppActionCallResponse,
+  CreateAppActionCallProps,
+  FetchAppActionResponse,
+} from '../../../entities/app-action-call'
 import * as raw from './raw'
 import { RestEndpoint } from '../types'
 import { GetAppActionCallDetailsParams, GetAppActionCallParams } from '../../../common-types'
@@ -21,8 +25,74 @@ export const getCallDetails: RestEndpoint<'AppActionCall', 'getCallDetails'> = (
   http: AxiosInstance,
   params: GetAppActionCallDetailsParams
 ) => {
-  return raw.get<WebhookCallDetailsProps>(
+  return raw.get<AppActionCallResponse>(
     http,
     `/spaces/${params.spaceId}/environments/${params.environmentId}/actions/${params.appActionId}/calls/${params.callId}`
   )
 }
+
+const APP_ACTION_CALL_RETRY_INTERVAL = 2000
+const APP_ACTION_CALL_RETRIES = 10
+
+async function callAppActionResult(
+  http: AxiosInstance,
+  params: GetAppActionCallParams,
+  {
+    resolve,
+    reject,
+    retryInterval = APP_ACTION_CALL_RETRY_INTERVAL,
+    retries = APP_ACTION_CALL_RETRIES,
+    checkCount = 0,
+    callId,
+  }: FetchAppActionResponse & {
+    resolve: (appActionResponse: AppActionCallResponse) => unknown
+    reject: (err: Error) => unknown
+    callId: string
+  }
+) {
+  const appActionResponse = await getCallDetails(http, { ...params, callId })
+
+  if (appActionResponse && appActionResponse.sys && appActionResponse.sys.id) {
+    resolve(appActionResponse)
+  } else if (checkCount === retries) {
+    const error = new Error()
+    error.message = 'The app action response is taking longer than expected to process.'
+    reject(error)
+  } else {
+    checkCount++
+    setTimeout(
+      () =>
+        callAppActionResult(http, params, {
+          resolve,
+          reject,
+          retryInterval,
+          retries,
+          checkCount,
+          callId,
+        }),
+      retryInterval
+    )
+  }
+}
+
+export const createWithResponse: RestEndpoint<'AppActionCall', 'createWithResponse'> = async (
+  http: AxiosInstance,
+  params: GetAppActionCallParams,
+  data: CreateAppActionCallProps
+) => {
+  const createResponse = await raw.post<AppActionCallProps>(
+    http,
+    `/spaces/${params.spaceId}/environments/${params.environmentId}/app_installations/${params.appDefinitionId}/actions/${params.appActionId}/calls`,
+    data
+  )
+
+  const callId = createResponse.sys.id
+
+  return new Promise<AppActionCallResponse>((resolve, reject) =>
+    callAppActionResult(http, params, {
+      resolve,
+      reject,
+      callId,
+    })
+  )
+}

lib/common-types.ts

@@ -2,7 +2,11 @@ import { AxiosRequestConfig, AxiosRequestHeaders } from 'axios'
 import { OpPatch } from 'json-patch'
 import { Stream } from 'stream'
 import { AppActionProps, CreateAppActionProps } from './entities/app-action'
-import { AppActionCallProps, CreateAppActionCallProps } from './entities/app-action-call'
+import {
+  AppActionCallProps,
+  AppActionCallResponse,
+  CreateAppActionCallProps,
+} from './entities/app-action-call'
 import { AppBundleProps, CreateAppBundleProps } from './entities/app-bundle'
 import { ApiKeyProps, CreateApiKeyProps } from './entities/api-key'
 import { AppDefinitionProps, CreateAppDefinitionProps } from './entities/app-definition'
@@ -298,6 +302,11 @@ type MRInternal<UA extends boolean> = {
   (opts: MROpts<'AppAction', 'update', UA>): MRReturn<'AppAction', 'update'>
 
   (opts: MROpts<'AppActionCall', 'create', UA>): MRReturn<'AppActionCall', 'create'>
+  (opts: MROpts<'AppActionCall', 'createWithResponse', UA>): MRReturn<
+    'AppActionCall',
+    'createWithResponse'
+  >
+  (opts: MROpts<'AppActionCall', 'getCallDetails', UA>): MRReturn<'AppActionCall', 'getCallDetails'>
 
   (opts: MROpts<'AppBundle', 'get', UA>): MRReturn<'AppBundle', 'get'>
   (opts: MROpts<'AppBundle', 'getMany', UA>): MRReturn<'AppBundle', 'getMany'>
@@ -705,7 +714,12 @@ export type MRActions = {
     }
     getCallDetails: {
       params: GetAppActionCallDetailsParams
-      return: WebhookCallDetailsProps
+      return: AppActionCallResponse
+    }
+    createWithResponse: {
+      params: GetAppActionCallParams
+      payload: CreateAppActionCallProps
+      return: AppActionCallResponse
     }
   }
   AppBundle: {

lib/entities/app-action-call.ts

@@ -1,9 +1,18 @@
 import copy from 'fast-copy'
 import { toPlainObject } from 'contentful-sdk-core'
 import { Except } from 'type-fest'
-import { BasicMetaSysProps, DefaultElements, MakeRequest, SysLink } from '../common-types'
+import {
+  BasicMetaSysProps,
+  DefaultElements,
+  GetAppActionCallDetailsParams,
+  GetAppActionCallParams,
+  MakeRequest,
+  SysLink,
+} from '../common-types'
+import { WebhookCallDetailsProps } from './webhook'
+import enhanceWithMethods from '../enhance-with-methods'
 
-type AppActionCallSys = Except<BasicMetaSysProps, 'version' | 'id'> & {
+type AppActionCallSys = Except<BasicMetaSysProps, 'version'> & {
   appDefinition: SysLink
   space: SysLink
   environment: SysLink
@@ -22,8 +31,65 @@ export type CreateAppActionCallProps = {
   parameters: { [key: string]: any }
 }
 
+type AppActionCallApi = {
+  createWithResponse(): Promise<AppActionCallResponse>
+  getCallDetails(): Promise<AppActionCallResponse>
+}
+
+export type AppActionCallResponse = WebhookCallDetailsProps
+
+export interface AppActionCallResponseData
+  extends AppActionCallResponse,
+    DefaultElements<AppActionCallResponse>,
+    AppActionCallApi {}
+
 export interface AppActionCall extends AppActionCallProps, DefaultElements<AppActionCallProps> {}
 
+/**
+ * @private
+ */
+export default function createAppActionCallApi(makeRequest: MakeRequest): AppActionCallApi {
+  return {
+    createWithResponse: function () {
+      const payload: CreateAppActionCallProps = {
+        parameters: {
+          recipient: 'Alice <alice@my-company.com>',
+          message_body: 'Hello from Bob!',
+        },
+      }
+
+      return makeRequest({
+        entityType: 'AppActionCall',
+        action: 'createWithResponse',
+        params: {
+          spaceId: 'space-id',
+          environmentId: 'environment-id',
+          appDefinitionId: 'app-definiton-id',
+          appActionId: 'app-action-id',
+        },
+        payload: payload,
+      }).then((data) => wrapAppActionCallResponse(makeRequest, data))
+    },
+
+    getCallDetails: function getCallDetails() {
+      const getParams = (raw: GetAppActionCallDetailsParams): GetAppActionCallDetailsParams => ({
+        spaceId: raw.spaceId,
+        environmentId: raw.environmentId,
+        callId: raw.callId,
+        appActionId: raw.appActionId,
+      })
+
+      const raw = this.toPlainObject() as GetAppActionCallDetailsParams
+
+      return makeRequest({
+        entityType: 'AppActionCall',
+        action: 'getCallDetails',
+        params: getParams(raw),
+      }).then((data) => wrapAppActionCallResponse(makeRequest, data))
+    },
+  }
+}
+
 /**
  * @private
  * @param http - HTTP client instance
@@ -37,3 +103,27 @@ export function wrapAppActionCall(
   const signedRequest = toPlainObject(copy(data))
   return signedRequest
 }
+
+/**
+ * @private
+ * @param http - HTTP client instance
+ * @param data - Raw AppActionCall data
+ * @return Wrapped AppActionCall data
+ */
+export function wrapAppActionCallResponse(
+  makeRequest: MakeRequest,
+  data: AppActionCallResponse
+): AppActionCallResponseData {
+  const appActionCallResponse = toPlainObject(copy(data))
+  const appActionCallResponseWithMethods = enhanceWithMethods(
+    appActionCallResponse,
+    createAppActionCallApi(makeRequest)
+  )
+  return appActionCallResponseWithMethods
+}
+
+export interface FetchAppActionResponse {
+  retryInterval?: number
+  retries?: number
+  checkCount?: number
+}

lib/plain/common-types.ts

@@ -117,7 +117,11 @@ import { DefaultParams, OptionalDefaults } from './wrappers/wrap'
 import { AssetKeyProps, CreateAssetKeyProps } from '../entities/asset-key'
 import { AppUploadProps } from '../entities/app-upload'
 import { AppActionProps, CreateAppActionProps } from '../entities/app-action'
-import { AppActionCallProps, CreateAppActionCallProps } from '../entities/app-action-call'
+import {
+  AppActionCallProps,
+  AppActionCallResponse,
+  CreateAppActionCallProps,
+} from '../entities/app-action-call'
 import { AppBundleProps, CreateAppBundleProps } from '../entities/app-bundle'
 import { AppDetailsProps, CreateAppDetailsProps } from '../entities/app-details'
 import { AppSignedRequestProps, CreateAppSignedRequestProps } from '../entities/app-signed-request'
@@ -215,7 +219,11 @@ export type PlainClientAPI = {
     ): Promise<AppActionCallProps>
     getCallDetails(
       params: OptionalDefaults<GetAppActionCallDetailsParams>
-    ): Promise<WebhookCallDetailsProps>
+    ): Promise<AppActionCallResponse>
+    createWithResponse(
+      params: OptionalDefaults<GetAppActionCallParams>,
+      payload: CreateAppActionCallProps
+    ): Promise<AppActionCallResponse>
   }
   appBundle: {
     get(params: OptionalDefaults<GetAppBundleParams>): Promise<AppBundleProps>

lib/plain/plain-client.ts

@@ -68,6 +68,7 @@ export const createPlainClient = (
     appActionCall: {
       create: wrap(wrapParams, 'AppActionCall', 'create'),
       getCallDetails: wrap(wrapParams, 'AppActionCall', 'getCallDetails'),
+      createWithResponse: wrap(wrapParams, 'AppActionCall', 'createWithResponse'),
     },
     appBundle: {
       get: wrap(wrapParams, 'AppBundle', 'get'),

test/unit/adapters/REST/endpoints/app-action-call-test.ts

@@ -0,0 +1,99 @@
+import { expect } from 'chai'
+import { describe, it } from 'mocha'
+import { cloneMock } from '../../../mocks/entities'
+import setupRestAdapter from '../helpers/setupRestAdapter'
+import sinon from 'sinon'
+import {
+  CreateAppActionCallProps,
+  wrapAppActionCallResponse,
+} from '../../../../../lib/entities/app-action-call'
+import { MakeRequest, MakeRequestOptions } from '../../../../../lib/export-types'
+
+function setup(mockName, params = {}) {
+  const entityMock = cloneMock(mockName)
+  const promise = Promise.resolve({ data: entityMock })
+  return {
+    ...setupRestAdapter(promise, params),
+    entityMock,
+  }
+}
+
+describe('Rest App Action Call', () => {
+  it('should create a new App Action Call', async () => {
+    const { httpMock, adapterMock, entityMock } = setup('appActionCallResponse')
+    const entity = wrapAppActionCallResponse(
+      ((...args: [MakeRequestOptions]) => adapterMock.makeRequest(...args)) as MakeRequest,
+      entityMock
+    )
+
+    const payload: CreateAppActionCallProps = {
+      parameters: {
+        recipient: 'Alice <alice@my-company.com>',
+        message_body: 'Hello from Bob!',
+      },
+    }
+
+    const response = await entity.createWithResponse()
+
+    expect(response).to.be.an('object')
+    expect(response).to.deep.equal(entityMock)
+
+    sinon.assert.calledWith(
+      httpMock.post,
+      `/spaces/space-id/environments/environment-id/app_installations/app-definiton-id/actions/app-action-id/calls`,
+      payload
+    )
+
+    sinon.assert.calledWith(
+      httpMock.get,
+      `/spaces/space-id/environments/environment-id/actions/app-action-id/calls/call-id`
+    )
+  })
+
+  it('should get details of an App Action Call', async () => {
+    const { httpMock, adapterMock, entityMock } = setup('appActionCallDetails')
+    const entity = wrapAppActionCallResponse(
+      ((...args: [MakeRequestOptions]) => adapterMock.makeRequest(...args)) as MakeRequest,
+      entityMock
+    )
+
+    const response = await entity.getCallDetails()
+
+    expect(response).to.be.an('object')
+    expect(response).to.deep.equal(entityMock)
+
+    sinon.assert.calledWith(
+      httpMock.get,
+      `/spaces/space-id/environments/environment-id/actions/app-action-id/calls/call-id`
+    )
+  })
+
+  it('should throw an error if maximum retries is reached', async () => {
+    const { httpMock } = setup('appActionCall')
+
+    const callAppActionResultStub = sinon
+      .stub()
+      .rejects(new Error('The app action response is taking longer than expected to process.'))
+
+    const params = {
+      spaceId: 'space-id',
+      environmentId: 'environment-id',
+      appDefinitionId: 'app-definition-id',
+      appActionId: 'app-action-id',
+    }
+
+    try {
+      await callAppActionResultStub(httpMock, params, {
+        resolve: sinon.fake(),
+        reject: sinon.fake(),
+        callId: 'call-id',
+        retries: 2,
+        checkCount: 2,
+      })
+    } catch (error) {
+      expect(error.message).to.equal(
+        'The app action response is taking longer than expected to process.'
+      )
+    }
+  })
+})