nuxt-convex-module 0.0.0

package/dist/runtime/vue/composables/use-paginated-query.js

@@ -0,0 +1,513 @@
+import { getFunctionName } from "convex/server";
+import { ConvexError, compareValues, convexToJson } from "convex/values";
+import { computed, shallowRef, toValue } from "vue";
+import { useConvex } from "../client.js";
+import { useConvexQueries } from "./use-queries.js";
+const splitQuery = (key, splitCursor, continueCursor) => (prevState) => {
+  const queries = { ...prevState.queries };
+  const splitKey1 = prevState.nextPageKey;
+  const splitKey2 = prevState.nextPageKey + 1;
+  const nextPageKey = prevState.nextPageKey + 2;
+  queries[splitKey1] = {
+    query: prevState.query,
+    args: {
+      ...prevState.args,
+      paginationOpts: {
+        ...prevState.queries[key].args.paginationOpts,
+        endCursor: splitCursor
+      }
+    }
+  };
+  queries[splitKey2] = {
+    query: prevState.query,
+    args: {
+      ...prevState.args,
+      paginationOpts: {
+        ...prevState.queries[key].args.paginationOpts,
+        cursor: splitCursor,
+        endCursor: continueCursor
+      }
+    }
+  };
+  const ongoingSplits = { ...prevState.ongoingSplits };
+  ongoingSplits[key] = [splitKey1, splitKey2];
+  return {
+    ...prevState,
+    nextPageKey,
+    queries,
+    ongoingSplits
+  };
+};
+const completeSplitQuery = (key) => (prevState) => {
+  const completedSplit = prevState.ongoingSplits[key];
+  if (completedSplit === void 0) {
+    return prevState;
+  }
+  const queries = { ...prevState.queries };
+  delete queries[key];
+  const ongoingSplits = { ...prevState.ongoingSplits };
+  delete ongoingSplits[key];
+  let pageKeys = prevState.pageKeys.slice();
+  const pageIndex = prevState.pageKeys.findIndex((v) => v === key);
+  if (pageIndex >= 0) {
+    pageKeys = [
+      ...prevState.pageKeys.slice(0, pageIndex),
+      ...completedSplit,
+      ...prevState.pageKeys.slice(pageIndex + 1)
+    ];
+  }
+  return {
+    ...prevState,
+    queries,
+    pageKeys,
+    ongoingSplits
+  };
+};
+function isPaginatedQueryValue(value) {
+  return typeof value === "object" && value !== null && "page" in value && Array.isArray(value.page) && "isDone" in value && "continueCursor" in value;
+}
+const INTERNAL_ERROR_STATUS = "Error";
+const SPLIT_PAGE_STATUSES = ["SplitRecommended", "SplitRequired"];
+export function usePaginatedQuery(query, args, options) {
+  const internal = usePaginatedQueryInternal(
+    () => query,
+    args,
+    () => options
+  );
+  return splitToRefs(internal);
+}
+function splitToRefs(internal) {
+  const current = () => {
+    const value = internal.value;
+    if (value.status === INTERNAL_ERROR_STATUS) throw value.error;
+    return value;
+  };
+  return {
+    results: computed(() => current().results),
+    status: computed(() => current().status),
+    isLoading: computed(() => current().isLoading),
+    loadMore: (numItems) => {
+      current().loadMore(numItems);
+    }
+  };
+}
+function usePaginatedQueryInternal(query, args, options) {
+  const initialOptions = toValue(options);
+  if (typeof initialOptions?.initialNumItems !== "number" || initialOptions.initialNumItems < 0) {
+    throw new Error(
+      `\`options.initialNumItems\` must be a positive number. Received \`${initialOptions?.initialNumItems}\`.`
+    );
+  }
+  const convex = useConvex();
+  const logger = convex.logger;
+  function createInitialState(q, currentArgs, skip, initialNumItems) {
+    const id = nextPaginationId();
+    return {
+      query: q,
+      args: currentArgs,
+      id,
+      nextPageKey: 1,
+      pageKeys: skip ? [] : [0],
+      queries: skip ? {} : {
+        0: {
+          query: q,
+          args: {
+            ...currentArgs,
+            paginationOpts: {
+              numItems: initialNumItems,
+              cursor: null,
+              id
+            }
+          }
+        }
+      },
+      ongoingSplits: {},
+      skip
+    };
+  }
+  const initialQuery = toValue(query);
+  const initialRawArgs = toValue(args);
+  const initialSkip = initialRawArgs === "skip";
+  const initialArgsObject = initialSkip ? {} : initialRawArgs;
+  const { initialNumItems: initialInitialNumItems } = toValue(options);
+  const state = shallowRef(
+    createInitialState(initialQuery, initialArgsObject, initialSkip, initialInitialNumItems)
+  );
+  const queriesInput = computed(() => {
+    const q = toValue(query);
+    const rawArgs = toValue(args);
+    const skip = rawArgs === "skip";
+    const argsObject = skip ? {} : rawArgs;
+    const { initialNumItems } = toValue(options);
+    const currentState = state.value;
+    const needsReset = getFunctionName(q) !== getFunctionName(currentState.query) || JSON.stringify(convexToJson(argsObject)) !== JSON.stringify(convexToJson(currentState.args)) || skip !== currentState.skip;
+    if (needsReset) {
+      state.value = createInitialState(q, argsObject, skip, initialNumItems);
+    }
+    return state.value.queries;
+  });
+  const allResults = useConvexQueries(queriesInput);
+  function resetState() {
+    const q = toValue(query);
+    const rawArgs = toValue(args);
+    const skip = rawArgs === "skip";
+    const argsObject = skip ? {} : rawArgs;
+    const { initialNumItems } = toValue(options);
+    state.value = createInitialState(q, argsObject, skip, initialNumItems);
+  }
+  return computed(() => {
+    const currState = state.value;
+    const { initialNumItems } = toValue(options);
+    const resultsObject = allResults.value;
+    let lastResult;
+    let maybeError;
+    const allItems = [];
+    for (const pageKey of currState.pageKeys) {
+      const currResult = resultsObject[pageKey];
+      if (currResult === void 0) {
+        lastResult = void 0;
+        break;
+      }
+      if (currResult instanceof Error) {
+        const isInvalidCursor = currResult.message.includes("InvalidCursor") || currResult instanceof ConvexError && typeof currResult.data === "object" && currResult.data?.isConvexSystemError === true && currResult.data?.paginationError === "InvalidCursor";
+        if (isInvalidCursor) {
+          logger.warn?.(
+            "usePaginatedQuery hit error, resetting pagination state: " + currResult.message
+          );
+          resetState();
+          return {
+            results: [],
+            status: "LoadingFirstPage",
+            isLoading: true,
+            loadMore: noopLoadMore
+          };
+        }
+        maybeError = currResult;
+        break;
+      }
+      if (!isPaginatedQueryValue(currResult)) {
+        throw new Error("Paginated query returned a non-pagination result.");
+      }
+      const result = currResult;
+      const ongoingSplit = currState.ongoingSplits[pageKey];
+      if (ongoingSplit !== void 0) {
+        if (resultsObject[ongoingSplit[0]] !== void 0 && resultsObject[ongoingSplit[1]] !== void 0) {
+          state.value = completeSplitQuery(pageKey)(state.value);
+        }
+      } else if (result.splitCursor && (SPLIT_PAGE_STATUSES.includes(result.pageStatus) || result.page.length > initialNumItems * 2)) {
+        state.value = splitQuery(pageKey, result.splitCursor, result.continueCursor)(state.value);
+      }
+      if (result.pageStatus === SPLIT_PAGE_STATUSES[1]) {
+        lastResult = void 0;
+        break;
+      }
+      allItems.push(...result.page);
+      lastResult = result;
+    }
+    if (maybeError !== void 0) {
+      return {
+        results: allItems,
+        status: INTERNAL_ERROR_STATUS,
+        isLoading: false,
+        error: maybeError,
+        loadMore: noopLoadMore
+      };
+    }
+    if (lastResult === void 0) {
+      if (currState.nextPageKey === 1) {
+        return {
+          results: allItems,
+          status: "LoadingFirstPage",
+          isLoading: true,
+          loadMore: noopLoadMore
+        };
+      }
+      return {
+        results: allItems,
+        status: "LoadingMore",
+        isLoading: true,
+        loadMore: noopLoadMore
+      };
+    }
+    if (lastResult.isDone) {
+      return {
+        results: allItems,
+        status: "Exhausted",
+        isLoading: false,
+        loadMore: noopLoadMore
+      };
+    }
+    const continueCursor = lastResult.continueCursor;
+    let alreadyLoadingMore = false;
+    return {
+      results: allItems,
+      status: "CanLoadMore",
+      isLoading: false,
+      loadMore: (numItems) => {
+        if (alreadyLoadingMore) return;
+        alreadyLoadingMore = true;
+        const prev = state.value;
+        const pageKeys = [...prev.pageKeys, prev.nextPageKey];
+        const queries = { ...prev.queries };
+        queries[prev.nextPageKey] = {
+          query: prev.query,
+          // Pair the cursor with the args snapshot captured in state (not the
+          // live args input) so the page query stays consistent with the
+          // session that produced the cursor, mirroring upstream's
+          // `prevState.args`.
+          args: {
+            ...prev.args,
+            paginationOpts: {
+              numItems,
+              cursor: continueCursor,
+              id: prev.id
+            }
+          }
+        };
+        state.value = {
+          ...prev,
+          nextPageKey: prev.nextPageKey + 1,
+          pageKeys,
+          queries
+        };
+      }
+    };
+  });
+}
+let paginationId = 0;
+function nextPaginationId() {
+  return ++paginationId;
+}
+export function resetPaginationId() {
+  paginationId = 0;
+}
+function noopLoadMore(_numItems) {
+}
+export const useConvexPaginatedQuery = usePaginatedQuery;
+export function optimisticallyUpdateValueInPaginatedQuery(localStore, query, args, updateValue) {
+  const expectedArgs = JSON.stringify(convexToJson(args));
+  for (const queryResult of localStore.getAllQueries(query)) {
+    if (queryResult.value !== void 0) {
+      const { paginationOpts: _, ...innerArgs } = queryResult.args;
+      if (JSON.stringify(convexToJson(innerArgs)) === expectedArgs) {
+        const value = queryResult.value;
+        if (typeof value === "object" && value !== null && Array.isArray(value.page)) {
+          localStore.setQuery(query, queryResult.args, {
+            ...value,
+            page: value.page.map(updateValue)
+          });
+        }
+      }
+    }
+  }
+}
+export function insertAtTop(options) {
+  const { paginatedQuery, argsToMatch, localQueryStore, item } = options;
+  const queries = localQueryStore.getAllQueries(paginatedQuery);
+  const queriesThatMatch = queries.filter((q) => matchesArgs(q.args, argsToMatch));
+  const firstPage = queriesThatMatch.find(
+    (q) => q.args.paginationOpts.cursor === null
+  );
+  if (firstPage === void 0 || firstPage.value === void 0) {
+    return;
+  }
+  const value = firstPage.value;
+  localQueryStore.setQuery(paginatedQuery, firstPage.args, {
+    ...value,
+    page: [item, ...value.page]
+  });
+}
+export function insertAtBottomIfLoaded(options) {
+  const { paginatedQuery, argsToMatch, localQueryStore, item } = options;
+  const queries = localQueryStore.getAllQueries(paginatedQuery);
+  const queriesThatMatch = queries.filter((q) => matchesArgs(q.args, argsToMatch));
+  const lastPage = queriesThatMatch.find(
+    (q) => q.value !== void 0 && q.value.isDone
+  );
+  if (lastPage === void 0) return;
+  const value = lastPage.value;
+  localQueryStore.setQuery(paginatedQuery, lastPage.args, {
+    ...value,
+    page: [...value.page, item]
+  });
+}
+export function insertAtPosition(options) {
+  const {
+    paginatedQuery,
+    argsToMatch,
+    sortOrder,
+    sortKeyFromItem,
+    localQueryStore,
+    item
+  } = options;
+  const queries = localQueryStore.getAllQueries(paginatedQuery);
+  const queryGroups = {};
+  for (const q of queries) {
+    if (argsToMatch !== void 0 && !Object.keys(argsToMatch).every(
+      (k) => argsToMatch[k] === q.args[k]
+    )) {
+      continue;
+    }
+    const key = JSON.stringify(
+      Object.fromEntries(
+        Object.entries(q.args).map(([k, v]) => [
+          k,
+          k === "paginationOpts" ? v.id : v
+        ])
+      )
+    );
+    queryGroups[key] ??= [];
+    queryGroups[key].push(q);
+  }
+  for (const pageQueries of Object.values(queryGroups)) {
+    insertAtPositionInPages({
+      pageQueries,
+      paginatedQuery,
+      sortOrder,
+      sortKeyFromItem,
+      localQueryStore,
+      item
+    });
+  }
+}
+function insertAtPositionInPages(options) {
+  const {
+    pageQueries,
+    sortOrder,
+    sortKeyFromItem,
+    localQueryStore,
+    item,
+    paginatedQuery
+  } = options;
+  const insertedKey = sortKeyFromItem(item);
+  const loadedPages = pageQueries.filter(
+    (q) => q.value !== void 0 && q.value.page.length > 0
+  );
+  const sortedPages = loadedPages.slice().sort((a, b) => {
+    const aKey = sortKeyFromItem(
+      a.value.page[0]
+    );
+    const bKey = sortKeyFromItem(
+      b.value.page[0]
+    );
+    return sortOrder === "asc" ? compareValues(aKey, bKey) : compareValues(bKey, aKey);
+  });
+  const firstLoadedPage = sortedPages[0];
+  if (firstLoadedPage === void 0) return;
+  const firstValue = firstLoadedPage.value;
+  const firstPageKey = sortKeyFromItem(firstValue.page[0]);
+  const isBeforeFirstPage = sortOrder === "asc" ? compareValues(insertedKey, firstPageKey) <= 0 : compareValues(insertedKey, firstPageKey) >= 0;
+  if (isBeforeFirstPage) {
+    if (firstLoadedPage.args.paginationOpts.cursor === null) {
+      localQueryStore.setQuery(paginatedQuery, firstLoadedPage.args, {
+        ...firstValue,
+        page: [item, ...firstValue.page]
+      });
+    }
+    return;
+  }
+  const lastLoadedPage = sortedPages[sortedPages.length - 1];
+  if (lastLoadedPage === void 0) return;
+  const lastValue = lastLoadedPage.value;
+  const lastPageKey = sortKeyFromItem(
+    lastValue.page[lastValue.page.length - 1]
+  );
+  const isAfterLastPage = sortOrder === "asc" ? compareValues(insertedKey, lastPageKey) >= 0 : compareValues(insertedKey, lastPageKey) <= 0;
+  if (isAfterLastPage) {
+    if (lastValue.isDone) {
+      localQueryStore.setQuery(paginatedQuery, lastLoadedPage.args, {
+        ...lastValue,
+        page: [...lastValue.page, item]
+      });
+    }
+    return;
+  }
+  const successorPageIndex = sortedPages.findIndex((p) => {
+    const headKey = sortKeyFromItem(
+      p.value.page[0]
+    );
+    return sortOrder === "asc" ? compareValues(headKey, insertedKey) > 0 : compareValues(headKey, insertedKey) < 0;
+  });
+  const pageToUpdate = successorPageIndex === -1 ? sortedPages[sortedPages.length - 1] : sortedPages[successorPageIndex - 1];
+  if (pageToUpdate === void 0) return;
+  const pageValue = pageToUpdate.value;
+  const indexWithinPage = pageValue.page.findIndex((e) => {
+    const k = sortKeyFromItem(e);
+    return sortOrder === "asc" ? compareValues(k, insertedKey) >= 0 : compareValues(k, insertedKey) <= 0;
+  });
+  const newPage = indexWithinPage === -1 ? [...pageValue.page, item] : [
+    ...pageValue.page.slice(0, indexWithinPage),
+    item,
+    ...pageValue.page.slice(indexWithinPage)
+  ];
+  localQueryStore.setQuery(paginatedQuery, pageToUpdate.args, {
+    ...pageValue,
+    page: newPage
+  });
+}
+function matchesArgs(args, argsToMatch) {
+  if (argsToMatch === void 0) return true;
+  return Object.keys(argsToMatch).every(
+    (k) => compareValues(argsToMatch[k], args[k]) === 0
+  );
+}
+export function usePaginatedQuery_experimental(queryOrOptions, args, options) {
+  const firstValue = toValue(queryOrOptions);
+  const isObjectOptions = typeof firstValue === "object" && firstValue !== null && "query" in firstValue;
+  if (isObjectOptions) {
+    const optsGetter = () => toValue(
+      queryOrOptions
+    );
+    const internal2 = usePaginatedQueryInternal(
+      () => optsGetter().query,
+      () => optsGetter().args,
+      () => ({ initialNumItems: optsGetter().initialNumItems })
+    );
+    return computed(
+      () => reshapeToObjectForm2(internal2.value, optsGetter().throwOnError ?? false)
+    );
+  }
+  const query = queryOrOptions;
+  const internal = usePaginatedQueryInternal(
+    () => query,
+    args,
+    () => options
+  );
+  return splitToRefs(internal);
+}
+function reshapeToObjectForm2(internal, throwOnError) {
+  const { results, loadMore } = internal;
+  if (internal.status === INTERNAL_ERROR_STATUS) {
+    if (throwOnError) {
+      throw internal.error;
+    }
+    return {
+      // Upstream returns an empty array on error, never the pages loaded
+      // before the failure.
+      data: [],
+      status: "error",
+      canLoadMore: false,
+      isLoading: false,
+      error: internal.error,
+      loadMore
+    };
+  }
+  if (internal.status === "LoadingFirstPage" || internal.status === "LoadingMore") {
+    return {
+      data: internal.status === "LoadingFirstPage" ? void 0 : results,
+      status: "pending",
+      canLoadMore: false,
+      isLoading: true,
+      error: void 0,
+      loadMore
+    };
+  }
+  return {
+    data: results,
+    status: "success",
+    canLoadMore: internal.status === "CanLoadMore",
+    isLoading: false,
+    error: void 0,
+    loadMore
+  };
+}

