@mx-space/api-client 1.0.0 → 1.0.2

package/__tests__/utils/auto-bind.spec.ts

@@ -1,27 +0,0 @@
-import { autoBind } from '~/utils/auto-bind'
-
-describe('test auto bind', () => {
-  it('should bind in class', () => {
-    class A {
-      constructor() {
-        autoBind(this)
-      }
-      name = 'A'
-      foo() {
-        return this?.name
-      }
-    }
-
-    expect(new A().foo()).toBe('A')
-
-    function tester(caller: any) {
-      return caller()
-    }
-    expect(tester(new A().foo)).toBe('A')
-
-    function tester2<T extends (...args: any) => any>(caller: T) {
-      return caller.call({})
-    }
-    expect(tester2(new A().foo)).toBe('A')
-  })
-})

package/__tests__/utils/camelcase-keys.spec.ts

@@ -1,86 +0,0 @@
-import camelcaseKeysLib from 'camelcase-keys'
-
-import { camelcaseKeys } from '~/utils/camelcase-keys'
-
-describe('test camelcase keys', () => {
-  it('case 1 normal', () => {
-    const obj = {
-      tool: 'too',
-      tool_name: 'too_name',
-
-      a_b: 1,
-      a: 1,
-      b: {
-        c_d: 1,
-      },
-    }
-
-    expect(camelcaseKeys(obj)).toStrictEqual(
-      camelcaseKeysLib(obj, {
-        deep: true,
-      }),
-    )
-  })
-
-  it('case 2: key has number', () => {
-    const obj = {
-      b147da0eaecbea00aeb62055: {
-        data: {},
-      },
-      a_c11ab_Ac: [
-        {
-          a_b: 1,
-        },
-        1,
-      ],
-    }
-
-    expect(camelcaseKeys(obj)).toStrictEqual({
-      b147da0eaecbea00aeb62055: {
-        data: {},
-      },
-      aC11abAc: [
-        {
-          aB: 1,
-        },
-        1,
-      ],
-    })
-  })
-
-  it('case 3: not a object', () => {
-    const value = 1
-    expect(camelcaseKeys(value)).toBe(value)
-  })
-
-  it('case 4: nullable value', () => {
-    let value = null
-    expect(camelcaseKeys(value)).toBe(value)
-
-    value = undefined
-    expect(camelcaseKeys(value)).toBe(value)
-
-    value = NaN
-    expect(camelcaseKeys(value)).toBe(value)
-  })
-
-  it('case 5: array', () => {
-    const arr = [
-      {
-        a_b: 1,
-      },
-      null,
-      undefined,
-      +0,
-      -0,
-      Infinity,
-      {
-        a_b: 1,
-      },
-    ]
-
-    expect(camelcaseKeys(arr)).toStrictEqual(
-      camelcaseKeysLib(arr, { deep: true }),
-    )
-  })
-})

package/__tests__/utils/index.test.ts

@@ -1,33 +0,0 @@
-import { destructureData } from '~/utils'
-
-describe('test utils', () => {
-  test('destructureData', () => {
-    const d = destructureData({ data: { a: 1, b: 2 } })
-    expect(d).toEqual({ a: 1, b: 2 })
-
-    const d2 = destructureData({ data: { a: 1, b: 2 }, c: 3 })
-    expect(d2).toEqual({ data: { a: 1, b: 2 }, c: 3 })
-
-    const d3 = destructureData({ data: [{ a: 1 }] })
-    expect(d3).toEqual({ data: [{ a: 1 }] })
-
-    const d4 = destructureData({ a: 1 })
-    expect(d4).toEqual({ a: 1 })
-
-    const d5 = destructureData([])
-    expect(d5).toEqual([])
-
-    const d6 = destructureData({ data: [] })
-    expect(d6).toEqual({ data: [] })
-
-    const d7 = destructureData(
-      (() => {
-        const d = { data: { a: 1 } }
-        Object.defineProperty(d, '$raw', { value: { a: 1 }, enumerable: false })
-        return d
-      })(),
-    )
-    expect(d7).toEqual({ a: 1 })
-    expect(d7.$raw).toBeTruthy()
-  })
-})

package/__tests__/utils/path.spec.ts

@@ -1,8 +0,0 @@
-import { resolveFullPath } from '~/utils/path'
-
-describe('TEST path.utils', () => {
-  it('should resolve full path', () => {
-    const path = resolveFullPath('http://localhost:3000', '/api/v1/users')
-    expect(path).toBe('http://localhost:3000/api/v1/users')
-  })
-})

