Class RethinkDBStore

constructor

• new RethinkDBStore(options?: RethinkDBStoreOptions): RethinkDBStore

  Parameters

  • options: RethinkDBStoreOptions = {}

  Returns RethinkDBStore

Readonlyname

Readonlylibrary

connect

• connect(): Promise<void>

  Returns Promise<void>

disconnect

• disconnect(): Promise<void>

  Returns Promise<void>

isConnected

• isConnected(): boolean

  Returns boolean

getClient

• getClient(): unknown

  Returns the underlying rethinkdb-ts term-builder (r).

  Returns unknown

insert

• insert<T = any>(
      table: string,
      doc: Record<string, unknown> | Record<string, unknown>[],
  ): Promise<T>

  Insert a document (or array of documents) into table.

  Type Parameters

  • T = any

  Parameters

  • table: string
  • doc: Record<string, unknown> | Record<string, unknown>[]

  Returns Promise<T>

get

• get<T = any>(table: string, id: unknown): Promise<T | null>

  Fetch a single document from table by its primary key. Resolves to null if not found.

  Type Parameters

  • T = any

  Parameters

  • table: string
  • id: unknown

  Returns Promise<T | null>

update

• update<T = any>(
      table: string,
      id: unknown,
      patch: Record<string, unknown>,
  ): Promise<T>

  Partially update the document with primary key id in table, merging patch.

  Type Parameters

  • T = any

  Parameters

  • table: string
  • id: unknown
  • patch: Record<string, unknown>

  Returns Promise<T>

delete

• delete<T = any>(table: string, id: unknown): Promise<T>

  Delete the document with primary key id from table.

  Type Parameters

  • T = any

  Parameters

  • table: string
  • id: unknown

  Returns Promise<T>

filter

• filter<T = any>(table: string, predicate: unknown): Promise<T[]>

  Return all documents in table matching predicate as an array. predicate is any ReQL filter argument - a match object ({ active: true }) or a predicate function (row => row('age').gt(18)). The result is materialized (cursor drained to an array) before returning.

  Type Parameters

  • T = any

  Parameters

  • table: string
  • predicate: unknown

  Returns Promise<T[]>

findAll

• findAll<T = any>(
      table: string,
      where?: Record<string | symbol, unknown>,
      options?: RethinkFindOptions,
  ): Promise<T[]>

  Fetch all documents in table matching an ORM where clause, with optional ordering, offset, and limit. The where object accepts the full ORM operator surface (Op.gt, Op.in, Op.like, Op.and/Op.or, ...), translated to a native ReQL filter predicate - so standard queries never require hand-written ReQL.

  Type Parameters

  • T = any

  Parameters

  • table: string
  • where: Record<string | symbol, unknown> = {}
  • options: RethinkFindOptions = {}

  Returns Promise<T[]>

findOne

• findOne<T = any>(
      table: string,
      where?: Record<string | symbol, unknown>,
      options?: Omit<RethinkFindOptions, "limit">,
  ): Promise<T | null>

  Fetch the first document in table matching an ORM where clause (respecting order), or null.

  Type Parameters

  • T = any

  Parameters

  • table: string
  • where: Record<string | symbol, unknown> = {}
  • options: Omit<RethinkFindOptions, "limit"> = {}

  Returns Promise<T | null>

count

• count(table: string, where?: Record<string | symbol, unknown>): Promise<number>

  Count documents in table matching an ORM where clause.

  Parameters

  • table: string
  • where: Record<string | symbol, unknown> = {}

  Returns Promise<number>

updateWhere

• updateWhere<T = any>(
      table: string,
      where: Record<string | symbol, unknown>,
      patch: Record<string, unknown>,
  ): Promise<T>

  Update every document in table matching an ORM where clause, merging patch.

  Type Parameters

  • T = any

  Parameters

  • table: string
  • where: Record<string | symbol, unknown>
  • patch: Record<string, unknown>

  Returns Promise<T>

deleteWhere

• deleteWhere<T = any>(
      table: string,
      where: Record<string | symbol, unknown>,
  ): Promise<T>

  Delete every document in table matching an ORM where clause.

  Type Parameters

  • T = any

  Parameters

  • table: string
  • where: Record<string | symbol, unknown>

  Returns Promise<T>

upsert

