@mx-space/api-client 1.19.0 → 1.19.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mx-space/api-client",
-  "version": "1.19.0",
+  "version": "1.19.1",
   "description": "A api client for mx-space server@next",
   "type": "module",
   "engines": {
@@ -8,9 +8,12 @@
   },
   "license": "MIT",
   "author": "Innei",
+  "files": [
+    "dist"
+  ],
   "main": "dist/index.cjs",
   "module": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "types": "dist/index.d.mts",
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",

package/controllers/ack.ts

@@ -1,42 +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,
-  > {
-    ack: AckController<ResponseWrapper>
-  }
-}
-
-/**
- * @support core >= 4.4.0
- */
-export class AckController<ResponseWrapper> implements IController {
-  base = 'ack'
-  name = 'ack'
-
-  constructor(private client: HTTPClient) {
-    autoBind(this)
-  }
-
-  public get proxy(): IRequestHandler<ResponseWrapper> {
-    return this.client.proxy(this.base)
-  }
-
-  read(type: 'post' | 'note', id: string) {
-    return this.proxy.post<never>({
-      data: {
-        type: 'read',
-        payload: {
-          type,
-          id,
-        },
-      },
-    })
-  }
-}

package/controllers/activity.ts

@@ -1,108 +0,0 @@
-import type { IRequestAdapter } from '~/interfaces/adapter'
-import type { IController } from '~/interfaces/controller'
-import type { IRequestHandler } from '~/interfaces/request'
-import type { AuthUser } from '~/models'
-import type {
-  ActivityPresence,
-  LastYearPublication,
-  RecentActivities,
-  RoomsData,
-} from '~/models/activity'
-import { autoBind } from '~/utils/auto-bind'
-import type { HTTPClient } from '../core'
-
-declare module '../core/client' {
-  interface HTTPClient<
-    T extends IRequestAdapter = IRequestAdapter,
-    ResponseWrapper = unknown,
-  > {
-    activity: ActivityController<ResponseWrapper>
-  }
-}
-
-/**
- * @support core >= 4.3.0
- */
-export class ActivityController<ResponseWrapper> implements IController {
-  base = 'activity'
-  name = 'activity'
-
-  constructor(private client: HTTPClient) {
-    autoBind(this)
-  }
-
-  public get proxy(): IRequestHandler<ResponseWrapper> {
-    return this.client.proxy(this.base)
-  }
-
-  likeIt(type: 'Post' | 'Note', id: string) {
-    return this.proxy.like.post<never>({
-      data: {
-        type: type.toLowerCase(),
-        id,
-      },
-    })
-  }
-
-  /**
-   *
-   * @support core >= 5.0.0
-   */
-  getPresence(roomName: string) {
-    return this.proxy.presence.get<{
-      data: Record<string, ActivityPresence>
-      readers: Record<string, AuthUser>
-    }>({
-      params: {
-        room_name: roomName,
-      },
-    })
-  }
-
-  /**
-   *
-   * @support core >= 5.0.0
-   */
-  updatePresence({
-    identity,
-    position,
-    roomName,
-    sid,
-    ts,
-    displayName,
-    readerId,
-  }: {
-    roomName: string
-    position: number
-    identity: string
-    sid: string
-
-    displayName?: string
-    ts?: number
-    readerId?: string
-  }) {
-    return this.proxy.presence.update.post({
-      data: {
-        identity,
-        position,
-        ts: ts || Date.now(),
-        roomName,
-        sid,
-        readerId,
-        displayName,
-      },
-    })
-  }
-
-  async getRoomsInfo() {
-    return this.proxy.rooms.get<RoomsData>()
-  }
-
-  async getRecentActivities() {
-    return this.proxy.recent.get<RecentActivities>()
-  }
-
-  async getLastYearPublication(): Promise<LastYearPublication> {
-    return this.proxy(`last-year`).publication.get<LastYearPublication>()
-  }
-}

package/controllers/aggregate.ts

