@tanstack/db 0.3.2 → 0.4.1

package/dist/esm/collection/lifecycle.d.ts

@@ -0,0 +1,81 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { CollectionConfig, CollectionStatus } from '../types.js';
+import { CollectionEventsManager } from './events.js';
+import { CollectionIndexesManager } from './indexes.js';
+import { CollectionChangesManager } from './changes.js';
+import { CollectionSyncManager } from './sync.js';
+import { CollectionStateManager } from './state.js';
+export declare class CollectionLifecycleManager<TOutput extends object = Record<string, unknown>, TKey extends string | number = string | number, TSchema extends StandardSchemaV1 = StandardSchemaV1, TInput extends object = TOutput> {
+    private config;
+    private id;
+    private indexes;
+    private events;
+    private changes;
+    private sync;
+    private state;
+    status: CollectionStatus;
+    hasBeenReady: boolean;
+    hasReceivedFirstCommit: boolean;
+    onFirstReadyCallbacks: Array<() => void>;
+    gcTimeoutId: ReturnType<typeof setTimeout> | null;
+    private idleCallbackId;
+    /**
+     * Creates a new CollectionLifecycleManager instance
+     */
+    constructor(config: CollectionConfig<TOutput, TKey, TSchema>, id: string);
+    setDeps(deps: {
+        indexes: CollectionIndexesManager<TOutput, TKey, TSchema, TInput>;
+        events: CollectionEventsManager;
+        changes: CollectionChangesManager<TOutput, TKey, TSchema, TInput>;
+        sync: CollectionSyncManager<TOutput, TKey, TSchema, TInput>;
+        state: CollectionStateManager<TOutput, TKey, TSchema, TInput>;
+    }): void;
+    /**
+     * Validates state transitions to prevent invalid status changes
+     */
+    validateStatusTransition(from: CollectionStatus, to: CollectionStatus): void;
+    /**
+     * Safely update the collection status with validation
+     * @private
+     */
+    setStatus(newStatus: CollectionStatus): void;
+    /**
+     * Validates that the collection is in a usable state for data operations
+     * @private
+     */
+    validateCollectionUsable(operation: string): void;
+    /**
+     * Mark the collection as ready for use
+     * This is called by sync implementations to explicitly signal that the collection is ready,
+     * providing a more intuitive alternative to using commits for readiness signaling
+     * @private - Should only be called by sync implementations
+     */
+    markReady(): void;
+    /**
+     * Start the garbage collection timer
+     * Called when the collection becomes inactive (no subscribers)
+     */
+    startGCTimer(): void;
+    /**
+     * Cancel the garbage collection timer
+     * Called when the collection becomes active again
+     */
+    cancelGCTimer(): void;
+    /**
+     * Schedule cleanup to run during browser idle time
+     * This prevents blocking the UI thread during cleanup operations
+     */
+    private scheduleIdleCleanup;
+    /**
+     * Perform cleanup operations, optionally in chunks during idle time
+     * @returns true if cleanup was completed, false if it was rescheduled
+     */
+    private performCleanup;
+    /**
+     * Register a callback to be executed when the collection first becomes ready
+     * Useful for preloading collections
+     * @param callback Function to call when the collection first becomes ready
+     */
+    onFirstReady(callback: () => void): void;
+    cleanup(): void;
+}

package/dist/esm/collection/lifecycle.js