package/dist/runtime/vue/composables/use-queries.d.ts

@@ -0,0 +1,62 @@
+import { type MaybeRefOrGetter, type ShallowRef } from 'vue';
+import { type CreateWatch } from '../queries-observer.js';
+import type { RequestForQueries } from 'convex/react';
+/**
+ * Load a variable number of reactive Convex queries.
+ *
+ * `useQueries` is similar to {@link useQuery} but it allows
+ * loading multiple queries which can be useful for loading a dynamic number
+ * of queries without violating the rules of composables.
+ *
+ * This composable accepts an object whose keys are identifiers for each query and the
+ * values are objects of `{ query: FunctionReference, args: Record<string, Value> }`. The
+ * `query` is a FunctionReference for the Convex query function to load, and the `args` are
+ * the arguments to that function.
+ *
+ * The composable returns an object that maps each identifier to the result of the query,
+ * `undefined` if the query is still loading, or an instance of `Error` if the query
+ * threw an exception.
+ *
+ * For example if you loaded a query like:
+ * ```typescript
+ * const results = useQueries({
+ *   messagesInGeneral: {
+ *     query: "listMessages",
+ *     args: { channel: "#general" }
+ *   }
+ * });
+ * ```
+ * then the result would look like:
+ * ```typescript
+ * {
+ *   messagesInGeneral: [{
+ *     channel: "#general",
+ *     body: "hello"
+ *     _id: ...,
+ *     _creationTime: ...
+ *   }]
+ * }
+ * ```
+ *
+ * This composable returns a reactive result that updates
+ * whenever any of the query results change.
+ *
+ * Throws an error if no Convex client has been provided (see {@link useConvex}).
+ *
+ * @param queries - An object mapping identifiers to objects of
+ * `{query: string, args: Record<string, Value> }` describing which query
+ * functions to fetch. Reactive (ref/computed/getter) or plain.
+ * @returns A shallow ref of an object with the same keys as the input. The
+ * values are the result of the query function, `undefined` if it's still
+ * loading, or an `Error` if it threw an exception.
+ *
+ * @public
+ */
+export declare function useQueries(queries: MaybeRefOrGetter<RequestForQueries>): ShallowRef<Record<string, any | undefined | Error>>;
+/**
+ * Internal version of `useQueries` that is exported for testing.
+ */
+export declare function useQueriesHelper(queries: MaybeRefOrGetter<RequestForQueries>, createWatch: CreateWatch): ShallowRef<Record<string, any | undefined | Error>>;
+export type { RequestForQueries } from 'convex/react';
+/** @public */
+export declare const useConvexQueries: typeof useQueries;

