Function createQueryFromOpts

packages/query-db-collection/src/query.ts:1081–1239

(
      opts: LoadSubsetOptions = {},
      queryFunction: typeof queryFn = queryFn,
    )

          })

    const createQueryFromOpts = (
      opts: LoadSubsetOptions = {},
      queryFunction: typeof queryFn = queryFn,
    ): true | Promise<void> => {
      if (!startupRetentionSettled) {
        return startupRetentionMaintenancePromise.then(() => {
          const resumed = createQueryFromOpts(opts, queryFunction)
          return resumed === true ? undefined : resumed
        })
      }

      // Generate key using common function
      const key = generateQueryKeyFromOptions(opts)
      const hashedQueryKey = hashKey(key)
      const extendedMeta = { ...meta, loadSubsetOptions: opts }
      const retainedEntry = metadata?.collection.get(
        `${QUERY_COLLECTION_GC_PREFIX}${hashedQueryKey}`,
      )
      if (
        parsePersistedQueryRetentionEntry(retainedEntry, hashedQueryKey) !==
        undefined
      ) {
        retainedQueriesPendingRevalidation.add(hashedQueryKey)
      }
      cancelPersistedRetentionExpiry(hashedQueryKey)

      validateQueryKeyPrefix(key)

      if (state.observers.has(hashedQueryKey)) {
        // We already have a query for this queryKey
        // Increment reference count since another consumer is using this observer
        queryRefCounts.set(
          hashedQueryKey,
          (queryRefCounts.get(hashedQueryKey) || 0) + 1,
        )

        // Get the current result and return based on its state
        const observer = state.observers.get(hashedQueryKey)!
        const currentResult = observer.getCurrentResult()

        if (currentResult.isSuccess) {
          // Data is already available, return true synchronously
          return true
        } else if (currentResult.isError) {
          // Error already occurred, reject immediately
          return Promise.reject(currentResult.error)
        } else {
          // Check QueryClient cache directly - observer's getCurrentResult() may show
          // a loading state even when data exists in cache. This happens because observer
          // state can lag behind the QueryClient cache during unsubscribe/resubscribe
          // cycles (e.g., when a live query is cleaned up and recreated).
          const cachedData = queryClient.getQueryData(key)
          if (cachedData !== undefined) {
            return true
          }

          // Query is still loading, wait for the first result
          return new Promise<void>((resolve, reject) => {