@@ -0,0 +1,196 @@
+import { InvalidCollectionStatusTransitionError, CollectionInErrorStateError } from "../errors.js";
+import { safeCancelIdleCallback, safeRequestIdleCallback } from "../utils/browser-polyfills.js";
+class CollectionLifecycleManager {
+  /**
+   * Creates a new CollectionLifecycleManager instance
+   */
+  constructor(config, id) {
+    this.status = `idle`;
+    this.hasBeenReady = false;
+    this.hasReceivedFirstCommit = false;
+    this.onFirstReadyCallbacks = [];
+    this.gcTimeoutId = null;
+    this.idleCallbackId = null;
+    this.config = config;
+    this.id = id;
+  }
+  setDeps(deps) {
+    this.indexes = deps.indexes;
+    this.events = deps.events;
+    this.changes = deps.changes;
+    this.sync = deps.sync;
+    this.state = deps.state;
+  }
+  /**
+   * Validates state transitions to prevent invalid status changes
+   */
+  validateStatusTransition(from, to) {
+    if (from === to) {
+      return;
+    }
+    const validTransitions = {
+      idle: [`loading`, `error`, `cleaned-up`],
+      loading: [`initialCommit`, `ready`, `error`, `cleaned-up`],
+      initialCommit: [`ready`, `error`, `cleaned-up`],
+      ready: [`cleaned-up`, `error`],
+      error: [`cleaned-up`, `idle`],
+      "cleaned-up": [`loading`, `error`]
+    };
+    if (!validTransitions[from].includes(to)) {
+      throw new InvalidCollectionStatusTransitionError(from, to, this.id);
+    }
+  }
+  /**
+   * Safely update the collection status with validation
+   * @private
+   */
+  setStatus(newStatus) {
+    this.validateStatusTransition(this.status, newStatus);
+    const previousStatus = this.status;
+    this.status = newStatus;
+    if (newStatus === `ready` && !this.indexes.isIndexesResolved) {
+      this.indexes.resolveAllIndexes().catch((error) => {
+        console.warn(`Failed to resolve indexes:`, error);
+      });
+    }
+    this.events.emitStatusChange(newStatus, previousStatus);
+  }
+  /**
+   * Validates that the collection is in a usable state for data operations
+   * @private
+   */
+  validateCollectionUsable(operation) {
+    switch (this.status) {
+      case `error`:
+        throw new CollectionInErrorStateError(operation, this.id);
+      case `cleaned-up`:
+        this.sync.startSync();
+        break;
+    }
+  }
+  /**
+   * Mark the collection as ready for use
+   * This is called by sync implementations to explicitly signal that the collection is ready,
+   * providing a more intuitive alternative to using commits for readiness signaling
+   * @private - Should only be called by sync implementations
+   */
+  markReady() {
+    if (this.status === `loading` || this.status === `initialCommit`) {
+      this.setStatus(`ready`);
+      if (!this.hasBeenReady) {
+        this.hasBeenReady = true;
+        if (!this.hasReceivedFirstCommit) {
+          this.hasReceivedFirstCommit = true;
+        }
+        const callbacks = [...this.onFirstReadyCallbacks];
+        this.onFirstReadyCallbacks = [];
+        callbacks.forEach((callback) => callback());
+      }
+    }
+    if (this.changes.changeSubscriptions.size > 0) {
+      this.changes.emitEmptyReadyEvent();
+    }
+  }
+  /**
+   * Start the garbage collection timer
+   * Called when the collection becomes inactive (no subscribers)
+   */
+  startGCTimer() {
+    if (this.gcTimeoutId) {
+      clearTimeout(this.gcTimeoutId);
+    }
+    const gcTime = this.config.gcTime ?? 3e5;
+    if (gcTime === 0) {
+      return;
+    }
+    this.gcTimeoutId = setTimeout(() => {
+      if (this.changes.activeSubscribersCount === 0) {
+        this.scheduleIdleCleanup();
+      }
+    }, gcTime);
+  }
+  /**
+   * Cancel the garbage collection timer
+   * Called when the collection becomes active again
+   */
+  cancelGCTimer() {
+    if (this.gcTimeoutId) {
+      clearTimeout(this.gcTimeoutId);
+      this.gcTimeoutId = null;
+    }
+    if (this.idleCallbackId !== null) {
+      safeCancelIdleCallback(this.idleCallbackId);
+      this.idleCallbackId = null;
+    }
+  }
+  /**
+   * Schedule cleanup to run during browser idle time
+   * This prevents blocking the UI thread during cleanup operations
+   */
+  scheduleIdleCleanup() {
+    if (this.idleCallbackId !== null) {
+      safeCancelIdleCallback(this.idleCallbackId);
+    }
+    this.idleCallbackId = safeRequestIdleCallback(
+      (deadline) => {
+        if (this.changes.activeSubscribersCount === 0) {
+          const cleanupCompleted = this.performCleanup(deadline);
+          if (cleanupCompleted) {
+            this.idleCallbackId = null;
+          }
+        } else {
+          this.idleCallbackId = null;
+        }
+      },
+      { timeout: 1e3 }
+    );
+  }
+  /**
+   * Perform cleanup operations, optionally in chunks during idle time
+   * @returns true if cleanup was completed, false if it was rescheduled
+   */
+  performCleanup(deadline) {
+    const hasTime = !deadline || deadline.timeRemaining() > 0 || deadline.didTimeout;
+    if (hasTime) {
+      this.events.cleanup();
+      this.sync.cleanup();
+      this.state.cleanup();
+      this.changes.cleanup();
+      this.indexes.cleanup();
+      if (this.gcTimeoutId) {
+        clearTimeout(this.gcTimeoutId);
+        this.gcTimeoutId = null;
+      }
+      this.hasBeenReady = false;
+      this.onFirstReadyCallbacks = [];
+      this.setStatus(`cleaned-up`);
+      return true;
+    } else {
+      this.scheduleIdleCleanup();
+      return false;
+    }
+  }
+  /**
+   * Register a callback to be executed when the collection first becomes ready
+   * Useful for preloading collections
+   * @param callback Function to call when the collection first becomes ready
+   */
+  onFirstReady(callback) {
+    if (this.hasBeenReady) {
+      callback();
+      return;
+    }
+    this.onFirstReadyCallbacks.push(callback);
+  }
+  cleanup() {
+    if (this.idleCallbackId !== null) {
+      safeCancelIdleCallback(this.idleCallbackId);
+      this.idleCallbackId = null;
+    }
+    this.performCleanup();
+  }
+}
+export {
+  CollectionLifecycleManager
+};
+//# sourceMappingURL=lifecycle.js.map