package/dist/runtime/vue/composables/use-queries.js

@@ -0,0 +1,37 @@
+import { onScopeDispose, shallowRef, toValue, watchEffect } from "vue";
+import { useConvexOrThrow } from "../client.js";
+import { QueriesObserver } from "../queries-observer.js";
+export function useQueries(queries) {
+  const convex = useConvexOrThrow("useQuery");
+  const createWatch = (query, args, {
+    journal,
+    paginationOptions
+  }) => {
+    if (paginationOptions) {
+      return convex.watchPaginatedQuery(query, args, paginationOptions);
+    } else {
+      return convex.watchQuery(query, args, journal ? { journal } : {});
+    }
+  };
+  return useQueriesHelper(queries, createWatch);
+}
+export function useQueriesHelper(queries, createWatch) {
+  const observer = new QueriesObserver(createWatch);
+  const results = shallowRef({});
+  watchEffect((onCleanup) => {
+    const currentQueries = toValue(queries);
+    if (import.meta.server) {
+      results.value = observer.getLocalResults(currentQueries);
+      return;
+    }
+    observer.setQueries(currentQueries);
+    results.value = observer.getLocalResults(currentQueries);
+    const unsubscribe = observer.subscribe(() => {
+      results.value = observer.getLocalResults(toValue(queries));
+    });
+    onCleanup(unsubscribe);
+  });
+  onScopeDispose(() => observer.destroy());
+  return results;
+}
+export const useConvexQueries = useQueries;

