@mx-space/api-client 1.0.0-beta.2 → 1.0.0

package/__tests__/core/client.test.ts

@@ -0,0 +1,293 @@
+import { AxiosError, AxiosResponse } from 'axios'
+import { vi } from 'vitest'
+
+import { axiosAdaptor } from '~/adaptors/axios'
+import { umiAdaptor } from '~/adaptors/umi-request'
+import {
+  NoteController,
+  PostController,
+  allContollerNames,
+  allControllers,
+} from '~/controllers'
+import { RequestError, createClient } from '~/core'
+import { IRequestAdapter } from '~/interfaces/adapter'
+import { ClientOptions } from '~/interfaces/client'
+
+const { spyOn } = vi
+
+// axios wrapper test
+const generateClient = <
+  Response = AxiosResponse<unknown>,
+  AdaptorType extends IRequestAdapter = typeof axiosAdaptor,
+>(
+  adapter?: AdaptorType,
+  options?: ClientOptions,
+) =>
+  createClient(adapter ?? axiosAdaptor)<Response>(
+    'http://127.0.0.1:2323',
+    options,
+  )
+describe('test client', () => {
+  it('should create new client with axios', () => {
+    const client = generateClient()
+    expect(client).toBeDefined()
+  })
+
+  describe('client `get` method', () => {
+    test('case 1', async () => {
+      spyOn(axiosAdaptor, 'get').mockImplementation((url) => {
+        if (url === 'http://127.0.0.1:2323/a/a?foo=bar') {
+          return Promise.resolve({ data: { ok: 1 } })
+        }
+
+        return Promise.resolve({ data: null })
+      })
+
+      const client = generateClient()
+      const data = await client.proxy.a.a.get({ params: { foo: 'bar' } })
+
+      expect(data).toStrictEqual({ ok: 1 })
+    })
+
+    test('case 2', async () => {
+      spyOn(axiosAdaptor, 'get').mockImplementation((url) => {
+        if (url === 'http://127.0.0.1:2323/a/a') {
+          return Promise.resolve({ data: { ok: 1 } })
+        }
+
+        return Promise.resolve({ data: null })
+      })
+
+      const client = generateClient()
+      const data = await client.proxy.a.a.get()
+
+      expect(data).toStrictEqual({ ok: 1 })
+
+      {
+        spyOn(axiosAdaptor, 'get').mockImplementation((url) => {
+          if (url === 'http://127.0.0.1:2323/a/b') {
+            return Promise.resolve({ data: { ok: 1 } })
+          }
+
+          return Promise.resolve({ data: null })
+        })
+
+        const client = generateClient()
+        const data = await client.proxy.a.b.get()
+
+        expect(data).toStrictEqual({ ok: 1 })
+      }
+    })
+  })
+
+  it('should throw error if not inject other client', () => {
+    const client = generateClient()
+    allContollerNames.forEach((name) => {
+      expect(() => (client as any)[name].name).toThrow(
+        `${
+          name.charAt(0).toUpperCase() + name.slice(1)
+        } Client not inject yet, please inject with client.injectClients(...)`,
+      )
+    })
+  })
+
+  it('should work if inject client', () => {
+    const client = generateClient()
+
+    client.injectControllers(allControllers)
+    allContollerNames.forEach((name) => {
+      expect(() => (client as any)[name].name).toBeDefined()
+    })
+  })
+
+  it('should inject single client worked', () => {
+    const client = generateClient()
+
+    client.injectControllers(PostController)
+    expect(client.post.name).toBeDefined()
+  })
+
+  it('should inject multi client worked', () => {
+    const client = generateClient()
+
+    client.injectControllers(PostController, NoteController)
+    expect(client.post.name).toBeDefined()
+    expect(client.note.name).toBeDefined()
+  })
+
+  it('should inject controller when init', () => {
+    const client = createClient(axiosAdaptor)('http://127.0.0.1:2323', {
+      controllers: [PostController, NoteController],
+    })
+    expect(client.post.name).toBeDefined()
+    expect(client.note.name).toBeDefined()
+  })
+
+  it('should infer response wrapper type', async () => {
+    const client = generateClient<AxiosResponse>(axiosAdaptor)
+    client.injectControllers(PostController)
+    spyOn(axiosAdaptor, 'get').mockImplementation((url) => {
+      if (url === 'http://127.0.0.1:2323/posts/latest') {
+        return Promise.resolve({ data: { ok: 1 }, status: 200 })
+      }
+
+      return Promise.resolve({ data: null })
+    })
+
+    const data = await client.post.getLatest()
+
+    expect(data.$raw.status).toBe(200)
+  })
+
+  it('should infer axios instance type', async () => {
+    const client = generateClient<AxiosResponse>(axiosAdaptor)
+    spyOn(axiosAdaptor, 'get').mockImplementation((url) => {
+      if (url === 'http://127.0.0.1:2323/a') {
+        return Promise.resolve({ data: { ok: 1 }, status: 200 })
+      }
+
+      return Promise.resolve({ data: null })
+    })
+    expect(client.instance.default).toBe(axiosAdaptor.default)
+    const res = await client.proxy.a.get()
+    expect(res.$raw.status).toBe(200)
+
+    {
+      spyOn(umiAdaptor, 'get').mockImplementation((url) => {
+        if (url === 'http://127.0.0.1:2323/a') {
+          return Promise.resolve({
+            data: { ok: 1 },
+            response: { status: 200, body: {} },
+          })
+        }
+
+        return Promise.resolve({ data: null })
+      })
+      const client2 = createClient(umiAdaptor)('http://127.0.0.1:2323')
+      expect(client2.instance.default).toBe(umiAdaptor.default)
+      const res = await client2.proxy.a.get()
+      expect(res.$raw.response.status).toBe(200)
+      expect(res.$raw.response.body).toStrictEqual({})
+    }
+  })
+
+  it('should resolve joint path call toString()', () => {
+    const client = generateClient()
+    {
+      const path = client.proxy.foo.bar.toString()
+      expect(path).toBe('/foo/bar')
+    }
+
+    {
+      const path = client.proxy.foo.bar.toString(true)
+      expect(path).toBe('http://127.0.0.1:2323/foo/bar')
+    }
+  })
+
+  it('should do not json convert case if payload is string or other primitive type', async () => {
+    const client = generateClient<AxiosResponse>(axiosAdaptor)
+    spyOn(axiosAdaptor, 'get').mockImplementation((url) => {
+      if (url === 'http://127.0.0.1:2323/a') {
+        return Promise.resolve({ data: 'foo', status: 200 })
+      }
+
+      return Promise.resolve({ data: null })
+    })
+
+    const data = await client.proxy.a.get()
+    expect(data).toBe('foo')
+  })
+
+  it('should throw exception with custom message and code', async () => {
+    const client = generateClient<AxiosResponse>(axiosAdaptor, {
+      // @ts-ignore
+      getCodeMessageFromException: (e: AxiosError) => {
+        return {
+          code: e.response?.status,
+          message: e.message,
+        }
+      },
+    })
+    spyOn(axiosAdaptor, 'get').mockImplementation(() => {
+      return Promise.reject(
+        new AxiosError(
+          'not found',
+          'NOT_FOUND',
+          {},
+          {},
+          {
+            status: 404,
+            config: {},
+            data: {},
+            headers: {},
+            statusText: 'not found',
+          },
+        ),
+      )
+    })
+
+    try {
+      await client.proxy.a.get()
+    } catch (er: any) {
+      expect(er).toBeInstanceOf(RequestError)
+      expect(er.status).toBe(404)
+    }
+  })
+
+  it('should throw custom exception', async () => {
+    class MyRequestError extends Error {
+      constructor(
+        message: string,
+        public status: number,
+        public path: string,
+        public raw: any,
+      ) {
+        super(message)
+      }
+
+      toResponse() {
+        return {
+          status: this.status,
+        }
+      }
+    }
+
+    const client = generateClient<AxiosResponse>(axiosAdaptor, {
+      // @ts-ignore
+      customThrowResponseError(err) {
+        return new MyRequestError(
+          err.message,
+          err.response?.status,
+          err.path,
+          err.raw,
+        )
+      },
+    })
+
+    spyOn(axiosAdaptor, 'get').mockImplementation(() => {
+      return Promise.reject(
+        new AxiosError(
+          'not found',
+          'NOT_FOUND',
+          {},
+          {},
+          {
+            status: 404,
+            config: {},
+            data: {},
+            headers: {},
+            statusText: 'not found',
+          },
+        ),
+      )
+    })
+
+    try {
+      await client.proxy.a.get()
+    } catch (er: any) {
+      expect(er).toBeInstanceOf(MyRequestError)
+      expect(er.toResponse).toBeDefined()
+      expect(er.status).toBe(404)
+    }
+  })
+})