package/dist/esm/collection/lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.js","sources":["../../../src/collection/lifecycle.ts"],"sourcesContent":["import {\n  CollectionInErrorStateError,\n  InvalidCollectionStatusTransitionError,\n} from \"../errors\"\nimport {\n  safeCancelIdleCallback,\n  safeRequestIdleCallback,\n} from \"../utils/browser-polyfills\"\nimport type { IdleCallbackDeadline } from \"../utils/browser-polyfills\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\nimport type { CollectionConfig, CollectionStatus } from \"../types\"\nimport type { CollectionEventsManager } from \"./events\"\nimport type { CollectionIndexesManager } from \"./indexes\"\nimport type { CollectionChangesManager } from \"./changes\"\nimport type { CollectionSyncManager } from \"./sync\"\nimport type { CollectionStateManager } from \"./state\"\n\nexport class CollectionLifecycleManager<\n  TOutput extends object = Record<string, unknown>,\n  TKey extends string | number = string | number,\n  TSchema extends StandardSchemaV1 = StandardSchemaV1,\n  TInput extends object = TOutput,\n> {\n  private config: CollectionConfig<TOutput, TKey, TSchema>\n  private id: string\n  private indexes!: CollectionIndexesManager<TOutput, TKey, TSchema, TInput>\n  private events!: CollectionEventsManager\n  private changes!: CollectionChangesManager<TOutput, TKey, TSchema, TInput>\n  private sync!: CollectionSyncManager<TOutput, TKey, TSchema, TInput>\n  private state!: CollectionStateManager<TOutput, TKey, TSchema, TInput>\n\n  public status: CollectionStatus = `idle`\n  public hasBeenReady = false\n  public hasReceivedFirstCommit = false\n  public onFirstReadyCallbacks: Array<() => void> = []\n  public gcTimeoutId: ReturnType<typeof setTimeout> | null = null\n  private idleCallbackId: number | null = null\n\n  /**\n   * Creates a new CollectionLifecycleManager instance\n   */\n  constructor(config: CollectionConfig<TOutput, TKey, TSchema>, id: string) {\n    this.config = config\n    this.id = id\n  }\n\n  setDeps(deps: {\n    indexes: CollectionIndexesManager<TOutput, TKey, TSchema, TInput>\n    events: CollectionEventsManager\n    changes: CollectionChangesManager<TOutput, TKey, TSchema, TInput>\n    sync: CollectionSyncManager<TOutput, TKey, TSchema, TInput>\n    state: CollectionStateManager<TOutput, TKey, TSchema, TInput>\n  }) {\n    this.indexes = deps.indexes\n    this.events = deps.events\n    this.changes = deps.changes\n    this.sync = deps.sync\n    this.state = deps.state\n  }\n\n  /**\n   * Validates state transitions to prevent invalid status changes\n   */\n  public validateStatusTransition(\n    from: CollectionStatus,\n    to: CollectionStatus\n  ): void {\n    if (from === to) {\n      // Allow same state transitions\n      return\n    }\n    const validTransitions: Record<\n      CollectionStatus,\n      Array<CollectionStatus>\n    > = {\n      idle: [`loading`, `error`, `cleaned-up`],\n      loading: [`initialCommit`, `ready`, `error`, `cleaned-up`],\n      initialCommit: [`ready`, `error`, `cleaned-up`],\n      ready: [`cleaned-up`, `error`],\n      error: [`cleaned-up`, `idle`],\n      \"cleaned-up\": [`loading`, `error`],\n    }\n\n    if (!validTransitions[from].includes(to)) {\n      throw new InvalidCollectionStatusTransitionError(from, to, this.id)\n    }\n  }\n\n  /**\n   * Safely update the collection status with validation\n   * @private\n   */\n  public setStatus(newStatus: CollectionStatus): void {\n    this.validateStatusTransition(this.status, newStatus)\n    const previousStatus = this.status\n    this.status = newStatus\n\n    // Resolve indexes when collection becomes ready\n    if (newStatus === `ready` && !this.indexes.isIndexesResolved) {\n      // Resolve indexes asynchronously without blocking\n      this.indexes.resolveAllIndexes().catch((error) => {\n        console.warn(`Failed to resolve indexes:`, error)\n      })\n    }\n\n    // Emit event\n    this.events.emitStatusChange(newStatus, previousStatus)\n  }\n\n  /**\n   * Validates that the collection is in a usable state for data operations\n   * @private\n   */\n  public validateCollectionUsable(operation: string): void {\n    switch (this.status) {\n      case `error`:\n        throw new CollectionInErrorStateError(operation, this.id)\n      case `cleaned-up`:\n        // Automatically restart the collection when operations are called on cleaned-up collections\n        this.sync.startSync()\n        break\n    }\n  }\n\n  /**\n   * Mark the collection as ready for use\n   * This is called by sync implementations to explicitly signal that the collection is ready,\n   * providing a more intuitive alternative to using commits for readiness signaling\n   * @private - Should only be called by sync implementations\n   */\n  public markReady(): void {\n    // Can transition to ready from loading or initialCommit states\n    if (this.status === `loading` || this.status === `initialCommit`) {\n      this.setStatus(`ready`)\n\n      // Call any registered first ready callbacks (only on first time becoming ready)\n      if (!this.hasBeenReady) {\n        this.hasBeenReady = true\n\n        // Also mark as having received first commit for backwards compatibility\n        if (!this.hasReceivedFirstCommit) {\n          this.hasReceivedFirstCommit = true\n        }\n\n        const callbacks = [...this.onFirstReadyCallbacks]\n        this.onFirstReadyCallbacks = []\n        callbacks.forEach((callback) => callback())\n      }\n    }\n\n    // Always notify dependents when markReady is called, after status is set\n    // This ensures live queries get notified when their dependencies become ready\n    if (this.changes.changeSubscriptions.size > 0) {\n      this.changes.emitEmptyReadyEvent()\n    }\n  }\n\n  /**\n   * Start the garbage collection timer\n   * Called when the collection becomes inactive (no subscribers)\n   */\n  public startGCTimer(): void {\n    if (this.gcTimeoutId) {\n      clearTimeout(this.gcTimeoutId)\n    }\n\n    const gcTime = this.config.gcTime ?? 300000 // 5 minutes default\n\n    // If gcTime is 0, GC is disabled\n    if (gcTime === 0) {\n      return\n    }\n\n    this.gcTimeoutId = setTimeout(() => {\n      if (this.changes.activeSubscribersCount === 0) {\n        // Schedule cleanup during idle time to avoid blocking the UI thread\n        this.scheduleIdleCleanup()\n      }\n    }, gcTime)\n  }\n\n  /**\n   * Cancel the garbage collection timer\n   * Called when the collection becomes active again\n   */\n  public cancelGCTimer(): void {\n    if (this.gcTimeoutId) {\n      clearTimeout(this.gcTimeoutId)\n      this.gcTimeoutId = null\n    }\n    // Also cancel any pending idle cleanup\n    if (this.idleCallbackId !== null) {\n      safeCancelIdleCallback(this.idleCallbackId)\n      this.idleCallbackId = null\n    }\n  }\n\n  /**\n   * Schedule cleanup to run during browser idle time\n   * This prevents blocking the UI thread during cleanup operations\n   */\n  private scheduleIdleCleanup(): void {\n    // Cancel any existing idle callback\n    if (this.idleCallbackId !== null) {\n      safeCancelIdleCallback(this.idleCallbackId)\n    }\n\n    // Schedule cleanup with a timeout of 1 second\n    // This ensures cleanup happens even if the browser is busy\n    this.idleCallbackId = safeRequestIdleCallback(\n      (deadline) => {\n        // Perform cleanup if we still have no subscribers\n        if (this.changes.activeSubscribersCount === 0) {\n          const cleanupCompleted = this.performCleanup(deadline)\n          // Only clear the callback ID if cleanup actually completed\n          if (cleanupCompleted) {\n            this.idleCallbackId = null\n          }\n        } else {\n          // No need to cleanup, clear the callback ID\n          this.idleCallbackId = null\n        }\n      },\n      { timeout: 1000 }\n    )\n  }\n\n  /**\n   * Perform cleanup operations, optionally in chunks during idle time\n   * @returns true if cleanup was completed, false if it was rescheduled\n   */\n  private performCleanup(deadline?: IdleCallbackDeadline): boolean {\n    // If we have a deadline, we can potentially split cleanup into chunks\n    // For now, we'll do all cleanup at once but check if we have time\n    const hasTime =\n      !deadline || deadline.timeRemaining() > 0 || deadline.didTimeout\n\n    if (hasTime) {\n      // Perform all cleanup operations\n      this.events.cleanup()\n      this.sync.cleanup()\n      this.state.cleanup()\n      this.changes.cleanup()\n      this.indexes.cleanup()\n\n      if (this.gcTimeoutId) {\n        clearTimeout(this.gcTimeoutId)\n        this.gcTimeoutId = null\n      }\n\n      this.hasBeenReady = false\n      this.onFirstReadyCallbacks = []\n\n      // Set status to cleaned-up\n      this.setStatus(`cleaned-up`)\n      return true\n    } else {\n      // If we don't have time, reschedule for the next idle period\n      this.scheduleIdleCleanup()\n      return false\n    }\n  }\n\n  /**\n   * Register a callback to be executed when the collection first becomes ready\n   * Useful for preloading collections\n   * @param callback Function to call when the collection first becomes ready\n   */\n  public onFirstReady(callback: () => void): void {\n    // If already ready, call immediately\n    if (this.hasBeenReady) {\n      callback()\n      return\n    }\n\n    this.onFirstReadyCallbacks.push(callback)\n  }\n\n  public cleanup(): void {\n    // Cancel any pending idle cleanup\n    if (this.idleCallbackId !== null) {\n      safeCancelIdleCallback(this.idleCallbackId)\n      this.idleCallbackId = null\n    }\n\n    // Perform cleanup immediately (used when explicitly called)\n    this.performCleanup()\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/collection/mutations.d.ts

