📄 tanstack/db/latest/docs/reference/interfaces/collection
File: collection.md | Updated: 11/15/2025
Source: https://tanstack.com/db/latest/docs/reference/interfaces/Collection
Search...
+ K
Auto
Docs Examples GitHub Contributors
Docs Examples GitHub Contributors
Docs Examples GitHub Contributors
Docs Examples Github Contributors
Docs Examples Github Contributors
Docs Examples Github Contributors
Docs Examples Github Contributors
Docs Examples Github Contributors
Maintainers Partners Support Learn StatsBETA Discord Merch Blog GitHub Ethos Brand Guide
Documentation
Framework
React
Version
Latest
Search...
+ K
Menu
Getting Started
Guides
Collections
Frameworks
Community
API Reference
Framework
React
Version
Latest
Menu
Getting Started
Guides
Collections
Frameworks
Community
API Reference
On this page
Collection
Copy Markdown
Defined in: packages/db/src/collection/index.ts:48
Enhanced Collection interface that includes both data type T and utilities TUtils
- CollectionImpl <T, TKey, TUtils, TSchema, TInsertInput>
Type Parameters
---------------
### T
T extends object = Record<string, unknown>
The type of items in the collection
TKey extends string | number = string | number
The type of the key for the collection
TUtils extends UtilsRecord = UtilsRecord
The utilities record type
TSchema extends StandardSchemaV1 = StandardSchemaV1
TInsertInput extends object = T
The type for insert operations (can be different from T for schemas with defaults)
Properties
----------
### _lifecycle
ts
_lifecycle: CollectionLifecycleManager<T, TKey, TSchema, TInsertInput>;
_lifecycle: CollectionLifecycleManager<T, TKey, TSchema, TInsertInput>;
Defined in: packages/db/src/collection/index.ts:220
ts
_state: CollectionStateManager<T, TKey, TSchema, TInsertInput>;
_state: CollectionStateManager<T, TKey, TSchema, TInsertInput>;
Defined in: packages/db/src/collection/index.ts:232
ts
_sync: CollectionSyncManager<T, TKey, TSchema, TInsertInput>;
_sync: CollectionSyncManager<T, TKey, TSchema, TInsertInput>;
Defined in: packages/db/src/collection/index.ts:221
ts
config: CollectionConfig<T, TKey, TSchema>;
config: CollectionConfig<T, TKey, TSchema>;
Defined in: packages/db/src/collection/index.ts:211
ts
id: string;
id: string;
Defined in: packages/db/src/collection/index.ts:210
ts
readonly optional singleResult: true;
readonly optional singleResult: true;
Defined in: packages/db/src/collection/index.ts:56
ts
readonly utils: TUtils;
readonly utils: TUtils;
Defined in: packages/db/src/collection/index.ts:55
Accessors
---------
### compareOptions
#### Get Signature
ts
get compareOptions(): StringCollationConfig;
get compareOptions(): StringCollationConfig;
Defined in: packages/db/src/collection/index.ts:516
CollectionImpl .compareOptions
### indexes #### Get Signature
ts
get indexes(): Map<number, BaseIndex<TKey>>;
get indexes(): Map<number, BaseIndex<TKey>>;
Defined in: packages/db/src/collection/index.ts:501
Get resolved indexes for query optimization
Map<number, BaseIndex <TKey>>
### isLoadingSubset #### Get Signature
ts
get isLoadingSubset(): boolean;
get isLoadingSubset(): boolean;
Defined in: packages/db/src/collection/index.ts:367
Check if the collection is currently loading more data
boolean
true if the collection has pending load more operations, false otherwise
CollectionImpl .isLoadingSubset
ts
get size(): number;
get size(): number;
Defined in: packages/db/src/collection/index.ts:404
Get the current size of the collection (cached)
number
ts
get state(): Map<TKey, TOutput>;
get state(): Map<TKey, TOutput>;
Defined in: packages/db/src/collection/index.ts:693
Gets the current state of the collection as a Map
ts
const itemsMap = collection.state
console.log(`Collection has ${itemsMap.size} items`)
for (const [key, item] of itemsMap) {
console.log(`${key}: ${item.title}`)
}
// Check if specific item exists
if (itemsMap.has("todo-1")) {
console.log("Todo 1 exists:", itemsMap.get("todo-1"))
}
const itemsMap = collection.state
console.log(`Collection has ${itemsMap.size} items`)
for (const [key, item] of itemsMap) {
console.log(`${key}: ${item.title}`)
}
// Check if specific item exists
if (itemsMap.has("todo-1")) {
console.log("Todo 1 exists:", itemsMap.get("todo-1"))
}
Map<TKey, TOutput>
Map containing all items in the collection, with keys as identifiers
ts
get status(): CollectionStatus;
get status(): CollectionStatus;
Defined in: packages/db/src/collection/index.ts:322
Gets the current status of the collection
### subscriberCount #### Get Signature
ts
get subscriberCount(): number;
get subscriberCount(): number;
Defined in: packages/db/src/collection/index.ts:329
Get the number of subscribers to the collection
number
CollectionImpl .subscriberCount
### toArray #### Get Signature
ts
get toArray(): TOutput[];
get toArray(): TOutput[];
Defined in: packages/db/src/collection/index.ts:722
Gets the current state of the collection as an Array
TOutput[]
An Array containing all items in the collection
Methods
-------
### [iterator]()
ts
iterator: IterableIterator<[TKey, T]>;
iterator: IterableIterator<[TKey, T]>;
Defined in: packages/db/src/collection/index.ts:432
Get all entries (virtual derived state)
IterableIterator<[TKey, T]>
ts
cleanup(): Promise<void>;
cleanup(): Promise<void>;
Defined in: packages/db/src/collection/index.ts:856
Clean up the collection by stopping sync and clearing data This can be called manually or automatically by garbage collection
Promise<void>
ts
createIndex<TResolver>(indexCallback, config): IndexProxy<TKey>;
createIndex<TResolver>(indexCallback, config): IndexProxy<TKey>;
Defined in: packages/db/src/collection/index.ts:491
Creates an index on a collection for faster queries. Indexes significantly improve query performance by allowing constant time lookups and logarithmic time range queries instead of full scans.
#### Type Parameters ##### TResolver
TResolver extends IndexResolver <TKey> = typeof BTreeIndex
The type of the index resolver (constructor or async loader)
#### Parameters ##### indexCallback
(row) => any
Function that extracts the indexed value from each item
IndexOptions <TResolver> = {}
Configuration including index type and type-specific options
IndexProxy <TKey>
An index proxy that provides access to the index when ready
ts
// Create a default B+ tree index
const ageIndex = collection.createIndex((row) => row.age)
// Create a ordered index with custom options
const ageIndex = collection.createIndex((row) => row.age, {
indexType: BTreeIndex,
options: {
compareFn: customComparator,
compareOptions: { direction: 'asc', nulls: 'first', stringSort: 'lexical' }
},
name: 'age_btree'
})
// Create an async-loaded index
const textIndex = collection.createIndex((row) => row.content, {
indexType: async () => {
const { FullTextIndex } = await import('./indexes/fulltext.js')
return FullTextIndex
},
options: { language: 'en' }
})
// Create a default B+ tree index
const ageIndex = collection.createIndex((row) => row.age)
// Create a ordered index with custom options
const ageIndex = collection.createIndex((row) => row.age, {
indexType: BTreeIndex,
options: {
compareFn: customComparator,
compareOptions: { direction: 'asc', nulls: 'first', stringSort: 'lexical' }
},
name: 'age_btree'
})
// Create an async-loaded index
const textIndex = collection.createIndex((row) => row.content, {
indexType: async () => {
const { FullTextIndex } = await import('./indexes/fulltext.js')
return FullTextIndex
},
options: { language: 'en' }
})
ts
currentStateAsChanges(options):
| void
| ChangeMessage<T, string | number>[];
currentStateAsChanges(options):
| void
| ChangeMessage<T, string | number>[];
Defined in: packages/db/src/collection/index.ts:760
Returns the current state of the collection as an array of changes
CurrentStateAsChangesOptions = {}
Options including optional where filter
| void | ChangeMessage <T, string | number>[]
An array of changes
ts
// Get all items as changes
const allChanges = collection.currentStateAsChanges()
// Get only items matching a condition
const activeChanges = collection.currentStateAsChanges({
where: (row) => row.status === 'active'
})
// Get only items using a pre-compiled expression
const activeChanges = collection.currentStateAsChanges({
whereExpression: eq(row.status, 'active')
})
// Get all items as changes
const allChanges = collection.currentStateAsChanges()
// Get only items matching a condition
const activeChanges = collection.currentStateAsChanges({
where: (row) => row.status === 'active'
})
// Get only items using a pre-compiled expression
const activeChanges = collection.currentStateAsChanges({
whereExpression: eq(row.status, 'active')
})
CollectionImpl .currentStateAsChanges
ts
delete(keys, config?): Transaction<any>;
delete(keys, config?): Transaction<any>;
Defined in: packages/db/src/collection/index.ts:670
Deletes one or more items from the collection
Single key or array of keys to delete
TKey | TKey[]
Optional configuration including metadata
Transaction <any>
A Transaction object representing the delete operation(s)
ts
// Delete a single item
const tx = collection.delete("todo-1")
await tx.isPersisted.promise
// Delete a single item
const tx = collection.delete("todo-1")
await tx.isPersisted.promise
ts
// Delete multiple items
const tx = collection.delete(["todo-1", "todo-2"])
await tx.isPersisted.promise
// Delete multiple items
const tx = collection.delete(["todo-1", "todo-2"])
await tx.isPersisted.promise
ts
// Delete with metadata
const tx = collection.delete("todo-1", { metadata: { reason: "completed" } })
await tx.isPersisted.promise
// Delete with metadata
const tx = collection.delete("todo-1", { metadata: { reason: "completed" } })
await tx.isPersisted.promise
ts
// Handle errors
try {
const tx = collection.delete("item-1")
await tx.isPersisted.promise
console.log('Delete successful')
} catch (error) {
console.log('Delete failed:', error)
}
// Handle errors
try {
const tx = collection.delete("item-1")
await tx.isPersisted.promise
console.log('Delete successful')
} catch (error) {
console.log('Delete failed:', error)
}
ts
entries(): IterableIterator<[TKey, T]>;
entries(): IterableIterator<[TKey, T]>;
Defined in: packages/db/src/collection/index.ts:425
Get all entries (virtual derived state)
IterableIterator<[TKey, T]>
ts
forEach(callbackfn): void;
forEach(callbackfn): void;
Defined in: packages/db/src/collection/index.ts:439
Execute a callback for each entry in the collection
#### Parameters ##### callbackfn
(value, key, index) => void
void
ts
get(key): T | undefined;
get(key): T | undefined;
Defined in: packages/db/src/collection/index.ts:390
Get the current value for a key (virtual derived state)
TKey
T | undefined
ts
getKeyFromItem(item): TKey;
getKeyFromItem(item): TKey;
Defined in: packages/db/src/collection/index.ts:454
T
TKey
CollectionImpl .getKeyFromItem
ts
has(key): boolean;
has(key): boolean;
Defined in: packages/db/src/collection/index.ts:397
Check if a key exists in the collection (virtual derived state)
TKey
boolean
ts
insert(data, config?):
| Transaction<Record<string, unknown>>
| Transaction<T>;
insert(data, config?):
| Transaction<Record<string, unknown>>
| Transaction<T>;
Defined in: packages/db/src/collection/index.ts:557
Inserts one or more items into the collection
TInsertInput | TInsertInput[]
Optional configuration including metadata
| Transaction <Record<string, unknown>> | Transaction <T>
A Transaction object representing the insert operation(s)
If the data fails schema validation
ts
// Insert a single todo (requires onInsert handler)
const tx = collection.insert({ id: "1", text: "Buy milk", completed: false })
await tx.isPersisted.promise
// Insert a single todo (requires onInsert handler)
const tx = collection.insert({ id: "1", text: "Buy milk", completed: false })
await tx.isPersisted.promise
ts
// Insert multiple todos at once
const tx = collection.insert([\
{ id: "1", text: "Buy milk", completed: false },\
{ id: "2", text: "Walk dog", completed: true }\
])
await tx.isPersisted.promise
// Insert multiple todos at once
const tx = collection.insert([\
{ id: "1", text: "Buy milk", completed: false },\
{ id: "2", text: "Walk dog", completed: true }\
])
await tx.isPersisted.promise
ts
// Insert with metadata
const tx = collection.insert({ id: "1", text: "Buy groceries" },
{ metadata: { source: "mobile-app" } }
)
await tx.isPersisted.promise
// Insert with metadata
const tx = collection.insert({ id: "1", text: "Buy groceries" },
{ metadata: { source: "mobile-app" } }
)
await tx.isPersisted.promise
ts
// Handle errors
try {
const tx = collection.insert({ id: "1", text: "New item" })
await tx.isPersisted.promise
console.log('Insert successful')
} catch (error) {
console.log('Insert failed:', error)
}
// Handle errors
try {
const tx = collection.insert({ id: "1", text: "New item" })
await tx.isPersisted.promise
console.log('Insert successful')
} catch (error) {
console.log('Insert failed:', error)
}
ts
isReady(): boolean;
isReady(): boolean;
Defined in: packages/db/src/collection/index.ts:359
Check if the collection is ready for use Returns true if the collection has been marked as ready by its sync implementation
boolean
true if the collection is ready, false otherwise
ts
if (collection.isReady()) {
console.log('Collection is ready, data is available')
// Safe to access collection.state
} else {
console.log('Collection is still loading')
}
if (collection.isReady()) {
console.log('Collection is ready, data is available')
// Safe to access collection.state
} else {
console.log('Collection is still loading')
}
ts
keys(): IterableIterator<TKey>;
keys(): IterableIterator<TKey>;
Defined in: packages/db/src/collection/index.ts:411
Get all keys (virtual derived state)
IterableIterator<TKey>
ts
map<U>(callbackfn): U[];
map<U>(callbackfn): U[];
Defined in: packages/db/src/collection/index.ts:448
Create a new array with the results of calling a function for each entry in the collection
U
#### Parameters ##### callbackfn
(value, key, index) => U
U[]
ts
off<T>(event, callback): void;
off<T>(event, callback): void;
Defined in: packages/db/src/collection/index.ts:835
Unsubscribe from a collection event
T extends | "status:idle" | "status:loading" | "status:ready" | "status:error" | "status:cleaned-up" | "status:change" | "subscribers:change" | "loadingSubset:change"
T
CollectionEventHandler<T>
void
ts
on<T>(event, callback): () => void;
on<T>(event, callback): () => void;
Defined in: packages/db/src/collection/index.ts:815
Subscribe to a collection event
T extends | "status:idle" | "status:loading" | "status:ready" | "status:error" | "status:cleaned-up" | "status:change" | "subscribers:change" | "loadingSubset:change"
T
CollectionEventHandler<T>
ts
(): void;
(): void;
void
ts
once<T>(event, callback): () => void;
once<T>(event, callback): () => void;
Defined in: packages/db/src/collection/index.ts:825
Subscribe to a collection event once
T extends | "status:idle" | "status:loading" | "status:ready" | "status:error" | "status:cleaned-up" | "status:change" | "subscribers:change" | "loadingSubset:change"
T
CollectionEventHandler<T>
ts
(): void;
(): void;
void
ts
onFirstReady(callback): void;
onFirstReady(callback): void;
Defined in: packages/db/src/collection/index.ts:343
Register a callback to be executed when the collection first becomes ready Useful for preloading collections
#### Parameters ##### callback
() => void
Function to call when the collection first becomes ready
void
ts
collection.onFirstReady(() => {
console.log('Collection is ready for the first time')
// Safe to access collection.state now
})
collection.onFirstReady(() => {
console.log('Collection is ready for the first time')
// Safe to access collection.state now
})
ts
preload(): Promise<void>;
preload(): Promise<void>;
Defined in: packages/db/src/collection/index.ts:383
Preload the collection data by starting sync if not already started Multiple concurrent calls will share the same promise
Promise<void>
ts
startSyncImmediate(): void;
startSyncImmediate(): void;
Defined in: packages/db/src/collection/index.ts:375
Start sync immediately - internal method for compiled queries This bypasses lazy loading for special cases like live query results
void
CollectionImpl .startSyncImmediate
ts
stateWhenReady(): Promise<Map<TKey, T>>;
stateWhenReady(): Promise<Map<TKey, T>>;
Defined in: packages/db/src/collection/index.ts:707
Gets the current state of the collection as a Map, but only resolves when data is available Waits for the first sync commit to complete before resolving
Promise<Map<TKey, T>>
Promise that resolves to a Map containing all items in the collection
CollectionImpl .stateWhenReady
ts
subscribeChanges(callback, options): CollectionSubscription;
subscribeChanges(callback, options): CollectionSubscription;
Defined in: packages/db/src/collection/index.ts:805
Subscribe to changes in the collection
#### Parameters ##### callback
(changes) => void
Function called when items change
Subscription options including includeInitialState and where filter
CollectionSubscription
Unsubscribe function - Call this to stop listening for changes
ts
// Basic subscription
const subscription = collection.subscribeChanges((changes) => {
changes.forEach(change => {
console.log(`${change.type}: ${change.key}`, change.value)
})
})
// Later: subscription.unsubscribe()
// Basic subscription
const subscription = collection.subscribeChanges((changes) => {
changes.forEach(change => {
console.log(`${change.type}: ${change.key}`, change.value)
})
})
// Later: subscription.unsubscribe()
ts
// Include current state immediately
const subscription = collection.subscribeChanges((changes) => {
updateUI(changes)
}, { includeInitialState: true })
// Include current state immediately
const subscription = collection.subscribeChanges((changes) => {
updateUI(changes)
}, { includeInitialState: true })
ts
// Subscribe only to changes matching a condition
const subscription = collection.subscribeChanges((changes) => {
updateUI(changes)
}, {
includeInitialState: true,
where: (row) => row.status === 'active'
})
// Subscribe only to changes matching a condition
const subscription = collection.subscribeChanges((changes) => {
updateUI(changes)
}, {
includeInitialState: true,
where: (row) => row.status === 'active'
})
ts
// Subscribe using a pre-compiled expression
const subscription = collection.subscribeChanges((changes) => {
updateUI(changes)
}, {
includeInitialState: true,
whereExpression: eq(row.status, 'active')
})
// Subscribe using a pre-compiled expression
const subscription = collection.subscribeChanges((changes) => {
updateUI(changes)
}, {
includeInitialState: true,
whereExpression: eq(row.status, 'active')
})
CollectionImpl .subscribeChanges
ts
toArrayWhenReady(): Promise<T[]>;
toArrayWhenReady(): Promise<T[]>;
Defined in: packages/db/src/collection/index.ts:732
Gets the current state of the collection as an Array, but only resolves when data is available Waits for the first sync commit to complete before resolving
Promise<T[]>
Promise that resolves to an Array containing all items in the collection
CollectionImpl .toArrayWhenReady
### update() #### Call Signature
ts
update(key, callback): Transaction;
update(key, callback): Transaction;
Defined in: packages/db/src/collection/index.ts:602
Updates one or more items in the collection using a callback function
unknown[]
(drafts) => void
A Transaction object representing the update operation(s)
If the updated data fails schema validation
ts
// Update single item by key
const tx = collection.update("todo-1", (draft) => {
draft.completed = true
})
await tx.isPersisted.promise
// Update single item by key
const tx = collection.update("todo-1", (draft) => {
draft.completed = true
})
await tx.isPersisted.promise
ts
// Update multiple items
const tx = collection.update(["todo-1", "todo-2"], (drafts) => {
drafts.forEach(draft => { draft.completed = true })
})
await tx.isPersisted.promise
// Update multiple items
const tx = collection.update(["todo-1", "todo-2"], (drafts) => {
drafts.forEach(draft => { draft.completed = true })
})
await tx.isPersisted.promise
ts
// Update with metadata
const tx = collection.update("todo-1",
{ metadata: { reason: "user update" } },
(draft) => { draft.text = "Updated text" }
)
await tx.isPersisted.promise
// Update with metadata
const tx = collection.update("todo-1",
{ metadata: { reason: "user update" } },
(draft) => { draft.text = "Updated text" }
)
await tx.isPersisted.promise
ts
// Handle errors
try {
const tx = collection.update("item-1", draft => { draft.value = "new" })
await tx.isPersisted.promise
console.log('Update successful')
} catch (error) {
console.log('Update failed:', error)
}
// Handle errors
try {
const tx = collection.update("item-1", draft => { draft.value = "new" })
await tx.isPersisted.promise
console.log('Update successful')
} catch (error) {
console.log('Update failed:', error)
}
ts
update(
keys,
config,
callback): Transaction;
update(
keys,
config,
callback): Transaction;
Defined in: packages/db/src/collection/index.ts:608
Updates one or more items in the collection using a callback function
unknown[]
Single key or array of keys to update
(drafts) => void
A Transaction object representing the update operation(s)
If the updated data fails schema validation
ts
// Update single item by key
const tx = collection.update("todo-1", (draft) => {
draft.completed = true
})
await tx.isPersisted.promise
// Update single item by key
const tx = collection.update("todo-1", (draft) => {
draft.completed = true
})
await tx.isPersisted.promise
ts
// Update multiple items
const tx = collection.update(["todo-1", "todo-2"], (drafts) => {
drafts.forEach(draft => { draft.completed = true })
})
await tx.isPersisted.promise
// Update multiple items
const tx = collection.update(["todo-1", "todo-2"], (drafts) => {
drafts.forEach(draft => { draft.completed = true })
})
await tx.isPersisted.promise
ts
// Update with metadata
const tx = collection.update("todo-1",
{ metadata: { reason: "user update" } },
(draft) => { draft.text = "Updated text" }
)
await tx.isPersisted.promise
// Update with metadata
const tx = collection.update("todo-1",
{ metadata: { reason: "user update" } },
(draft) => { draft.text = "Updated text" }
)
await tx.isPersisted.promise
ts
// Handle errors
try {
const tx = collection.update("item-1", draft => { draft.value = "new" })
await tx.isPersisted.promise
console.log('Update successful')
} catch (error) {
console.log('Update failed:', error)
}
// Handle errors
try {
const tx = collection.update("item-1", draft => { draft.value = "new" })
await tx.isPersisted.promise
console.log('Update successful')
} catch (error) {
console.log('Update failed:', error)
}
ts
update(id, callback): Transaction;
update(id, callback): Transaction;
Defined in: packages/db/src/collection/index.ts:615
Updates one or more items in the collection using a callback function
unknown
(draft) => void
A Transaction object representing the update operation(s)
If the updated data fails schema validation
ts
// Update single item by key
const tx = collection.update("todo-1", (draft) => {
draft.completed = true
})
await tx.isPersisted.promise
// Update single item by key
const tx = collection.update("todo-1", (draft) => {
draft.completed = true
})
await tx.isPersisted.promise
ts
// Update multiple items
const tx = collection.update(["todo-1", "todo-2"], (drafts) => {
drafts.forEach(draft => { draft.completed = true })
})
await tx.isPersisted.promise
// Update multiple items
const tx = collection.update(["todo-1", "todo-2"], (drafts) => {
drafts.forEach(draft => { draft.completed = true })
})
await tx.isPersisted.promise
ts
// Update with metadata
const tx = collection.update("todo-1",
{ metadata: { reason: "user update" } },
(draft) => { draft.text = "Updated text" }
)
await tx.isPersisted.promise
// Update with metadata
const tx = collection.update("todo-1",
{ metadata: { reason: "user update" } },
(draft) => { draft.text = "Updated text" }
)
await tx.isPersisted.promise
ts
// Handle errors
try {
const tx = collection.update("item-1", draft => { draft.value = "new" })
await tx.isPersisted.promise
console.log('Update successful')
} catch (error) {
console.log('Update failed:', error)
}
// Handle errors
try {
const tx = collection.update("item-1", draft => { draft.value = "new" })
await tx.isPersisted.promise
console.log('Update successful')
} catch (error) {
console.log('Update failed:', error)
}
ts
update(
id,
config,
callback): Transaction;
update(
id,
config,
callback): Transaction;
Defined in: packages/db/src/collection/index.ts:621
Updates one or more items in the collection using a callback function
unknown
(draft) => void
A Transaction object representing the update operation(s)
If the updated data fails schema validation
ts
// Update single item by key
const tx = collection.update("todo-1", (draft) => {
draft.completed = true
})
await tx.isPersisted.promise
// Update single item by key
const tx = collection.update("todo-1", (draft) => {
draft.completed = true
})
await tx.isPersisted.promise
ts
// Update multiple items
const tx = collection.update(["todo-1", "todo-2"], (drafts) => {
drafts.forEach(draft => { draft.completed = true })
})
await tx.isPersisted.promise
// Update multiple items
const tx = collection.update(["todo-1", "todo-2"], (drafts) => {
drafts.forEach(draft => { draft.completed = true })
})
await tx.isPersisted.promise
ts
// Update with metadata
const tx = collection.update("todo-1",
{ metadata: { reason: "user update" } },
(draft) => { draft.text = "Updated text" }
)
await tx.isPersisted.promise
// Update with metadata
const tx = collection.update("todo-1",
{ metadata: { reason: "user update" } },
(draft) => { draft.text = "Updated text" }
)
await tx.isPersisted.promise
ts
// Handle errors
try {
const tx = collection.update("item-1", draft => { draft.value = "new" })
await tx.isPersisted.promise
console.log('Update successful')
} catch (error) {
console.log('Update failed:', error)
}
// Handle errors
try {
const tx = collection.update("item-1", draft => { draft.value = "new" })
await tx.isPersisted.promise
console.log('Update successful')
} catch (error) {
console.log('Update failed:', error)
}
ts
validateData(
data,
type,
key?): T;
validateData(
data,
type,
key?): T;
Defined in: packages/db/src/collection/index.ts:508
Validates the data against the schema
unknown
"insert" | "update"
TKey
T
ts
values(): IterableIterator<T>;
values(): IterableIterator<T>;
Defined in: packages/db/src/collection/index.ts:418
Get all values (virtual derived state)
IterableIterator<T>
ts
waitFor<T>(event, timeout?): Promise<AllCollectionEvents[T]>;
waitFor<T>(event, timeout?): Promise<AllCollectionEvents[T]>;
Defined in: packages/db/src/collection/index.ts:845
Wait for a collection event
T extends | "status:idle" | "status:loading" | "status:ready" | "status:error" | "status:cleaned-up" | "status:change" | "subscribers:change" | "loadingSubset:change"
T
number
Promise<AllCollectionEvents[T]>