package/__tests__/helpers/adaptor-test.ts

@@ -0,0 +1,108 @@
+import { allControllers } from '~/controllers'
+import { HTTPClient, RequestError, createClient } from '~/core'
+import { IRequestAdapter } from '~/interfaces/adapter'
+
+import { createMockServer } from './e2e-mock-server'
+
+export const testAdaptor = (adaptor: IRequestAdapter) => {
+  let client: HTTPClient
+  const { app, close, port } = createMockServer()
+
+  afterAll(() => {
+    close()
+  })
+
+  beforeAll(() => {
+    client = createClient(adaptor)(`http://localhost:${port}`)
+    client.injectControllers(allControllers)
+  })
+  test('get', async () => {
+    app.get('/posts/1', (req, res) => {
+      res.send({
+        id: '1',
+        category_id: '11',
+      })
+    })
+    const res = await client.post.getPost('1')
+
+    expect(res).toStrictEqual({
+      id: '1',
+      categoryId: '11',
+    })
+
+    expect(res.$raw.data.category_id).toEqual('11')
+  })
+
+  test('post', async () => {
+    app.post('/comments/1', (req, res) => {
+      const { body } = req
+
+      res.send({
+        ...body,
+      })
+    })
+    const dto = {
+      text: 'hello',
+      author: 'test',
+      mail: '1@ee.com',
+    }
+    const res = await client.comment.comment('1', dto)
+
+    expect(res).toStrictEqual(dto)
+  })
+
+  test('get with search query', async () => {
+    app.get('/search/post', (req, res) => {
+      if (req.query.keyword) {
+        return res.send({ result: 1 })
+      }
+      res.send(null)
+    })
+
+    const res = await client.search.search('post', 'keyword')
+    expect(res).toStrictEqual({ result: 1 })
+  })
+
+  test('rawResponse rawRequest should defined', async () => {
+    app.get('/search/post', (req, res) => {
+      if (req.query.keyword) {
+        return res.send({ result: 1 })
+      }
+      res.send(null)
+    })
+
+    const res = await client.search.search('post', 'keyword')
+    expect(res.$raw).toBeDefined()
+    expect(res.$raw.data).toBeDefined()
+  })
+
+  it('should error catch', async () => {
+    app.get('/error', (req, res) => {
+      res.status(500).send({
+        message: 'error message',
+      })
+    })
+    await expect(client.proxy.error.get()).rejects.toThrowError(RequestError)
+  })
+
+  it('should use number as path', async () => {
+    app.get('/1/1', (req, res) => {
+      res.send({ data: 1, foo_bar: 'foo' })
+    })
+
+    const res = await client.proxy(1)(1).get<{ data: number; fooBar: string }>()
+
+    expect(res).toStrictEqual({ data: 1, fooBar: 'foo' })
+    expect(res.$raw.data).toStrictEqual({ data: 1, foo_bar: 'foo' })
+    expect(res.$request).toBeDefined()
+  })
+
+  it('should get string payload', async () => {
+    app.get('/string', (req, res) => {
+      res.send('x')
+    })
+
+    const res = await client.proxy('string').get<string>()
+    expect(res).toStrictEqual('x')
+  })
+}

