@mx-space/api-client 0.6.3 → 0.7.1

package/controllers/post.ts

@@ -0,0 +1,94 @@
+import { IRequestAdapter } from '~/interfaces/adapter'
+import { IController } from '~/interfaces/controller'
+import { IRequestHandler, RequestProxyResult } from '~/interfaces/request'
+import { SelectFields } from '~/interfaces/types'
+import { PaginateResult } from '~/models/base'
+import { PostModel } from '~/models/post'
+import { autoBind } from '~/utils/auto-bind'
+import { HTTPClient } from '../core/client'
+
+declare module '../core/client' {
+  interface HTTPClient<
+    T extends IRequestAdapter = IRequestAdapter,
+    ResponseWrapper = unknown,
+  > {
+    post: PostController<ResponseWrapper>
+  }
+}
+
+export type PostListOptions = {
+  select?: SelectFields<keyof PostModel>
+  year?: number
+  sortBy?: 'categoryId' | 'title' | 'created' | 'modified'
+  sortOrder?: 1 | -1
+}
+
+export class PostController<ResponseWrapper> implements IController {
+  constructor(private client: HTTPClient) {
+    autoBind(this)
+  }
+
+  base = 'posts'
+
+  name = 'post'
+
+  public get proxy(): IRequestHandler<ResponseWrapper> {
+    return this.client.proxy(this.base)
+  }
+
+  /**
+   * 获取文章列表分页
+   * @param page
+   * @param perPage
+   * @returns
+   */
+  getList(page = 1, perPage = 10, options: PostListOptions = {}) {
+    const { select, sortBy, sortOrder, year } = options
+    return this.proxy.get<PaginateResult<PostModel>>({
+      params: {
+        page,
+        size: perPage,
+        select: select?.join(' '),
+        sortBy,
+        sortOrder,
+        year,
+      },
+    })
+  }
+
+  /**
+   * 根据分类和路径查找文章
+   * @param categoryName
+   * @param slug
+   */
+  getPost(
+    categoryName: string,
+    slug: string,
+  ): RequestProxyResult<PostModel, ResponseWrapper>
+  /**
+   * 根据 ID 查找文章
+   * @param id
+   */
+  getPost(id: string): RequestProxyResult<PostModel, ResponseWrapper>
+  getPost(idOrCategoryName: string, slug?: string): any {
+    if (arguments.length == 1) {
+      return this.proxy(idOrCategoryName).get<PostModel>()
+    } else {
+      return this.proxy(idOrCategoryName)(slug).get<PostModel>()
+    }
+  }
+
+  /**
+   * 获取最新的文章
+   */
+  getLatest() {
+    return this.proxy.latest.get<PostModel>()
+  }
+
+  /**
+   * 点赞
+   */
+  thumbsUp(id: string) {
+    return this.proxy('_thumbs-up').get<void>({ params: { id } })
+  }
+}

package/controllers/project.ts

@@ -0,0 +1,27 @@
+import { IRequestAdapter } from '~/interfaces/adapter'
+import { ProjectModel } from '~/models/project'
+import { autoBind } from '~/utils/auto-bind'
+import { HTTPClient } from '../core'
+import { BaseCrudController } from './base'
+
+declare module '../core/client' {
+  interface HTTPClient<
+    T extends IRequestAdapter = IRequestAdapter,
+    ResponseWrapper = unknown,
+  > {
+    project: ProjectController<ResponseWrapper>
+  }
+}
+
+export class ProjectController<ResponseWrapper> extends BaseCrudController<
+  ProjectModel,
+  ResponseWrapper
+> {
+  constructor(protected readonly client: HTTPClient) {
+    super(client)
+    autoBind(this)
+  }
+
+  base = 'projects'
+  name = 'project'
+}

package/controllers/recently.ts

@@ -0,0 +1,53 @@
+import { IRequestAdapter } from '~/interfaces/adapter'
+import { IController } from '~/interfaces/controller'
+import { IRequestHandler } from '~/interfaces/request'
+import { RecentlyModel } from '~/models/recently'
+import { autoBind } from '~/utils/auto-bind'
+import { HTTPClient } from '../core'
+
+declare module '../core/client' {
+  interface HTTPClient<
+    T extends IRequestAdapter = IRequestAdapter,
+    ResponseWrapper = unknown,
+  > {
+    recently: RecentlyController<ResponseWrapper>
+    shorthand: RecentlyController<ResponseWrapper>
+  }
+}
+
+export class RecentlyController<ResponseWrapper> implements IController {
+  base = 'recently'
+  name = ['recently', 'shorthand']
+
+  constructor(private readonly client: HTTPClient) {
+    autoBind(this)
+  }
+
+  get proxy(): IRequestHandler<ResponseWrapper> {
+    return this.client.proxy(this.base)
+  }
+  /**
+   * 获取最新一条
+   */
+  getLatestOne() {
+    return this.proxy.latest.get<RecentlyModel>()
+  }
+
+  getAll() {
+    return this.proxy.all.get<{ data: RecentlyModel[] }>()
+  }
+
+  getList(
+    before?: string | undefined,
+    after?: string | undefined,
+    size?: number | number,
+  ) {
+    return this.proxy.get<{ data: RecentlyModel[] }>({
+      params: {
+        before,
+        after,
+        size,
+      },
+    })
+  }
+}

