Class Slice<T>

constructor

• new Slice<T extends Meta = any>(slice: string | number, api: Api): Slice<T>

  An object to aid in constructing requests

  Type Parameters

  • T extends Meta = any

  Parameters

  • slice: string | number

    Slice ID to interact with
  • api: Api

    Api to send the requests through

  Returns Slice<T>

cache$

Optionalunsubscribe

cache

• get cache(): T[]

  Cached slice data

  Returns T[]
• set cache(cache: T[]): void

  Set cached data & alert subscribers

  Parameters

  • cache: T[]

  Returns void

offlineEnabled

• get offlineEnabled(): undefined | boolean

  Is slice offline support enabled

  Returns undefined | boolean

count

• count(arg?: string | object): ApiCall<T>

  Count the returned rows

  Parameters

  • arg: string | object = 'id'

    Count argument

  Returns ApiCall<T>

delete

• delete(id: number | number[]): ApiCall<T>

  Set the request type to delete

  Parameters

  • id: number | number[]

    ID(s) to delete

  Returns ApiCall<T>

getInfo

• getInfo(reload?: boolean): Promise<SliceInfo>

  Get slice information

  Parameters

  • Optionalreload: boolean

    Ignore cache & reload info

  Returns Promise<SliceInfo>

insert

• insert(rows: T | T[]): ApiCall<T>

  Set the request type to insert

  Parameters

  • rows: T | T[]

    Rows to be inserted into the slice

  Returns ApiCall<T>

pushChanges

• pushChanges(): Promise<void>

  Returns Promise<void>

save

• save(rows: T | T[]): ApiCall<T>

  Save multiple rows to the slice, automatically inserts/updates

  Parameters

  • rows: T | T[]

    Rows to add to slice

  Returns ApiCall<T>

select

• select(id?: number | number[]): ApiCall<T>

  Set the request type to select

  Parameters

  • Optionalid: number | number[]

    ID(s) to select, leaving blank will return all rows

  Returns ApiCall<T>

sync

• sync(on?: boolean): undefined | BehaviorSubject<T[]>

  Synchronize cache with server

  Parameters

  • on: boolean = true

    Enable/disable events

  Returns undefined | BehaviorSubject<T[]>

  Cache which can be subscribed to

  Example

  const slice: Slice = new Slice<T>(Slices.Contact);
  slice.sync().subscribe((rows: T[]) => {});
  Copy

update

• update(rows: T | T[]): ApiCall<T>

  Set the request type to update

  Parameters

  • rows: T | T[]

    Rows to be updated, each row must have an ID

  Returns ApiCall<T>