Query Builder

const builder = client.queryBuilder();

builder.collection(name: string)

builder.find(callback: (builder: FindBuilder) => LogicalExpression)

builder.whereField(field: string)

builder.select(callback: (selection: SelectionBuilder) => SelectionBuilder)

builder.selectFields(fields: string[])

builder.selectAll()

builder.limit(count: number)

builder.offset(count: number)

builder.orderBy(field: string, direction?: 'asc' | 'desc')

builder.groupBy(field: string)

builder.joinOne(alias: string, collection: string)

builder.joinMany(alias: string, collection: string)

const result = await builder.execute<T>();

const record = await builder.executeUnique<T>();

const request = builder.getQueryRequest();

const count = await builder.count();

const sum = await builder.sumBy(field: string);

const avg = await builder.avgBy(field: string);

const min = await builder.minBy<T>(field: string);

const max = await builder.maxBy<T>(field: string);

const values = await builder.distinctBy(field: string);

const count = await builder.countDistinct(field: string);

.equals(value)
.notEquals(value)
.greaterThan(value)
.lessThan(value)
.greaterThanOrEqual(value)
.lessThanOrEqual(value)
.between(min, max)
.notBetween(min, max)

.contains(value)
.startsWith(value)
.endsWith(value)
.regExpMatches(pattern)
.includesCaseInsensitive(value)
.startsWithCaseInsensitive(value)
.endsWithCaseInsensitive(value)
.wildcard(pattern)
.glob(pattern)

.dateEquals(date)
.dateBefore(date)
.dateAfter(date)
.dateBetween(start, end)
.dateToday()
.dateThisWeek()
.dateThisMonth()
.dateThisYear()

.in(values)
.notIn(values)
.arrayLength(length)
.arrayContains(value)
.arrayNotContains(value)

.isTrue()
.isFalse()

.isNull()
.isNotNull()
.exists()
.notExists()
.isEmpty()
.isNotEmpty()

.isString()
.isNumber()
.isBoolean()
.isArray()
.isObject()

.geoWithinRadius(lat, lng, radius)
.geoWithinBounds(ne, sw)
.inCountry(code)

joinBuilder.onField(field: string)

joinBuilder.selectFields(fields: string[])

joinBuilder.selectAll()

joinBuilder.build()

.equals(value)       // Use '$data.fieldname' to reference parent
.in(values)
.greaterThan(value)
.lessThan(value)
.isNull()
.isNotNull()

import { LogicalOperator } from '@onchaindb/sdk';

LogicalOperator.And([...conditions])
LogicalOperator.Or([...conditions])
LogicalOperator.Not(condition)
LogicalOperator.Condition(fieldCondition)

import { SelectionBuilder } from '@onchaindb/sdk';

new SelectionBuilder()
  .field('name')
  .fields(['id', 'email'])
  .nested('profile', nested => nested.field('bio'))
  .excludeFields(['password'])
  .build();

SelectionBuilder.all();  // Select all