Store

A store of records.

class Store<R extends UnknownRecord = UnknownRecord, Props = unknown> {}

Constructs a new instance of the Store class

{
  schema: StoreSchema<R, Props>
  initialData?: SerializedStore<R>
  id?: string
  props: Props
}

Properties

Get an array of all values in the store.

allRecords: () => R[]

Removes all records from the store.

clear: () => void

Create a computed cache.

createComputedCache: <Result, Record extends R = R>(
  name: string,
  derive: (record: Record) => Result | undefined,
  isEqual?: ((a: Record, b: Record) => boolean) | undefined
) => ComputedCache<Result, Record>

Create a computed cache from a selector

createSelectedComputedCache: <Selection, Result, Record extends R = R>(
  name: string,
  selector: (record: Record) => Selection | undefined,
  derive: (input: Selection) => Result | undefined
) => ComputedCache<Result, Record>

Get the value of a store record by its id.

get: <K extends IdOf<R>>(id: K) => RecordFromId<K> | undefined

Get whether the record store has a id.

has: <K extends IdOf<R>>(id: K) => boolean

An atom containing the store's history.

readonly history: Atom<number, RecordsDiff<R>>

The random id of the store.

readonly id: string

Add a new listener to the store.

listen: (
  onHistory: StoreListener<R>,
  filters?: Partial<StoreListenerFilters>
) => () => void

Merge changes from a remote source without triggering listeners.

mergeRemoteChanges: (fn: () => void) => void

readonly props: Props

Add some records to the store. It's an error if they already exist.

put: (records: R[], phaseOverride?: 'initialize') => void

A StoreQueries instance for this store.

readonly query: StoreQueries<R>

Remove some records from the store via their ids.

remove: (ids: IdOf<R>[]) => void

readonly schema: StoreSchema<R, Props>

readonly scopedTypes: {
  readonly [K in RecordScope]: ReadonlySet<R['typeName']>
}

Creates a JSON payload from the record store.

serialize: (scope?: 'all' | RecordScope) => SerializedStore<R>

readonly sideEffects: StoreSideEffects<R>

Get the value of a store record by its id without updating its epoch.

unsafeGetWithoutCapture: <K extends IdOf<R>>(
  id: K
) => RecordFromId<K> | undefined

Update a record. To update multiple records at once, use the update method of the TypedStore class.

update: <K extends IdOf<R>>(
  id: K,
  updater: (record: RecordFromId<K>) => RecordFromId<K>
) => void

Methods

applyDiff(
  diff: RecordsDiff<R>,
  {
    runCallbacks,
    ignoreEphemeralKeys,
  }?: {
    ignoreEphemeralKeys?: boolean
    runCallbacks?: boolean
  }
): void

RecordsDiff<R>

{
  ignoreEphemeralKeys?: boolean
  runCallbacks?: boolean
}

void

dispose(): void

Run fn and return a RecordsDiff of the changes that occurred as a result.

extractingChanges(fn: () => void): RecordsDiff<R>

() => void

RecordsDiff<R>

Filters out non-document changes from a diff. Returns null if there are no changes left.

filterChangesByScope(
  change: RecordsDiff<R>,
  scope: RecordScope
): {
  added: { [K in IdOf<R>]: R }
  removed: { [K in IdOf<R>]: R }
  updated: { [K_1 in IdOf<R>]: [from: R, to: R] }
} | null

RecordsDiff<R>

RecordScope

{
  added: { [K in IdOf<R>]: R }
  removed: { [K in IdOf<R>]: R }
  updated: { [K_1 in IdOf<R>]: [from: R, to: R] }
} | null

getSnapshot(scope?: 'all' | RecordScope): StoreSnapshot<R>

'all' | RecordScope

StoreSnapshot<R>

Get a serialized snapshot of the store and its schema.

const snapshot = store.getStoreSnapshot()
store.loadStoreSnapshot(snapshot)

getStoreSnapshot(scope?: 'all' | RecordScope): StoreSnapshot<R>

'all' | RecordScope

StoreSnapshot<R>

loadSnapshot(snapshot: StoreSnapshot<R>): void

StoreSnapshot<R>

void

Load a serialized snapshot.

const snapshot = store.getStoreSnapshot()
store.loadStoreSnapshot(snapshot)

loadStoreSnapshot(snapshot: StoreSnapshot<R>): void

StoreSnapshot<R>

void

Migrate a serialized snapshot of the store and its schema.

const snapshot = store.getSnapshot()
store.migrateSnapshot(snapshot)

migrateSnapshot(snapshot: StoreSnapshot<R>): StoreSnapshot<R>

StoreSnapshot<R>

StoreSnapshot<R>

validate(
  phase: 'createRecord' | 'initialize' | 'tests' | 'updateRecord'
): void

  | 'createRecord'
  | 'initialize'
  | 'tests'
  | 'updateRecord'

void