package/dist/runtime/vue/composables/use-query.d.ts

@@ -0,0 +1,87 @@
+import type { FunctionArgs, FunctionReference } from 'convex/server';
+import { type ComputedRef, type MaybeRefOrGetter } from 'vue';
+import type { UseQueryResult as ConvexUseQueryResult } from 'convex/react';
+export type OptionalRestArgsOrSkip<FuncRef extends FunctionReference<any>> = FuncRef['_args'] extends Record<string, never> ? [args?: MaybeRefOrGetter<Record<string, never> | 'skip'>] : [args: MaybeRefOrGetter<FuncRef['_args'] | 'skip'>];
+/**
+ * Result returned by object-form {@link useQuery_experimental}.
+ *
+ * @public
+ */
+export type UseQueryResult<QueryResult, ThrowOnError extends boolean = false> = ConvexUseQueryResult<QueryResult, ThrowOnError>;
+type UseQueryOptions<Query extends FunctionReference<'query'>, ThrowOnError extends boolean> = {
+    query: Query;
+    args: MaybeRefOrGetter<FunctionArgs<Query> | 'skip'>;
+    throwOnError?: ThrowOnError;
+};
+/**
+ * Load a reactive query within a Vue component.
+ *
+ * This Vue composable subscribes to a Convex query and updates the returned
+ * ref whenever the query result changes. The subscription is managed
+ * automatically -- it starts when the component mounts and stops when it
+ * unmounts.
+ *
+ * Throws an error if no Convex client has been provided.
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * import { useQuery } from '#imports'
+ * import { api } from '#convex/api'
+ *
+ * // Reactively loads tasks; the ref updates when data changes:
+ * const tasks = useQuery(api.tasks.list, { completed: false })
+ * // tasks.value is `undefined` while loading
+ *
+ * // Pass "skip" (or a reactive getter returning it) to conditionally
+ * // disable the query:
+ * const profile = useQuery(
+ *   api.users.get,
+ *   computed(() => userId.value ? { userId: userId.value } : 'skip'),
+ * )
+ * </script>
+ * ```
+ *
+ * @param query - a {@link server.FunctionReference} for the public query to run
+ * like `api.dir1.dir2.filename.func`.
+ * @param args - The arguments to the query function or the string `"skip"` if
+ * the query should not be loaded. Accepts a ref, computed, or getter for
+ * reactive args.
+ * @returns a computed ref with the result of the query. Contains `undefined`
+ * while loading.
+ *
+ * @public
+ */
+export declare function useQuery<Query extends FunctionReference<'query'>>(query: Query, ...args: OptionalRestArgsOrSkip<Query>): ComputedRef<Query['_returnType'] | undefined>;
+/**
+ * Load a reactive query within a Vue component using an options object.
+ *
+ * This is an experimental form of {@link useQuery} that accepts a single
+ * {@link UseQueryOptions} object instead of positional arguments.
+ *
+ * Consumers are expected to check the returned object `status` field to
+ * make proper use of the result. If an error occurs, it will be present
+ * in the result object unless `throwOnError` is `true`, in which case
+ * the error will be thrown instead.
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * import { useQuery_experimental as useQuery } from '#imports'
+ * import { api } from '#convex/api'
+ *
+ * const state = useQuery({ query: api.tasks.list, args: { completed: false } })
+ * // state.value.status: 'pending' | 'success' | 'error'
+ * </script>
+ * ```
+ *
+ * @param options - Query options. Pass `args: "skip"` to disable the query.
+ * @returns a computed ref with the current query state as a
+ * {@link UseQueryResult} object.
+ *
+ * @public
+ */
+export declare function useQuery_experimental<Query extends FunctionReference<'query'>, ThrowOnError extends boolean = false>(options: UseQueryOptions<Query, ThrowOnError>): ComputedRef<UseQueryResult<Query['_returnType'], ThrowOnError>>;
+/** @public */
+export declare const useConvexQuery: typeof useQuery;
+export {};