@mx-space/api-client 1.18.1 → 1.19.1

package/controllers/search.ts

@@ -1,108 +0,0 @@
-import type { IRequestAdapter } from '~/interfaces/adapter'
-import type { IController } from '~/interfaces/controller'
-import type { IRequestHandler, RequestProxyResult } from '~/interfaces/request'
-import type { PaginateResult } from '~/models/base'
-import type { NoteModel } from '~/models/note'
-import type { PageModel } from '~/models/page'
-import type { PostModel } from '~/models/post'
-import { autoBind } from '~/utils/auto-bind'
-import type { 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/severless.ts

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

package/controllers/snippet.ts

@@ -1,35 +0,0 @@
-import type { IRequestAdapter } from '~/interfaces/adapter'
-import type { IController } from '~/interfaces/controller'
-import type { IRequestHandler } from '~/interfaces/request'
-import { autoBind } from '~/utils/auto-bind'
-import type { 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(id: string) {
-  //   return this.proxy(id).get<Omit<SnippetModel, 'data'>>()
-  // }
-
-  getByReferenceAndName<T = unknown>(reference: string, name: string) {
-    return this.proxy(reference)(name).get<T>()
-  }
-}

package/controllers/subscribe.ts

@@ -1,58 +0,0 @@
-import type { IRequestAdapter } from '~/interfaces/adapter'
-import type { IController } from '~/interfaces/controller'
-import type { IRequestHandler } from '~/interfaces/request'
-import type { SubscribeType } from '~/models/subscribe'
-import { autoBind } from '~/utils/auto-bind'
-import type { HTTPClient } from '../core'
-
-declare module '../core/client' {
-  interface HTTPClient<
-    T extends IRequestAdapter = IRequestAdapter,
-    ResponseWrapper = unknown,
-  > {
-    subscribe: SubscribeController<ResponseWrapper>
-  }
-}
-
-export class SubscribeController<ResponseWrapper> implements IController {
-  base = 'subscribe'
-  name = 'subscribe'
-
-  constructor(protected client: HTTPClient) {
-    autoBind(this)
-  }
-
-  public get proxy(): IRequestHandler<ResponseWrapper> {
-    return this.client.proxy(this.base)
-  }
-
-  /**
-   * 检查开启状态
-   */
-  check() {
-    return this.proxy.status.get<{
-      enable: boolean
-      bitMap: Record<SubscribeType, number>
-      allowBits: number[]
-      allowTypes: SubscribeType[]
-    }>()
-  }
-
-  subscribe(email: string, types: SubscribeType[]) {
-    return this.proxy.post<never>({
-      data: {
-        email,
-        types,
-      },
-    })
-  }
-
-  unsubscribe(email: string, cancelToken: string) {
-    return this.proxy.unsubscribe.get<string>({
-      params: {
-        email,
-        cancelToken,
-      },
-    })
-  }
-}

package/controllers/topic.ts

@@ -1,37 +0,0 @@
-import type { IRequestAdapter } from '~/interfaces/adapter'
-import type { IController } from '~/interfaces/controller'
-import type { IRequestHandler } from '~/interfaces/request'
-import type { TopicModel } from '~/models/topic'
-import { autoBind } from '~/utils/auto-bind'
-import type { HTTPClient } from '../core'
-import { BaseCrudController } from './base'
-
-declare module '../core/client' {
-  interface HTTPClient<
-    T extends IRequestAdapter = IRequestAdapter,
-    ResponseWrapper = unknown,
-  > {
-    topic: TopicController<ResponseWrapper>
-  }
-}
-
-export class TopicController<ResponseWrapper>
-  extends BaseCrudController<TopicModel, ResponseWrapper>
-  implements IController
-{
-  base = 'topics'
-  name = 'topic'
-
-  constructor(protected client: HTTPClient) {
-    super(client)
-    autoBind(this)
-  }
-
-  public get proxy(): IRequestHandler<ResponseWrapper> {
-    return this.client.proxy(this.base)
-  }
-
-  getTopicBySlug(slug: string) {
-    return this.proxy.slug(slug).get<TopicModel>()
-  }
-}

package/controllers/user.ts

@@ -1,61 +0,0 @@
-import type { IRequestAdapter } from '~/interfaces/adapter'
-import type { IController } from '~/interfaces/controller'
-import type { IRequestHandler } from '~/interfaces/request'
-import type { TLogin, UserModel } from '~/models/user'
-import { autoBind } from '~/utils/auto-bind'
-import type { 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,
-      },
-    })
-  }
-
-  loginWithToken(token?: string) {
-    return this.proxy.login.put<{ token: string }>({
-      params: token
-        ? {
-            token: `bearer ${token.replace(/^bearer\s/i, '')}`,
-          }
-        : undefined,
-    })
-  }
-
-  checkTokenValid(token: string) {
-    return this.proxy.check_logged.get<{ ok: number; isGuest: boolean }>({
-      params: {
-        token: `bearer ${token.replace(/^bearer\s/i, '')}`,
-      },
-    })
-  }
-}