@@ -1,75 +0,0 @@
-import type { IRequestAdapter } from '~/interfaces/adapter'
-import type { IController } from '~/interfaces/controller'
-import type { SortOrder } from '~/interfaces/options'
-import type { IRequestHandler, RequestProxyResult } from '~/interfaces/request'
-import type {
-  AggregateRootWithTheme,
-  AggregateStat,
-  AggregateTop,
-  TimelineData,
-  TimelineType,
-} from '~/models/aggregate'
-import { sortOrderToNumber } from '~/utils'
-import { autoBind } from '~/utils/auto-bind'
-import type { HTTPClient } from '../core'
-
-declare module '../core/client' {
-  interface HTTPClient<
-    T extends IRequestAdapter = IRequestAdapter,
-    ResponseWrapper = unknown,
-  > {
-    aggregate: AggregateController<ResponseWrapper>
-  }
-}
-
-export class AggregateController<ResponseWrapper> implements IController {
-  base = 'aggregate'
-  name = 'aggregate'
-  constructor(private client: HTTPClient) {
-    autoBind(this)
-  }
-  public get proxy(): IRequestHandler<ResponseWrapper> {
-    return this.client.proxy(this.base)
-  }
-
-  /**
-   * 获取聚合数据
-   */
-  getAggregateData<Theme>(
-    theme?: string,
-  ): RequestProxyResult<AggregateRootWithTheme<Theme>, ResponseWrapper> {
-    return this.proxy.get<AggregateRootWithTheme<Theme>>({
-      params: {
-        theme,
-      },
-    })
-  }
-
-  /**
-   * 获取最新发布的内容
-   */
-  getTop(size = 5) {
-    return this.proxy.top.get<AggregateTop>({ params: { size } })
-  }
-
-  getTimeline(options?: {
-    sort?: SortOrder
-    type?: TimelineType
-    year?: number
-  }) {
-    const { sort, type, year } = options || {}
-    return this.proxy.timeline.get<{ data: TimelineData }>({
-      params: {
-        sort: sort && sortOrderToNumber(sort),
-        type,
-        year,
-      },
-    })
-  }
-  /**
-   * 获取聚合数据统计
-   */
-  getStat() {
-    return this.proxy.stat.get<AggregateStat>()
-  }
-}

package/controllers/ai.ts

@@ -1,70 +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'
-import type { AIDeepReadingModel, AISummaryModel } from '../models/ai'
-
-declare module '../core/client' {
-  interface HTTPClient<
-    T extends IRequestAdapter = IRequestAdapter,
-    ResponseWrapper = unknown,
-  > {
-    ai: AIController<ResponseWrapper>
-  }
-}
-
-/**
- * @support core >= 5.6.0
- */
-export class AIController<ResponseWrapper> implements IController {
-  base = 'ai'
-  name = 'ai'
-
-  constructor(private client: HTTPClient) {
-    autoBind(this)
-  }
-
-  public get proxy(): IRequestHandler<ResponseWrapper> {
-    return this.client.proxy(this.base)
-  }
-
-  async getSummary({
-    articleId,
-    lang = 'zh-CN',
-    onlyDb,
-  }: {
-    articleId: string
-    lang?: string
-    onlyDb?: boolean
-  }) {
-    return this.proxy.summaries.article(articleId).get<AISummaryModel>({
-      params: {
-        lang,
-        onlyDb,
-      },
-    })
-  }
-
-  async generateSummary(articleId: string, lang = 'zh-CN', token = '') {
-    return this.proxy.summaries.generate.post<AISummaryModel>({
-      params: {
-        token,
-      },
-      data: {
-        lang,
-        refId: articleId,
-      },
-    })
-  }
-
-  /**
-   * Core >= 8.3.0
-   * @param articleId
-   */
-  async getDeepReading(articleId: string) {
-    return this.proxy('deep-readings')
-      .article(articleId)
-      .get<AIDeepReadingModel>()
-  }
-}

package/controllers/base.ts

@@ -1,36 +0,0 @@
-import type { IRequestHandler, RequestProxyResult } from '~/interfaces/request'
-import type { PaginateResult } from '~/models/base'
-import { autoBind } from '~/utils/auto-bind'
-import type { HTTPClient } from '../core'
-
-export type SortOptions = {
-  sortBy?: string
-  sortOrder?: 1 | -1 | 'asc' | 'desc'
-}
-export abstract class BaseCrudController<T, ResponseWrapper> {
-  base!: string
-  constructor(protected client: HTTPClient) {
-    autoBind(this)
-  }
-  public get proxy(): IRequestHandler<ResponseWrapper> {
-    return this.client.proxy(this.base)
-  }
-
-  getById(id: string): RequestProxyResult<T, ResponseWrapper> {
-    return this.proxy(id).get<T>()
-  }
-
-  getAll() {
-    return this.proxy.all.get<{ data: T[] }>()
-  }
-  /**
-   * 带分页的查询
-   * @param page
-   * @param perPage
-   */
-  getAllPaginated(page?: number, perPage?: number, sortOption?: SortOptions) {
-    return this.proxy.get<PaginateResult<T>>({
-      params: { page, size: perPage, ...sortOption },
-    })
-  }
-}

package/controllers/category.ts

