Query Builder

const builder = client.queryBuilder();

builder.collection(name: string)

builder.find(callback: (builder: ConditionBuilder) => LogicalOperator | LogicalOperator[])

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.sortBy(field: string, direction?: 'asc' | 'desc' | 'ASC' | 'DESC')

builder.take(count: number)   // Alias for limit()
builder.skip(count: number)   // Alias for offset()

builder.includeHistory(include?: boolean)

builder.groupBy(field: string)

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

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

interface QueryResponse<T = any> {
  records: T[];   // Array of matching records
  total?: number; // Total number of matching records (before pagination)
  error?: string; // Error message if query partially failed
}

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

const record = await builder.executeUnique<T>();
// Returns T | null

const result = await builder.executeWithPayment<T>(quoteId, paymentProof, network?);

const request = builder.getQueryRequest();

const raw = builder.buildRawQuery();

const cloned = builder.clone();

const valid = builder.isValid();

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<T>(field: string);

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

const stats = await builder.runAggregate({
  total:        { '$count': '*' },
  totalLikes:   { '$sum': 'likes' },
  avgLikes:     { '$avg': 'likes' },
  maxLikes:     { '$max': 'likes' },
  minLikes:     { '$min': 'likes' },
  uniqueAuthors: { '$countDistinct': 'author_id' }
});
// Returns: { total: 4, totalLikes: 203, avgLikes: 50.75, maxLikes: 67, minLikes: 38, uniqueAuthors: 2 }

count(): Promise<Record<string, number>>

sumBy(field: string): Promise<Record<string, number>>

avgBy(field: string): Promise<Record<string, number>>

maxBy<T = any>(field: string): Promise<Record<string, T>>

minBy<T = any>(field: string): Promise<Record<string, T>>

run(spec: AggregateSpec): Promise<Record<string, any>[]>

const rows = await builder.groupBy('category').run({
  total:    { '$count': '*' },
  revenue:  { '$sum': 'amount' },
  avgOrder: { '$avg': 'amount' }
});
// Returns: [{ category: 'electronics', total: 12, revenue: 5000, avgOrder: 416.67 }, ...]

const salesByCategory = await builder.groupBy('category').sumBy('amount');
// { "electronics": 5000, "clothing": 3000 }

const countByStatus = await builder.groupBy('status').count();
// { "active": 42, "inactive": 8 }

const avgByRegion = await builder.groupBy('user.country').avgBy('orderTotal');
// { "US": 89.50, "UK": 72.30, "DE": 95.10 }

const highestByDept = await builder.groupBy('department').maxBy('salary');
// { "engineering": 250000, "marketing": 180000 }

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

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

.in(values)
.notIn(values)

.isTrue()
.isFalse()

.isNull()
.isNotNull()
.exists()
.notExists()

.isLocalIp()
.isExternalIp()
.inCountry(countryCode)
.cidr(cidrRange)          // CIDR range check (string or string[])

.b64(value)              // Base64 matching
.inDataset(values)       // Case-sensitive membership check (string[])
.keywords(keywords)      // Case-insensitive substring match against multiple keywords (string[])

// Records created after a specific date
builder.whereField('createdAt').greaterThanOrEqual('2024-10-01T00:00:00Z')

// Records within a date range (use find() for multiple conditions on the same field)
builder.find(b => [
  b.field('createdAt').greaterThanOrEqual('2024-10-01'),
  b.field('createdAt').lessThanOrEqual('2024-12-31'),
])

// Records created this month
const startOfMonth = new Date(new Date().getFullYear(), new Date().getMonth(), 1).toISOString();
builder.whereField('createdAt').greaterThanOrEqual(startOfMonth)

joinBuilder.onField(field: string)

joinBuilder.on(callback: (builder: ConditionBuilder) => LogicalOperator | LogicalOperator[])

joinBuilder.selectFields(fields: string[])

joinBuilder.selectAll()

builder
  .joinMany('tweets', 'tweets')
    .onField('address').equals('$data.address')
    .selectAll()
    .joinOne('profile', 'profiles')
      .onField('user_id').equals('$data.author')
      .selectFields(['bio', 'avatar'])
      .build()
    .build()
  .execute();

joinBuilder.build()

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

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

// Chaining methods
condition.and(...moreConditions)
condition.or(...moreConditions)
condition.not(...moreConditions)

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

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

SelectionBuilder.all();  // Select all