@tanstack/svelte-query 5.0.0-alpha.5 → 5.0.0-alpha.51

package/src/types.ts

@@ -10,87 +10,91 @@ import type {
   DefinedQueryObserverResult,
   DefaultError,
 } from '@tanstack/query-core'
-import type { QueryClient } from '@tanstack/query-core'
 import type { Readable, Writable } from 'svelte/store'
 
+/** Allows a type to be either the base object or a store of that object */
 export type WritableOrVal<T> = T | Writable<T>
 
-export interface ContextOptions {
-  /**
-   * Use this to pass your Svelte Query context. Otherwise, `defaultContext` will be used.
-   */
-  context?: QueryClient | undefined
-}
-
-export interface CreateBaseQueryOptions<
+/** Options for createBaseQuery */
+export type CreateBaseQueryOptions<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
   TQueryData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
-> extends ContextOptions,
-    QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {}
+> = WritableOrVal<
+  QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>
+>
 
-export interface CreateBaseQueryResult<TData = unknown, TError = DefaultError>
-  extends Readable<QueryObserverResult<TData, TError>> {}
+/** Result from createBaseQuery */
+export type CreateBaseQueryResult<
+  TData = unknown,
+  TError = DefaultError,
+> = Readable<QueryObserverResult<TData, TError>>
 
-export interface CreateQueryOptions<
+/** Options for createQuery */
+export type CreateQueryOptions<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
-> extends CreateBaseQueryOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryFnData,
-    TQueryKey
-  > {}
+> = CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>
 
-export interface CreateQueryResult<TData = unknown, TError = DefaultError>
-  extends CreateBaseQueryResult<TData, TError> {}
+/** Result from createQuery */
+export type CreateQueryResult<
+  TData = unknown,
+  TError = DefaultError,
+> = CreateBaseQueryResult<TData, TError>
 
-export interface CreateInfiniteQueryOptions<
+/** Options for createInfiniteQuery */
+export type CreateInfiniteQueryOptions<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
   TQueryData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
   TPageParam = unknown,
-> extends InfiniteQueryObserverOptions<
+> = WritableOrVal<
+  InfiniteQueryObserverOptions<
     TQueryFnData,
     TError,
     TData,
     TQueryData,
     TQueryKey,
     TPageParam
-  > {}
+  >
+>
 
+/** Result from createInfiniteQuery */
 export type CreateInfiniteQueryResult<
   TData = unknown,
   TError = DefaultError,
 > = Readable<InfiniteQueryObserverResult<TData, TError>>
 
+/** Options for createBaseQuery with initialData */
 export type DefinedCreateBaseQueryResult<
   TData = unknown,
   TError = DefaultError,
 > = Readable<DefinedQueryObserverResult<TData, TError>>
 
+/** Options for createQuery with initialData */
 export type DefinedCreateQueryResult<
   TData = unknown,
   TError = DefaultError,
 > = DefinedCreateBaseQueryResult<TData, TError>
 
-export interface CreateMutationOptions<
+/** Options for createMutation */
+export type CreateMutationOptions<
   TData = unknown,
   TError = DefaultError,
   TVariables = void,
   TContext = unknown,
-> extends ContextOptions,
-    Omit<
-      MutationObserverOptions<TData, TError, TVariables, TContext>,
-      '_defaulted' | 'variables'
-    > {}
+> = WritableOrVal<
+  Omit<
+    MutationObserverOptions<TData, TError, TVariables, TContext>,
+    '_defaulted' | 'variables'
+  >
+>
 
 export type CreateMutateFunction<
   TData = unknown,
@@ -120,13 +124,12 @@ export type CreateBaseMutationResult<
   mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TContext>
 }
 
-export interface CreateMutationResult<
+/** Result from createMutation */
+export type CreateMutationResult<
   TData = unknown,
   TError = DefaultError,
   TVariables = unknown,
   TContext = unknown,
