@tanstack/solid-query 5.0.0-alpha.86 → 5.0.0-alpha.88

package/build/dev.cjs

@@ -0,0 +1,354 @@
+'use strict';
+
+var queryCore = require('@tanstack/query-core');
+var solidJs = require('solid-js');
+var web = require('solid-js/web');
+var store = require('solid-js/store');
+
+// src/setBatchUpdatesFn.ts
+queryCore.notifyManager.setBatchNotifyFunction(solidJs.batch);
+exports.QueryClient = class QueryClient extends queryCore.QueryClient {
+  constructor(config = {}) {
+    super(config);
+  }
+};
+exports.QueryClientContext = solidJs.createContext(void 0);
+exports.useQueryClient = (queryClient) => {
+  if (queryClient) {
+    return queryClient;
+  }
+  const client = solidJs.useContext(exports.QueryClientContext);
+  if (!client) {
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  }
+  return client;
+};
+exports.QueryClientProvider = (props) => {
+  solidJs.onMount(() => {
+    props.client.mount();
+  });
+  solidJs.onCleanup(() => props.client.unmount());
+  return web.createComponent(exports.QueryClientContext.Provider, {
+    get value() {
+      return props.client;
+    },
+    get children() {
+      return props.children;
+    }
+  });
+};
+
+// src/utils.ts
+function shouldThrowError(throwError, params) {
+  if (typeof throwError === "function") {
+    return throwError(...params);
+  }
+  return !!throwError;
+}
+
+// src/createBaseQuery.ts
+function reconcileFn(store$1, result, reconcileOption) {
+  if (reconcileOption === false)
+    return result;
+  if (typeof reconcileOption === "function") {
+    const newData2 = reconcileOption(store$1.data, result.data);
+    return { ...result, data: newData2 };
+  }
+  const newData = store.reconcile(result.data, { key: reconcileOption })(store$1.data);
+  return { ...result, data: newData };
+}
+function createBaseQuery(options, Observer, queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const defaultedOptions = client().defaultQueryOptions(options());
+  defaultedOptions._optimisticResults = "optimistic";
+  defaultedOptions.structuralSharing = false;
+  if (web.isServer) {
+    defaultedOptions.retry = false;
+    defaultedOptions.throwOnError = true;
+  }
+  const observer = new Observer(client(), defaultedOptions);
+  const [state, setState] = store.createStore(
+    observer.getOptimisticResult(defaultedOptions)
+  );
+  const createServerSubscriber = (resolve, reject) => {
+    return observer.subscribe((result) => {
+      queryCore.notifyManager.batchCalls(() => {
+        const query = observer.getCurrentQuery();
+        const { refetch: refetch2, ...rest } = store.unwrap(result);
+        const unwrappedResult = {
+          ...rest,
+          // hydrate() expects a QueryState object, which is similar but not
+          // quite the same as a QueryObserverResult object. Thus, for now, we're
+          // copying over the missing properties from state in order to support hydration
+          dataUpdateCount: query.state.dataUpdateCount,
+          fetchFailureCount: query.state.fetchFailureCount,
+          // Removing these properties since they might not be serializable
+          // fetchFailureReason: query.state.fetchFailureReason,
+          // fetchMeta: query.state.fetchMeta,
+          isInvalidated: query.state.isInvalidated
+        };
+        if (unwrappedResult.isError) {
+          {
+            console.error(unwrappedResult.error);
+          }
+          reject(unwrappedResult.error);
+        }
+        if (unwrappedResult.isSuccess) {
+          resolve(unwrappedResult);
+        }
+      })();
+    });
+  };
+  const createClientSubscriber = () => {
+    return observer.subscribe((result) => {
+      queryCore.notifyManager.batchCalls(() => {
+        const reconcileOptions = observer.options.reconcile;
+        if (queryResource()?.data && result.data && !queryResource.loading) {
+          setState((store) => {
+            return reconcileFn(
+              store,
+              result,
+              reconcileOptions === void 0 ? "id" : reconcileOptions
+            );
+          });
+          mutate(state);
+        } else {
+          setState((store) => {
+            return reconcileFn(
+              store,
+              result,
+              reconcileOptions === void 0 ? "id" : reconcileOptions
+            );
+          });
+          refetch();
+        }
+      })();
+    });
+  };
+  let unsubscribe = null;
+  const [queryResource, { refetch, mutate }] = solidJs.createResource(
+    () => {
+      return new Promise((resolve, reject) => {
+        if (web.isServer) {
+          unsubscribe = createServerSubscriber(resolve, reject);
+        } else {
+          if (!unsubscribe) {
+            unsubscribe = createClientSubscriber();
+          }
+        }
+        if (!state.isLoading) {
+          resolve(state);
+        }
+      });
+    },
+    {
+      initialValue: state,
+      // If initialData is provided, we resolve the resource immediately
+      ssrLoadFrom: options().initialData ? "initial" : "server",
+      get deferStream() {
+        return options().deferStream;
+      },
+      /**
+       * If this resource was populated on the server (either sync render, or streamed in over time), onHydrated
+       * will be called. This is the point at which we can hydrate the query cache state, and setup the query subscriber.
+       *
+       * Leveraging onHydrated allows us to plug into the async and streaming support that solidjs resources already support.
+       *
+       * Note that this is only invoked on the client, for queries that were originally run on the server.
+       */
+      onHydrated(_k, info) {
+        if (info.value) {
+          queryCore.hydrate(client(), {
+            queries: [
+              {
+                queryKey: defaultedOptions.queryKey,
+                queryHash: defaultedOptions.queryHash,
+                state: info.value
+              }
+            ]
+          });
+        }
+        if (!unsubscribe) {
+          const newOptions = { ...defaultedOptions };
+          if (defaultedOptions.staleTime || !defaultedOptions.initialData) {
+            newOptions.refetchOnMount = false;
+          }
+          observer.setOptions(newOptions);
+          setState(observer.getOptimisticResult(newOptions));
+          unsubscribe = createClientSubscriber();
+        }
+      }
+    }
+  );
+  solidJs.onCleanup(() => {
+    if (unsubscribe) {
+      unsubscribe();
+      unsubscribe = null;
+    }
+  });
+  solidJs.createComputed(
+    solidJs.on(
+      () => client().defaultQueryOptions(options()),
+      () => observer.setOptions(client().defaultQueryOptions(options())),
+      {
+        // Defer because we don't need to trigger on first render
+        // This only cares about changes to options after the observer is created
+        defer: true
+      }
+    )
+  );
+  solidJs.createComputed(
+    solidJs.on(
+      () => state.status,
+      () => {
+        if (state.isError && !state.isFetching && shouldThrowError(observer.options.throwOnError, [
+          state.error,
+          observer.getCurrentQuery()
+        ])) {
+          throw state.error;
+        }
+      }
+    )
+  );
+  const handler = {
+    get(target, prop) {
+      const val = queryResource()?.[prop];
+      return val !== void 0 ? val : Reflect.get(target, prop);
+    }
+  };
+  return new Proxy(state, handler);
+}
+
+// src/createQuery.ts
+function queryOptions(options) {
+  return options;
+}
+function createQuery(options, queryClient) {
+  return createBaseQuery(
+    solidJs.createMemo(() => options()),
+    queryCore.QueryObserver,
+    queryClient
+  );
+}
+function useIsFetching(filters, queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const queryCache = solidJs.createMemo(() => client().getQueryCache());
+  const [fetches, setFetches] = solidJs.createSignal(client().isFetching(filters?.()));
+  const unsubscribe = queryCache().subscribe(() => {
+    setFetches(client().isFetching(filters?.()));
+  });
+  solidJs.onCleanup(unsubscribe);
+  return fetches;
+}
+function createInfiniteQuery(options, queryClient) {
+  return createBaseQuery(
+    solidJs.createMemo(() => options()),
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+    queryCore.InfiniteQueryObserver,
+    queryClient
+  );
+}
+function createMutation(options, queryClient) {
+  const client = exports.useQueryClient(queryClient?.());
+  const observer = new queryCore.MutationObserver(
+    client,
+    options()
+  );
+  const mutate = (variables, mutateOptions) => {
+    observer.mutate(variables, mutateOptions).catch(noop);
+  };
+  const [state, setState] = store.createStore({
+    ...observer.getCurrentResult(),
+    mutate,
+    mutateAsync: observer.getCurrentResult().mutate
+  });
+  solidJs.createComputed(() => {
+    observer.setOptions(options());
+  });
+  solidJs.createComputed(
+    solidJs.on(
+      () => state.status,
+      () => {
+        if (state.isError && shouldThrowError(observer.options.throwOnError, [state.error])) {
+          throw state.error;
+        }
+      }
+    )
+  );
+  const unsubscribe = observer.subscribe((result) => {
+    setState({
+      ...result,
+      mutate,
+      mutateAsync: result.mutate
+    });
+  });
+  solidJs.onCleanup(unsubscribe);
+  return state;
+}
+function noop() {
+}
+function useIsMutating(filters, queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const mutationCache = solidJs.createMemo(() => client().getMutationCache());
+  const [mutations, setMutations] = solidJs.createSignal(
+    client().isMutating(filters?.())
+  );
+  const unsubscribe = mutationCache().subscribe((_result) => {
+    setMutations(client().isMutating(filters?.()));
+  });
+  solidJs.onCleanup(unsubscribe);
+  return mutations;
+}
+function createQueries(queriesOptions, queryClient) {
+  const client = exports.useQueryClient(queryClient?.());
+  const defaultedQueries = queriesOptions().queries.map((options) => {
+    const defaultedOptions = client.defaultQueryOptions(options);
+    defaultedOptions._optimisticResults = "optimistic";
+    return defaultedOptions;
+  });
+  const observer = new queryCore.QueriesObserver(
+    client,
+    defaultedQueries,
+    queriesOptions().combine ? {
+      combine: queriesOptions().combine
+    } : void 0
+  );
+  const [state, setState] = store.createStore(
+    observer.getOptimisticResult(defaultedQueries)[1]()
+  );
+  const unsubscribe = observer.subscribe((result) => {
+    queryCore.notifyManager.batchCalls(() => {
+      setState(store.unwrap(result));
+    })();
+  });
+  solidJs.onCleanup(unsubscribe);
+  solidJs.createComputed(() => {
+    const updatedQueries = queriesOptions().queries.map((options) => {
+      const defaultedOptions = client.defaultQueryOptions(options);
+      defaultedOptions._optimisticResults = "optimistic";
+      return defaultedOptions;
+    });
+    observer.setQueries(
+      updatedQueries,
+      queriesOptions().combine ? {
+        combine: queriesOptions().combine
+      } : void 0,
+      { listeners: false }
+    );
+  });
+  return state;
+}
+
+exports.createInfiniteQuery = createInfiniteQuery;
+exports.createMutation = createMutation;
+exports.createQueries = createQueries;
+exports.createQuery = createQuery;
+exports.queryOptions = queryOptions;
+exports.useIsFetching = useIsFetching;
+exports.useIsMutating = useIsMutating;
+Object.keys(queryCore).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return queryCore[k]; }
+  });
+});