@@ -1,118 +0,0 @@
-import type { IRequestAdapter } from '~/interfaces/adapter'
-import type { IController } from '~/interfaces/controller'
-import type {
-  IRequestHandler,
-  RequestProxyResult,
-  ResponseProxyExtraRaw,
-} from '~/interfaces/request'
-import { attachRawFromOneToAnthor, destructureData } from '~/utils'
-import { autoBind } from '~/utils/auto-bind'
-import type { HTTPClient } from '../core/client'
-import { RequestError } from '../core/error'
-import type {
-  CategoryEntries,
-  CategoryModel,
-  CategoryWithChildrenModel,
-  TagModel,
-} from '../models/category'
-import { CategoryType } from '../models/category'
-import type { PostModel } from '../models/post'
-
-declare module '../core/client' {
-  interface HTTPClient<
-    T extends IRequestAdapter = IRequestAdapter,
-    ResponseWrapper = unknown,
-  > {
-    category: CategoryController<ResponseWrapper>
-  }
-}
-
-export class CategoryController<ResponseWrapper> implements IController {
-  name = 'category'
-  base = 'categories'
-  constructor(private client: HTTPClient) {
-    autoBind(this)
-  }
-
-  public get proxy(): IRequestHandler<ResponseWrapper> {
-    return this.client.proxy(this.base)
-  }
-
-  getAllCategories(): RequestProxyResult<
-    { data: CategoryModel[] },
-    ResponseWrapper
-  > {
-    return this.proxy.get({
-      params: {
-        type: CategoryType.Category,
-      },
-    })
-  }
-
-  getAllTags(): RequestProxyResult<{ data: TagModel[] }, ResponseWrapper> {
-    return this.proxy.get<{ data: TagModel[] }>({
-      params: {
-        type: CategoryType.Tag,
-      },
-    })
-  }
-
-  async getCategoryDetail(
-    id: string,
-  ): Promise<ResponseProxyExtraRaw<CategoryWithChildrenModel>>
-  async getCategoryDetail(
-    ids: string[],
-  ): Promise<ResponseProxyExtraRaw<Map<string, CategoryWithChildrenModel>>>
-  async getCategoryDetail(ids: string | string[]): Promise<any> {
-    if (typeof ids === 'string') {
-      const data = await this.proxy.get<CategoryEntries>({
-        params: {
-          ids,
-        },
-      })
-      const result = Object.values(data.entries)[0]
-      attachRawFromOneToAnthor(data, result)
-      return result
-    } else if (Array.isArray(ids)) {
-      const data = await this.proxy.get<CategoryEntries>({
-        params: {
-          ids: ids.join(','),
-        },
-      })
-      const entries = data?.entries
-      if (!entries) {
-        throw new RequestError(
-          'data structure error',
-          500,
-          data.$request.path,
-          data,
-        )
-      }
-
-      const map = new Map<string, CategoryWithChildrenModel>(
-        Object.entries(entries).map(([id, value]) => [id.toLowerCase(), value]),
-      )
-
-      attachRawFromOneToAnthor(data, map)
-      return map
-    }
-  }
-
-  async getCategoryByIdOrSlug(idOrSlug: string) {
-    const res = await this.proxy(idOrSlug).get<CategoryWithChildrenModel>()
-    return destructureData(res) as typeof res
-  }
-
-  async getTagByName(name: string) {
-    const res = await this.proxy(name).get<{
-      tag: string
-      data: Pick<PostModel, 'id' | 'title' | 'slug' | 'category' | 'created'>[]
-    }>({
-      params: {
-        tag: 1,
-      },
-    })
-
-    return res
-  }
-}

package/controllers/comment.ts

