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

package/core/attach-request.ts

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

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

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

package/core/index.ts

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