LocalStorageCollectionConfig

optional autoIndex: "off" | "eager";

"off"

optional compare: (x, y) => number;

// For a collection with a 'createdAt' field
compare: (x, y) => x.createdAt.getTime() - y.createdAt.getTime()

optional defaultIndexType: IndexConstructor<TKey>;

import { BasicIndex } from '@tanstack/db'
const collection = createCollection({
  defaultIndexType: BasicIndex,
  autoIndex: 'eager',
  // ...
})

optional defaultStringCollation: StringCollationConfig;

optional gcTime: number;

getKey: (item) => TKey;

// For a collection with a 'uuid' field as the primary key
getKey: (item) => item.uuid

optional id: string;

optional onDelete: 
  | DeleteMutationFn<T, TKey, UtilsRecord, void>
| DeleteMutationFn<T, TKey, UtilsRecord, any>;

// Basic delete handler
onDelete: async ({ transaction, collection }) => {
  const deletedKey = transaction.mutations[0].key
  await api.deleteTodo(deletedKey)
}

// Delete handler with refetch (Query Collection)
onDelete: async ({ transaction, collection }) => {
  const keysToDelete = transaction.mutations.map(m => m.key)
  await api.deleteTodos(keysToDelete)
  // Trigger refetch to sync server state
  await collection.utils.refetch()
  // Prevent the pre-1.0 compatibility wrapper from refetching again.
  return { refetch: false }
}

// Delete handler with sync wait (Electric Collection)
onDelete: async ({ transaction, collection }) => {
  const mutation = transaction.mutations[0]
  const result = await api.deleteTodo(mutation.original.id)
  // Wait for txid to sync
  await collection.utils.awaitTxId(result.txid)
}

// Delete handler with confirmation
onDelete: async ({ transaction, collection }) => {
  const mutation = transaction.mutations[0]
  const shouldDelete = await confirmDeletion(mutation.original)
  if (!shouldDelete) {
    throw new Error('Delete cancelled by user')
  }
  await api.deleteTodo(mutation.original.id)
}

// Delete handler with optimistic rollback
onDelete: async ({ transaction, collection }) => {
  const mutation = transaction.mutations[0]
  try {
    await api.deleteTodo(mutation.original.id)
  } catch (error) {
    // Transaction will automatically rollback optimistic changes
    console.error('Delete failed, rolling back:', error)
    throw error
  }
}

optional onInsert: 
  | InsertMutationFn<T, TKey, UtilsRecord, void>
| InsertMutationFn<T, TKey, UtilsRecord, any>;

// Basic insert handler
onInsert: async ({ transaction, collection }) => {
  const newItem = transaction.mutations[0].modified
  await api.createTodo(newItem)
}

// Insert handler with refetch (Query Collection)
onInsert: async ({ transaction, collection }) => {
  const newItem = transaction.mutations[0].modified
  await api.createTodo(newItem)
  // Trigger refetch to sync server state
  await collection.utils.refetch()
  // Prevent the pre-1.0 compatibility wrapper from refetching again.
  return { refetch: false }
}

// Insert handler with sync wait (Electric Collection)
onInsert: async ({ transaction, collection }) => {
  const newItem = transaction.mutations[0].modified
  const result = await api.createTodo(newItem)
  // Wait for txid to sync
  await collection.utils.awaitTxId(result.txid)
}

// Insert handler with multiple items
onInsert: async ({ transaction, collection }) => {
  const items = transaction.mutations.map(m => m.modified)
  await api.createTodos(items)
  // Refetch to get updated data from server
  await collection.utils.refetch()
  return { refetch: false }
}

// Insert handler with error handling
onInsert: async ({ transaction, collection }) => {
  try {
    const newItem = transaction.mutations[0].modified
    await api.createTodo(newItem)
  } catch (error) {
    console.error('Insert failed:', error)
    throw error // This will cause the transaction to rollback
  }
}

optional onUpdate: 
  | UpdateMutationFn<T, TKey, UtilsRecord, void>
| UpdateMutationFn<T, TKey, UtilsRecord, any>;

// Basic update handler
onUpdate: async ({ transaction, collection }) => {
  const updatedItem = transaction.mutations[0].modified
  await api.updateTodo(updatedItem.id, updatedItem)
}

// Update handler with refetch (Query Collection)
onUpdate: async ({ transaction, collection }) => {
  const mutation = transaction.mutations[0]
  const changes = mutation.changes // Only the changed fields
  await api.updateTodo(mutation.original.id, changes)
  // Trigger refetch to sync server state
  await collection.utils.refetch()
  // Prevent the pre-1.0 compatibility wrapper from refetching again.
  return { refetch: false }
}

// Update handler with sync wait (Electric Collection)
onUpdate: async ({ transaction, collection }) => {
  const mutation = transaction.mutations[0]
  const result = await api.updateTodo(mutation.original.id, mutation.changes)
  // Wait for txid to sync
  await collection.utils.awaitTxId(result.txid)
}

// Update handler with multiple items
onUpdate: async ({ transaction, collection }) => {
  const updates = transaction.mutations.map(m => ({
    id: m.key,
    changes: m.changes
  }))
  await api.updateTodos(updates)
  await collection.utils.refetch()
  return { refetch: false }
}

// Update handler with optimistic rollback
onUpdate: async ({ transaction, collection }) => {
  const mutation = transaction.mutations[0]
  try {
    await api.updateTodo(mutation.original.id, mutation.changes)
  } catch (error) {
    // Transaction will automatically rollback optimistic changes
    console.error('Update failed, rolling back:', error)
    throw error
  }
}

optional parser: Parser;

optional schema: TSchema;

optional startSync: boolean;

false

optional storage: StorageApi;

optional storageEventApi: StorageEventApi;

storageKey: string;

optional syncMode: SyncMode;

optional utils: UtilsRecord;