package/build/dev.js

@@ -0,0 +1,341 @@
+import { notifyManager, QueryClient as QueryClient$1, MutationObserver, QueriesObserver, hydrate, QueryObserver, InfiniteQueryObserver } from '@tanstack/query-core';
+export * from '@tanstack/query-core';
+import { batch, createContext, useContext, onMount, onCleanup, createMemo, createSignal, createComputed, on, createResource } from 'solid-js';
+import { createComponent, isServer } from 'solid-js/web';
+import { createStore, unwrap, reconcile } from 'solid-js/store';
+
+// src/setBatchUpdatesFn.ts
+notifyManager.setBatchNotifyFunction(batch);
+var QueryClient = class extends QueryClient$1 {
+  constructor(config = {}) {
+    super(config);
+  }
+};
+var QueryClientContext = createContext(void 0);
+var useQueryClient = (queryClient) => {
+  if (queryClient) {
+    return queryClient;
+  }
+  const client = useContext(QueryClientContext);
+  if (!client) {
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  }
+  return client;
+};
+var QueryClientProvider = (props) => {
+  onMount(() => {
+    props.client.mount();
+  });
+  onCleanup(() => props.client.unmount());
+  return createComponent(QueryClientContext.Provider, {
+    get value() {
+      return props.client;
+    },
+    get children() {
+      return props.children;
+    }
+  });
+};
+
+// src/utils.ts
+function shouldThrowError(throwError, params) {
+  if (typeof throwError === "function") {
+    return throwError(...params);
+  }
+  return !!throwError;
+}
+
+// src/createBaseQuery.ts
+function reconcileFn(store, result, reconcileOption) {
+  if (reconcileOption === false)
+    return result;
+  if (typeof reconcileOption === "function") {
+    const newData2 = reconcileOption(store.data, result.data);
+    return { ...result, data: newData2 };
+  }
+  const newData = reconcile(result.data, { key: reconcileOption })(store.data);
+  return { ...result, data: newData };
+}
+function createBaseQuery(options, Observer, queryClient) {
+  const client = createMemo(() => useQueryClient(queryClient?.()));
+  const defaultedOptions = client().defaultQueryOptions(options());
+  defaultedOptions._optimisticResults = "optimistic";
+  defaultedOptions.structuralSharing = false;
+  if (isServer) {
+    defaultedOptions.retry = false;
+    defaultedOptions.throwOnError = true;
+  }
+  const observer = new Observer(client(), defaultedOptions);
+  const [state, setState] = createStore(
+    observer.getOptimisticResult(defaultedOptions)
+  );
+  const createServerSubscriber = (resolve, reject) => {
+    return observer.subscribe((result) => {
+      notifyManager.batchCalls(() => {
+        const query = observer.getCurrentQuery();
+        const { refetch: refetch2, ...rest } = unwrap(result);
+        const unwrappedResult = {
+          ...rest,
+          // hydrate() expects a QueryState object, which is similar but not
+          // quite the same as a QueryObserverResult object. Thus, for now, we're
+          // copying over the missing properties from state in order to support hydration
+          dataUpdateCount: query.state.dataUpdateCount,
+          fetchFailureCount: query.state.fetchFailureCount,
+          // Removing these properties since they might not be serializable
+          // fetchFailureReason: query.state.fetchFailureReason,
+          // fetchMeta: query.state.fetchMeta,
+          isInvalidated: query.state.isInvalidated
+        };
+        if (unwrappedResult.isError) {
+          {
+            console.error(unwrappedResult.error);
+          }
+          reject(unwrappedResult.error);
+        }
+        if (unwrappedResult.isSuccess) {
+          resolve(unwrappedResult);
+        }
+      })();
+    });
+  };
+  const createClientSubscriber = () => {
+    return observer.subscribe((result) => {
+      notifyManager.batchCalls(() => {
+        const reconcileOptions = observer.options.reconcile;
+        if (queryResource()?.data && result.data && !queryResource.loading) {
+          setState((store) => {
+            return reconcileFn(
+              store,
+              result,
+              reconcileOptions === void 0 ? "id" : reconcileOptions
+            );
+          });
+          mutate(state);
+        } else {
+          setState((store) => {
+            return reconcileFn(
+              store,
+              result,
+              reconcileOptions === void 0 ? "id" : reconcileOptions
+            );
+          });
+          refetch();
+        }
+      })();
+    });
+  };
+  let unsubscribe = null;
+  const [queryResource, { refetch, mutate }] = createResource(
+    () => {
+      return new Promise((resolve, reject) => {
+        if (isServer) {
+          unsubscribe = createServerSubscriber(resolve, reject);
+        } else {
+          if (!unsubscribe) {
+            unsubscribe = createClientSubscriber();
+          }
+        }
+        if (!state.isLoading) {
+          resolve(state);
+        }
+      });
+    },
+    {
+      initialValue: state,
+      // If initialData is provided, we resolve the resource immediately
+      ssrLoadFrom: options().initialData ? "initial" : "server",
+      get deferStream() {
+        return options().deferStream;
+      },
+      /**
+       * If this resource was populated on the server (either sync render, or streamed in over time), onHydrated
+       * will be called. This is the point at which we can hydrate the query cache state, and setup the query subscriber.
+       *
+       * Leveraging onHydrated allows us to plug into the async and streaming support that solidjs resources already support.
+       *
+       * Note that this is only invoked on the client, for queries that were originally run on the server.
+       */
+      onHydrated(_k, info) {
+        if (info.value) {
+          hydrate(client(), {
+            queries: [
+              {
+                queryKey: defaultedOptions.queryKey,
+                queryHash: defaultedOptions.queryHash,
+                state: info.value
+              }
+            ]
+          });
+        }
+        if (!unsubscribe) {
+          const newOptions = { ...defaultedOptions };
+          if (defaultedOptions.staleTime || !defaultedOptions.initialData) {
+            newOptions.refetchOnMount = false;
+          }
+          observer.setOptions(newOptions);
+          setState(observer.getOptimisticResult(newOptions));
+          unsubscribe = createClientSubscriber();
+        }
+      }
+    }
+  );
+  onCleanup(() => {
+    if (unsubscribe) {
+      unsubscribe();
+      unsubscribe = null;
+    }
+  });
+  createComputed(
+    on(
+      () => client().defaultQueryOptions(options()),
+      () => observer.setOptions(client().defaultQueryOptions(options())),
+      {
+        // Defer because we don't need to trigger on first render
+        // This only cares about changes to options after the observer is created
+        defer: true
+      }
+    )
+  );
+  createComputed(
+    on(
+      () => state.status,
+      () => {
+        if (state.isError && !state.isFetching && shouldThrowError(observer.options.throwOnError, [
+          state.error,
+          observer.getCurrentQuery()
+        ])) {
+          throw state.error;
+        }
+      }
+    )
+  );
+  const handler = {
+    get(target, prop) {
+      const val = queryResource()?.[prop];
+      return val !== void 0 ? val : Reflect.get(target, prop);
+    }
+  };
+  return new Proxy(state, handler);
+}
+
+// src/createQuery.ts
+function queryOptions(options) {
+  return options;
+}
+function createQuery(options, queryClient) {
+  return createBaseQuery(
+    createMemo(() => options()),
+    QueryObserver,
+    queryClient
+  );
+}
+function useIsFetching(filters, queryClient) {
+  const client = createMemo(() => useQueryClient(queryClient?.()));
+  const queryCache = createMemo(() => client().getQueryCache());
+  const [fetches, setFetches] = createSignal(client().isFetching(filters?.()));
+  const unsubscribe = queryCache().subscribe(() => {
+    setFetches(client().isFetching(filters?.()));
+  });
+  onCleanup(unsubscribe);
+  return fetches;
+}
+function createInfiniteQuery(options, queryClient) {
+  return createBaseQuery(
+    createMemo(() => options()),
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+    InfiniteQueryObserver,
+    queryClient
+  );
+}
+function createMutation(options, queryClient) {
+  const client = useQueryClient(queryClient?.());
+  const observer = new MutationObserver(
+    client,
+    options()
+  );
+  const mutate = (variables, mutateOptions) => {
+    observer.mutate(variables, mutateOptions).catch(noop);
+  };
+  const [state, setState] = createStore({
+    ...observer.getCurrentResult(),
+    mutate,
+    mutateAsync: observer.getCurrentResult().mutate
+  });
+  createComputed(() => {
+    observer.setOptions(options());
+  });
+  createComputed(
+    on(
+      () => state.status,
+      () => {
+        if (state.isError && shouldThrowError(observer.options.throwOnError, [state.error])) {
+          throw state.error;
+        }
+      }
+    )
+  );
+  const unsubscribe = observer.subscribe((result) => {
+    setState({
+      ...result,
+      mutate,
+      mutateAsync: result.mutate
+    });
+  });
+  onCleanup(unsubscribe);
+  return state;
+}
+function noop() {
+}
+function useIsMutating(filters, queryClient) {
+  const client = createMemo(() => useQueryClient(queryClient?.()));
+  const mutationCache = createMemo(() => client().getMutationCache());
+  const [mutations, setMutations] = createSignal(
+    client().isMutating(filters?.())
+  );
+  const unsubscribe = mutationCache().subscribe((_result) => {
+    setMutations(client().isMutating(filters?.()));
+  });
+  onCleanup(unsubscribe);
+  return mutations;
+}
+function createQueries(queriesOptions, queryClient) {
+  const client = useQueryClient(queryClient?.());
+  const defaultedQueries = queriesOptions().queries.map((options) => {
+    const defaultedOptions = client.defaultQueryOptions(options);
+    defaultedOptions._optimisticResults = "optimistic";
+    return defaultedOptions;
+  });
+  const observer = new QueriesObserver(
+    client,
+    defaultedQueries,
+    queriesOptions().combine ? {
+      combine: queriesOptions().combine
+    } : void 0
+  );
+  const [state, setState] = createStore(
+    observer.getOptimisticResult(defaultedQueries)[1]()
+  );
+  const unsubscribe = observer.subscribe((result) => {
+    notifyManager.batchCalls(() => {
+      setState(unwrap(result));
+    })();
+  });
+  onCleanup(unsubscribe);
+  createComputed(() => {
+    const updatedQueries = queriesOptions().queries.map((options) => {
+      const defaultedOptions = client.defaultQueryOptions(options);
+      defaultedOptions._optimisticResults = "optimistic";
+      return defaultedOptions;
+    });
+    observer.setQueries(
+      updatedQueries,
+      queriesOptions().combine ? {
+        combine: queriesOptions().combine
+      } : void 0,
+      { listeners: false }
+    );
+  });
+  return state;
+}
+
+export { QueryClient, QueryClientContext, QueryClientProvider, createInfiniteQuery, createMutation, createQueries, createQuery, queryOptions, useIsFetching, useIsMutating, useQueryClient };