package/__tests__/helpers/e2e-mock-server.ts

@@ -0,0 +1,22 @@
+import cors from 'cors'
+import express from 'express'
+import { AddressInfo } from 'net'
+
+type Express = ReturnType<typeof express>
+export const createMockServer = (options: { port?: number } = {}) => {
+  const { port = 0 } = options
+
+  const app: Express = express()
+  app.use(express.json())
+  app.use(cors())
+  const server = app.listen(port)
+
+  return {
+    app,
+    port: (server.address() as AddressInfo).port,
+    server,
+    close() {
+      server.close()
+    },
+  }
+}

package/__tests__/helpers/global-fetch.ts

@@ -0,0 +1,39 @@
+// @ts-nocheck
+
+/* eslint-disable */
+import AbortController from 'abort-controller'
+import fetch, { Headers, Request, Response } from 'node-fetch'
+
+const TEN_MEGABYTES = 1000 * 1000 * 10
+
+if (!globalThis.fetch) {
+  globalThis.fetch = (url, options) =>
+    fetch(url, { highWaterMark: TEN_MEGABYTES, ...options })
+}
+
+if (!globalThis.Headers) {
+  globalThis.Headers = Headers
+}
+
+if (!globalThis.Request) {
+  globalThis.Request = Request
+}
+
+if (!globalThis.Response) {
+  globalThis.Response = Response
+}
+
+if (!globalThis.AbortController) {
+  globalThis.AbortController = AbortController
+}
+
+if (!globalThis.ReadableStream) {
+  try {
+    // eslint-disable-next-line node/file-extension-in-import, node/no-unsupported-features/es-syntax
+    globalThis.ReadableStream = await import(
+      'web-streams-polyfill/ponyfill/es2018'
+    )
+  } catch {}
+}
+
+export {}

