Class Slice<T>

constructor

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

  An object to aid in constructing requests

  Type Parameters

  • T = any

  Parameters

  • slice: string | number

    Slice ID to interact with
  • api: Api

    Api to send the requests through

  Returns Slice<T>

alias

const id: {id: number, field2: any}[] = await new Slice<T>(12345)
		.select().alias({id: 'id', field1: 'field2'}).exec().keys();
Copy

Optionaldebugging

Optionalunsubscribe

Staticapi

raw

• get raw(): Partial<{ $pop: undefined | string; [key: string]: any }>

  Get raw API request

  Returns Partial<{ $pop: undefined | string; [key: string]: any }>

and

• and(): Slice<T>

  Add an 'AND' condition inside the where argument

  Returns Slice<T>

  Example

  const rows: T[] = await new Slice<T>(12345).select()
                  .where('field1', '>', 1)
                  .and()
                  .where({field2: 2, field3: 3})
                  .exec().rows();
  Copy

count

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

  Count the returned rows

  Parameters

  • arg: string | object = 'id'

    Count argument

  Returns Slice<T>

  Example

  const count = await new Slice(12345).count()
  					.where({field1: 1})
  					.exec().count();
  Copy

debug

• debug(enabled?: boolean): Slice<T>

  Output the formed request to the console for inspection

  Parameters

  • enabled: boolean = true

    Enable/Disable console logging

  Returns Slice<T>

delete

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

  Set the request type to delete

  Parameters

  • Optionalid: number | number[]

    ID(s) to delete

  Returns Slice<T>

  Example

  await new Slice(12345).delete(id).exec();
  Copy

excel

• excel(formula: string): Slice<T>

  Filter rows from slice based on an excel expression

  Parameters

  • formula: string

    Excel formula to use as where clause

  Returns Slice<T>

  Example

  const rows: T[] = await new Slice<T>(12345).select()
                  .excel('contains({property}, foobar)')
                  .exec().rows();
  Copy

exec

• exec<T = any>(options?: ApiRequestOptions): Promise<T>

  Compile the request and send it

  Type Parameters

  • T = any

  Parameters

  • Optionaloptions: ApiRequestOptions

    API Request options

  Returns Promise<T>

  API response

fields

• fields(whitelist: string[]): Slice<T>

  Whitelist fields by passing an array of keys or alias fields by using a map

  Parameters

  • whitelist: string[]

    Either a list of keys to whitelist or a map of keys to rename

  Returns Slice<T>

  Example

  const id: {id: number, field1: any}[] = await new Slice<T>(12345)
  		.select().fields(['id', 'field1']).exec().keys();
  Copy

• fields(alias: { [key: string]: string | object }): Slice<T>

  Whitelist fields by passing an array of keys or alias fields by using a map

  Parameters

  • alias: { [key: string]: string | object }

  Returns Slice<T>

  Example

  const id: {id: number, field1: any}[] = await new Slice<T>(12345)
  		.select().fields(['id', 'field1']).exec().keys();
  Copy

id

• id(): Slice<T>

  Unwrap response returning the first ID

  Returns Slice<T>

insert

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

  Set the request type to insert

  Parameters

  • rows: T | T[]

    Rows to be inserted into the slice

  Returns Slice<T>

  Example

  const id: number = await new Slice<T>(12345).insert([
  		{field1: 1},
  		{field1: 2}
  ]).exec().keys();
  Copy

limit

• limit(num: number): Slice<T>

  Limit number of rows returned

  Parameters

  • num: number

    Number of rows to return

  Returns Slice<T>

  Example

  const rows: T[] = await new Slice<T>(12345).select().limit(10)
                  .exec().rows();
  Copy

or

• or(): Slice<T>

  Add an 'OR' condition inside the where argument

  Returns Slice<T>

  Example

  const rows: T[] = await new Slice<T>(12345).select()
                  .where('field1', '>', 1)
                  .or()
                  .where({field2: 2, field3: 3})
                  .or()
                  .where(['$gt', ['$field', field4], 4)
                  .exec().rows();
  Copy

order

• order(field: string, ascending?: boolean): Slice<T>

  Order rows by a field

  Parameters

  • field: string

    property name
  • ascending: boolean = true

    Sort in ascending or descending order

  Returns Slice<T>

  Example

  const rows: T[] = new Slice<T>(12345).select().order('field1', true) // true = ascending
  					.exec().rows();
  Copy

pop

• pop(field: null | string): Slice<T>

  Unwrap response, returning the field

  Parameters

  • field: null | string

    Colon seperated path: rows:0

  Returns Slice<T>

row

• row(): Slice<T>

  Unwrap response returning the first row

  Returns Slice<T>

rows

• rows(): Slice<T>

  Unwrap response returning the rows

  Returns Slice<T>

select

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

  Set the request type to select

  Parameters

  • Optionalid: number | number[]

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

  Returns Slice<T>

  Example

  const rows: T[] = new Slice<T>(12345).select().exec().rows();
  const row: T = new Slice<T>(12345).select(id).exec().row();
  Copy

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[]): Slice<T>

  Set the request type to update

  Parameters

  • rows: T | T[]

    Rows to be updated, each row must have an ID

  Returns Slice<T>

  Example

  const ids: number[] = await new Slice<Type>(12345).update([
  		{id: 1, field1: 1},
  		{id: 2, field1: 1}
  ]).exec().keys();
  Copy

where

• where(field: string | object, operator?: string, value?: any): Slice<T>

  Add where condition to request

  Parameters

  • field: string | object

    property to compare or a map of equality comparisons
  • Optionaloperator: string

    Operation to compare with. Accepts JS operators (>=, ==, !=, ...) as well as datalynk styax ($gte, $eq, $is, $not, ...)
  • Optionalvalue: any

    value to compare against

  Returns Slice<T>

  Example

  const rows: T[] = await new Slice<T>(12345).select()
                  .where('field1', '>', 1)
                  .where({field2: 2, field3: 3}) // Automatic AND
                  .or()
                  .where(['$gt', ['$field', field4], 4)
                  .exec().rows();
  Copy