@mx-space/api-client 1.0.0-alpha.2 → 1.0.0-alpha.4

package/package.json

@@ -1,14 +1,43 @@
 {
   "name": "@mx-space/api-client",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.4",
   "type": "module",
   "description": "A api client for mx-space server@next",
   "author": "Innei",
   "license": "MIT",
-  "main": "build/index.cjs",
-  "module": "build/index.js",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
   "types": "types/index.d.ts",
-  "unpkg": "build/index.umd.min.js",
+  "unpkg": "dist/index.umd.min.js",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./types/index.d.ts"
+      ],
+      "./adaptors/*": [
+        "./types/adaptors/*.d.ts"
+      ]
+    }
+  },
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json",
+    "./adaptors/*": {
+      "types": "./types/adaptors/*.d.ts",
+      "import": {
+        "type": "./types/adaptors/*.d.ts",
+        "default": "./dist/adaptors/*.js"
+      },
+      "require": {
+        "type": "./types/adaptors/*.d.ts",
+        "default": "./dist/adaptors/*.cjs"
+      }
+    }
+  },
   "husky": {
     "hooks": {
       "pre-commit": "lint-staged"
@@ -39,7 +68,7 @@
     "postbuild": "tsc-alias -p tsconfig.build.json && tsc-alias -p tsconfig.cjs.json && npm run types",
     "types": "rm -rf types && tsc --build tsconfig.types.json && tsc-alias -p tsconfig.types.json",
     "package": "NODE_ENV=production npm run build && rollup -c",
-    "prepackage": "rm -rf build",
+    "prepackage": "rm -rf dist",
     "test": "vitest",
     "dev": "vite"
   },
@@ -48,21 +77,22 @@
     "@rollup/plugin-node-resolve": "14.0.1",
     "@rollup/plugin-typescript": "8.5.0",
     "@types/cors": "2.8.12",
-    "@types/lodash": "4.14.184",
-    "@types/node": "16.11.58",
+    "@types/lodash": "4.14.186",
+    "@types/node": "16.11.65",
     "abort-controller": "3.0.0",
     "axios": "0.27.2",
     "camelcase-keys": "8.0.2",
     "gh-pages": "4.0.0",
+    "globby": "*",
     "isomorphic-unfetch": "3.1.0",
-    "jsdom": "20.0.0",
+    "jsdom": "20.0.1",
     "ky": "0.31.3",
     "lodash": "4.17.21",
     "node-fetch": "3.2.10",
-    "rollup": "2.79.0",
+    "rollup": "2.79.1",
     "rollup-plugin-peer-deps-external": "2.2.4",
     "rollup-plugin-terser": "7.0.2",
     "tsc-alias": "1.7.0",
     "umi-request": "1.4.0"
   }
-}
+}

package/readme.md

@@ -20,9 +20,6 @@
 以 `axios` 为例。
 
 ```ts
-// esm format (spa recommend)
-// cjs format (ssr recommend)
-// import { axiosAdaptor } from '@mx-space/api-client/lib/adaptors/axios'
 import {
   AggregateController,
   CategoryController,
@@ -31,7 +28,7 @@ import {
   allControllers, // ...
   createClient,
 } from '@mx-space/api-client'
-import { axiosAdaptor } from '@mx-space/api-client/esm/adaptors/axios'
+import { axiosAdaptor } from '@mx-space/api-client/adaptors/axios'
 
 const endpoint = 'https://api.innei.dev/v2'
 const client = createClient(axiosAdaptor)(endpoint)

package/adaptors/axios.ts

@@ -1,44 +0,0 @@
-import type { AxiosInstance, AxiosResponse } from 'axios'
-import axios from 'axios'
-
-import type { 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)
-  },
-})
-
-export default axiosAdaptor

package/adaptors/ky.ts

@@ -1,76 +0,0 @@
-import ky from 'ky'
-import type { Options, ResponsePromise } from 'ky'
-import type { KyInstance } from 'ky/distribution/types/ky'
-
-import type { 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)
-
-export default defaultKyAdaptor

package/adaptors/umi-request.ts

@@ -1,38 +0,0 @@
-import type { RequestMethod, RequestResponse } from 'umi-request'
-import { extend } from 'umi-request'
-
-import type { 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)
-  },
-})
-
-export default umiAdaptor

package/core/attach-request.ts

@@ -1,43 +0,0 @@
-import type { 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 type {
-  IAdaptorRequestResponseType,
-  IRequestAdapter,
-} from '~/interfaces/adapter'
-import type { ClientOptions } from '~/interfaces/client'
-import type { IController } from '~/interfaces/controller'
-import type { RequestOptions } from '~/interfaces/instance'
-import type { IRequestHandler, Method } from '~/interfaces/request'
-import type { 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'

package/utils/auto-bind.ts

@@ -1,48 +0,0 @@
-// @ts-nocheck
-// @copy: https://github.com/sindresorhus/auto-bind/blob/main/index.js
-
-// Gets all non-builtin properties up the prototype chain.
-const getAllProperties = (object) => {
-  const properties = new Set()
-
-  do {
-    for (const key of Reflect.ownKeys(object)) {
-      properties.add([object, key])
-    }
-  } while (
-    (object = Reflect.getPrototypeOf(object)) &&
-    object !== Object.prototype
-  )
-
-  return properties
-}
-
-export function autoBind(self, { include, exclude } = {}) {
-  const filter = (key) => {
-    const match = (pattern) =>
-      typeof pattern === 'string' ? key === pattern : pattern.test(key)
-
-    if (include) {
-      return include.some(match)
-    }
-
-    if (exclude) {
-      return !exclude.some(match)
-    }
-
-    return true
-  }
-
-  for (const [object, key] of getAllProperties(self.constructor.prototype)) {
-    if (key === 'constructor' || !filter(key)) {
-      continue
-    }
-
-    const descriptor = Reflect.getOwnPropertyDescriptor(object, key)
-    if (descriptor && typeof descriptor.value === 'function') {
-      self[key] = self[key].bind(self)
-    }
-  }
-
-  return self
-}

package/utils/camelcase-keys.ts

@@ -1,26 +0,0 @@
-import { isPlainObject } from '.'
-
-/**
- * A simple camelCase function that only handles strings, but not handling symbol, date, or other complex case.
- * If you need to handle more complex cases, please use camelcase-keys package.
- */
-export const camelcaseKeys = <T = any>(obj: any): T => {
-  if (Array.isArray(obj)) {
-    return obj.map((x) => camelcaseKeys(x)) as any
-  }
-
-  if (isPlainObject(obj)) {
-    return Object.keys(obj).reduce((result: any, key) => {
-      result[camelcase(key)] = camelcaseKeys(obj[key])
-      return result
-    }, {}) as any
-  }
-
-  return obj
-}
-
-export function camelcase(str: string) {
-  return str.replace(/([-_][a-z])/gi, ($1) => {
-    return $1.toUpperCase().replace('-', '').replace('_', '')
-  })
-}