package/controllers/say.ts

@@ -0,0 +1,40 @@
+import { IRequestAdapter } from '~/interfaces/adapter'
+import { IController } from '~/interfaces/controller'
+import { IRequestHandler } from '~/interfaces/request'
+import { SayModel } from '~/models/say'
+import { autoBind } from '~/utils/auto-bind'
+import { HTTPClient } from '../core'
+import { BaseCrudController } from './base'
+
+declare module '../core/client' {
+  interface HTTPClient<
+    T extends IRequestAdapter = IRequestAdapter,
+    ResponseWrapper = unknown,
+  > {
+    say: SayController<ResponseWrapper>
+  }
+}
+
+export class SayController<ResponseWrapper>
+  extends BaseCrudController<SayModel, ResponseWrapper>
+  implements IController
+{
+  base = 'says'
+  name = 'say'
+
+  constructor(protected client: HTTPClient) {
+    super(client)
+    autoBind(this)
+  }
+
+  public get proxy(): IRequestHandler<ResponseWrapper> {
+    return this.client.proxy(this.base)
+  }
+
+  /**
+   * 获取随机一条
+   */
+  getRandom() {
+    return this.proxy.random.get<{ data: SayModel | null }>()
+  }
+}

package/controllers/search.ts

@@ -0,0 +1,108 @@
+import { IRequestAdapter } from '~/interfaces/adapter'
+import { IController } from '~/interfaces/controller'
+import { IRequestHandler, RequestProxyResult } from '~/interfaces/request'
+import { PaginateResult } from '~/models/base'
+import { NoteModel } from '~/models/note'
+import { PostModel } from '~/models/post'
+import { autoBind } from '~/utils/auto-bind'
+import { PageModel } from '..'
+import { HTTPClient } from '../core'
+
+declare module '../core/client' {
+  interface HTTPClient<
+    T extends IRequestAdapter = IRequestAdapter,
+    ResponseWrapper = unknown,
+  > {
+    search: SearchController<ResponseWrapper>
+  }
+}
+
+export type SearchType = 'post' | 'note'
+
+export type SearchOption = {
+  orderBy?: string
+  order?: number
+  rawAlgolia?: boolean
+}
+export class SearchController<ResponseWrapper> implements IController {
+  base = 'search'
+  name = 'search'
+
+  constructor(private readonly client: HTTPClient) {
+    autoBind(this)
+  }
+
+  get proxy(): IRequestHandler<ResponseWrapper> {
+    return this.client.proxy(this.base)
+  }
+
+  search(
+    type: 'note',
+    keyword: string,
+    options?: Omit<SearchOption, 'rawAlgolia'>,
+  ): Promise<
+    RequestProxyResult<
+      PaginateResult<
+        Pick<NoteModel, 'modified' | 'id' | 'title' | 'created' | 'nid'>
+      >,
+      ResponseWrapper
+    >
+  >
+  search(
+    type: 'post',
+    keyword: string,
+    options?: Omit<SearchOption, 'rawAlgolia'>,
+  ): Promise<
+    RequestProxyResult<
+      PaginateResult<
+        Pick<
+          PostModel,
+          'modified' | 'id' | 'title' | 'created' | 'slug' | 'category'
+        >
+      >,
+      ResponseWrapper
+    >
+  >
+  search(
+    type: SearchType,
+    keyword: string,
+    options: Omit<SearchOption, 'rawAlgolia'> = {},
+  ): any {
+    return this.proxy(type).get({
+      params: { keyword, ...options },
+    })
+  }
+  /**
+   * 从 algolya 搜索
+   * https://www.algolia.com/doc/api-reference/api-methods/search/
+   * @param keyword
+   * @param options
+   * @returns
+   */
+  searchByAlgolia(keyword: string, options?: SearchOption) {
+    return this.proxy('algolia').get<
+      RequestProxyResult<
+        PaginateResult<
+          | (Pick<
+              PostModel,
+              'modified' | 'id' | 'title' | 'created' | 'slug' | 'category'
+            > & { type: 'post' })
+          | (Pick<
+              NoteModel,
+              'id' | 'created' | 'id' | 'modified' | 'title' | 'nid'
+            > & { type: 'note' })
+          | (Pick<
+              PageModel,
+              'id' | 'title' | 'created' | 'modified' | 'slug'
+            > & { type: 'page' })
+        > & {
+          /**
+           * @see: algoliasearch <https://www.algolia.com/doc/api-reference/api-methods/search/>
+           */
+          raw?: any
+        },
+        ResponseWrapper
+      >
+    >({ params: { keyword, ...options } })
+  }
+}

