Class ApiCall<T>

constructor

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

  Type Parameters

  • T extends Meta = any

  Parameters

  • api: Api
  • slice: string | number

  Returns ApiCall<T>

alias

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

Optionaldebugging

Readonlyslice

raw

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

  Get raw API request

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

and

• and(): this

  Add an 'AND' condition inside the where argument

  Returns this

  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): this

  Count the returned rows

  Parameters

  • arg: string | object = 'id'

    Count argument

  Returns this

  Example

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

debug

• debug(enabled?: boolean): this

  Output the formed request to the console for inspection

  Parameters

  • enabled: boolean = true

    Enable/Disable console logging

  Returns this

delete

• delete(id?: number | number[]): this

  Set the request type to delete

  Parameters

  • Optionalid: number | number[]

    ID(s) to delete

  Returns this

  Example

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

excel

• excel(formula: string): this

  Filter rows from slice based on an excel expression

  Parameters

  • formula: string

    Excel formula to use as where clause

  Returns this

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

  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 this

  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 }): this

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

  Parameters

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

  Returns this

  Example

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

id

• id(): this

  Unwrap response returning the first ID

  Returns this

insert

• insert(rows: T | T[]): this

  Set the request type to insert

  Parameters

  • rows: T | T[]

    Rows to be inserted into the slice

  Returns this

  Example

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

limit

• limit(num: number): this

  Limit number of rows returned

  Parameters

  • num: number

    Number of rows to return

  Returns this

  Example

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

or

• or(): ApiCall<T>

  Add an 'OR' condition inside the where argument

  Returns ApiCall<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): this

  Order rows by a field

  Parameters

  • field: string

    property name
  • ascending: boolean = true

    Sort in ascending or descending order

  Returns this

  Example

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

pop

• pop(field: null | string): this

  Unwrap response, returning the field

  Parameters

  • field: null | string

    Colon seperated path: rows:0

  Returns this

row

• row(): this

  Unwrap response returning the first row

  Returns this

rows

• rows(): this

  Unwrap response returning the rows

  Returns this

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

  Set the request type to select

  Parameters

  • Optionalid: number | number[]

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

  Returns this

  Example

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

update

• update(rows: T | T[]): this

  Set the request type to update

  Parameters

  • rows: T | T[]

    Rows to be updated, each row must have an ID

  Returns this

  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): this

  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 this

  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