Adding AS types & grant requests support to open-payments client

packages/open-payments/scripts/generate-types.ts

@@ -1,16 +1,32 @@
 import fs from 'fs'
 import openapiTS from 'openapi-typescript'
 import config from '../src/config'
+
+const generateTypesFromOpenApi = async (
+  specUrl: string,
+  outputFileName: string
+) => {
+  const generatedTypesOutput = await openapiTS(specUrl)
+
+  fs.writeFile(outputFileName, generatedTypesOutput, (error) => {
+    if (error) {
+      console.log(`Error when writing types to ${outputFileName}`, { error })
+    }
+  })
+}
+
 ;(async () => {
-  try {
-    const output = await openapiTS(config.OPEN_PAYMENTS_OPEN_API_URL)
-    const fileName = 'src/generated/types.ts'
+  const rootFolder = `src/generated`
 
-    fs.writeFile(fileName, output, (error) => {
-      if (error) {
-        console.log(`Error when writing types to ${fileName}`, { error })
-      }
-    })
+  try {
+    await generateTypesFromOpenApi(
+      config.OPEN_PAYMENTS_RS_OPEN_API_URL,
+      `${rootFolder}/resource-server-types.ts`
+    )
+    await generateTypesFromOpenApi(
+      config.OPEN_PAYMENTS_AS_OPEN_API_URL,
+      `${rootFolder}/auth-server-types.ts`
+    )
   } catch (error) {
     console.log('Error when generating types', {
       error

packages/open-payments/src/client/grant.test.ts

@@ -0,0 +1,159 @@
+import nock from 'nock'
+import {
+  createGrantRoutes,
+  isInteractiveGrant,
+  isNonInteractiveGrant,
+  requestInteractiveGrant,
+  requestNonInteractiveGrant
+} from './grant'
+import { OpenAPI, HttpMethod, createOpenAPI } from 'openapi'
+import config from '../config'
+import {
+  defaultAxiosInstance,
+  mockInteractiveGrant,
+  mockInteractiveGrantRequest,
+  mockNonInteractiveGrant,
+  mockNonInteractiveGrantRequest,
+  mockOpenApiResponseValidators,
+  silentLogger
+} from '../test/helpers'
+
+describe('grant', (): void => {
+  let openApi: OpenAPI
+
+  beforeAll(async () => {
+    openApi = await createOpenAPI(config.OPEN_PAYMENTS_AS_OPEN_API_URL)
+  })
+
+  const axiosInstance = defaultAxiosInstance
+  const logger = silentLogger
+  const baseUrl = 'http://localhost:1000'
+  const openApiValidators = mockOpenApiResponseValidators()
+
+  describe('createGrantRoutes', (): void => {
+    test('creates response validator for grant requests', async (): Promise<void> => {
+      jest.spyOn(openApi, 'createResponseValidator')
+
+      createGrantRoutes({ axiosInstance, openApi, logger })
+      expect(openApi.createResponseValidator).toHaveBeenCalledTimes(1)
+      expect(openApi.createResponseValidator).toHaveBeenCalledWith({
+        path: '/',
+        method: HttpMethod.POST
+      })
+    })
+  })
+
+  describe('requestInteractiveGrant', (): void => {
+    test('returns interactive grant if passes validation', async (): Promise<void> => {
+      const interactiveGrant = mockInteractiveGrant()
+
+      nock(baseUrl).post('/').reply(200, interactiveGrant)
+
+      const result = await requestInteractiveGrant(
+        {
+          axiosInstance,
+          logger
+        },
+        {
+          url: `${baseUrl}/`,
+          request: mockInteractiveGrantRequest()
+        },
+        openApiValidators.successfulValidator
+      )
+      expect(result).toStrictEqual(interactiveGrant)
+    })
+
+    test('throws if interactive grant does not pass validation', async (): Promise<void> => {
+      const incorrectInteractiveGrant = mockInteractiveGrant({
+        interact: undefined
+      })
+
+      nock(baseUrl).post('/').reply(200, incorrectInteractiveGrant)
+
+      expect(
+        requestInteractiveGrant(
+          {
+            axiosInstance,
+            logger
+          },
+          {
+            url: `${baseUrl}/`,
+            request: mockInteractiveGrantRequest()
+          },
+          openApiValidators.successfulValidator
+        )
+      ).rejects.toThrow('Could not validate interactive grant')
+    })
+  })
+
+  describe('requestNonInteractiveGrant', (): void => {
+    test('returns non-interactive grant if passes validation', async (): Promise<void> => {
+      const nonInteractiveGrant = mockNonInteractiveGrant()
+
+      nock(baseUrl).post('/').reply(200, nonInteractiveGrant)
+
+      const result = await requestNonInteractiveGrant(
+        {
+          axiosInstance,
+          logger
+        },
+        {
+          url: `${baseUrl}/`,
+          request: mockNonInteractiveGrantRequest()
+        },
+        openApiValidators.successfulValidator
+      )
+      expect(result).toStrictEqual(nonInteractiveGrant)
+    })
+
+    test('throws if non-interactive grant does not pass validation', async (): Promise<void> => {
+      const incorrectNonInteractiveGrant = mockNonInteractiveGrant({
+        access_token: undefined
+      })
+
+      nock(baseUrl).post('/').reply(200, incorrectNonInteractiveGrant)
+
+      expect(
+        requestNonInteractiveGrant(
+          {
+            axiosInstance,
+            logger
+          },
+          {
+            url: `${baseUrl}/`,
+            request: mockNonInteractiveGrantRequest()
+          },
+          openApiValidators.successfulValidator
+        )
+      ).rejects.toThrow('Could not validate non-interactive grant')
+    })
+  })
+
+  describe('isInteractiveGrant', (): void => {
+    test('returns true if has interact property', async (): Promise<void> => {
+      expect(isInteractiveGrant(mockInteractiveGrant())).toBe(true)
+    })
+
+    test('returns false if has access_token property', async (): Promise<void> => {
+      const grant = mockInteractiveGrant()
+
+      grant['access_token'] = { value: 'token' }
+
+      expect(isInteractiveGrant(grant)).toBe(false)
+    })
+  })
+
+  describe('isNonInteractiveGrant', (): void => {
+    test('returns true if has access_token property', async (): Promise<void> => {
+      expect(isNonInteractiveGrant(mockNonInteractiveGrant())).toBe(true)
+    })
+
+    test('returns false if has interact property', async (): Promise<void> => {
+      const grant = mockNonInteractiveGrant()
+
+      grant['interact'] = { redirect: 'http://example.com/redirect' }
+
+      expect(isNonInteractiveGrant(grant)).toBe(false)
+    })
+  })
+})

packages/open-payments/src/client/grant.ts

@@ -0,0 +1,117 @@
+import { HttpMethod, ResponseValidator } from 'openapi'
+import { RouteDeps } from '.'
+import {
+  getASPath,
+  InteractiveGrant,
+  InteractiveGrantRequest,
+  NonInteractiveGrant,
+  NonInteractiveGrantRequest
+} from '../types'
+import { post } from './requests'
+
+interface RequestGrantArgs<T> {
+  url: string
+  request: T
+}
+
+export interface GrantRoutes {
+  requestInteractiveGrant(
+    args: RequestGrantArgs<InteractiveGrantRequest>
+  ): Promise<InteractiveGrant>
+  requestNonInteractiveGrant(
+    args: RequestGrantArgs<NonInteractiveGrantRequest>
+  ): Promise<NonInteractiveGrant>
+}
+
+export const createGrantRoutes = (deps: RouteDeps): GrantRoutes => {
+  const { axiosInstance, openApi, logger } = deps
+
+  const requestGrantValidator = openApi.createResponseValidator<
+    InteractiveGrant | NonInteractiveGrant
+  >({
+    path: getASPath('/'),
+    method: HttpMethod.POST
+  })
+  return {
+    requestInteractiveGrant: (
+      args: RequestGrantArgs<InteractiveGrantRequest>
+    ) =>
+      requestInteractiveGrant(
+        { axiosInstance, logger },
+        args,
+        requestGrantValidator
+      ),
+    requestNonInteractiveGrant: (
+      args: RequestGrantArgs<NonInteractiveGrantRequest>
+    ) =>
+      requestNonInteractiveGrant(
+        { axiosInstance, logger },
+        args,
+        requestGrantValidator
+      )
+  }
+}
+
+export const requestInteractiveGrant = async (
+  deps: Pick<RouteDeps, 'axiosInstance' | 'logger'>,
+  args: RequestGrantArgs<InteractiveGrantRequest>,
+  validateOpenApiResponse: ResponseValidator<
+    InteractiveGrant | NonInteractiveGrant
+  >
+) => {
+  const { axiosInstance, logger } = deps
+  const { url } = args
+
+  const grant = await post(
+    { axiosInstance, logger },
+    { url: args.url, body: args.request },
+    validateOpenApiResponse
+  )
+
+  if (!isInteractiveGrant(grant)) {
+    const errorMessage = 'Could not validate interactive grant'
+    logger.error({ url, grant }, errorMessage)
+    throw new Error(errorMessage)
+  }
+
+  return grant
+}
+
+export const requestNonInteractiveGrant = async (
+  deps: Pick<RouteDeps, 'axiosInstance' | 'logger'>,
+  args: RequestGrantArgs<NonInteractiveGrantRequest>,
+  validateOpenApiResponse: ResponseValidator<
+    InteractiveGrant | NonInteractiveGrant
+  >
+) => {
+  const { axiosInstance, logger } = deps
+  const { url } = args
+
+  const grant = await post(
+    { axiosInstance, logger },
+    { url: args.url, body: args.request },
+    validateOpenApiResponse
+  )
+
+  if (!isNonInteractiveGrant(grant)) {
+    const errorMessage = 'Could not validate non-interactive grant'
+    logger.error({ url, grant }, errorMessage)
+    throw new Error(errorMessage)
+  }
+
+  return grant
+}
+
+export const isInteractiveGrant = (
+  grant: InteractiveGrant | NonInteractiveGrant
+): grant is InteractiveGrant =>
+  !('access_token' in grant) &&
+  'interact' in grant &&
+  !!(grant as InteractiveGrant).interact
+
+export const isNonInteractiveGrant = (
+  grant: InteractiveGrant | NonInteractiveGrant
+): grant is NonInteractiveGrant =>
+  !('interact' in grant) &&
+  'access_token' in grant &&
+  !!(grant as NonInteractiveGrant).access_token

packages/open-payments/src/client/ilp-stream-connection.test.ts

@@ -7,7 +7,7 @@ describe('ilp-stream-connection', (): void => {
   let openApi: OpenAPI
 
   beforeAll(async () => {
-    openApi = await createOpenAPI(config.OPEN_PAYMENTS_OPEN_API_URL)
+    openApi = await createOpenAPI(config.OPEN_PAYMENTS_RS_OPEN_API_URL)
   })
 
   const axiosInstance = defaultAxiosInstance

packages/open-payments/src/client/ilp-stream-connection.ts

@@ -1,6 +1,6 @@
 import { HttpMethod } from 'openapi'
-import { ClientDeps } from '.'
-import { getPath, ILPStreamConnection } from '../types'
+import { RouteDeps } from '.'
+import { getRSPath, ILPStreamConnection } from '../types'
 import { get } from './requests'
 
 interface GetArgs {
@@ -12,13 +12,13 @@ export interface ILPStreamConnectionRoutes {
 }
 
 export const createILPStreamConnectionRoutes = (
-  clientDeps: ClientDeps
+  deps: RouteDeps
 ): ILPStreamConnectionRoutes => {
-  const { axiosInstance, openApi, logger } = clientDeps
+  const { axiosInstance, openApi, logger } = deps
 
   const getILPStreamConnectionValidator =
     openApi.createResponseValidator<ILPStreamConnection>({
-      path: getPath('/connections/{id}'),
+      path: getRSPath('/connections/{id}'),
       method: HttpMethod.GET
     })
 

packages/open-payments/src/client/incoming-payment.test.ts

@@ -18,7 +18,7 @@ describe('incoming-payment', (): void => {
   let openApi: OpenAPI
 
   beforeAll(async () => {
-    openApi = await createOpenAPI(config.OPEN_PAYMENTS_OPEN_API_URL)
+    openApi = await createOpenAPI(config.OPEN_PAYMENTS_RS_OPEN_API_URL)
   })
 
   const axiosInstance = defaultAxiosInstance