package/__tests__/helpers/instance.ts

@@ -0,0 +1,11 @@
+import { axiosAdaptor } from '~/adaptors/axios'
+import { HTTPClient, createClient } from '~/core'
+import { IController } from '~/interfaces/controller'
+
+export const mockRequestInstance = (
+  injectController: new (client: HTTPClient) => IController,
+) => {
+  const client = createClient(axiosAdaptor)('https://api.innei.ren/v2')
+  client.injectControllers(injectController)
+  return client
+}

package/__tests__/helpers/response.ts

@@ -0,0 +1,76 @@
+import { isEqual } from 'lodash'
+import { URLSearchParams } from 'url'
+import { vi } from 'vitest'
+
+import { axiosAdaptor } from '~/adaptors/axios'
+
+const { spyOn } = vi
+
+export const buildResponseDataWrapper = (data: any) => ({ data })
+
+export const mockResponse = <T>(
+  path: string,
+  data: T,
+  method = 'get',
+  requestBody?: any,
+) => {
+  const exceptUrlObject = new URL(
+    path.startsWith('http')
+      ? path
+      : `https://example.com/${path.replace(/^\//, '')}`,
+  )
+  // @ts-ignore
+  spyOn(axiosAdaptor, method).mockImplementation(
+    // @ts-ignore
+    async (requestUrl: string, options: any) => {
+      const requestUrlObject = new URL(requestUrl)
+
+      if (requestBody) {
+        const { data } = options || {}
+        if (!isEqual(requestBody, data)) {
+          throw new Error(
+            `body not equal, got: ${JSON.stringify(
+              data,
+            )} except: ${JSON.stringify(requestBody)}`,
+          )
+        }
+      }
+
+      if (
+        requestUrlObject.pathname.endsWith(exceptUrlObject.pathname) &&
+        (exceptUrlObject.search
+          ? isSearchEqual(
+              exceptUrlObject.searchParams,
+              requestUrlObject.searchParams,
+            )
+          : true)
+      ) {
+        return buildResponseDataWrapper(data)
+      } else {
+        return buildResponseDataWrapper({
+          error: 1,
+          requestPath: requestUrlObject.pathname + requestUrlObject.search,
+          expectPath: path,
+        })
+      }
+    },
+  )
+
+  return data
+}
+
+const isSearchEqual = (a: URLSearchParams, b: URLSearchParams) => {
+  const keys = Array.from(a.keys()).sort()
+  if (keys.toString() !== Array.from(b.keys()).sort().toString()) {
+    return false
+  }
+  return keys.every((key) => {
+    const res = a.get(key) === b.get(key)
+    if (!res) {
+      console.log(
+        `key ${key} not equal, receive ${a.get(key)} want ${b.get(key)}`,
+      )
+    }
+    return res
+  })
+}