package/dtos/comment.ts

@@ -1,12 +0,0 @@
-export interface CommentDto {
-  author: string
-
-  text: string
-
-  mail: string
-
-  url?: string
-
-  source?: 'github' | 'google'
-  avatar?: string
-}

package/dtos/index.ts

@@ -1 +0,0 @@
-export * from './comment'

package/index.ts

@@ -1,12 +0,0 @@
-import { createClient } from './core'
-
-export * from './controllers'
-export * from './models'
-export * from './dtos'
-
-export { createClient, RequestError } from './core'
-export type { HTTPClient } from './core'
-export { camelcaseKeys as simpleCamelcaseKeys } from './utils/camelcase-keys'
-
-export default createClient
-export type { IRequestAdapter } from './interfaces/adapter'

package/interfaces/adapter.ts

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

package/interfaces/client.ts

@@ -1,20 +0,0 @@
-import type { IController } from './controller'
-import type { Class } from './types'
-
-interface IClientOptions {
-  controllers: Class<IController>[]
-  getCodeMessageFromException: <T = Error>(
-    error: T,
-  ) => {
-    message?: string | undefined | null
-    code?: number | undefined | null
-  }
-  customThrowResponseError: <T extends Error = Error>(err: any) => T
-  transformResponse: <T = any>(data: any) => T
-  /**
-   *
-   * @default (res) => res.data
-   */
-  getDataFromResponse: <T = any>(response: unknown) => T
-}
-export type ClientOptions = Partial<IClientOptions>

package/interfaces/controller.ts

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

package/interfaces/instance.ts

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

package/interfaces/options.ts

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

package/interfaces/params.ts

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

package/interfaces/request.ts

@@ -1,87 +0,0 @@
-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<ResponseWrapper> {
-  (path?: string | number): IRequestHandler<ResponseWrapper>
-  // @ts-ignore
-  get: <P = unknown>(
-    options?: Omit<NoStringIndex<RequestOptions>, 'data'>,
-  ) => RequestProxyResult<P, ResponseWrapper>
-  // @ts-ignore
-  post: <P = unknown>(
-    options?: RequestOptions,
-  ) => RequestProxyResult<P, ResponseWrapper>
-  // @ts-ignore
-  patch: <P = unknown>(
-    options?: RequestOptions,
-  ) => RequestProxyResult<P, ResponseWrapper>
-  // @ts-ignore
-  delete: <P = unknown>(
-    options?: Omit<NoStringIndex<RequestOptions>, 'data'>,
-  ) => RequestProxyResult<P, ResponseWrapper>
-  // @ts-ignore
-  put: <P = unknown>(
-    options?: RequestOptions,
-  ) => RequestProxyResult<P, ResponseWrapper>
-  // @ts-ignore
-  toString: (withBase?: boolean) => string
-  // @ts-ignore
-  valueOf: (withBase?: boolean) => string
-  [key: string]: IRequestHandler<ResponseWrapper>
-}
-
-export type RequestProxyResult<
-  T,
-  ResponseWrapper,
-  R = ResponseWrapper extends unknown
-    ? { data: T; [key: string]: any }
-    : ResponseWrapper extends { data: T }
-      ? ResponseWrapper
-      : Omit<ResponseWrapper, 'data'> & { data: T },
-> = Promise<ResponseProxyExtraRaw<T, R, ResponseWrapper>>
-
-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]
-}
-
-type ResponseWrapperType<Response, RawData, T> = {
-  $raw: Response extends { data: infer T }
-    ? Response
-    : Response extends unknown
-      ? {
-          [i: string]: any
-          data: RawData extends unknown ? CamelKeysToSnake<T> : RawData
-        }
-      : Response
-  $request: {
-    path: string
-    method: string
-    [k: string]: string
-  }
-
-  $serialized: T
-}
-
-export type ResponseProxyExtraRaw<
-  T,
-  RawData = unknown,
-  Response = unknown,
-> = T extends object
-  ? T & ResponseWrapperType<Response, RawData, T>
-  : T extends unknown
-    ? T & ResponseWrapperType<Response, RawData, T>
-    : unknown

