@tanstack/db 0.0.21 → 0.0.23

package/dist/cjs/types.d.cts

@@ -8,6 +8,24 @@ import { Transaction } from './transactions.cjs';
  * @internal This is used by the type resolution system
  */
 export type InferSchemaOutput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<T> extends object ? StandardSchemaV1.InferOutput<T> : Record<string, unknown> : Record<string, unknown>;
+/**
+ * Helper type to extract the input type from a standard schema
+ *
+ * @internal This is used for collection insert type inference
+ */
+export type InferSchemaInput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferInput<T> extends object ? StandardSchemaV1.InferInput<T> : Record<string, unknown> : Record<string, unknown>;
+/**
+ * Helper type to determine the insert input type
+ * This takes the raw generics (TExplicit, TSchema, TFallback) instead of the resolved T.
+ *
+ * Priority:
+ * 1. Explicit generic TExplicit (if not 'unknown')
+ * 2. Schema input type (if schema provided)
+ * 3. Fallback type TFallback
+ *
+ * @internal This is used for collection insert type inference
+ */
+export type ResolveInsertInput<TExplicit = unknown, TSchema extends StandardSchemaV1 = never, TFallback extends object = Record<string, unknown>> = unknown extends TExplicit ? [TSchema] extends [never] ? TFallback : InferSchemaInput<TSchema> : TExplicit extends object ? TExplicit : Record<string, unknown>;
 /**
  * Helper type to determine the final type based on priority:
  * 1. Explicit generic TExplicit (if not 'unknown')
@@ -28,25 +46,32 @@ export type Fn = (...args: Array<any>) => any;
  * A record of utility functions that can be attached to a collection
  */
 export type UtilsRecord = Record<string, Fn>;
+/**
+ *
+ * @remarks `update` and `insert` are both represented as `Partial<T>`, but changes for `insert` could me made more precise by inferring the schema input type. In practice, this has almost 0 real world impact so it's not worth the added type complexity.
+ *
+ * @see  https://github.com/TanStack/db/pull/209#issuecomment-3053001206
+ */
+export type ResolveTransactionChanges<T extends object = Record<string, unknown>, TOperation extends OperationType = OperationType> = TOperation extends `delete` ? T : Partial<T>;
 /**
  * Represents a pending mutation within a transaction
  * Contains information about the original and modified data, as well as metadata
  */
