clientHelpers.go.tmpl

{{define "clientHelpers"}}
{{- $webrpcErrors := .WebrpcErrors -}}
{{- $schemaErrors := .SchemaErrors -}}
{{- $opts := .Opts -}}
const createHTTPRequest = (body: object = {}, headers: object = {}, signal: AbortSignal | null = null): object => {
  const reqHeaders: {[key: string]: string} = { ...headers, 'Content-Type': 'application/json' }
  {{- if eq $opts.webrpcHeader true }}
  reqHeaders[WebrpcHeader] = WebrpcHeaderValue
  {{- end }}

  return {
    method: 'POST',
    headers: reqHeaders,
    body: JSON.stringify(body || {}),
    signal
  }
}

const buildResponse = (res: Response): Promise<any> => {
  return res.text().then(text => {
    let data
    try {
      data = JSON.parse(text)
    } catch(error) {
      let message = ''
      if (error instanceof Error)  {
        message = error.message
      }
      throw WebrpcBadResponseError.new({
        status: res.status,
        cause: `JSON.parse(): ${message}: response text: ${text}`},
      )
    }
    if (!res.ok) {
      const code: number = (typeof data.code === 'number') ? data.code : 0
      throw (webrpcErrorByCode[code] || WebrpcError).new(data)
    }
    return data
  })
}

//
// Errors
//

export class WebrpcError extends Error {
  name: string
  code: number
  message: string
  status: number
  cause?: string

  /** @deprecated Use message instead of msg. Deprecated in webrpc v0.11.0. */
  msg: string

  constructor(name: string, code: number, message: string, status: number, cause?: string) {
    super(message)
    this.name = name || 'WebrpcError'
    this.code = typeof code === 'number' ? code : 0
    this.message = message || `endpoint error ${this.code}`
    this.msg = this.message
    this.status = typeof status === 'number' ? status : 0
    this.cause = cause
    Object.setPrototypeOf(this, WebrpcError.prototype)
  }

  static new(payload: any): WebrpcError {
    return new this(payload.error, payload.code, payload.message || payload.msg, payload.status, payload.cause)
  }
}

// Webrpc errors
{{ range $_, $error := $webrpcErrors}}
export class {{$error.Name}}Error extends WebrpcError {
  constructor(
    name: string = '{{$error.Name}}',
    code: number = {{$error.Code}},
    message: string = `{{$error.Message}}`,
    status: number = 0,
    cause?: string
  ) {
    super(name, code, message, status, cause)
    Object.setPrototypeOf(this, {{$error.Name}}Error.prototype)
  }
}
{{ end }}

// Schema errors
{{ range $_, $error := $schemaErrors}}
export class {{$error.Name}}Error extends WebrpcError {
  constructor(
    name: string = '{{$error.Name}}',
    code: number = {{$error.Code}},
    message: string = `{{$error.Message}}`,
    status: number = 0,
    cause?: string
  ) {
    super(name, code, message, status, cause)
    Object.setPrototypeOf(this, {{$error.Name}}Error.prototype)
  }
}
{{ end }}

export enum errors {
{{- range $_, $error := $webrpcErrors}}
  {{$error.Name}} = '{{$error.Name}}',
{{- end}}
{{- range $_, $error := $schemaErrors}}
  {{$error.Name}} = '{{$error.Name}}',
{{- end}}
}

export enum WebrpcErrorCodes {
{{- range $_, $error := $webrpcErrors}}
  {{$error.Name}} = {{$error.Code}},
{{- end }}
{{- range $_, $error := $schemaErrors}}
  {{$error.Name}} = {{$error.Code}},
{{- end }}
}

export const webrpcErrorByCode: { [code: number]: any } = {
{{- range $_, $error := $webrpcErrors}}
  [{{$error.Code}}]: {{$error.Name}}Error,
{{- end }}
{{- range $_, $error := $schemaErrors}}
  [{{$error.Code}}]: {{$error.Name}}Error,
{{- end }}
}

export type Fetch = (input: RequestInfo, init?: RequestInit) => Promise<Response>
{{if $opts.streaming}}
export interface WebrpcStreamOptions<T> extends WebrpcOptions {
  onMessage: (message: T) => void;
  onError: (error: WebrpcError, reconnect: () => void) => void;
  onOpen?: () => void;
  onClose?: () => void;
}

export interface WebrpcOptions {
  headers?: HeadersInit;
  signal?: AbortSignal;
}

export interface WebrpcStreamController {
  abort: (reason?: any) => void;
  closed: Promise<void>;
}
{{end}}
{{end}}