@tanstack/db 0.2.3 → 0.2.5

package/dist/esm/collection.d.ts

@@ -4,7 +4,7 @@ import { IndexProxy } from './indexes/lazy-index.js';
 import { Transaction } from './transactions.js';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 import { SingleRowRefProxy } from './query/builder/ref-proxy.js';
-import { ChangeListener, ChangeMessage, CollectionConfig, CollectionStatus, CurrentStateAsChangesOptions, Fn, InsertConfig, OperationConfig, OptimisticChangeMessage, ResolveInsertInput, ResolveType, SubscribeChangesOptions, Transaction as TransactionType, UtilsRecord, WritableDeep } from './types.js';
+import { ChangeListener, ChangeMessage, CollectionConfig, CollectionStatus, CurrentStateAsChangesOptions, Fn, InferSchemaInput, InferSchemaOutput, InsertConfig, OperationConfig, OptimisticChangeMessage, SubscribeChangesOptions, Transaction as TransactionType, UtilsRecord, WritableDeep } from './types.js';
 import { IndexOptions } from './indexes/index-options.js';
 import { BaseIndex, IndexResolver } from './indexes/base-index.js';
 interface PendingSyncedTransaction<T extends object = Record<string, unknown>> {
@@ -26,11 +26,9 @@ export interface Collection<T extends object = Record<string, unknown>, TKey ext
 /**
  * Creates a new Collection instance with the given configuration
  *
- * @template TExplicit - The explicit type of items in the collection (highest priority)
+ * @template T - The schema type if a schema is provided, otherwise the type of items in the collection
  * @template TKey - The type of the key for the collection
  * @template TUtils - The utilities record type
- * @template TSchema - The schema type for validation and type inference (second priority)
- * @template TFallback - The fallback type if no explicit or schema type is provided
  * @param options - Collection options with optional utilities
  * @returns A new Collection with utilities exposed both at top level and under .utils
  *
@@ -94,26 +92,22 @@ export interface Collection<T extends object = Record<string, unknown>, TKey ext
  *   sync: { sync: () => {} }
  * })
  *
- * // Note: You can provide an explicit type, a schema, or both. When both are provided, the explicit type takes precedence.
  */
-export declare function createCollection<TSchema extends StandardSchemaV1, TKey extends string | number = string | number, TUtils extends UtilsRecord = {}, TFallback extends object = Record<string, unknown>>(options: CollectionConfig<ResolveType<unknown, TSchema, TFallback>, TKey, TSchema, ResolveInsertInput<unknown, TSchema, TFallback>> & {
-    schema: TSchema;
+export declare function createCollection<T extends StandardSchemaV1, TKey extends string | number = string | number, TUtils extends UtilsRecord = {}>(options: CollectionConfig<InferSchemaOutput<T>, TKey, T> & {
+    schema: T;
     utils?: TUtils;
-}): Collection<ResolveType<unknown, TSchema, TFallback>, TKey, TUtils, TSchema, ResolveInsertInput<unknown, TSchema, TFallback>>;
-export declare function createCollection<TExplicit extends object, TKey extends string | number = string | number, TUtils extends UtilsRecord = {}, TSchema extends StandardSchemaV1 = StandardSchemaV1, TFallback extends object = Record<string, unknown>>(options: CollectionConfig<ResolveType<TExplicit, TSchema, TFallback>, TKey, TSchema, ResolveInsertInput<TExplicit, TSchema, TFallback>> & {
-    schema: TSchema;
+}): Collection<InferSchemaOutput<T>, TKey, TUtils, T, InferSchemaInput<T>>;
+export declare function createCollection<T extends object, TKey extends string | number = string | number, TUtils extends UtilsRecord = {}>(options: CollectionConfig<T, TKey, never> & {
+    schema?: never;
     utils?: TUtils;
-}): Collection<ResolveType<TExplicit, TSchema, TFallback>, TKey, TUtils, TSchema, ResolveInsertInput<TExplicit, TSchema, TFallback>>;
-export declare function createCollection<TExplicit = unknown, TKey extends string | number = string | number, TUtils extends UtilsRecord = {}, TSchema extends StandardSchemaV1 = StandardSchemaV1, TFallback extends object = Record<string, unknown>>(options: CollectionConfig<ResolveType<TExplicit, TSchema, TFallback>, TKey, TSchema, ResolveInsertInput<TExplicit, TSchema, TFallback>> & {
-    utils?: TUtils;
-}): Collection<ResolveType<TExplicit, TSchema, TFallback>, TKey, TUtils, TSchema, ResolveInsertInput<TExplicit, TSchema, TFallback>>;
-export declare class CollectionImpl<T extends object = Record<string, unknown>, TKey extends string | number = string | number, TUtils extends UtilsRecord = {}, TSchema extends StandardSchemaV1 = StandardSchemaV1, TInsertInput extends object = T> {
-    config: CollectionConfig<T, TKey, TSchema, TInsertInput>;
+}): Collection<T, TKey, TUtils, never, T>;
+export declare class CollectionImpl<TOutput extends object = Record<string, unknown>, TKey extends string | number = string | number, TUtils extends UtilsRecord = {}, TSchema extends StandardSchemaV1 = StandardSchemaV1, TInput extends object = TOutput> {
+    config: CollectionConfig<TOutput, TKey, TSchema>;
     transactions: SortedMap<string, Transaction<any>>;
-    pendingSyncedTransactions: Array<PendingSyncedTransaction<T>>;
-    syncedData: Map<TKey, T> | SortedMap<TKey, T>;
+    pendingSyncedTransactions: Array<PendingSyncedTransaction<TOutput>>;
+    syncedData: Map<TKey, TOutput> | SortedMap<TKey, TOutput>;
     syncedMetadata: Map<TKey, unknown>;
-    optimisticUpserts: Map<TKey, T>;
+    optimisticUpserts: Map<TKey, TOutput>;
     optimisticDeletes: Set<TKey>;
     private _size;
     private lazyIndexes;
@@ -194,7 +188,7 @@ export declare class CollectionImpl<T extends object = Record<string, unknown>,
      * @param config - Configuration object for the collection
      * @throws Error if sync config is missing
      */
-    constructor(config: CollectionConfig<T, TKey, TSchema, TInsertInput>);
+    constructor(config: CollectionConfig<TOutput, TKey, TSchema>);
     /**
      * Start sync immediately - internal method for compiled queries
      * This bypasses lazy loading for special cases like live query results
@@ -261,7 +255,7 @@ export declare class CollectionImpl<T extends object = Record<string, unknown>,
     /**
      * Get the current value for a key (virtual derived state)
      */
-    get(key: TKey): T | undefined;
+    get(key: TKey): TOutput | undefined;
     /**
      * Check if a key exists in the collection (virtual derived state)
      */
@@ -277,23 +271,23 @@ export declare class CollectionImpl<T extends object = Record<string, unknown>,
     /**
      * Get all values (virtual derived state)
      */
-    values(): IterableIterator<T>;
+    values(): IterableIterator<TOutput>;
     /**
      * Get all entries (virtual derived state)
      */
-    entries(): IterableIterator<[TKey, T]>;
+    entries(): IterableIterator<[TKey, TOutput]>;
     /**
      * Get all entries (virtual derived state)
      */
-    [Symbol.iterator](): IterableIterator<[TKey, T]>;
+    [Symbol.iterator](): IterableIterator<[TKey, TOutput]>;
     /**
      * Execute a callback for each entry in the collection
      */
-    forEach(callbackfn: (value: T, key: TKey, index: number) => void): void;
+    forEach(callbackfn: (value: TOutput, key: TKey, index: number) => void): void;
     /**
      * Create a new array with the results of calling a function for each entry in the collection
      */
-    map<U>(callbackfn: (value: T, key: TKey, index: number) => U): Array<U>;
+    map<U>(callbackfn: (value: TOutput, key: TKey, index: number) => U): Array<U>;
     /**
      * Attempts to commit pending synced transactions if there are no active transactions
      * This method processes operations from pending transactions and applies them to the synced data
@@ -305,7 +299,7 @@ export declare class CollectionImpl<T extends object = Record<string, unknown>,
      */
     private scheduleTransactionCleanup;
     private ensureStandardSchema;
-    getKeyFromItem(item: T): TKey;
+    getKeyFromItem(item: TOutput): TKey;
     generateGlobalKey(key: any, item: any): string;
     /**
      * Creates an index on a collection for faster queries.
@@ -337,7 +331,7 @@ export declare class CollectionImpl<T extends object = Record<string, unknown>,
      *   options: { language: 'en' }
      * })
      */
-    createIndex<TResolver extends IndexResolver<TKey> = typeof BTreeIndex>(indexCallback: (row: SingleRowRefProxy<T>) => any, config?: IndexOptions<TResolver>): IndexProxy<TKey>;
+    createIndex<TResolver extends IndexResolver<TKey> = typeof BTreeIndex>(indexCallback: (row: SingleRowRefProxy<TOutput>) => any, config?: IndexOptions<TResolver>): IndexProxy<TKey>;
     /**
      * Resolve all lazy indexes (called when collection first syncs)
      * @private
@@ -357,7 +351,7 @@ export declare class CollectionImpl<T extends object = Record<string, unknown>,
      * @private
      */
     private updateIndexes;
-    validateData(data: unknown, type: `insert` | `update`, key?: TKey): T | never;
+    validateData(data: unknown, type: `insert` | `update`, key?: TKey): TOutput | never;
     /**
      * Inserts one or more items into the collection
      * @param items - Single item or array of items to insert
@@ -394,7 +388,7 @@ export declare class CollectionImpl<T extends object = Record<string, unknown>,
      *   console.log('Insert failed:', error)
      * }
      */
-    insert: (data: TInsertInput | Array<TInsertInput>, config?: InsertConfig) => Transaction<Record<string, unknown>> | Transaction<T>;
+    insert: (data: TInput | Array<TInput>, config?: InsertConfig) => Transaction<Record<string, unknown>> | Transaction<TOutput>;
     /**
      * Updates one or more items in the collection using a callback function
      * @param keys - Single key or array of keys to update
@@ -434,10 +428,10 @@ export declare class CollectionImpl<T extends object = Record<string, unknown>,
      *   console.log('Update failed:', error)
      * }
      */
-    update<TItem extends object = T>(key: Array<TKey | unknown>, callback: (drafts: Array<WritableDeep<TItem>>) => void): TransactionType;
-    update<TItem extends object = T>(keys: Array<TKey | unknown>, config: OperationConfig, callback: (drafts: Array<WritableDeep<TItem>>) => void): TransactionType;
-    update<TItem extends object = T>(id: TKey | unknown, callback: (draft: WritableDeep<TItem>) => void): TransactionType;
-    update<TItem extends object = T>(id: TKey | unknown, config: OperationConfig, callback: (draft: WritableDeep<TItem>) => void): TransactionType;
+    update(key: Array<TKey | unknown>, callback: (drafts: Array<WritableDeep<TInput>>) => void): TransactionType;
+    update(keys: Array<TKey | unknown>, config: OperationConfig, callback: (drafts: Array<WritableDeep<TInput>>) => void): TransactionType;
+    update(id: TKey | unknown, callback: (draft: WritableDeep<TInput>) => void): TransactionType;
+    update(id: TKey | unknown, config: OperationConfig, callback: (draft: WritableDeep<TInput>) => void): TransactionType;
     /**
      * Deletes one or more items from the collection
      * @param keys - Single key or array of keys to delete
@@ -485,27 +479,27 @@ export declare class CollectionImpl<T extends object = Record<string, unknown>,
      *   console.log("Todo 1 exists:", itemsMap.get("todo-1"))
      * }
      */
-    get state(): Map<TKey, T>;
+    get state(): Map<TKey, TOutput>;
     /**
      * 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
      *
      * @returns Promise that resolves to a Map containing all items in the collection
      */
-    stateWhenReady(): Promise<Map<TKey, T>>;
+    stateWhenReady(): Promise<Map<TKey, TOutput>>;
     /**
      * Gets the current state of the collection as an Array
      *
      * @returns An Array containing all items in the collection
      */
-    get toArray(): T[];
+    get toArray(): TOutput[];
     /**
      * 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
      *
      * @returns Promise that resolves to an Array containing all items in the collection
      */
-    toArrayWhenReady(): Promise<Array<T>>;
+    toArrayWhenReady(): Promise<Array<TOutput>>;
     /**
      * Returns the current state of the collection as an array of changes
      * @param options - Options including optional where filter
@@ -524,7 +518,7 @@ export declare class CollectionImpl<T extends object = Record<string, unknown>,
      *   whereExpression: eq(row.status, 'active')
      * })
      */
-    currentStateAsChanges(options?: CurrentStateAsChangesOptions<T>): Array<ChangeMessage<T>>;
+    currentStateAsChanges(options?: CurrentStateAsChangesOptions<TOutput>): Array<ChangeMessage<TOutput>>;
     /**
      * Subscribe to changes in the collection
      * @param callback - Function called when items change
@@ -564,11 +558,11 @@ export declare class CollectionImpl<T extends object = Record<string, unknown>,
      *   whereExpression: eq(row.status, 'active')
      * })
      */
-    subscribeChanges(callback: (changes: Array<ChangeMessage<T>>) => void, options?: SubscribeChangesOptions<T>): () => void;
+    subscribeChanges(callback: (changes: Array<ChangeMessage<TOutput>>) => void, options?: SubscribeChangesOptions<TOutput>): () => void;
     /**
      * Subscribe to changes for a specific key
      */
-    subscribeChangesKey(key: TKey, listener: ChangeListener<T, TKey>, { includeInitialState }?: {
+    subscribeChangesKey(key: TKey, listener: ChangeListener<TOutput, TKey>, { includeInitialState }?: {
         includeInitialState?: boolean;
     }): () => void;
     /**

package/dist/esm/collection.js

@@ -9,7 +9,9 @@ import { getActiveTransaction, createTransaction } from "./transactions.js";
 import { MissingInsertHandlerError, DuplicateKeyError, MissingDeleteHandlerError, NoKeysPassedToDeleteError, DeleteKeyNotFoundError, CollectionRequiresConfigError, CollectionRequiresSyncConfigError, CollectionInErrorStateError, InvalidCollectionStatusTransitionError, NoPendingSyncTransactionWriteError, SyncTransactionAlreadyCommittedWriteError, NoPendingSyncTransactionCommitError, SyncTransactionAlreadyCommittedError, DuplicateKeySyncError, CollectionIsInErrorStateError, SyncCleanupError, NegativeActiveSubscribersError, InvalidSchemaError, UndefinedKeyError, SchemaMustBeSynchronousError, SchemaValidationError, MissingUpdateArgumentError, MissingUpdateHandlerError, NoKeysPassedToUpdateError, UpdateKeyNotFoundError, KeyUpdateNotAllowedError } from "./errors.js";
 import { currentStateAsChanges, createFilteredCallback } from "./change-events.js";
 function createCollection(options) {
-  const collection = new CollectionImpl(options);
+  const collection = new CollectionImpl(
+    options
+  );
   if (options.utils) {
     collection.utils = { ...options.utils };
   } else {
@@ -802,7 +804,10 @@ class CollectionImpl {
           switch (mutation.type) {
             case `insert`:
             case `update`:
-              this.optimisticUpserts.set(mutation.key, mutation.modified);
+              this.optimisticUpserts.set(
+                mutation.key,
+                mutation.modified
+              );
               this.optimisticDeletes.delete(mutation.key);
               break;
             case `delete`:
@@ -1234,7 +1239,12 @@ class CollectionImpl {
           });
           throw new SchemaValidationError(type, typedIssues);
         }
-        return data;
+        const validatedMergedData = result2.value;
+        const modifiedKeys = Object.keys(data);
+        const extractedChanges = Object.fromEntries(
+          modifiedKeys.map((k) => [k, validatedMergedData[k]])
+        );
+        return extractedChanges;
       }
     }
     const result = standardSchema[`~standard`].validate(data);
@@ -1315,7 +1325,16 @@ class CollectionImpl {
         mutationId: crypto.randomUUID(),
         original: originalItem,
         modified: modifiedItem,
-        changes: validatedUpdatePayload,
+        // Pick the values from modifiedItem based on what's passed in - this is for cases
+        // where a schema has default values or transforms. The modified data has the extra
+        // default or transformed values but for changes, we just want to show the data that
+        // was actually passed in.
+        changes: Object.fromEntries(
+          Object.keys(itemChanges).map((k) => [
+            k,
+            modifiedItem[k]
+          ])
+        ),
         globalKey,
         key,
         metadata: config.metadata,