package/interfaces/types.ts

@@ -1,3 +0,0 @@
-export type Class<T> = new (...args: any[]) => T
-
-export type SelectFields<T extends string> = `${'+' | '-' | ''}${T}`[]

package/mod-dts.mjs

@@ -1,21 +0,0 @@
-import { readFileSync, writeFileSync } from 'node:fs'
-import path from 'node:path'
-
-const __dirname = new URL(import.meta.url).pathname.replace(/\/[^/]*$/, '')
-const PKG = JSON.parse(readFileSync(path.resolve(__dirname, './package.json')))
-
-const dts = path.resolve(__dirname, './dist/index.d.cts')
-const dtsm = path.resolve(__dirname, './dist/index.d.mts')
-const content = readFileSync(dts, 'utf-8')
-
-for (const file of [dts, dtsm]) {
-  // replace declare module '../core/client'
-  // with declare module '@mx-space/api-client'
-  writeFileSync(
-    file,
-    content.replaceAll(
-      /declare module '..\/core\/client'/g,
-      'declare module ' + `'${PKG.name}'`,
-    ),
-  )
-}

package/models/activity.ts

@@ -1,133 +0,0 @@
-import type { CollectionRefTypes } from '@core/constants/db.constant'
-import type { CategoryModel } from './category'
-
-export interface ActivityPresence {
-  operationTime: number
-  identity: string
-  roomName: string
-  position: number
-  joinedAt: number
-  connectedAt: number
-  updatedAt: number
-  readerId?: string
-
-  displayName?: string
-}
-
-export interface RoomOmittedNote {
-  title: string
-  nid: number
-  id: string
-  created: string
-}
-
-export interface RoomOmittedPage {
-  title: string
-  slug: string
-  id: string
-  created: string
-}
-
-export interface RoomOmittedPost {
-  slug: string
-  title: string
-  categoryId: string
-  category: CategoryModel
-  id: string
-  created: string
-}
-export interface RoomsData {
-  rooms: string[]
-  roomCount: {
-    [key: string]: number
-  }
-  objects: {
-    posts: RoomOmittedPost[]
-    notes: RoomOmittedNote[]
-    pages: RoomOmittedPage[]
-  }
-}
-
-export interface RecentActivities {
-  like: RecentLike[]
-  comment: RecentComment[]
-  recent: RecentRecent[]
-  post: RecentPost[]
-  note: RecentNote[]
-}
-
-export interface RecentComment {
-  created: string
-  author: string
-  text: string
-  id: string
-  title: string
-  slug?: string
-  type: string
-  avatar: string
-  nid?: string
-}
-
-export interface RecentLike {
-  created: string
-  id: string
-  type: CollectionRefTypes.Post | CollectionRefTypes.Note
-  nid?: number
-  slug?: string
-  title: string
-}
-
-export interface RecentNote {
-  id: string
-  created: string
-  title: string
-  modified: string
-  nid: number
-}
-
-export interface RecentPost {
-  id: string
-  created: string
-  title: string
-  modified: string
-  slug: string
-}
-
-export interface RecentRecent {
-  id: string
-
-  content: string
-  up: number
-  down: number
-  created: string
-}
-
-export interface LastYearPublication {
-  posts: PostsItem[]
-  notes: NotesItem[]
-}
-
-interface PostsItem {
-  id: string
-  created: string
-  title: string
-  slug: string
-  categoryId: string
-  category: Category
-}
-interface Category {
-  id: string
-  type: number
-  name: string
-  slug: string
-  created: string
-}
-interface NotesItem {
-  id: string
-  created: string
-  title: string
-  mood: string
-  weather: string
-  nid: number
-  bookmark: boolean
-}