@mx-space/api-client 0.6.3 → 0.7.0-alpha.0

package/src/core/attach-request.ts

@@ -0,0 +1,43 @@
+import type { HTTPClient } from '.'
+
+export function attachRequestMethod<T extends HTTPClient>(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/src/core/client.ts

@@ -0,0 +1,249 @@
+import camelcaseKeys from 'camelcase-keys'
+import { 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 '~/types/helper'
+import { isPlainObject } from '~/utils'
+import { allContollerNames } from '../controllers'
+import { attachRequestMethod } from './attach-request'
+import { RequestError } from './error'
+
+// export interface HTTPClient {
+//   aggregate: AggregateController
+//   category: CategoryController
+//   comment: CommentController
+//   link: LinkController
+//   note: NoteController
+//   page: PageController
+//   post: PostController
+//   project: ProjectController
+//   recently: RecentlyController
+//   say: SayController
+//   search: SearchController
+//   snippet: SnippetController
+//   user: UserController
+
+//   master: HTTPClient['user']
+
+//   friend: HTTPClient['link']
+
+//   shorthand: HTTPClient['recently']
+// }
+
+const methodPrefix = '_$'
+
+export class HTTPClient<T extends IRequestAdapter = IRequestAdapter> {
+  private _proxy: IRequestHandler
+
+  constructor(private _endpoint: string, private _adaptor: T) {
+    // super()
+    this._endpoint = _endpoint
+      .replace(/\/*$/, '')
+      .replace('localhost', '127.0.0.1')
+    this._proxy = this.buildRoute(this)()
+
+    this.initGetClient()
+
+    attachRequestMethod(this)
+
+    // const proxy = new Proxy(this, {
+    //   get(target, key, r) {
+    //     return (
+    //       Reflect.get(target, key, r) ||
+    //       (typeof key === 'string' &&
+    //         Reflect.get(target, methodPrefix + key, r))
+    //     )
+    //   },
+    // })
+
+    // return proxy
+  }
+
+  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,
+    )
+  }
+
+  public get proxy() {
+    return this._proxy
+  }
+
+  private resolveFullPath(path: string) {
+    if (!path.startsWith('/')) {
+      path = '/' + path
+    }
+    return `${this.endpoint}${path}`
+  }
+
+  private buildRoute(manager: this): () => IRequestHandler {
+    // 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,
+      Symbol.for('util.inspect.custom'),
+    ]
+    // 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 () => route.join('/')
+          if (methods.includes(name)) {
+            return async (options: RequestOptions) => {
+              const url = that.resolveFullPath(route.join('/'))
+              route.length = 0
+              let res: 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 (endpoint: string, options?: ClientOptions) => {
+    const client = new HTTPClient(endpoint, adapter)
+    const { controllers } = options || {}
+    if (controllers) {
+      client.injectControllers(controllers)
+    }
+    return client
+  }
+}

package/src/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/src/core/index.ts

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

package/src/dtos/comment.ts

@@ -0,0 +1,9 @@
+export class CommentDto {
+  author!: string
+
+  text!: string
+
+  mail!: string
+
+  url?: string
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+import _camelcaseKeys from 'camelcase-keys'
+
+export * from './controllers'
+export { createClient, HTTPClient, RequestError } from './core'
+export * from './models'
+
+// export helper lib
+export const camelcaseKeysDeep = <T>(obj: T) => {
+  return camelcaseKeys(obj, { deep: true }) as T
+}
+
+export const camelcaseKeys = _camelcaseKeys

package/src/interfaces/adapter.ts

@@ -0,0 +1,30 @@
+import { RequestOptions } from './instance'
+type RequestResponseType<P> = Promise<Record<string, any> & { data: P }>
+
+export type IRequestAdapter<T = any> = Readonly<{
+  default: T
+  get<P = unknown>(
+    url: string,
+    options?: Omit<RequestOptions, 'data'>,
+  ): RequestResponseType<P>
+
+  post<P = unknown>(
+    url: string,
+    options: Partial<RequestOptions>,
+  ): RequestResponseType<P>
+
+  patch<P = unknown>(
+    url: string,
+    options: Partial<RequestOptions>,
+  ): RequestResponseType<P>
+
+  delete<P = unknown>(
+    url: string,
+    options?: Omit<RequestOptions, 'data'>,
+  ): RequestResponseType<P>
+
+  put<P = unknown>(
+    url: string,
+    options: Partial<RequestOptions>,
+  ): RequestResponseType<P>
+}>

package/src/interfaces/client.ts

@@ -0,0 +1,6 @@
+import { Class } from '~/types/helper'
+import { IController } from './controller'
+
+export type ClientOptions = {
+  controllers?: Class<IController>[]
+}

package/src/interfaces/controller.ts

@@ -0,0 +1,5 @@
+export interface IController {
+  base: string
+
+  name: string | string[]
+}

package/src/interfaces/instance.ts

@@ -0,0 +1,8 @@
+export interface RequestOptions {
+  method?: string
+  data?: Record<string, any>
+  params?: Record<string, any> | URLSearchParams
+  headers?: Record<string, string>
+
+  [key: string]: any
+}

package/src/interfaces/options.ts

@@ -0,0 +1 @@
+export type SortOrder = 'asc' | 'desc'

package/src/interfaces/params.ts

@@ -0,0 +1,4 @@
+export interface PaginationParams {
+  size?: number
+  page?: number
+}

package/src/interfaces/request.ts

@@ -0,0 +1,57 @@
+import type { RequestOptions } from './instance'
+type NoStringIndex<T> = { [K in keyof T as string extends K ? never : K]: T[K] }
+
+export type Method = 'get' | 'delete' | 'post' | 'put' | 'patch'
+
+export interface IRequestHandler {
+  (path?: string | number): IRequestHandler
+  // @ts-ignore
+  get<P = unknown>(
+    options?: Omit<NoStringIndex<RequestOptions>, 'data'>,
+  ): RequestProxyResult<P>
+  // @ts-ignore
+  post<P = unknown>(options?: RequestOptions): RequestProxyResult<P>
+  // @ts-ignore
+  patch<P = unknown>(options?: RequestOptions): RequestProxyResult<P>
+  // @ts-ignore
+  delete<P = unknown>(
+    options?: Omit<NoStringIndex<RequestOptions>, 'data'>,
+  ): RequestProxyResult<P>
+  // @ts-ignore
+  put<P = unknown>(options?: RequestOptions): RequestProxyResult<P>
+  [key: string]: IRequestHandler
+}
+
+export type RequestProxyResult<
+  T,
+  R = { data: T; [key: string]: any },
+> = Promise<ResponseProxyExtraRaw<T, R>>
+
+type CamelToSnake<T extends string, P extends string = ''> = string extends T
+  ? string
+  : T extends `${infer C0}${infer R}`
+  ? CamelToSnake<
+      R,
+      `${P}${C0 extends Lowercase<C0> ? '' : '_'}${Lowercase<C0>}`
+    >
+  : P
+
+type CamelKeysToSnake<T> = {
+  [K in keyof T as CamelToSnake<Extract<K, string>>]: T[K]
+}
+
+export type ResponseProxyExtraRaw<
+  T,
+  RawData = unknown,
+  Response = unknown,
+> = T extends object
+  ? T & {
+      $raw: Response extends unknown
+        ? {
+            [i: string]: any
+            data: RawData extends unknown ? CamelKeysToSnake<T> : RawData
+          }
+        : Response
+      $request: { path: string; method: string; [k: string]: string }
+    }
+  : T

package/src/models/aggregate.ts

@@ -0,0 +1,71 @@
+import { CategoryModel } from './category'
+import { NoteModel } from './note'
+import { PageModel } from './page'
+import { PostModel } from './post'
+import { SayModel } from './say'
+import { SeoOptionModel } from './setting'
+import { UserModel } from './user'
+
+export interface AggregateRoot {
+  user: UserModel
+  seo: SeoOptionModel
+  url: Url
+  categories: CategoryModel[]
+  pageMeta: Pick<PageModel, 'title' | 'id' | 'slug' | 'order'>[] | null
+}
+
+export interface Url {
+  wsUrl: string
+  serverUrl: string
+  webUrl: string
+}
+
+export interface AggregateTop {
+  notes: Pick<NoteModel, 'id' | 'title' | 'created' | 'nid'>[]
+  posts: Pick<PostModel, 'id' | 'slug' | 'created' | 'title' | 'category'>[]
+  says: SayModel[]
+}
+
+export enum TimelineType {
+  Post,
+  Note,
+}
+
+export interface TimelineData {
+  notes?: Pick<
+    NoteModel,
+    | 'id'
+    | 'nid'
+    | 'title'
+    | 'weather'
+    | 'mood'
+    | 'created'
+    | 'modified'
+    | 'hasMemory'
+  >[]
+
+  posts?: (Pick<
+    PostModel,
+    'id' | 'title' | 'slug' | 'created' | 'modified' | 'category'
+  > & { url: string })[]
+}
+
+export interface AggregateStat {
+  allComments: number
+  categories: number
+  comments: number
+  linkApply: number
+  links: number
+  notes: number
+  pages: number
+  posts: number
+  says: number
+  recently: number
+  unreadComments: number
+  online: number
+  todayMaxOnline: string
+  todayOnlineTotal: string
+  callTime: number
+  uv: number
+  todayIPAccessCount: number
+}

package/src/models/base.ts

@@ -0,0 +1,43 @@
+export interface Count {
+  read: number
+  like: number
+}
+
+export interface Image {
+  height: number
+  width: number
+  type: string
+  accent?: string
+  src: string
+}
+
+export interface Pager {
+  total: number
+  size: number
+  currentPage: number
+  totalPage: number
+  hasPrevPage: boolean
+  hasNextPage: boolean
+}
+
+export interface PaginateResult<T> {
+  data: T[]
+  pagination: Pager
+}
+
+export interface BaseModel {
+  created: string
+  id: string
+}
+
+export interface BaseCommentIndexModel extends BaseModel {
+  commentsIndex?: number
+
+  allowComment: boolean
+}
+export interface TextBaseModel extends BaseCommentIndexModel {
+  title: string
+  text: string
+  images?: Image[]
+  modified: string | null
+}

package/src/models/category.ts

@@ -0,0 +1,25 @@
+import { BaseModel } from './base'
+import { PostModel } from './post'
+
+export enum CategoryType {
+  Category,
+  Tag,
+}
+
+export interface CategoryModel extends BaseModel {
+  type: CategoryType
+  count: number
+  slug: string
+  name: string
+}
+export type CategoryWithChildrenModel = CategoryModel & {
+  children: Pick<PostModel, 'id' | 'title' | 'slug' | 'modified' | 'created'>[]
+}
+
+export type CategoryEntries = {
+  entries: Record<string, CategoryWithChildrenModel>
+}
+export interface TagModel {
+  count: number
+  name: string
+}

package/src/models/comment.ts

@@ -0,0 +1,37 @@
+import { BaseModel } from './base'
+import { CategoryModel } from './category'
+
+export enum RefType {
+  Page = 'Page',
+  Post = 'Post',
+  Note = 'Note',
+}
+export interface CommentModel extends BaseModel {
+  refType: RefType
+  state: number
+  comments_index: number
+  author: string
+  text: string
+  mail?: string
+  url?: string
+  ip?: string
+  agent?: string
+  key: string
+
+  avatar: string
+  parent?: CommentModel | string
+  children: CommentModel[]
+}
+export interface CommentRef {
+  id: string
+  categoryId?: string
+  slug: string
+  title: string
+  category?: CategoryModel
+}
+
+export enum CommentState {
+  Unread,
+  Read,
+  Junk,
+}

package/src/models/index.ts

@@ -0,0 +1,14 @@
+export * from './aggregate'
+export * from './base'
+export * from './category'
+export * from './comment'
+export * from './link'
+export * from './note'
+export * from './page'
+export * from './post'
+export * from './project'
+export * from './recently'
+export * from './say'
+export * from './setting'
+export * from './snippet'
+export * from './user'

package/src/models/link.ts

@@ -0,0 +1,23 @@
+import { BaseModel } from './base'
+
+export enum LinkType {
+  Friend,
+  Collection,
+}
+
+export enum LinkState {
+  Pass,
+  Audit,
+  Outdate,
+  Banned,
+}
+
+export interface LinkModel extends BaseModel {
+  name: string
+  url: string
+  avatar: string
+  description?: string
+  type: LinkType
+  state: LinkState
+  hide: boolean
+}