• upsert<T = any>(
      table: string,
      doc: Record<string, unknown> | Record<string, unknown>[],
      conflict?: "replace" | "update",
  ): Promise<T>

  Insert doc, updating (or replacing) the existing row on a primary-key conflict - RethinkDB's native upsert via insert(..., { conflict }).

  Type Parameters

  • T = any

  Parameters

  • table: string
  • doc: Record<string, unknown> | Record<string, unknown>[]
  • conflict: "replace" | "update" = 'update'

  Returns Promise<T>

distinct

• distinct<T = any>(table: string, field?: string, index?: string): Promise<T[]>

  Distinct values of field across table (optionally over a secondary index).

  Type Parameters

  • T = any

  Parameters

  • table: string
  • Optionalfield: string
  • Optionalindex: string

  Returns Promise<T[]>

getAll

• getAll<T = any>(table: string, keys: unknown[], index?: string): Promise<T[]>

  Fetch documents whose key (or secondary-index value) is one of keys.

  Type Parameters

  • T = any

  Parameters

  • table: string
  • keys: unknown[]
  • Optionalindex: string

  Returns Promise<T[]>

aggregate

• aggregate(
      table: string,
      options?: RethinkAggregateOptions,
  ): Promise<Record<string, unknown>[]>

  Grouped aggregation over table using ReQL's native group/reduction chain (count/sum/avg/min/max), with an optional ORM where pre-filter. Returns one entry per group: { group, ...aggregates }.

  Parameters

  • table: string
  • options: RethinkAggregateOptions = {}

  Returns Promise<Record<string, unknown>[]>

indexCreate

• indexCreate<T = any>(
      table: string,
      name: string,
      indexer?: unknown,
      options?: Record<string, unknown>,
  ): Promise<T>

  Create a secondary index on table. indexer may be a field name, list of fields (compound), or a ReQL function.

  Type Parameters

  • T = any

  Parameters

  • table: string
  • name: string
  • Optionalindexer: unknown
  • Optionaloptions: Record<string, unknown>

  Returns Promise<T>

indexDrop

• indexDrop<T = any>(table: string, name: string): Promise<T>

  Drop a secondary index from table.

  Type Parameters

  • T = any

  Parameters

  • table: string
  • name: string

  Returns Promise<T>

indexList

• indexList(table: string): Promise<string[]>

  List secondary index names on table.

  Parameters

  • table: string

  Returns Promise<string[]>

indexWait

• indexWait<T = any>(table: string, ...names: string[]): Promise<T>

  Wait for one or all secondary indexes on table to finish building.

  Type Parameters

  • T = any

  Parameters

  • table: string
  • ...names: string[]

  Returns Promise<T>

createTable

• createTable<T = any>(dbOrName: string, name?: string): Promise<T>

  Create a table. Pass a single name to create it in the connection's default database, or (db, name) to create it in a specific database.

  Type Parameters

  • T = any

  Parameters

  • dbOrName: string
  • Optionalname: string

  Returns Promise<T>

dropTable

• dropTable<T = any>(dbOrName: string, name?: string): Promise<T>

  Drop a table. Pass a single name, or (db, name) for a specific database.

  Type Parameters

  • T = any

  Parameters

  • dbOrName: string
  • Optionalname: string

  Returns Promise<T>

listTables

• listTables(db?: string): Promise<string[]>

  List tables in the default (or given) database.

  Parameters

  • Optionaldb: string

  Returns Promise<string[]>

createDatabase

• createDatabase<T = any>(name: string): Promise<T>

  Create a database.

  Type Parameters

  • T = any

  Parameters

  • name: string

  Returns Promise<T>

dropDatabase

• dropDatabase<T = any>(name: string): Promise<T>

  Drop a database.

  Type Parameters

  • T = any

  Parameters

  • name: string

  Returns Promise<T>

listDatabases

• listDatabases(): Promise<string[]>

  List all databases.

  Returns Promise<string[]>

withTransaction

• withTransaction<T>(_fn: (store: this) => Promise<T>): Promise<never>

  RethinkDB has no multi-document transactions. Single-document writes are atomic, and updateWhere/deleteWhere apply atomically per document, but there is no way to commit changes across documents/tables as a unit. This throws a clear, typed capability error rather than silently pretending to provide isolation.

  Type Parameters

  • T

  Parameters

  • _fn: (store: this) => Promise<T>

  Returns Promise<never>

run

• run<T = any>(query: any): Promise<T>

  Run an arbitrary ReQL query term (built from getClient()), for operations not wrapped here. In single-connection mode the store's connection is supplied to .run() automatically.

  Type Parameters

  • T = any

  Parameters

  • query: any

  Returns Promise<T>