package/controllers/snippet.ts

@@ -0,0 +1,36 @@
+import { IRequestAdapter } from '~/interfaces/adapter'
+import { IController } from '~/interfaces/controller'
+import { IRequestHandler } from '~/interfaces/request'
+import { SnippetModel } from '~/models/snippet'
+import { autoBind } from '~/utils/auto-bind'
+import { HTTPClient } from '../core'
+
+declare module '../core/client' {
+  interface HTTPClient<
+    T extends IRequestAdapter = IRequestAdapter,
+    ResponseWrapper = unknown,
+  > {
+    snippet: SnippetController<ResponseWrapper>
+  }
+}
+
+export class SnippetController<ResponseWrapper> implements IController {
+  base = 'snippets'
+  name = 'snippet'
+
+  constructor(protected client: HTTPClient) {
+    autoBind(this)
+  }
+
+  get proxy(): IRequestHandler<ResponseWrapper> {
+    return this.client.proxy(this.base)
+  }
+
+  getById<T = unknown>(id: string) {
+    return this.proxy(id).get<SnippetModel<T>>()
+  }
+
+  getByReferenceAndName<T = unknown>(reference: string, name: string) {
+    return this.proxy(reference)(name).get<T>()
+  }
+}

package/controllers/user.ts

@@ -0,0 +1,51 @@
+import { IRequestAdapter } from '~/interfaces/adapter'
+import { IController } from '~/interfaces/controller'
+import { IRequestHandler } from '~/interfaces/request'
+import { TLogin, UserModel } from '~/models/user'
+import { autoBind } from '~/utils/auto-bind'
+import { HTTPClient } from '../core'
+
+declare module '../core/client' {
+  interface HTTPClient<
+    T extends IRequestAdapter = IRequestAdapter,
+    ResponseWrapper = unknown,
+  > {
+    user: UserController<ResponseWrapper>
+    master: UserController<ResponseWrapper>
+  }
+}
+
+export class UserController<ResponseWrapper> implements IController {
+  constructor(private readonly client: HTTPClient) {
+    autoBind(this)
+  }
+
+  base = 'master'
+
+  name = ['user', 'master']
+
+  public get proxy(): IRequestHandler<ResponseWrapper> {
+    return this.client.proxy(this.base)
+  }
+
+  getMasterInfo() {
+    return this.proxy.get<UserModel>()
+  }
+
+  login(username: string, password: string) {
+    return this.proxy.login.post<TLogin>({
+      data: {
+        username,
+        password,
+      },
+    })
+  }
+
+  checkTokenValid(token: string) {
+    return this.proxy.check_logged.get<{ ok: number; isGuest: boolean }>({
+      params: {
+        token: 'bearer ' + token.replace(/^Bearer\s/i, ''),
+      },
+    })
+  }
+}

package/core/attach-request.ts

@@ -0,0 +1,43 @@
+import type { HTTPClient } from '.'
+
+export function attachRequestMethod<T extends HTTPClient<any, any>>(target: T) {
+  Object.defineProperty(target, '$$get', {
+    value: function (url: string, options?: any) {
+      // HINT: method get only accept search params;
+      const { params = {} } = options
+      const qs = handleSearchParams(params)
+
+      return target.instance.get(url + `${qs ? `${'?' + qs}` : ''}`)
+    },
+  })
+  ;(['put', 'post', 'patch', 'delete'] as const).forEach((method) => {
+    Object.defineProperty(target, '$$' + method, {
+      value: function (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,239 @@
+import camelcaseKeys from 'camelcase-keys'
+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 { 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 _proxy: IRequestHandler<ResponseWrapper>
+
+  constructor(private _endpoint: string, private _adaptor: T) {
+    this._endpoint = _endpoint
+      .replace(/\/*$/, '')
+      .replace('localhost', '127.0.0.1')
+    this._proxy = this.buildRoute(this)()
+
+    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 resolveFullPath(path: string) {
+    if (!path.startsWith('/')) {
+      path = '/' + path
+    }
+    return `${this.endpoint}${path}`
+  }
+
+  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 = that.resolveFullPath(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 = that.resolveFullPath(route.join('/'))
+              route.length = 0
+              let res: Record<string, any> & { data: any }
+              try {
+                res = await manager.request({
+                  method: name,
+                  ...options,
+                  url,
+                })
+              } catch (e: any) {
+                throw new RequestError(
+                  e.message,
+                  e.code ||
+                    e.status ||
+                    e.statusCode ||
+                    e.response?.status ||
+                    e.response?.statusCode ||
+                    e.response?.code ||
+                    500,
+                  url,
+                  e,
+                )
+              }
+
+              const data = res.data
+              if (!data) {
+                return null
+              }
+
+              const transform =
+                Array.isArray(data) || isPlainObject(data)
+                  ? camelcaseKeys(data, { deep: true })
+                  : 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)
+    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)
+  }
+}