package/adaptors/axios.ts

@@ -1,44 +0,0 @@
-import axios, { AxiosInstance, AxiosResponse } from 'axios'
-
-import { IRequestAdapter } from '~/interfaces/adapter'
-
-// eslint-disable-next-line spaced-comment
-const $http = /*#__PURE__*/ axios.create({})
-
-// ignore axios `method` declare not assignable to `Method`
-export const axiosAdaptor: IRequestAdapter<
-  AxiosInstance,
-  AxiosResponse<unknown>
-> = Object.preventExtensions({
-  get default() {
-    return $http
-  },
-  responseWrapper: {} as any as AxiosResponse<unknown>,
-  get(url, options) {
-    // @ts-ignore
-    return $http.get(url, options)
-  },
-  post(url, options) {
-    const { data, ...config } = options || {}
-    // @ts-ignore
-    return $http.post(url, data, config)
-  },
-  put(url, options) {
-    const { data, ...config } = options || {}
-    // @ts-ignore
-    return $http.put(url, data, config)
-  },
-  delete(url, options) {
-    const { ...config } = options || {}
-    // @ts-ignore
-    return $http.delete(url, config)
-  },
-  patch(url, options) {
-    const { data, ...config } = options || {}
-    // @ts-ignore
-    return $http.patch(url, data, config)
-  },
-})
-
-// eslint-disable-next-line import/no-default-export
-export default axiosAdaptor

package/adaptors/ky.ts

@@ -1,76 +0,0 @@
-import ky, { Options, ResponsePromise } from 'ky'
-import { KyInstance } from 'ky/distribution/types/ky'
-
-import { IRequestAdapter } from '~/interfaces/adapter'
-
-// eslint-disable-next-line spaced-comment
-const $http: KyInstance = /*#__PURE__*/ ky.create({})
-// TODO post data not only json,
-const getDataFromKyResponse = async (response: ResponsePromise) => {
-  const res = await response
-
-  const isJsonType = res.headers
-    .get('content-type')
-    ?.includes('application/json')
-  const json = isJsonType ? await res.clone().json() : null
-
-  const result: Awaited<ResponsePromise> & {
-    data: any
-  } = {
-    ...res,
-    data: json ?? (await res.clone().text()),
-  }
-  return result
-}
-
-export const createKyAdaptor = (ky: KyInstance) => {
-  const adaptor: IRequestAdapter<KyInstance, ResponsePromise> =
-    Object.preventExtensions({
-      get default() {
-        return ky
-      },
-
-      responseWrapper: {} as any as ResponsePromise,
-      get(url, options) {
-        return getDataFromKyResponse(ky.get(url, options))
-      },
-      post(url, options) {
-        const data = options.data
-        delete options.data
-        const kyOptions: Options = {
-          ...options,
-          json: data,
-        }
-
-        return getDataFromKyResponse(ky.post(url, kyOptions))
-      },
-      put(url, options) {
-        const data = options.data
-        delete options.data
-        const kyOptions: Options = {
-          ...options,
-          json: data,
-        }
-        return getDataFromKyResponse(ky.put(url, kyOptions))
-      },
-
-      patch(url, options) {
-        const data = options.data
-        delete options.data
-        const kyOptions: Options = {
-          ...options,
-          json: data,
-        }
-        return getDataFromKyResponse(ky.patch(url, kyOptions))
-      },
-      delete(url, options) {
-        return getDataFromKyResponse(ky.delete(url, options))
-      },
-    })
-  return adaptor
-}
-
-export const defaultKyAdaptor = createKyAdaptor($http)
-
-// eslint-disable-next-line import/no-default-export
-export default defaultKyAdaptor

package/adaptors/umi-request.ts

@@ -1,38 +0,0 @@
-import { RequestMethod, RequestResponse, extend } from 'umi-request'
-
-import { IRequestAdapter } from '~/interfaces/adapter'
-
-// eslint-disable-next-line spaced-comment
-const $http = /*#__PURE__*/ extend({
-  getResponse: true,
-  requestType: 'json',
-  responseType: 'json',
-})
-
-export const umiAdaptor: IRequestAdapter<
-  RequestMethod<true>,
-  RequestResponse
-> = Object.preventExtensions({
-  get default() {
-    return $http
-  },
-  responseWrapper: {} as any as RequestResponse,
-  get(url, options) {
-    return $http.get(url, options)
-  },
-  post(url, options) {
-    return $http.post(url, options)
-  },
-  put(url, options) {
-    return $http.put(url, options)
-  },
-  delete(url, options) {
-    return $http.delete(url, options)
-  },
-  patch(url, options) {
-    return $http.patch(url, options)
-  },
-})
-
-// eslint-disable-next-line import/no-default-export
-export default umiAdaptor

