@tanstack/query-db-collection 0.3.0 → 1.0.1

package/dist/cjs/index.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const query = require("./query.cjs");
 const errors = require("./errors.cjs");
+const db = require("@tanstack/db");
 exports.queryCollectionOptions = query.queryCollectionOptions;
 exports.DeleteOperationItemNotFoundError = errors.DeleteOperationItemNotFoundError;
 exports.DuplicateKeyInBatchError = errors.DuplicateKeyInBatchError;
@@ -17,4 +18,32 @@ exports.QueryKeyRequiredError = errors.QueryKeyRequiredError;
 exports.SyncNotInitializedError = errors.SyncNotInitializedError;
 exports.UnknownOperationTypeError = errors.UnknownOperationTypeError;
 exports.UpdateOperationItemNotFoundError = errors.UpdateOperationItemNotFoundError;
+Object.defineProperty(exports, "extractFieldPath", {
+  enumerable: true,
+  get: () => db.extractFieldPath
+});
+Object.defineProperty(exports, "extractSimpleComparisons", {
+  enumerable: true,
+  get: () => db.extractSimpleComparisons
+});
+Object.defineProperty(exports, "extractValue", {
+  enumerable: true,
+  get: () => db.extractValue
+});
+Object.defineProperty(exports, "parseLoadSubsetOptions", {
+  enumerable: true,
+  get: () => db.parseLoadSubsetOptions
+});
+Object.defineProperty(exports, "parseOrderByExpression", {
+  enumerable: true,
+  get: () => db.parseOrderByExpression
+});
+Object.defineProperty(exports, "parseWhereExpression", {
+  enumerable: true,
+  get: () => db.parseWhereExpression
+});
+Object.defineProperty(exports, "walkExpression", {
+  enumerable: true,
+  get: () => db.walkExpression
+});
 //# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/index.d.cts

@@ -1,2 +1,3 @@
 export { queryCollectionOptions, type QueryCollectionConfig, type QueryCollectionUtils, type SyncOperation, } from './query.cjs';
 export * from './errors.cjs';
+export { parseWhereExpression, parseOrderByExpression, extractSimpleComparisons, parseLoadSubsetOptions, extractFieldPath, extractValue, walkExpression, type FieldPath, type SimpleComparison, type ParseWhereOptions, type ParsedOrderBy, } from '@tanstack/db';

package/dist/cjs/query.cjs

