Class ValtheraMemory

_collections

_plugins

adapter

emitter

executor

options

version

add

• add<T = Data>(query: Add<T>): Promise<T>

  Add data to a database.

  Type Parameters

  • T = Data

  Parameters

  • query: Add<T>

  Returns Promise<T>

bulkAdd

• bulkAdd<T = Data>(query: BulkAdd<T>): Promise<T[]>

  Type Parameters

  • T = Data

  Parameters

  • query: BulkAdd<T>

  Returns Promise<T[]>

c

• c<T = Data>(collection: string): Collection<T>

  Create a new instance of a Collection class.

  Type Parameters

  • T = Data

  Parameters

  • collection: string

  Returns Collection<T>

close

• close(...args: any[]): Promise<any>

  Parameters

  • ...args: any[]

  Returns Promise<any>

count

• count(query: Count): Promise<number>

  Parameters

  • query: Count

  Returns Promise<number>

createIndex

• createIndex(
      collection: string,
      fields: string[],
      opts?: IndexOpts,
  ): Promise<void>

  Create an index on a collection.

  Parameters

  • collection: string
  • fields: string[]
  • Optionalopts: IndexOpts

  Returns Promise<void>

ensureCollection

• ensureCollection(collection: string): Promise<boolean>

  Check and create the specified collection if it doesn't exist.

  Parameters

  • collection: string

  Returns Promise<boolean>

execute

• execute<T>(
      name: keyof ValtheraCompatible,
      query: string | VQuery<any, true>,
      txHandle?: TransactionHandle,
  ): Promise<T>

  Type Parameters

  • T

  Parameters

  • name: keyof ValtheraCompatible
  • query: string | VQuery<any, true>
  • OptionaltxHandle: TransactionHandle

  Returns Promise<T>

find

• find<T = Data>(query: Find<T>): Promise<T[]>

  Find data in a database.

  Type Parameters

  • T = Data

  Parameters

  • query: Find<T>

  Returns Promise<T[]>

findOne

• findOne<T = Data>(query: FindOne<T>): Promise<T | null>

  Find one data entry in a database.

  Type Parameters

  • T = Data

  Parameters

  • query: FindOne<T>

  Returns Promise<T | null>

getCollections

• getCollections(): Promise<string[]>

  Get the names of all available databases.

  Returns Promise<string[]>

init

• init(...args: any[]): Promise<any>

  Parameters

  • ...args: any[]

  Returns Promise<any>

issetCollection

• issetCollection(collection: string): Promise<boolean>

  Check if a collection exists.

  Parameters

  • collection: string

  Returns Promise<boolean>

plugin

• plugin(p: ValtheraPlugin, collections?: string | string[]): () => void

  Parameters

  • p: ValtheraPlugin
  • Optionalcollections: string | string[]

  Returns () => void

remove

• remove<T = Data>(query: Remove<T>): Promise<T[]>

  Remove data from a database.

  Type Parameters

  • T = Data

  Parameters

  • query: Remove<T>

  Returns Promise<T[]>

removeCollection

• removeCollection(collection: string): Promise<boolean>

  Removes a database collection from the database.

  Parameters

  • collection: string

  Returns Promise<boolean>

removeIndex

• removeIndex(collection: string, fields: string[]): Promise<void>

  Remove an index from a collection. Adapter-dependent.

  Parameters

  • collection: string
  • fields: string[]

  Returns Promise<void>

removeOne

• removeOne<T = Data>(query: Remove<T>): Promise<T | null>

  Remove one data entry from a database.

  Type Parameters

  • T = Data

  Parameters

  • query: Remove<T>

  Returns Promise<T | null>

toggleOne

• toggleOne<T = Data>(query: ToggleOne<T>): Promise<ToggleOneResult<T>>

  Asynchronously removes one entry in a database or adds a new one if it doesn't exist. Usage e.g. for toggling a flag.

  Type Parameters

  • T = Data

  Parameters

  • query: ToggleOne<T>

  Returns Promise<ToggleOneResult<T>>

transaction

• transaction<T>(
      collections: string[],
      fn: (tx: Transaction) => Promise<T>,
  ): Promise<T>
  Experimental

  Executes operations within a transaction. Automatically rolls back on error.

  Receives a transaction-scoped object (tx) whose operations are executed within the transaction context.

  This feature is highly experimental and may change or be removed at any time.

  • Transaction support depends on the adapter implementation.
  • Collections must be declared upfront to ensure proper locking.
  • Operations invoked via the original db reference are NOT part of the transaction.

  Type Parameters

  • T

  Parameters

  • collections: string[]
  • fn: (tx: Transaction) => Promise<T>

  Returns Promise<T>

update

• update<T = Data>(query: Update<T>): Promise<T[]>

  Update data in a database.

  Type Parameters

  • T = Data

  Parameters

  • query: Update<T>

  Returns Promise<T[]>

updateOne

• updateOne<T = Data>(query: Update<T>): Promise<T | null>

  Update one data entry in a database.

  Type Parameters

  • T = Data

  Parameters

  • query: Update<T>

  Returns Promise<T | null>

updateOneOrAdd

• updateOneOrAdd<T = Data>(
      query: VQueryT.UpdateOneOrAdd<T>,
  ): Promise<UpdateOneOrAddResult<T>>

  Asynchronously updates one entry in a database or adds a new one if it doesn't exist.

  Type Parameters

  • T = Data

  Parameters

  • query: VQueryT.UpdateOneOrAdd<T>

  Returns Promise<UpdateOneOrAddResult<T>>