@@ -1,71 +0,0 @@
-import type { IRequestAdapter } from '~/interfaces/adapter'
-import type { IController } from '~/interfaces/controller'
-import type { PaginationParams } from '~/interfaces/params'
-import type { IRequestHandler } from '~/interfaces/request'
-import type { ReaderModel } from '~/models'
-import type { PaginateResult } from '~/models/base'
-import type { CommentModel } from '~/models/comment'
-import { autoBind } from '~/utils/auto-bind'
-import type { HTTPClient } from '../core'
-import type { CommentDto } from '../dtos/comment'
-
-declare module '../core/client' {
-  interface HTTPClient<
-    T extends IRequestAdapter = IRequestAdapter,
-    ResponseWrapper = unknown,
-  > {
-    comment: CommentController<ResponseWrapper>
-  }
-}
-
-export class CommentController<ResponseWrapper> implements IController {
-  base = 'comments'
-  name = 'comment'
-
-  constructor(private readonly client: HTTPClient) {
-    autoBind(this)
-  }
-
-  get proxy(): IRequestHandler<ResponseWrapper> {
-    return this.client.proxy(this.base)
-  }
-
-  /**
-   * 根据 comment id 获取评论，包括子评论
-   */
-  getById(id: string) {
-    return this.proxy(id).get<CommentModel & { ref: string }>()
-  }
-
-  /**
-   * 获取文章的评论列表
-   * @param refId 文章 Id
-   */
-  getByRefId(refId: string, pagination: PaginationParams = {}) {
-    const { page, size } = pagination
-    return this.proxy.ref(refId).get<
-      PaginateResult<CommentModel & { ref: string }> & {
-        readers: Record<string, ReaderModel>
-      }
-    >({
-      params: { page: page || 1, size: size || 10 },
-    })
-  }
-  /**
-   * 评论
-   */
-  comment(refId: string, data: CommentDto) {
-    return this.proxy(refId).post<CommentModel>({
-      data,
-    })
-  }
-
-  /**
-   * 回复评论
-   */
-  reply(commentId: string, data: CommentDto) {
-    return this.proxy.reply(commentId).post<CommentModel>({
-      data,
-    })
-  }
-}

package/controllers/index.ts

@@ -1,97 +0,0 @@
-import { AckController } from './ack'
-import { ActivityController } from './activity'
-import { AggregateController } from './aggregate'
-import { AIController } from './ai'
-import { CategoryController } from './category'
-import { CommentController } from './comment'
-import { LinkController } from './link'
-import { NoteController } from './note'
-import { PageController } from './page'
-import { PostController } from './post'
-import { ProjectController } from './project'
-import {
-  RecentlyAttitudeEnum,
-  RecentlyAttitudeResultEnum,
-  RecentlyController,
-} from './recently'
-import { SayController } from './say'
-import { SearchController } from './search'
-import { ServerlessController } from './severless'
-import { SnippetController } from './snippet'
-import { SubscribeController } from './subscribe'
-import { TopicController } from './topic'
-import { UserController } from './user'
-
-export const allControllers = [
-  AckController,
-  ActivityController,
-  AggregateController,
-  AIController,
-  CategoryController,
-  CommentController,
-  LinkController,
-  NoteController,
-  PageController,
-  PostController,
-  ProjectController,
-  RecentlyController,
-  SayController,
-  SearchController,
-  ServerlessController,
-  SnippetController,
-  SubscribeController,
-  TopicController,
-  UserController,
-]
-
-export const allControllerNames = [
-  'ai',
-  'ack',
-  'activity',
-  'aggregate',
-  'category',
-  'comment',
-  'link',
-  'note',
-  'page',
-  'post',
-  'project',
-  'topic',
-  'recently',
-  'say',
-  'search',
-  'snippet',
-  'serverless',
-  'subscribe',
-  'user',
-
-  // alias,
-  'friend',
-  'master',
-  'shorthand',
-] as const
-
-export {
-  AckController,
-  ActivityController,
-  AggregateController,
-  AIController,
-  CategoryController,
-  CommentController,
-  LinkController,
-  NoteController,
-  PageController,
-  PostController,
-  ProjectController,
-  // Enum
-  RecentlyAttitudeEnum,
-  RecentlyAttitudeResultEnum,
-  RecentlyController,
-  SayController,
-  SearchController,
-  ServerlessController,
-  SnippetController,
-  SubscribeController,
-  TopicController,
-  UserController,
-}

package/controllers/link.ts

@@ -1,46 +0,0 @@
-import type { IRequestAdapter } from '~/interfaces/adapter'
-import type { LinkModel } from '~/models/link'
-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,
-  > {
-    link: LinkController<ResponseWrapper>
-    friend: LinkController<ResponseWrapper>
-  }
-}
-
-export class LinkController<ResponseWrapper> extends BaseCrudController<
-  LinkModel,
-  ResponseWrapper
-> {
-  constructor(protected readonly client: HTTPClient) {
-    super(client)
-    autoBind(this)
-  }
-
-  // 是否可以申请友链
-  async canApplyLink() {
-    const { can } = await this.proxy.audit.get<{ can: boolean }>()
-    return can
-  }
-
-  // 申请友链
-  async applyLink(
-    data: Pick<
-      LinkModel,
-      'avatar' | 'name' | 'description' | 'url' | 'email'
-    > & {
-      author: string
-    },
-  ) {
-    return await this.proxy.audit.post<never>({ data })
-  }
-
-  name = ['link', 'friend']
-  base = 'links'
-}