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

StaticidMap

StaticnextId

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

  Whether this slice has local IndexedDB/offline support enabled.

  Offline-enabled slices can fall back to their local cache when either the browser loses network connectivity or the Datalynk client enters an unavailable recovery state after a returned server/API failure.

  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 the local slice cache with the server and subscribe to socket changes.

  For an offline-enabled slice, synchronization failures caused by network or API unavailability are contained in the background rather than becoming unhandled promise rejections. Local cached data remains usable while the Api recovery loop determines when the failed API path works again. When the client becomes online again, pending local changes are scheduled for upload without overlapping push operations.

  Calling sync(false) unsubscribes from slice socket events.

  Parameters

  • on: boolean = true

    Enable or disable synchronization/socket events.

  Returns undefined | BehaviorSubject<T[]>

  The observable local cache when synchronization is enabled.

  Example

  const slice: Slice = new Slice<T>(Slices.Contact);
  const rows$ = slice.sync();
  rows$?.subscribe((rows: T[]) => console.log(rows));
  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>