Function cleanupQueryInternal

packages/query-db-collection/src/query.ts:1490–1550

(hashedQueryKey: string)

     * Callers are responsible for ensuring the query is safe to cleanup.
     */
    const cleanupQueryInternal = (hashedQueryKey: string) => {
      unsubscribes.get(hashedQueryKey)?.()
      unsubscribes.delete(hashedQueryKey)
      cancelPersistedRetentionExpiry(hashedQueryKey)
      retainedQueriesPendingRevalidation.delete(hashedQueryKey)

      const rowKeys = queryToRows.get(hashedQueryKey) ?? new Set()
      const nextOwnersByRow = new Map<string | number, Set<string>>()
      const rowsToDelete: Array<any> = []

      rowKeys.forEach((rowKey) => {
        const queries = rowToQueries.get(rowKey)

        if (!queries) {
          return
        }

        const nextOwners = new Set(queries)
        nextOwners.delete(hashedQueryKey)
        nextOwnersByRow.set(rowKey, nextOwners)

        if (nextOwners.size === 0 && collection.has(rowKey)) {
          rowsToDelete.push(collection.get(rowKey))
        }
      })

      const shouldWriteMetadata =
        metadata !== undefined && nextOwnersByRow.size > 0
      const needsTransaction = shouldWriteMetadata || rowsToDelete.length > 0
      if (needsTransaction) {
        begin()
      }

      nextOwnersByRow.forEach((owners, rowKey) => {
        if (owners.size === 0) {
          rowToQueries.delete(rowKey)
        } else {
          rowToQueries.set(rowKey, owners)
        }

        if (shouldWriteMetadata) {
          setPersistedOwners(rowKey, owners)
        }
      })

      if (rowsToDelete.length > 0) {
        rowsToDelete.forEach((row) => {
          write({ type: `delete`, value: row })
        })
      }

      if (needsTransaction) {
        commit()
      }

      state.observers.delete(hashedQueryKey)
      queryToRows.delete(hashedQueryKey)
      hashToQueryKey.delete(hashedQueryKey)