package/core/attach-request.ts

@@ -1,43 +0,0 @@
-import { HTTPClient } from '.'
-
-export function attachRequestMethod<T extends HTTPClient<any, any>>(target: T) {
-  Object.defineProperty(target, '$$get', {
-    value(url: string, options?: any) {
-      // HINT: method get only accept search params;
-      const { params = {}, ...rest } = options
-      const qs = handleSearchParams(params)
-
-      return target.instance.get(`${url}${qs ? `${`?${qs}`}` : ''}`, rest)
-    },
-  })
-  ;(['put', 'post', 'patch', 'delete'] as const).forEach((method) => {
-    Object.defineProperty(target, `$$${method}`, {
-      value(path: string, options?: any) {
-        return target.instance[method](path, options)
-      },
-    })
-  })
-}
-// FIXME: only support string value
-function handleSearchParams(obj: URLSearchParams | Record<string, string>) {
-  if (!obj && typeof obj !== 'object') {
-    throw new TypeError('params must be object.')
-  }
-
-  if (obj instanceof URLSearchParams) {
-    return obj.toString()
-  }
-  const search = new URLSearchParams()
-
-  Object.entries<any>(obj).forEach(([k, v]) => {
-    if (
-      typeof v === 'undefined' ||
-      Object.prototype.toString.call(v) === '[object Null]'
-    ) {
-      return
-    }
-    search.set(k, v)
-  })
-
-  return search.toString()
-}

package/core/client.ts

