Class PublitApiRequest<T>

constructor

• new PublitApiRequest<T>(
      resource: string,
      options?: ApiRequestOptions,
  ): PublitApiRequest<T>

  Type Parameters

  • T

  Parameters

  • resource: string

    Resource endpoint for this request
  • options: ApiRequestOptions = {}

    Options for this request instance

  Returns PublitApiRequest<T>

options

requestInit

Optionalresponse

StaticdefaultOptions

url

• get url(): URL

  Returns URL

• set url(url: string | URL): void

  Parameters

  • url: string | URL

  Returns void

auxiliary

• auxiliary(attribute: keyof T): PublitApiRequest<T>

  Load attributes defined by the resource but not part of the model

  request.auxiliary('measurements')
  Copy

  Parameters

  • attribute: keyof T

    The attribute to filter on

  Returns PublitApiRequest<T>

count

• count(): Promise<ApiCountResponse<T>>

  Returns Promise<ApiCountResponse<T>>

debug

• debug(): PublitApiRequest<T>

  Returns PublitApiRequest<T>

delete

• delete(id: string): Promise<T>

  Deletes a single resource on the specified endpoint

  Parameters

  • id: string

  Returns Promise<T>

fetch

• fetch<T2 = T>(): Promise<T2>

  Performs the actual fetch request

  Type Parameters

  • T2 = T

  Returns Promise<T2>

groupBy

• groupBy<A extends string | number | symbol>(attribute: A): PublitApiRequest<T>

  Group results by a given attribute

  request.groupBy('work_id')
  Copy

  Type Parameters

  • A extends string | number | symbol

  Parameters

  • attribute: A

  Returns PublitApiRequest<T>

has

• has<R extends string | number | symbol>(
      relation: R,
      attribute?: string,
      operator?: Operator,
      value?: string | string[],
      combinator?: Combinator,
  ): PublitApiRequest<T>

  Allows for filtering through relations

  request.filter('authors', 'name', 'LIKE', 'John')
  request.filter('authors', 'name', 'LIKE', ['John', 'Doe'])
  request.filter('authors', 'name', 'LIKE', 'John', 'AND')
  request.filter('authors', 'name', 'EQUAL', 'John', 'AND')
  Copy

  Type Parameters

  • R extends string | number | symbol

  Parameters

  • relation: R

    The relation to filter on
  • Optionalattribute: string

    The attribute to filter on
  • Optionaloperator: Operator

    Operator to use for filtering
  • Optionalvalue: string | string[]

    Value to filter on
  • combinator: Combinator = 'OR'

    Combinator for any further has filters

  Returns PublitApiRequest<T>

index

• index(): Promise<ApiListResponse<T>>

  Lists all available resources on the specified endpoint

  Returns Promise<ApiListResponse<T>>

limit

• limit(limit: number, offset?: number): PublitApiRequest<T>

  Limit the number of results returned

  Usage:

  request.limit(10)
  request.limit(10, 20)
  Copy

  Parameters

  • limit: number

    Number of result to return
  • Optionaloffset: number

    Starting offset

  Returns PublitApiRequest<T>

only

• only(...attributes: (keyof T)[]): PublitApiRequest<T>

  Specify a subset of attributes to return in the response

  request.only('name', 'description')
  Copy

  Parameters

  • ...attributes: (keyof T)[]

  Returns PublitApiRequest<T>

orderBy

• orderBy(attribute: keyof T, direction?: "ASC" | "DESC"): PublitApiRequest<T>

  Order results by a given attribute

  request.orderBy('name', 'ASC')
  request.orderBy('name', 'DESC')
  Copy

  Parameters

  • attribute: keyof T

    The attribute to order by
  • Optionaldirection: "ASC" | "DESC"

    Direction to order by

  Returns PublitApiRequest<T>

scope

• scope(method: string, qualifier?: string): PublitApiRequest<T>

  Allows for filtering through pre defined scopes, if any

  request.scope('published')
  Copy

  Parameters

  • method: string
  • Optionalqualifier: string

  Returns PublitApiRequest<T>

setPayload

• setPayload(payload: unknown): void

  Parameters

  • payload: unknown

  Returns void

show

• show(id?: string): Promise<T>

  Retrieves a single resource from the specified endpoint

  Parameters

  • Optionalid: string

  Returns Promise<T>

store

• store<StoreT = T>(payload?: unknown): Promise<StoreT>

  Creates a new resource on the specified endpoint

  Type Parameters

  • StoreT = T

  Parameters

  • Optionalpayload: unknown

  Returns Promise<StoreT>

update

• update(id: string, payload?: unknown): Promise<T>

  Updates a single resource on the specified endpoint

  Parameters

  • id: string
  • Optionalpayload: unknown

  Returns Promise<T>

where

• where(
      attribute: string,
      operator: Operator,
      value: string | string[],
      combinator?: Combinator,
  ): PublitApiRequest<T>

  Allows for filtering on attributes on the requested object

  request.where('name', 'LIKE', 'John')
  request.where('name', 'LIKE', ['John', 'Doe'])
  request.where('name', 'LIKE', 'John', 'AND')
  request.where('name', 'EQUAL', 'John', 'AND')
  Copy

  Parameters

  • attribute: string

    The attribute to filter on
  • operator: Operator

    Operator to use for filtering
  • value: string | string[]

    Value to filter on
  • combinator: Combinator = 'OR'

    Combinator for any further where filters

  Returns PublitApiRequest<T>

with

• with(relation: string): PublitApiRequest<T>

  Load relations for the requested object

  E.g. .with('authors') or a deeper nested relation .with('authors.name'), which will load parent relations as well.

  request.with('authors')
  request.with('authors.works')
  Copy

  Parameters

  • relation: string

  Returns PublitApiRequest<T>

StaticfromUrl

• fromUrl<T>(url: string | URL): PublitApiRequest<T>

  Create a new ApiRequest from a given URL

  PublitApiRequest.fromUrl("https://api.publit.com/publishing/v2.0/works/1")
  Copy

  Type Parameters

  • T

  Parameters

  • url: string | URL

  Returns PublitApiRequest<T>