logseq/libs/src/modules/LSPlugin.Request.ts

import { LSPluginUser, WithOptional } from '../LSPlugin.user'
import { EventEmitter } from 'eventemitter3'

export type IRequestOptions<R = any> = {
  url: string
  abortable: boolean
  headers: Record<string, string>
  method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'
  data: Object | ArrayBuffer
  timeout: number
  returnType: 'json' | 'text' | 'base64' | 'arraybuffer'
  success: (result: R) => void
  fail: (err: any) => void
  final: () => void
}

export type RequestTaskID = string | number

const CLIENT_MSG_CALLBACK = '#lsp#request#callback'
const genTaskCallbackType = (id: RequestTaskID) => `task_callback_${id}`

/**
 * Request task
 */
export class LSPluginRequestTask<R = any> {
  private readonly _promise: Promise<R>
  private _aborted: boolean = false

  constructor(
    private _client: LSPluginRequest,
    private _requestId: RequestTaskID,
    private _requestOptions: Partial<IRequestOptions> = {}
  ) {
    this._promise = new Promise<any>((resolve, reject) => {
      if (!this._requestId) {
        return reject(null)
      }

      // task result listener
      this._client.once(genTaskCallbackType(this._requestId), (e) => {
        if (e && e instanceof Error) {
          reject(e)
        } else {
          resolve(e)
        }
      })
    })

    const { success, fail, final } = this._requestOptions

    this._promise
      .then((res) => {
        success?.(res)
      })
      .catch((e) => {
        fail?.(e)
      })
      .finally(() => {
        final?.()
      })
  }

  abort() {
    if (!this._requestOptions.abortable || this._aborted) return

    this._client.ctx._execCallableAPI('http_request_abort', this._requestId)

    this._aborted = true
  }

  get promise(): Promise<R> {
    return this._promise
  }

  get client(): LSPluginRequest {
    return this._client
  }

  get requestId(): RequestTaskID {
    return this._requestId
  }
}

/**
 * A simple request client
 */
export class LSPluginRequest extends EventEmitter {
  constructor(private _ctx: LSPluginUser) {
    super()

    // request callback listener
    this.ctx.caller.on(CLIENT_MSG_CALLBACK, (e: any) => {
      const reqId = e?.requestId
      if (!reqId) return

      this.emit(genTaskCallbackType(reqId), e?.payload)
    })
  }

  static createRequestTask(
    client: LSPluginRequest,
    requestID: RequestTaskID,
    requestOptions: Partial<IRequestOptions>
  ) {
    return new LSPluginRequestTask(client, requestID, requestOptions)
  }

  async _request<
    R extends {},
    T extends WithOptional<
      IRequestOptions<R>,
      keyof Omit<IRequestOptions, 'url'>
    >
  >(
    options: T
  ): Promise<
    T extends Pick<IRequestOptions, 'abortable'> ? LSPluginRequestTask<R> : R
  > {
    const pid = this.ctx.baseInfo.id
    const { success, fail, final, ...requestOptions } = options
    const reqID = this.ctx.Experiments.invokeExperMethod(
      'request',
      pid,
      requestOptions
    )

    const task = LSPluginRequest.createRequestTask(
      this.ctx.Request,
      reqID,
      options
    )

    if (!requestOptions.abortable) {
      return task.promise
    }

    return task as any
  }

  get ctx(): LSPluginUser {
    return this._ctx
  }
}