@@ -1,252 +0,0 @@
-import {
-  IAdaptorRequestResponseType,
-  IRequestAdapter,
-} from '~/interfaces/adapter'
-import { ClientOptions } from '~/interfaces/client'
-import { IController } from '~/interfaces/controller'
-import { RequestOptions } from '~/interfaces/instance'
-import { IRequestHandler, Method } from '~/interfaces/request'
-import { Class } from '~/interfaces/types'
-import { isPlainObject } from '~/utils'
-import { camelcaseKeys } from '~/utils/camelcase-keys'
-import { resolveFullPath } from '~/utils/path'
-
-import { allContollerNames } from '../controllers'
-import { attachRequestMethod } from './attach-request'
-import { RequestError } from './error'
-
-const methodPrefix = '_$'
-export type { HTTPClient }
-class HTTPClient<
-  T extends IRequestAdapter = IRequestAdapter,
-  ResponseWrapper = unknown,
-> {
-  private readonly _proxy: IRequestHandler<ResponseWrapper>
-
-  constructor(
-    private readonly _endpoint: string,
-    private _adaptor: T,
-    private options: Omit<ClientOptions, 'controllers'> = {},
-  ) {
-    this._endpoint = _endpoint
-      .replace(/\/*$/, '')
-      .replace('localhost', '127.0.0.1')
-    this._proxy = this.buildRoute(this)()
-    options.transformResponse =
-      options.transformResponse || ((data) => camelcaseKeys(data))
-
-    this.initGetClient()
-
-    attachRequestMethod(this)
-  }
-
-  private initGetClient() {
-    for (const name of allContollerNames) {
-      Object.defineProperty(this, name, {
-        get() {
-          const client = Reflect.get(this, `${methodPrefix}${name}`)
-          if (!client) {
-            throw new ReferenceError(
-              `${
-                name.charAt(0).toUpperCase() + name.slice(1)
-              } Client not inject yet, please inject with client.injectClients(...)`,
-            )
-          }
-          return client
-        },
-        configurable: false,
-        enumerable: false,
-      })
-    }
-  }
-
-  public injectControllers(...Controller: Class<IController>[]): void
-  public injectControllers(Controller: Class<IController>[]): void
-  public injectControllers(Controller: any, ...rest: any[]) {
-    Controller = Array.isArray(Controller) ? Controller : [Controller, ...rest]
-    for (const Client of Controller) {
-      const cl = new Client(this)
-
-      if (Array.isArray(cl.name)) {
-        for (const name of cl.name) {
-          attach.call(this, name, cl)
-        }
-      } else {
-        attach.call(this, cl.name, cl)
-      }
-    }
-
-    function attach(this: any, name: string, cl: IController) {
-      Object.defineProperty(this, `${methodPrefix}${name.toLowerCase()}`, {
-        get() {
-          return cl
-        },
-        enumerable: false,
-        configurable: false,
-      })
-    }
-  }
-
-  get endpoint() {
-    return this._endpoint
-  }
-
-  get instance() {
-    return this._adaptor
-  }
-
-  public request(options: {
-    url: string
-    method?: string
-    data?: any
-    params?: any
-  }) {
-    return (this as any)[`$$${String(options.method || 'get').toLowerCase()}`](
-      options.url,
-      options,
-    ) as Promise<IAdaptorRequestResponseType<any>>
-  }
-
-  public get proxy() {
-    return this._proxy
-  }
-
-  private buildRoute(manager: this): () => IRequestHandler<ResponseWrapper> {
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    const noop = () => {}
-    const methods = ['get', 'post', 'delete', 'patch', 'put']
-    const reflectors = [
-      'toString',
-      'valueOf',
-      'inspect',
-      'constructor',
-      Symbol.toPrimitive,
-    ]
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const that = this
-
-    return () => {
-      const route = ['']
-
-      const handler: any = {
-        get(target: any, name: Method) {
-          if (reflectors.includes(name))
-            return (withBase?: boolean) => {
-              if (withBase) {
-                const path = resolveFullPath(that.endpoint, route.join('/'))
-                route.length = 0
-                return path
-              } else {
-                const path = route.join('/')
-                route.length = 0
-                return path.startsWith('/') ? path : `/${path}`
-              }
-            }
-          if (methods.includes(name)) {
-            return async (options: RequestOptions) => {
-              const url = resolveFullPath(that.endpoint, route.join('/'))
-              route.length = 0
-              let res: Record<string, any> & { data: any }
-              try {
-                res = await manager.request({
-                  method: name,
-                  ...options,
-                  url,
-                })
-              } catch (e: any) {
-                let message = e.message
-                let code =
-                  e.code ||
-                  e.status ||
-                  e.statusCode ||
-                  e.response?.status ||
-                  e.response?.statusCode ||
-                  e.response?.code ||
-                  500
-
-                if (that.options.getCodeMessageFromException) {
-                  const errorInfo = that.options.getCodeMessageFromException(e)
-                  message = errorInfo.message || message
-                  code = errorInfo.code || code
-                }
-
-                throw that.options.customThrowResponseError
-                  ? that.options.customThrowResponseError(e)
-                  : new RequestError(message, code, url, e)
-              }
-
-              const data = res.data
-              if (!data) {
-                return null
-              }
-
-              const transform =
-                (Array.isArray(data) || isPlainObject(data)) &&
-                that.options.transformResponse
-                  ? that.options.transformResponse(data)
-                  : data
-
-              if (transform && typeof transform === 'object') {
-                Object.defineProperty(transform, '$raw', {
-                  get() {
-                    return res
-                  },
-                  enumerable: false,
-                  configurable: false,
-                })
-
-                // attach request config onto response
-
-                Object.defineProperty(transform, '$request', {
-                  get() {
-                    return {
-                      url,
-                      method: name,
-                      options,
-                    }
-                  },
-                  enumerable: false,
-                })
-              }
-
-              return transform
-            }
-          }
-          route.push(name)
-          return new Proxy(noop, handler)
-        },
-        // @ts-ignore
-        apply(target: any, _, args) {
-          route.push(...args.filter((x: string) => x !== null))
-          return new Proxy(noop, handler)
-        },
-      }
-
-      return new Proxy(noop, handler) as any
-    }
-  }
-}
-
-export function createClient<T extends IRequestAdapter>(adapter: T) {
-  return <
-    ResponseWrapper = T extends { responseWrapper: infer Type }
-      ? Type extends undefined
-        ? unknown
-        : Type
-      : unknown,
-  >(
-    endpoint: string,
-    options?: ClientOptions,
-  ) => {
-    const client = new HTTPClient<T, ResponseWrapper>(
-      endpoint,
-      adapter,
-      options,
-    )
-    const { controllers } = options || {}
-    if (controllers) {
-      client.injectControllers(controllers)
-    }
-    return client
-  }
-}

package/core/error.ts

@@ -1,10 +0,0 @@
-export class RequestError extends Error {
-  constructor(
-    message: string,
-    public status: number,
-    public path: string,
-    public raw: any,
-  ) {
-    super(message)
-  }
-}

package/core/index.ts

@@ -1,2 +0,0 @@
-export * from './client'
-export * from './error'