@@ -0,0 +1,33 @@
+import { CollectionImpl } from './index.js';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { CollectionConfig, InsertConfig, OperationConfig, Transaction as TransactionType, UtilsRecord, WritableDeep } from '../types.js';
+import { CollectionLifecycleManager } from './lifecycle.js';
+import { CollectionStateManager } from './state.js';
+export declare class CollectionMutationsManager<TOutput extends object = Record<string, unknown>, TKey extends string | number = string | number, TUtils extends UtilsRecord = {}, TSchema extends StandardSchemaV1 = StandardSchemaV1, TInput extends object = TOutput> {
+    private lifecycle;
+    private state;
+    private collection;
+    private config;
+    private id;
+    constructor(config: CollectionConfig<TOutput, TKey, TSchema>, id: string);
+    setDeps(deps: {
+        lifecycle: CollectionLifecycleManager<TOutput, TKey, TSchema, TInput>;
+        state: CollectionStateManager<TOutput, TKey, TSchema, TInput>;
+        collection: CollectionImpl<TOutput, TKey, TUtils, TSchema, TInput>;
+    }): void;
+    private ensureStandardSchema;
+    validateData(data: unknown, type: `insert` | `update`, key?: TKey): TOutput | never;
+    generateGlobalKey(key: any, item: any): string;
+    /**
+     * Inserts one or more items into the collection
+     */
+    insert: (data: TInput | Array<TInput>, config?: InsertConfig) => TransactionType<Record<string, unknown>> | TransactionType<TOutput>;
+    /**
+     * Updates one or more items in the collection using a callback function
+     */
+    update(keys: (TKey | unknown) | Array<TKey | unknown>, configOrCallback: ((draft: WritableDeep<TInput>) => void) | ((drafts: Array<WritableDeep<TInput>>) => void) | OperationConfig, maybeCallback?: ((draft: WritableDeep<TInput>) => void) | ((drafts: Array<WritableDeep<TInput>>) => void)): TransactionType<Record<string, unknown>> | TransactionType<TOutput>;
+    /**
+     * Deletes one or more items from the collection
+     */
+    delete: (keys: Array<TKey> | TKey, config?: OperationConfig) => TransactionType<any>;
+}