-export interface PendingMutation<T extends object = Record<string, unknown>, TOperation extends OperationType = OperationType> {
+export interface PendingMutation<T extends object = Record<string, unknown>, TOperation extends OperationType = OperationType, TCollection extends Collection<T, any, any, any, any> = Collection<T, any, any, any, any>> {
     mutationId: string;
     original: TOperation extends `insert` ? {} : T;
     modified: T;
-    changes: TOperation extends `insert` ? T : TOperation extends `delete` ? T : Partial<T>;
+    changes: ResolveTransactionChanges<T, TOperation>;
     globalKey: string;
     key: any;
-    type: OperationType;
+    type: TOperation;
     metadata: unknown;
     syncMetadata: Record<string, unknown>;
     /** Whether this mutation should be applied optimistically (defaults to true) */
     optimistic: boolean;
     createdAt: Date;
     updatedAt: Date;
-    collection: Collection<T, any, any>;
+    collection: TCollection;
 }
 /**
  * Configuration options for creating a new transaction
@@ -63,7 +88,7 @@ export type NonEmptyArray<T> = [T, ...Array<T>];
  * Utility type for a Transaction with at least one mutation
  * This is used internally by the Transaction.commit method
  */
-export type TransactionWithMutations<T extends object = Record<string, unknown>, TOperation extends OperationType = OperationType> = Transaction<T, TOperation> & {
+export type TransactionWithMutations<T extends object = Record<string, unknown>, TOperation extends OperationType = OperationType> = Transaction<T> & {
     mutations: NonEmptyArray<PendingMutation<T, TOperation>>;
 };
 export interface TransactionConfig<T extends object = Record<string, unknown>> {
@@ -77,11 +102,11 @@ export interface TransactionConfig<T extends object = Record<string, unknown>> {
 /**
  * Options for the createOptimisticAction helper
  */
-export interface CreateOptimisticActionsOptions<TVars = unknown> extends Omit<TransactionConfig, `mutationFn`> {
+export interface CreateOptimisticActionsOptions<TVars = unknown, T extends object = Record<string, unknown>> extends Omit<TransactionConfig<T>, `mutationFn`> {
     /** Function to apply optimistic updates locally before the mutation completes */
     onMutate: (vars: TVars) => void;
     /** Function to execute the mutation on the server */
-    mutationFn: (vars: TVars, params: MutationFnParams) => Promise<any>;
+    mutationFn: (vars: TVars, params: MutationFnParams<T>) => Promise<any>;
 }
 export type { Transaction };
 type Value<TExtensions = never> = string | number | boolean | bigint | null | TExtensions | Array<Value<TExtensions>> | {
@@ -91,7 +116,7 @@ export type Row<TExtensions = never> = Record<string, Value<TExtensions>>;
 export type OperationType = `insert` | `update` | `delete`;
 export interface SyncConfig<T extends object = Record<string, unknown>, TKey extends string | number = string | number> {
     sync: (params: {
-        collection: Collection<T, TKey>;
+        collection: Collection<T, TKey, any, any, any>;
         begin: () => void;
         write: (message: Omit<ChangeMessage<T>, `key`>) => void;
         commit: () => void;
@@ -189,7 +214,7 @@ export type CollectionStatus =
  | `error`
 /** Collection has been cleaned up and resources freed */
  | `cleaned-up`;
-export interface CollectionConfig<T extends object = Record<string, unknown>, TKey extends string | number = string | number, TSchema extends StandardSchemaV1 = StandardSchemaV1> {
+export interface CollectionConfig<T extends object = Record<string, unknown>, TKey extends string | number = string | number, TSchema extends StandardSchemaV1 = StandardSchemaV1, TInsertInput extends object = T> {
     id?: string;
     sync: SyncConfig<T, TKey>;
     schema?: TSchema;
@@ -265,7 +290,7 @@ export interface CollectionConfig<T extends object = Record<string, unknown>, TK
      *   })
      * }
      */
-    onInsert?: InsertMutationFn<T, TKey>;
+    onInsert?: InsertMutationFn<TInsertInput, TKey>;
     /**
      * Optional asynchronous handler function called before an update operation
      * @param params Object containing transaction and collection information

package/dist/esm/collection.d.ts

@@ -1,8 +1,8 @@
 import { SortedMap } from './SortedMap.js';
 import { Transaction } from './transactions.js';
-import { ChangeListener, ChangeMessage, CollectionConfig, CollectionStatus, Fn, InsertConfig, OperationConfig, OptimisticChangeMessage, ResolveType, Transaction as TransactionType, UtilsRecord } from './types.js';
+import { ChangeListener, ChangeMessage, CollectionConfig, CollectionStatus, Fn, InsertConfig, OperationConfig, OptimisticChangeMessage, ResolveInsertInput, ResolveType, Transaction as TransactionType, UtilsRecord } from './types.js';
 import { StandardSchemaV1 } from '@standard-schema/spec';
-export declare const collectionsStore: Map<string, CollectionImpl<any, any, {}>>;
+export declare const collectionsStore: Map<string, CollectionImpl<any, any, any, StandardSchemaV1<unknown, unknown>, any>>;
 interface PendingSyncedTransaction<T extends object = Record<string, unknown>> {
     committed: boolean;
     operations: Array<OptimisticChangeMessage<T>>;
@@ -12,8 +12,9 @@ interface PendingSyncedTransaction<T extends object = Record<string, unknown>> {
  * @template T - The type of items in the collection
  * @template TKey - The type of the key for the collection
  * @template TUtils - The utilities record type
+ * @template TInsertInput - The type for insert operations (can be different from T for schemas with defaults)
  */
-export interface Collection<T extends object = Record<string, unknown>, TKey extends string | number = string | number, TUtils extends UtilsRecord = {}> extends CollectionImpl<T, TKey> {
+export interface Collection<T extends object = Record<string, unknown>, TKey extends string | number = string | number, TUtils extends UtilsRecord = {}, TSchema extends StandardSchemaV1 = StandardSchemaV1, TInsertInput extends object = T> extends CollectionImpl<T, TKey, TUtils, TSchema, TInsertInput> {
     readonly utils: TUtils;
 }
 /**
@@ -89,9 +90,9 @@ export interface Collection<T extends object = Record<string, unknown>, TKey ext
  *
  * // Note: You must provide either an explicit type or a schema, but not both.
  */
-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> & {
+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>;
+}): Collection<ResolveType<TExplicit, TSchema, TFallback>, TKey, TUtils, TSchema, ResolveInsertInput<TExplicit, TSchema, TFallback>>;
 /**
  * Custom error class for schema validation errors
  */
@@ -106,8 +107,8 @@ export declare class SchemaValidationError extends Error {
         path?: ReadonlyArray<string | number | symbol>;
     }>, message?: string);
 }
-export declare class CollectionImpl<T extends object = Record<string, unknown>, TKey extends string | number = string | number, TUtils extends UtilsRecord = {}> {
-    config: CollectionConfig<T, TKey, any>;
+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>;
     transactions: SortedMap<string, Transaction<any>>;
     pendingSyncedTransactions: Array<PendingSyncedTransaction<T>>;
     syncedData: Map<TKey, T> | SortedMap<TKey, T>;
@@ -168,7 +169,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, any>);
+    constructor(config: CollectionConfig<T, TKey, TSchema, TInsertInput>);
     /**
      * Start sync immediately - internal method for compiled queries
      * This bypasses lazy loading for special cases like live query results
@@ -309,7 +310,7 @@ export declare class CollectionImpl<T extends object = Record<string, unknown>,
      *   console.log('Insert failed:', error)
      * }
      */
-    insert: (data: T | Array<T>, config?: InsertConfig) => Transaction<Record<string, unknown>, import('./types.js').OperationType>;
+    insert: (data: TInsertInput | Array<TInsertInput>, config?: InsertConfig) => Transaction<Record<string, unknown>> | Transaction<T>;
     /**
      * Updates one or more items in the collection using a callback function
      * @param keys - Single key or array of keys to update

package/dist/esm/collection.js

@@ -218,7 +218,7 @@ class CollectionImpl {
       items.forEach((item) => {
         var _a, _b;
         const validatedData = this.validateData(item, `insert`);
-        const key = this.getKeyFromItem(item);
+        const key = this.getKeyFromItem(validatedData);
         if (this.has(key)) {
           throw `Cannot insert document with ID "${key}" because it already exists in the collection`;
         }
@@ -227,7 +227,15 @@ class CollectionImpl {
           mutationId: crypto.randomUUID(),
           original: {},
           modified: validatedData,
-          changes: validatedData,
+          // Pick the values from validatedData based on what's passed in - this is for cases
+          // where a schema has default values. The validated data has the extra default
+          // values but for changes, we just want to show the data that was actually passed in.
+          changes: Object.fromEntries(
+            Object.keys(item).map((k) => [
+              k,
+              validatedData[k]
+            ])
+          ),
           globalKey,
           key,
           metadata: config2 == null ? void 0 : config2.metadata,
@@ -248,8 +256,8 @@ class CollectionImpl {
       } else {
         const directOpTransaction = createTransaction({
           mutationFn: async (params) => {
-            return this.config.onInsert({
-              ...params,
+            return await this.config.onInsert({
+              transaction: params.transaction,
               collection: this
             });
           }
@@ -308,7 +316,7 @@ class CollectionImpl {
         autoCommit: true,
         mutationFn: async (params) => {
           return this.config.onDelete({
-            ...params,
+            transaction: params.transaction,
             collection: this
           });
         }
@@ -1050,7 +1058,7 @@ class CollectionImpl {
     const directOpTransaction = createTransaction({
       mutationFn: async (params) => {
         return this.config.onUpdate({
-          ...params,
+          transaction: params.transaction,
           collection: this
         });
       }