Merge pull request TanStack#4 from lukesmurray/luke/fix-linting

fix lint and typecheck errors
lukesmurray · Sep 8, 2022 · 3cf1a54 · 3cf1a54
2 parents c65e561 + e7c8759
commit 3cf1a54
Show file tree

Hide file tree

Showing 6 changed files with 124 additions and 140 deletions.
diff --git a/packages/solid-query/.eslintrc b/packages/solid-query/.eslintrc
@@ -4,6 +4,7 @@
     "sourceType": "module"
   },
   "rules": {
-    "react/react-in-jsx-scope": "off"
+    "react/react-in-jsx-scope": "off",
+    "react-hooks/rules-of-hooks": "off"
   }
-}
+}
diff --git a/packages/solid-query/src/__tests__/QueryClientProvider.test.tsx b/packages/solid-query/src/__tests__/QueryClientProvider.test.tsx
@@ -1,15 +1,8 @@
-import { Context, createContext, useContext } from 'solid-js'
 import { render, screen, waitFor } from 'solid-testing-library'
 import { queryKey } from './utils'
 
 import { QueryCache } from '@tanstack/query-core'
-import { renderToString } from 'solid-js/web'
-import {
-  createQuery,
-  QueryClient,
-  QueryClientProvider,
-  useQueryClient,
-} from '..'
+import { createQuery, QueryClientProvider, useQueryClient } from '..'
 import { createQueryClient, sleep } from '../../../../tests/utils'
 
 describe('QueryClientProvider', () => {
@@ -138,63 +131,64 @@ describe('QueryClientProvider', () => {
     expect(queryCache.find(key())?.options.cacheTime).toBe(Infinity)
   })
 
-  describe('with custom context', () => {
-    it('uses the correct context', async () => {
-      const key = queryKey()
-
-      const contextOuter = createContext<QueryClient | undefined>(undefined)
-      const contextInner = createContext<QueryClient | undefined>(undefined)
-
-      const queryCacheOuter = new QueryCache()
-      const queryClientOuter = new QueryClient({ queryCache: queryCacheOuter })
-
-      const queryCacheInner = new QueryCache()
-      const queryClientInner = new QueryClient({ queryCache: queryCacheInner })
-
-      const queryCacheInnerInner = new QueryCache()
-      const queryClientInnerInner = new QueryClient({
-        queryCache: queryCacheInnerInner,
-      })
-
-      function Page() {
-        const queryOuter = createQuery(key, async () => 'testOuter', {
-          context: contextOuter,
-        })
-        const queryInner = createQuery(key, async () => 'testInner', {
-          context: contextInner,
-        })
-        const queryInnerInner = createQuery(key, async () => 'testInnerInner')
-
-        return (
-          <div>
-            <h1>
-              {queryOuter.data} {queryInner.data} {queryInnerInner.data}
-            </h1>
-          </div>
-        )
-      }
-
-      // contextSharing should be ignored when passing a custom context.
-      const contextSharing = true
-
-      render(() => (
-        <QueryClientProvider client={queryClientOuter} context={contextOuter}>
-          <QueryClientProvider client={queryClientInner} context={contextInner}>
-            <QueryClientProvider
-              client={queryClientInnerInner}
-              contextSharing={contextSharing}
-            >
-              <Page />
-            </QueryClientProvider>
-          </QueryClientProvider>
-        </QueryClientProvider>
-      ))
-
-      await waitFor(() =>
-        screen.getByText('testOuter testInner testInnerInner'),
-      )
-    })
-  })
+  // TODO(lukemurray): add test when we implement context sharing.
+  // describe('with custom context', () => {
+  //   it('uses the correct context', async () => {
+  //     const key = queryKey()
+
+  //     const contextOuter = createContext<QueryClient | undefined>(undefined)
+  //     const contextInner = createContext<QueryClient | undefined>(undefined)
+
+  //     const queryCacheOuter = new QueryCache()
+  //     const queryClientOuter = new QueryClient({ queryCache: queryCacheOuter })
+
+  //     const queryCacheInner = new QueryCache()
+  //     const queryClientInner = new QueryClient({ queryCache: queryCacheInner })
+
+  //     const queryCacheInnerInner = new QueryCache()
+  //     const queryClientInnerInner = new QueryClient({
+  //       queryCache: queryCacheInnerInner,
+  //     })
+
+  //     function Page() {
+  //       const queryOuter = createQuery(key, async () => 'testOuter', {
+  //         context: contextOuter,
+  //       })
+  //       const queryInner = createQuery(key, async () => 'testInner', {
+  //         context: contextInner,
+  //       })
+  //       const queryInnerInner = createQuery(key, async () => 'testInnerInner')
+
+  //       return (
+  //         <div>
+  //           <h1>
+  //             {queryOuter.data} {queryInner.data} {queryInnerInner.data}
+  //           </h1>
+  //         </div>
+  //       )
+  //     }
+
+  //     // contextSharing should be ignored when passing a custom context.
+  //     const contextSharing = true
+
+  //     render(() => (
+  //       <QueryClientProvider client={queryClientOuter} context={contextOuter}>
+  //         <QueryClientProvider client={queryClientInner} context={contextInner}>
+  //           <QueryClientProvider
+  //             client={queryClientInnerInner}
+  //             contextSharing={contextSharing}
+  //           >
+  //             <Page />
+  //           </QueryClientProvider>
+  //         </QueryClientProvider>
+  //       </QueryClientProvider>
+  //     ))
+
+  //     await waitFor(() =>
+  //       screen.getByText('testOuter testInner testInnerInner'),
+  //     )
+  //   })
+  // })
 
   describe('useQueryClient', () => {
     test('should throw an error if no query client has been set', () => {
@@ -214,58 +208,60 @@ describe('QueryClientProvider', () => {
       consoleMock.mockRestore()
     })
 
-    test('should use window to get the context when contextSharing is true', () => {
-      const queryCache = new QueryCache()
-      const queryClient = createQueryClient({ queryCache })
-
-      let queryClientFromHook: QueryClient | undefined
-      let queryClientFromWindow: QueryClient | undefined
-
-      function Page() {
-        queryClientFromHook = useQueryClient()
-        queryClientFromWindow = useContext(
-          window.SolidQueryClientContext as Context<QueryClient | undefined>,
-        )
-        return null
-      }
-
-      render(() => (
-        <QueryClientProvider client={queryClient} contextSharing={true}>
-          <Page />
-        </QueryClientProvider>
-      ))
-
-      expect(queryClientFromHook).toEqual(queryClient)
-      expect(queryClientFromWindow).toEqual(queryClient)
-    })
-
-    test('should not use window to get the context when contextSharing is true and window does not exist', () => {
-      const queryCache = new QueryCache()
-      const queryClient = createQueryClient({ queryCache })
-
-      // Mock a non web browser environment
-      const windowSpy = jest
-        .spyOn(window, 'window', 'get')
-        .mockImplementation(undefined)
-
-      let queryClientFromHook: QueryClient | undefined
-
-      function Page() {
-        queryClientFromHook = useQueryClient()
-        return null
-      }
-
-      // TODO(lukemurray): this test doesn't pass because the page function is
-      // never called. I'm not sure why.
-      renderToString(() => (
-        <QueryClientProvider client={queryClient} contextSharing={true}>
-          <Page />
-        </QueryClientProvider>
-      ))
-
-      expect(queryClientFromHook).toEqual(queryClient)
-
-      windowSpy.mockRestore()
-    })
+    // TODO(lukemurray): add test when we implement context sharing
+    // test('should use window to get the context when contextSharing is true', () => {
+    //   const queryCache = new QueryCache()
+    //   const queryClient = createQueryClient({ queryCache })
+
+    //   let queryClientFromHook: QueryClient | undefined
+    //   let queryClientFromWindow: QueryClient | undefined
+
+    //   function Page() {
+    //     queryClientFromHook = useQueryClient()
+    //     queryClientFromWindow = useContext(
+    //       window.SolidQueryClientContext as Context<QueryClient | undefined>,
+    //     )
+    //     return null
+    //   }
+
+    //   render(() => (
+    //     <QueryClientProvider client={queryClient} contextSharing={true}>
+    //       <Page />
+    //     </QueryClientProvider>
+    //   ))
+
+    //   expect(queryClientFromHook).toEqual(queryClient)
+    //   expect(queryClientFromWindow).toEqual(queryClient)
+    // })
+
+    // TODO(lukemurray): add test when we implement context sharing
+    // test('should not use window to get the context when contextSharing is true and window does not exist', () => {
+    //   const queryCache = new QueryCache()
+    //   const queryClient = createQueryClient({ queryCache })
+
+    //   // Mock a non web browser environment
+    //   const windowSpy = jest
+    //     .spyOn(window, 'window', 'get')
+    //     .mockImplementation(undefined)
+
+    //   let queryClientFromHook: QueryClient | undefined
+
+    //   function Page() {
+    //     queryClientFromHook = useQueryClient()
+    //     return null
+    //   }
+
+    //   // TODO(lukemurray): this test doesn't pass because the page function is
+    //   // never called. I'm not sure why.
+    //   renderToString(() => (
+    //     <QueryClientProvider client={queryClient} contextSharing={true}>
+    //       <Page />
+    //     </QueryClientProvider>
+    //   ))
+
+    //   expect(queryClientFromHook).toEqual(queryClient)
+
+    //   windowSpy.mockRestore()
+    // })
   })
 })
diff --git a/packages/solid-query/src/createBaseQuery.ts b/packages/solid-query/src/createBaseQuery.ts
@@ -2,14 +2,7 @@ import { QueryObserver } from '@tanstack/query-core'
 import type { QueryKey, QueryObserverResult } from '@tanstack/query-core'
 import { CreateBaseQueryOptions } from './types'
 import { useQueryClient } from './QueryClientProvider'
-import {
-  onMount,
-  onCleanup,
-  createComputed,
-  createResource,
-  createEffect,
-  batch,
-} from 'solid-js'
+import { onMount, onCleanup, createComputed, createResource } from 'solid-js'
 import { createStore } from 'solid-js/store'
 
 // Base Query Function that is used to create the query.
@@ -33,15 +26,15 @@ export function createBaseQuery<
 
   const defaultedOptions = queryClient.defaultQueryOptions(options)
   defaultedOptions._optimisticResults = 'optimistic'
-  const observer = new QueryObserver(queryClient, defaultedOptions)
+  const observer = new Observer(queryClient, defaultedOptions)
 
   const [state, setState] = createStore<QueryObserverResult<TData, TError>>(
     // @ts-ignore
     observer.getOptimisticResult(defaultedOptions),
   )
 
   const [dataResource, { refetch }] = createResource(() => {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve) => {
       if (state.isSuccess) resolve(state.data)
       if (state.isError && !state.isFetching) {
         throw state.error

diff --git a/packages/solid-query/src/types.ts b/packages/solid-query/src/types.ts
@@ -1,4 +1,4 @@
-import type { Context, Accessor } from 'solid-js'
+import type { Context } from 'solid-js'
 import type {
   QueryClient,
   QueryKey,

diff --git a/packages/solid-query/src/useIsFetching.ts b/packages/solid-query/src/useIsFetching.ts
@@ -1,9 +1,4 @@
-import {
-  QueryKey,
-  notifyManager,
-  parseFilterArgs,
-  QueryFilters,
-} from '@tanstack/query-core'
+import { QueryKey, parseFilterArgs, QueryFilters } from '@tanstack/query-core'
 
 import { ContextOptions } from './types'
 import { useQueryClient } from './QueryClientProvider'
@@ -30,7 +25,7 @@ export function useIsFetching(
 
   const [fetches, setFetches] = createSignal(queryClient.isFetching(filters))
 
-  const unsubscribe = queryCache.subscribe((result) => {
+  const unsubscribe = queryCache.subscribe((_result) => {
     setFetches(queryClient.isFetching(filters))
   })
 

diff --git a/packages/solid-query/src/useIsMutating.ts b/packages/solid-query/src/useIsMutating.ts
@@ -1,5 +1,4 @@
 import {
-  notifyManager,
   MutationKey,
   MutationFilters,
   parseMutationFilterArgs,
@@ -33,7 +32,7 @@ export function useIsMutating(
     queryClient.isMutating(filters),
   )
 
-  const unsubscribe = mutationCache.subscribe((result) => {
+  const unsubscribe = mutationCache.subscribe((_result) => {
     setMutations(queryClient.isMutating(filters))
   })