@@ -32,19 +32,32 @@ class QueryCollectionUtilsImpl {
   }
   // Getters for QueryObserver state
   get isFetching() {
-    return this.state.queryObserver?.getCurrentResult().isFetching ?? false;
+    return Array.from(this.state.observers.values()).some(
+      (observer) => observer.getCurrentResult().isFetching
+    );
   }
   get isRefetching() {
-    return this.state.queryObserver?.getCurrentResult().isRefetching ?? false;
+    return Array.from(this.state.observers.values()).some(
+      (observer) => observer.getCurrentResult().isRefetching
+    );
   }
   get isLoading() {
-    return this.state.queryObserver?.getCurrentResult().isLoading ?? false;
+    return Array.from(this.state.observers.values()).some(
+      (observer) => observer.getCurrentResult().isLoading
+    );
   }
   get dataUpdatedAt() {
-    return this.state.queryObserver?.getCurrentResult().dataUpdatedAt ?? 0;
+    return Math.max(
+      0,
+      ...Array.from(this.state.observers.values()).map(
+        (observer) => observer.getCurrentResult().dataUpdatedAt
+      )
+    );
   }
   get fetchStatus() {
-    return this.state.queryObserver?.getCurrentResult().fetchStatus ?? `idle`;
+    return Array.from(this.state.observers.values()).map(
+      (observer) => observer.getCurrentResult().fetchStatus
+    );
   }
 }
 function queryCollectionOptions(config) {
@@ -65,6 +78,7 @@ function queryCollectionOptions(config) {
     meta,
     ...baseCollectionConfig
   } = config;
+  const syncMode = baseCollectionConfig.syncMode ?? `eager`;
   if (!queryKey) {
     throw new errors.QueryKeyRequiredError();
   }
@@ -81,126 +95,266 @@ function queryCollectionOptions(config) {
     lastError: void 0,
     errorCount: 0,
     lastErrorUpdatedAt: 0,
-    queryObserver: void 0
+    observers: /* @__PURE__ */ new Map()
+  };
+  const hashToQueryKey = /* @__PURE__ */ new Map();
+  const queryToRows = /* @__PURE__ */ new Map();
+  const rowToQueries = /* @__PURE__ */ new Map();
+  const unsubscribes = /* @__PURE__ */ new Map();
+  const addRow = (rowKey, hashedQueryKey) => {
+    const rowToQueriesSet = rowToQueries.get(rowKey) || /* @__PURE__ */ new Set();
+    rowToQueriesSet.add(hashedQueryKey);
+    rowToQueries.set(rowKey, rowToQueriesSet);
+    const queryToRowsSet = queryToRows.get(hashedQueryKey) || /* @__PURE__ */ new Set();
+    queryToRowsSet.add(rowKey);
+    queryToRows.set(hashedQueryKey, queryToRowsSet);
+  };
+  const removeRow = (rowKey, hashedQuerKey) => {
+    const rowToQueriesSet = rowToQueries.get(rowKey) || /* @__PURE__ */ new Set();
+    rowToQueriesSet.delete(hashedQuerKey);
+    rowToQueries.set(rowKey, rowToQueriesSet);
+    const queryToRowsSet = queryToRows.get(hashedQuerKey) || /* @__PURE__ */ new Set();
+    queryToRowsSet.delete(rowKey);
+    queryToRows.set(hashedQuerKey, queryToRowsSet);
+    return rowToQueriesSet.size === 0;
   };
   const internalSync = (params) => {
     const { begin, write, commit, markReady, collection } = params;
-    const observerOptions = {
-      queryKey,
-      queryFn,
-      structuralSharing: true,
-      notifyOnChangeProps: `all`,
-      // Only include options that are explicitly defined to allow QueryClient defaultOptions to be used
-      ...meta !== void 0 && { meta },
-      ...enabled !== void 0 && { enabled },
-      ...refetchInterval !== void 0 && { refetchInterval },
-      ...retry !== void 0 && { retry },
-      ...retryDelay !== void 0 && { retryDelay },
-      ...staleTime !== void 0 && { staleTime }
-    };
-    const localObserver = new queryCore.QueryObserver(queryClient, observerOptions);
-    state.queryObserver = localObserver;
-    let isSubscribed = false;
-    let actualUnsubscribeFn = null;
-    const handleQueryResult = (result) => {
-      if (result.isSuccess) {
-        state.lastError = void 0;
-        state.errorCount = 0;
-        const rawData = result.data;
-        const newItemsArray = select ? select(rawData) : rawData;
-        if (!Array.isArray(newItemsArray) || newItemsArray.some((item) => typeof item !== `object`)) {
-          const errorMessage = select ? `@tanstack/query-db-collection: select() must return an array of objects. Got: ${typeof newItemsArray} for queryKey ${JSON.stringify(queryKey)}` : `@tanstack/query-db-collection: queryFn must return an array of objects. Got: ${typeof newItemsArray} for queryKey ${JSON.stringify(queryKey)}`;
-          console.error(errorMessage);
-          return;
-        }
-        const currentSyncedItems = new Map(
-          collection._state.syncedData.entries()
-        );
-        const newItemsMap = /* @__PURE__ */ new Map();
-        newItemsArray.forEach((item) => {
-          const key = getKey(item);
-          newItemsMap.set(key, item);
-        });
-        begin();
-        const shallowEqual = (obj1, obj2) => {
-          const keys1 = Object.keys(obj1);
-          const keys2 = Object.keys(obj2);
-          if (keys1.length !== keys2.length) return false;
-          return keys1.every((key) => {
-            if (typeof obj1[key] === `function`) return true;
-            return obj1[key] === obj2[key];
+    let syncStarted = false;
+    const createQueryFromOpts = (opts = {}, queryFunction = queryFn) => {
+      const key = typeof queryKey === `function` ? queryKey(opts) : queryKey;
+      const hashedQueryKey = queryCore.hashKey(key);
+      const extendedMeta = { ...meta, loadSubsetOptions: opts };
+      if (state.observers.has(hashedQueryKey)) {
+        const observer = state.observers.get(hashedQueryKey);
+        const currentResult = observer.getCurrentResult();
+        if (currentResult.isSuccess) {
+          return true;
+        } else if (currentResult.isError) {
+          return Promise.reject(currentResult.error);
+        } else {
+          return new Promise((resolve, reject) => {
+            const unsubscribe = observer.subscribe((result) => {
+              if (result.isSuccess) {
+                unsubscribe();
+                resolve();
+              } else if (result.isError) {
+                unsubscribe();
+                reject(result.error);
+              }
+            });
           });
-        };
-        currentSyncedItems.forEach((oldItem, key) => {
-          const newItem = newItemsMap.get(key);
-          if (!newItem) {
-            write({ type: `delete`, value: oldItem });
-          } else if (!shallowEqual(
-            oldItem,
-            newItem
-          )) {
-            write({ type: `update`, value: newItem });
+        }
+      }
+      const observerOptions = {
+        queryKey: key,
+        queryFn: queryFunction,
+        meta: extendedMeta,
+        structuralSharing: true,
+        notifyOnChangeProps: `all`,
+        // Only include options that are explicitly defined to allow QueryClient defaultOptions to be used
+        ...enabled !== void 0 && { enabled },
+        ...refetchInterval !== void 0 && { refetchInterval },
+        ...retry !== void 0 && { retry },
+        ...retryDelay !== void 0 && { retryDelay },
+        ...staleTime !== void 0 && { staleTime }
+      };
+      const localObserver = new queryCore.QueryObserver(queryClient, observerOptions);
+      hashToQueryKey.set(hashedQueryKey, key);
+      state.observers.set(hashedQueryKey, localObserver);
+      const readyPromise = new Promise((resolve, reject) => {
+        const unsubscribe = localObserver.subscribe((result) => {
+          if (result.isSuccess) {
+            unsubscribe();
+            resolve();
+          } else if (result.isError) {
+            unsubscribe();
+            reject(result.error);
           }
         });
-        newItemsMap.forEach((newItem, key) => {
-          if (!currentSyncedItems.has(key)) {
-            write({ type: `insert`, value: newItem });
+      });
+      if (syncStarted || collection.subscriberCount > 0) {
+        subscribeToQuery(localObserver, hashedQueryKey);
+      }
+      const subscription = opts.subscription;
+      subscription?.once(`unsubscribed`, () => {
+        queryClient.removeQueries({ queryKey: key, exact: true });
+      });
+      return readyPromise;
+    };
+    const makeQueryResultHandler = (queryKey2) => {
+      const hashedQueryKey = queryCore.hashKey(queryKey2);
+      const handleQueryResult = (result) => {
+        if (result.isSuccess) {
+          state.lastError = void 0;
+          state.errorCount = 0;
+          const rawData = result.data;
+          const newItemsArray = select ? select(rawData) : rawData;
+          if (!Array.isArray(newItemsArray) || newItemsArray.some((item) => typeof item !== `object`)) {
+            const errorMessage = select ? `@tanstack/query-db-collection: select() must return an array of objects. Got: ${typeof newItemsArray} for queryKey ${JSON.stringify(queryKey2)}` : `@tanstack/query-db-collection: queryFn must return an array of objects. Got: ${typeof newItemsArray} for queryKey ${JSON.stringify(queryKey2)}`;
+            console.error(errorMessage);
+            return;
           }
-        });
-        commit();
-        markReady();
-      } else if (result.isError) {
-        if (result.errorUpdatedAt !== state.lastErrorUpdatedAt) {
-          state.lastError = result.error;
-          state.errorCount++;
-          state.lastErrorUpdatedAt = result.errorUpdatedAt;
+          const currentSyncedItems = new Map(
+            collection._state.syncedData.entries()
+          );
+          const newItemsMap = /* @__PURE__ */ new Map();
+          newItemsArray.forEach((item) => {
+            const key = getKey(item);
+            newItemsMap.set(key, item);
+          });
+          begin();
+          const shallowEqual = (obj1, obj2) => {
+            const keys1 = Object.keys(obj1);
+            const keys2 = Object.keys(obj2);
+            if (keys1.length !== keys2.length) return false;
+            return keys1.every((key) => {
+              if (typeof obj1[key] === `function`) return true;
+              return obj1[key] === obj2[key];
+            });
+          };
+          currentSyncedItems.forEach((oldItem, key) => {
+            const newItem = newItemsMap.get(key);
+            if (!newItem) {
+              const needToRemove = removeRow(key, hashedQueryKey);
+              if (needToRemove) {
+                write({ type: `delete`, value: oldItem });
+              }
+            } else if (!shallowEqual(
+              oldItem,
+              newItem
+            )) {
+              write({ type: `update`, value: newItem });
+            }
+          });
+          newItemsMap.forEach((newItem, key) => {
+            addRow(key, hashedQueryKey);
+            if (!currentSyncedItems.has(key)) {
+              write({ type: `insert`, value: newItem });
+            }
+          });
+          commit();
+          markReady();
+        } else if (result.isError) {
+          if (result.errorUpdatedAt !== state.lastErrorUpdatedAt) {
+            state.lastError = result.error;
+            state.errorCount++;
+            state.lastErrorUpdatedAt = result.errorUpdatedAt;
+          }
+          console.error(
+            `[QueryCollection] Error observing query ${String(queryKey2)}:`,
+            result.error
+          );
+          markReady();
         }
-        console.error(
-          `[QueryCollection] Error observing query ${String(queryKey)}:`,
-          result.error
-        );
-        markReady();
-      }
+      };
+      return handleQueryResult;
     };
-    const subscribeToQuery = () => {
-      if (!isSubscribed) {
-        actualUnsubscribeFn = localObserver.subscribe(handleQueryResult);
-        isSubscribed = true;
-      }
+    const isSubscribed = (hashedQueryKey) => {
+      return unsubscribes.has(hashedQueryKey);
     };
-    const unsubscribeFromQuery = () => {
-      if (isSubscribed && actualUnsubscribeFn) {
-        actualUnsubscribeFn();
-        actualUnsubscribeFn = null;
-        isSubscribed = false;
+    const subscribeToQuery = (observer, hashedQueryKey) => {
+      if (!isSubscribed(hashedQueryKey)) {
+        const queryKey2 = hashToQueryKey.get(hashedQueryKey);
+        const handleQueryResult = makeQueryResultHandler(queryKey2);
+        const unsubscribeFn = observer.subscribe(handleQueryResult);
+        unsubscribes.set(hashedQueryKey, unsubscribeFn);
       }
     };
-    subscribeToQuery();
+    const subscribeToQueries = () => {
+      state.observers.forEach(subscribeToQuery);
+    };
+    const unsubscribeFromQueries = () => {
+      unsubscribes.forEach((unsubscribeFn) => {
+        unsubscribeFn();
+      });
+      unsubscribes.clear();
+    };
+    syncStarted = true;
     const unsubscribeFromCollectionEvents = collection.on(
       `subscribers:change`,
       ({ subscriberCount }) => {
         if (subscriberCount > 0) {
-          subscribeToQuery();
+          subscribeToQueries();
         } else if (subscriberCount === 0) {
-          unsubscribeFromQuery();
+          unsubscribeFromQueries();
         }
       }
     );
-    handleQueryResult(localObserver.getCurrentResult());
-    return async () => {
+    if (syncMode === `eager`) {
+      const initialResult = createQueryFromOpts({});
+      if (initialResult instanceof Promise) {
+        initialResult.catch(() => {
+        });
+      }
+    } else {
+      markReady();
+    }
+    subscribeToQueries();
+    state.observers.forEach((observer, hashedQueryKey) => {
+      const queryKey2 = hashToQueryKey.get(hashedQueryKey);
+      const handleQueryResult = makeQueryResultHandler(queryKey2);
+      handleQueryResult(observer.getCurrentResult());
+    });
+    const unsubscribeQueryCache = queryClient.getQueryCache().subscribe((event) => {
+      const hashedKey = event.query.queryHash;
+      if (event.type === `removed`) {
+        cleanupQuery(hashedKey);
+      }
+    });
+    function cleanupQuery(hashedQueryKey) {
+      unsubscribes.get(hashedQueryKey)?.();
+      const rowKeys = queryToRows.get(hashedQueryKey) ?? /* @__PURE__ */ new Set();
+      rowKeys.forEach((rowKey) => {
+        const queries = rowToQueries.get(rowKey);
+        if (queries && queries.size > 0) {
+          queries.delete(hashedQueryKey);
+          if (queries.size === 0) {
+            rowToQueries.delete(rowKey);
+            if (collection.has(rowKey)) {
+              begin();
+              write({ type: `delete`, value: collection.get(rowKey) });
+              commit();
+            }
+          }
+        }
+      });
+      unsubscribes.delete(hashedQueryKey);
+      state.observers.delete(hashedQueryKey);
+      queryToRows.delete(hashedQueryKey);
+      hashToQueryKey.delete(hashedQueryKey);
+    }
+    const cleanup = async () => {
       unsubscribeFromCollectionEvents();
-      unsubscribeFromQuery();
-      await queryClient.cancelQueries({ queryKey });
-      queryClient.removeQueries({ queryKey });
+      unsubscribeFromQueries();
+      const queryKeys = [...hashToQueryKey.values()];
+      hashToQueryKey.clear();
+      queryToRows.clear();
+      rowToQueries.clear();
+      state.observers.clear();
+      unsubscribeQueryCache();
+      await Promise.all(
+        queryKeys.map(async (queryKey2) => {
+          await queryClient.cancelQueries({ queryKey: queryKey2 });
+          queryClient.removeQueries({ queryKey: queryKey2 });
+        })
+      );
+    };
+    const loadSubsetDedupe = syncMode === `eager` ? void 0 : createQueryFromOpts;
+    return {
+      loadSubset: loadSubsetDedupe,
+      cleanup
     };
   };
   const refetch = async (opts) => {
-    if (!state.queryObserver) {
-      return;
-    }
-    return state.queryObserver.refetch({
-      throwOnError: opts?.throwOnError
+    const queryKeys = [...hashToQueryKey.values()];
+    const refetchPromises = queryKeys.map((queryKey2) => {
+      const queryObserver = state.observers.get(queryCore.hashKey(queryKey2));
+      return queryObserver.refetch({
+        throwOnError: opts?.throwOnError
+      });
     });
+    await Promise.all(refetchPromises);
   };
   let writeContext = null;
   const enhancedInternalSync = (params) => {
@@ -247,6 +401,7 @@ function queryCollectionOptions(config) {
   return {
     ...baseCollectionConfig,
     getKey,
+    syncMode,
     sync: { sync: enhancedInternalSync },
     onInsert: wrappedOnInsert,
     onUpdate: wrappedOnUpdate,