package/dist/esm/collection/mutations.js

@@ -0,0 +1,315 @@
+import { withArrayChangeTracking, withChangeTracking } from "../proxy.js";
+import { getActiveTransaction, createTransaction } from "../transactions.js";
+import { MissingInsertHandlerError, DuplicateKeyError, MissingDeleteHandlerError, NoKeysPassedToDeleteError, DeleteKeyNotFoundError, InvalidSchemaError, SchemaMustBeSynchronousError, SchemaValidationError, UndefinedKeyError, MissingUpdateArgumentError, MissingUpdateHandlerError, NoKeysPassedToUpdateError, UpdateKeyNotFoundError, KeyUpdateNotAllowedError } from "../errors.js";
+class CollectionMutationsManager {
+  constructor(config, id) {
+    this.insert = (data, config2) => {
+      this.lifecycle.validateCollectionUsable(`insert`);
+      const state = this.state;
+      const ambientTransaction = getActiveTransaction();
+      if (!ambientTransaction && !this.config.onInsert) {
+        throw new MissingInsertHandlerError();
+      }
+      const items = Array.isArray(data) ? data : [data];
+      const mutations = [];
+      items.forEach((item) => {
+        var _a, _b;
+        const validatedData = this.validateData(item, `insert`);
+        const key = this.config.getKey(validatedData);
+        if (this.state.has(key)) {
+          throw new DuplicateKeyError(key);
+        }
+        const globalKey = this.generateGlobalKey(key, item);
+        const mutation = {
+          mutationId: crypto.randomUUID(),
+          original: {},
+          modified: 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,
+          syncMetadata: ((_b = (_a = this.config.sync).getSyncMetadata) == null ? void 0 : _b.call(_a)) || {},
+          optimistic: (config2 == null ? void 0 : config2.optimistic) ?? true,
+          type: `insert`,
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date(),
+          collection: this.collection
+        };
+        mutations.push(mutation);
+      });
+      if (ambientTransaction) {
+        ambientTransaction.applyMutations(mutations);
+        state.transactions.set(ambientTransaction.id, ambientTransaction);
+        state.scheduleTransactionCleanup(ambientTransaction);
+        state.recomputeOptimisticState(true);
+        return ambientTransaction;
+      } else {
+        const directOpTransaction = createTransaction({
+          mutationFn: async (params) => {
+            return await this.config.onInsert({
+              transaction: params.transaction,
+              collection: this.collection
+            });
+          }
+        });
+        directOpTransaction.applyMutations(mutations);
+        directOpTransaction.commit();
+        state.transactions.set(directOpTransaction.id, directOpTransaction);
+        state.scheduleTransactionCleanup(directOpTransaction);
+        state.recomputeOptimisticState(true);
+        return directOpTransaction;
+      }
+    };
+    this.delete = (keys, config2) => {
+      const state = this.state;
+      this.lifecycle.validateCollectionUsable(`delete`);
+      const ambientTransaction = getActiveTransaction();
+      if (!ambientTransaction && !this.config.onDelete) {
+        throw new MissingDeleteHandlerError();
+      }
+      if (Array.isArray(keys) && keys.length === 0) {
+        throw new NoKeysPassedToDeleteError();
+      }
+      const keysArray = Array.isArray(keys) ? keys : [keys];
+      const mutations = [];
+      for (const key of keysArray) {
+        if (!this.state.has(key)) {
+          throw new DeleteKeyNotFoundError(key);
+        }
+        const globalKey = this.generateGlobalKey(key, this.state.get(key));
+        const mutation = {
+          mutationId: crypto.randomUUID(),
+          original: this.state.get(key),
+          modified: this.state.get(key),
+          changes: this.state.get(key),
+          globalKey,
+          key,
+          metadata: config2 == null ? void 0 : config2.metadata,
+          syncMetadata: state.syncedMetadata.get(key) || {},
+          optimistic: (config2 == null ? void 0 : config2.optimistic) ?? true,
+          type: `delete`,
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date(),
+          collection: this.collection
+        };
+        mutations.push(mutation);
+      }
+      if (ambientTransaction) {
+        ambientTransaction.applyMutations(mutations);
+        state.transactions.set(ambientTransaction.id, ambientTransaction);
+        state.scheduleTransactionCleanup(ambientTransaction);
+        state.recomputeOptimisticState(true);
+        return ambientTransaction;
+      }
+      const directOpTransaction = createTransaction({
+        autoCommit: true,
+        mutationFn: async (params) => {
+          return this.config.onDelete({
+            transaction: params.transaction,
+            collection: this.collection
+          });
+        }
+      });
+      directOpTransaction.applyMutations(mutations);
+      directOpTransaction.commit();
+      state.transactions.set(directOpTransaction.id, directOpTransaction);
+      state.scheduleTransactionCleanup(directOpTransaction);
+      state.recomputeOptimisticState(true);
+      return directOpTransaction;
+    };
+    this.id = id;
+    this.config = config;
+  }
+  setDeps(deps) {
+    this.lifecycle = deps.lifecycle;
+    this.state = deps.state;
+    this.collection = deps.collection;
+  }
+  ensureStandardSchema(schema) {
+    if (schema && `~standard` in schema) {
+      return schema;
+    }
+    throw new InvalidSchemaError();
+  }
+  validateData(data, type, key) {
+    if (!this.config.schema) return data;
+    const standardSchema = this.ensureStandardSchema(this.config.schema);
+    if (type === `update` && key) {
+      const existingData = this.state.get(key);
+      if (existingData && data && typeof data === `object` && typeof existingData === `object`) {
+        const mergedData = Object.assign({}, existingData, data);
+        const result2 = standardSchema[`~standard`].validate(mergedData);
+        if (result2 instanceof Promise) {
+          throw new SchemaMustBeSynchronousError();
+        }
+        if (`issues` in result2 && result2.issues) {
+          const typedIssues = result2.issues.map((issue) => {
+            var _a;
+            return {
+              message: issue.message,
+              path: (_a = issue.path) == null ? void 0 : _a.map((p) => String(p))
+            };
+          });
+          throw new SchemaValidationError(type, typedIssues);
+        }
+        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);
+    if (result instanceof Promise) {
+      throw new SchemaMustBeSynchronousError();
+    }
+    if (`issues` in result && result.issues) {
+      const typedIssues = result.issues.map((issue) => {
+        var _a;
+        return {
+          message: issue.message,
+          path: (_a = issue.path) == null ? void 0 : _a.map((p) => String(p))
+        };
+      });
+      throw new SchemaValidationError(type, typedIssues);
+    }
+    return result.value;
+  }
+  generateGlobalKey(key, item) {
+    if (typeof key === `undefined`) {
+      throw new UndefinedKeyError(item);
+    }
+    return `KEY::${this.id}/${key}`;
+  }
+  /**
+   * Updates one or more items in the collection using a callback function
+   */
+  update(keys, configOrCallback, maybeCallback) {
+    if (typeof keys === `undefined`) {
+      throw new MissingUpdateArgumentError();
+    }
+    const state = this.state;
+    this.lifecycle.validateCollectionUsable(`update`);
+    const ambientTransaction = getActiveTransaction();
+    if (!ambientTransaction && !this.config.onUpdate) {
+      throw new MissingUpdateHandlerError();
+    }
+    const isArray = Array.isArray(keys);
+    const keysArray = isArray ? keys : [keys];
+    if (isArray && keysArray.length === 0) {
+      throw new NoKeysPassedToUpdateError();
+    }
+    const callback = typeof configOrCallback === `function` ? configOrCallback : maybeCallback;
+    const config = typeof configOrCallback === `function` ? {} : configOrCallback;
+    const currentObjects = keysArray.map((key) => {
+      const item = this.state.get(key);
+      if (!item) {
+        throw new UpdateKeyNotFoundError(key);
+      }
+      return item;
+    });
+    let changesArray;
+    if (isArray) {
+      changesArray = withArrayChangeTracking(
+        currentObjects,
+        callback
+      );
+    } else {
+      const result = withChangeTracking(
+        currentObjects[0],
+        callback
+      );
+      changesArray = [result];
+    }
+    const mutations = keysArray.map((key, index) => {
+      const itemChanges = changesArray[index];
+      if (!itemChanges || Object.keys(itemChanges).length === 0) {
+        return null;
+      }
+      const originalItem = currentObjects[index];
+      const validatedUpdatePayload = this.validateData(
+        itemChanges,
+        `update`,
+        key
+      );
+      const modifiedItem = Object.assign(
+        {},
+        originalItem,
+        validatedUpdatePayload
+      );
+      const originalItemId = this.config.getKey(originalItem);
+      const modifiedItemId = this.config.getKey(modifiedItem);
+      if (originalItemId !== modifiedItemId) {
+        throw new KeyUpdateNotAllowedError(originalItemId, modifiedItemId);
+      }
+      const globalKey = this.generateGlobalKey(modifiedItemId, modifiedItem);
+      return {
+        mutationId: crypto.randomUUID(),
+        original: originalItem,
+        modified: modifiedItem,
+        // 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,
+        syncMetadata: state.syncedMetadata.get(key) || {},
+        optimistic: config.optimistic ?? true,
+        type: `update`,
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date(),
+        collection: this.collection
+      };
+    }).filter(Boolean);
+    if (mutations.length === 0) {
+      const emptyTransaction = createTransaction({
+        mutationFn: async () => {
+        }
+      });
+      emptyTransaction.commit();
+      state.scheduleTransactionCleanup(emptyTransaction);
+      return emptyTransaction;
+    }
+    if (ambientTransaction) {
+      ambientTransaction.applyMutations(mutations);
+      state.transactions.set(ambientTransaction.id, ambientTransaction);
+      state.scheduleTransactionCleanup(ambientTransaction);
+      state.recomputeOptimisticState(true);
+      return ambientTransaction;
+    }
+    const directOpTransaction = createTransaction({
+      mutationFn: async (params) => {
+        return this.config.onUpdate({
+          transaction: params.transaction,
+          collection: this.collection
+        });
+      }
+    });
+    directOpTransaction.applyMutations(mutations);
+    directOpTransaction.commit();
+    state.transactions.set(directOpTransaction.id, directOpTransaction);
+    state.scheduleTransactionCleanup(directOpTransaction);
+    state.recomputeOptimisticState(true);
+    return directOpTransaction;
+  }
+}
+export {
+  CollectionMutationsManager
+};
+//# sourceMappingURL=mutations.js.map