@mx-space/api-client 1.0.0 → 1.0.1

package/__tests__/contronllers/serverless.test.ts

@@ -1,19 +0,0 @@
-import { mockRequestInstance } from '~/__tests__/helpers/instance'
-import { mockResponse } from '~/__tests__/helpers/response'
-import { ServerlessController } from '~/controllers'
-
-describe('test Snippet client', () => {
-  const client = mockRequestInstance(ServerlessController)
-
-  test('GET /:reference/:name', async () => {
-    const mocked = mockResponse('/serverless/api/ping', { message: 'pong' })
-
-    const data = await client.serverless.getByReferenceAndName<{}>(
-      'api',
-      'ping',
-    )
-
-    expect(data).toEqual(mocked)
-    expect(data.$raw.data).toEqual(mocked)
-  })
-})

package/__tests__/contronllers/snippet.test.ts

@@ -1,38 +0,0 @@
-import { mockRequestInstance } from '~/__tests__/helpers/instance'
-import { mockResponse } from '~/__tests__/helpers/response'
-import { SnippetController } from '~/controllers'
-
-describe('test Snippet client', () => {
-  const client = mockRequestInstance(SnippetController)
-
-  // test('GET /:id', async () => {
-  //   const mocked = mockResponse('/snippets/61a0cac4b4aefa000fcc1822', {
-  //     id: '61a0cac4b4aefa000fcc1822',
-  //     type: 'json',
-  //     private: true,
-  //     reference: 'theme',
-  //     raw: '{}',
-  //     name: 'config',
-  //     created: '2021-11-26T11:53:40.863Z',
-  //     updated: '2021-11-26T11:53:40.863Z',
-  //   })
-
-  //   const data = await client.snippet.getById('61a0cac4b4aefa000fcc1822')
-
-  //   expect(data).toEqual(mocked)
-  //   expect(data.$raw.data).toEqual(mocked)
-  //   expect(data.raw).toEqual('{}')
-  // })
-
-  test('GET /:reference/:name', async () => {
-    const mocked = mockResponse('/snippets/theme/config', {})
-
-    const data = await client.snippet.getByReferenceAndName<{}>(
-      'theme',
-      'config',
-    )
-
-    expect(data).toEqual(mocked)
-    expect(data.$raw.data).toEqual(mocked)
-  })
-})

package/__tests__/contronllers/topic.test.ts

@@ -1,17 +0,0 @@
-import camelcaseKeys from 'camelcase-keys'
-
-import { mockRequestInstance } from '~/__tests__/helpers/instance'
-import { mockResponse } from '~/__tests__/helpers/response'
-import { TopicController } from '~/controllers/topic'
-
-describe('test topic client', () => {
-  const client = mockRequestInstance(TopicController)
-
-  test('GET /topics/slug/:slug', async () => {
-    const mocked = mockResponse('/topics/slug/111', {
-      name: 'name-topic',
-    })
-    const data = await client.topic.getTopicBySlug('111')
-    expect(data).toEqual(camelcaseKeys(mocked))
-  })
-})

package/__tests__/contronllers/user.test.ts

@@ -1,59 +0,0 @@
-import camelcaseKeys from 'camelcase-keys'
-
-import { mockRequestInstance } from '~/__tests__/helpers/instance'
-import { mockResponse } from '~/__tests__/helpers/response'
-import { UserController } from '~/controllers'
-
-describe('test user client', () => {
-  const client = mockRequestInstance(UserController)
-
-  test('GET /master', async () => {
-    const mocked = mockResponse('/master', {
-      id: '5ea4fe632507ba128f4c938c',
-      introduce: '这是我的小世界呀',
-      mail: 'i@innei.ren',
-      url: 'https://innei.ren',
-      name: 'Innei',
-      social_ids: {
-        bili_id: 26578164,
-        netease_id: 84302804,
-        github: 'Innei',
-      },
-      username: 'Innei',
-      created: '2020-04-26T03:22:11.784Z',
-      modified: '2020-11-13T09:38:49.014Z',
-      last_login_time: '2021-11-17T13:42:48.209Z',
-      avatar: 'https://cdn.innei.ren/avatar.png',
-    })
-    const data = await client.user.getMasterInfo()
-    expect(data.id).toEqual(mocked.id)
-    expect(data).toEqual(camelcaseKeys(mocked, { deep: true }))
-    expect(data.$raw.data).toEqual(mocked)
-  })
-
-  test('POST /login', async () => {
-    const mocked = mockResponse(
-      '/master/login',
-      {
-        id: '5ea4fe632507ba128f4c938c',
-      },
-      'post',
-    )
-    const data = await client.user.login('test', 'test')
-    expect(data.id).toEqual(mocked.id)
-    expect(data.$raw.data).toEqual(mocked)
-  })
-
-  test('GET /check_logged', async () => {
-    const mocked = mockResponse('/check_logged?token=bearer token', {
-      isGuest: true,
-    })
-    const data = await client.user.checkTokenValid('token')
-    expect(data).toEqual(mocked)
-  })
-
-  it('should call `master.xx` work', () => {
-    expect(client.master.getMasterInfo).toBeInstanceOf(Function)
-    expect(client.master).toEqual(client.user)
-  })
-})

package/__tests__/core/client.test.ts

@@ -1,293 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,39 +0,0 @@
-// @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

@@ -1,11 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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
-  })
-}