-> extends Readable<
-    CreateBaseMutationResult<TData, TError, TVariables, TContext>
-  > {}
+> = Readable<CreateBaseMutationResult<TData, TError, TVariables, TContext>>
 
 type Override<A, B> = { [K in keyof A]: K extends keyof B ? B[K] : A[K] }

package/build/lib/.gitignore

@@ -1,9 +0,0 @@
-.DS_Store
-node_modules
-/build
-/.svelte-kit
-/package
-.env
-.env.*
-!.env.example
-!lib/

package/src/__tests__/CreateMutation.svelte

@@ -1,17 +0,0 @@
-<script lang="ts">
-  import {
-    createMutation,
-    QueryClient,
-    type CreateMutationOptions,
-  } from '../index'
-  import { setQueryClientContext } from '../context'
-
-  export let options: CreateMutationOptions
-
-  const queryClient = new QueryClient()
-  setQueryClientContext(queryClient)
-
-  const mutation = createMutation(options)
-</script>
-
-<button on:click={() => $mutation.mutate()}>Click</button>

package/src/__tests__/CreateQueries.svelte

@@ -1,20 +0,0 @@
-<script lang="ts">
-  import { createQueries, QueryClient } from '../index'
-  import { setQueryClientContext } from '../context'
-  import type { QueriesOptions } from '../createQueries'
-
-  export let options: { queries: [...QueriesOptions<any>] }
-
-  const queryClient = new QueryClient()
-  setQueryClientContext(queryClient)
-
-  const queries = createQueries(options)
-</script>
-
-{#each $queries as query, index}
-  {#if query.isPending}
-    <p>Loading {index + 1}</p>
-  {:else if query.isSuccess}
-    <p>{query.data}</p>
-  {/if}
-{/each}

package/src/__tests__/CreateQuery.svelte

@@ -1,30 +0,0 @@
-<script lang="ts">
-  import {
-    createQuery,
-    QueryClient,
-    type CreateQueryOptions,
-    type WritableOrVal,
-  } from '../index'
-  import { setQueryClientContext } from '../context'
-
-  export let options: WritableOrVal<CreateQueryOptions<any>>
-
-  const queryClient = new QueryClient()
-  setQueryClientContext(queryClient)
-
-  const query = createQuery(options)
-</script>
-
-{#if $query.isPending}
-  <p>Loading</p>
-{:else if $query.isError}
-  <p>Error</p>
-{:else if $query.isSuccess}
-  <p>Success</p>
-{/if}
-
-<ul>
-  {#each $query.data ?? [] as entry}
-    <li>id: {entry.id}</li>
-  {/each}
-</ul>

package/src/__tests__/createMutation.test.ts

@@ -1,24 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-import { fireEvent, render, screen } from '@testing-library/svelte'
-import CreateMutation from './CreateMutation.svelte'
-import { sleep } from './utils'
-
-describe('createMutation', () => {
-  it('Call mutate and check function runs', async () => {
-    const mutationFn = vi.fn()
-
-    render(CreateMutation, {
-      props: {
-        options: {
-          mutationFn,
-        },
-      },
-    })
-
-    fireEvent.click(screen.getByRole('button'))
-
-    await sleep(20)
-
-    expect(mutationFn).toHaveBeenCalledTimes(1)
-  })
-})

package/src/__tests__/createQueries.test.ts

@@ -1,41 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { render, waitFor } from '@testing-library/svelte'
-import CreateQueries from './CreateQueries.svelte'
-import { sleep } from './utils'
-
-describe('createQueries', () => {
-  it('Render and wait for success', async () => {
-    const rendered = render(CreateQueries, {
-      props: {
-        options: {
-          queries: [
-            {
-              queryKey: ['key-1'],
-              queryFn: async () => {
-                await sleep(10)
-                return 'Success 1'
-              },
-            },
-            {
-              queryKey: ['key-2'],
-              queryFn: async () => {
-                await sleep(10)
-                return 'Success 2'
-              },
-            },
-          ],
-        },
-      },
-    })
-
-    await waitFor(() => {
-      expect(rendered.getByText('Loading 1')).toBeInTheDocument()
-      expect(rendered.getByText('Loading 2')).toBeInTheDocument()
-    })
-
-    await waitFor(() => {
-      expect(rendered.getByText('Success 1')).toBeInTheDocument()
-      expect(rendered.getByText('Success 2')).toBeInTheDocument()
-    })
-  })
-})

package/src/__tests__/createQuery.test.ts

@@ -1,64 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { render, waitFor } from '@testing-library/svelte'
-import { writable } from 'svelte/store'
-import CreateQuery from './CreateQuery.svelte'
-import { sleep } from './utils'
-import type { CreateQueryOptions, WritableOrVal } from '../types'
-
-describe('createQuery', () => {
-  it('Render and wait for success', async () => {
-    const rendered = render(CreateQuery, {
-      props: {
-        options: {
-          queryKey: ['test'],
-          queryFn: async () => {
-            await sleep(10)
-            return 'Success'
-          },
-        },
-      },
-    })
-
-    await waitFor(() => {
-      expect(rendered.getByText('Loading')).toBeInTheDocument()
-    })
-
-    await waitFor(() => {
-      expect(rendered.getByText('Success')).toBeInTheDocument()
-    })
-  })
-
-  it('should keep previous data when returned as placeholder data', async () => {
-    const options: WritableOrVal<CreateQueryOptions> = writable({
-      queryKey: ['test', [1]],
-      queryFn: async ({ queryKey }) => {
-        await sleep(50)
-        const ids = queryKey[1]
-        if (!ids || !Array.isArray(ids)) return []
-        return ids.map((id) => ({ id }))
-      },
-      placeholderData: (previousData: { id: number }[]) => previousData,
-    })
-    const rendered = render(CreateQuery, { props: { options } })
-
-    expect(rendered.queryByText('id: 1')).not.toBeInTheDocument()
-    expect(rendered.queryByText('id: 2')).not.toBeInTheDocument()
-
-    await sleep(100)
-
-    expect(rendered.queryByText('id: 1')).toBeInTheDocument()
-    expect(rendered.queryByText('id: 2')).not.toBeInTheDocument()
-
-    options.update((o) => ({ ...o, queryKey: ['test', [1, 2]] }))
-
-    await sleep(0)
-
-    expect(rendered.queryByText('id: 1')).toBeInTheDocument()
-    expect(rendered.queryByText('id: 2')).not.toBeInTheDocument()
-
-    await sleep(100)
-
-    expect(rendered.queryByText('id: 1')).toBeInTheDocument()
-    expect(rendered.queryByText('id: 2')).toBeInTheDocument()
-  })
-})

package/src/__tests__/utils.ts

@@ -1,40 +0,0 @@
-import { vi } from 'vitest'
-import { act } from '@testing-library/svelte'
-import { QueryClient, type QueryClientConfig } from '../index'
-
-export function createQueryClient(config?: QueryClientConfig): QueryClient {
-  return new QueryClient(config)
-}
-
-export function mockVisibilityState(value: DocumentVisibilityState) {
-  return vi.spyOn(document, 'visibilityState', 'get').mockReturnValue(value)
-}
-
-export function mockNavigatorOnLine(value: boolean) {
-  return vi.spyOn(navigator, 'onLine', 'get').mockReturnValue(value)
-}
-
-let queryKeyCount = 0
-export function queryKey(): Array<string> {
-  queryKeyCount++
-  return [`query_${queryKeyCount}`]
-}
-
-export function sleep(timeout: number): Promise<void> {
-  return new Promise((resolve, _reject) => {
-    setTimeout(resolve, timeout)
-  })
-}
-
-export async function simplefetcher() {
-  await sleep(10)
-  return 'test'
-}
-
-export function setActTimeout(fn: () => void, ms?: number) {
-  return setTimeout(() => {
-    act(() => {
-      fn()
-    })
-  }, ms)
-}