@tanstack/angular-query-experimental 5.12.1

package/src/tests/injectQuery.test.ts

@@ -0,0 +1,232 @@
+import { computed, signal } from '@angular/core'
+import { TestBed, fakeAsync, flush, tick } from '@angular/core/testing'
+import { QueryClient } from '@tanstack/query-core'
+import { expect, vi } from 'vitest'
+import { injectQuery } from '../injectQuery'
+import { provideAngularQuery } from '../providers'
+import {
+  delayedFetcher,
+  getSimpleFetcherWithReturnData,
+  rejectFetcher,
+  simpleFetcher,
+} from './test-utils'
+
+describe('injectQuery', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [provideAngularQuery(new QueryClient())],
+    })
+  })
+
+  it('should return pending status initially', fakeAsync(() => {
+    const query = TestBed.runInInjectionContext(() => {
+      return injectQuery(() => ({
+        queryKey: ['key1'],
+        queryFn: simpleFetcher,
+      }))
+    })
+
+    expect(query.status()).toBe('pending')
+    expect(query.isPending()).toBe(true)
+    expect(query.isFetching()).toBe(true)
+    expect(query.isStale()).toBe(true)
+    expect(query.isFetched()).toBe(false)
+
+    flush()
+  }))
+
+  it('should resolve to success and update signal: createQuery', fakeAsync(() => {
+    const query = TestBed.runInInjectionContext(() => {
+      return injectQuery(() => ({
+        queryKey: ['key2'],
+        queryFn: getSimpleFetcherWithReturnData('result2'),
+      }))
+    })
+
+    flush()
+
+    expect(query.status()).toBe('success')
+    expect(query.data()).toBe('result2')
+    expect(query.isPending()).toBe(false)
+    expect(query.isFetching()).toBe(false)
+    expect(query.isFetched()).toBe(true)
+    expect(query.isSuccess()).toBe(true)
+  }))
+
+  it('should reject and update signal', fakeAsync(() => {
+    const query = TestBed.runInInjectionContext(() => {
+      return injectQuery(() => ({
+        retry: false,
+        queryKey: ['key3'],
+        queryFn: rejectFetcher,
+      }))
+    })
+
+    flush()
+
+    expect(query.status()).toBe('error')
+    expect(query.data()).toBe(undefined)
+    expect(query.error()).toMatchObject({ message: 'Some error' })
+    expect(query.isPending()).toBe(false)
+    expect(query.isFetching()).toBe(false)
+    expect(query.isError()).toBe(true)
+    expect(query.failureCount()).toBe(1)
+    expect(query.failureReason()).toMatchObject({ message: 'Some error' })
+  }))
+
+  it('should update query on options contained signal change', fakeAsync(() => {
+    const key = signal(['key6', 'key7'])
+    const spy = vi.fn(simpleFetcher)
+
+    const query = TestBed.runInInjectionContext(() => {
+      return injectQuery(() => ({
+        queryKey: key(),
+        queryFn: spy,
+      }))
+    })
+    flush()
+    expect(spy).toHaveBeenCalledTimes(1)
+
+    expect(query.status()).toBe('success')
+
+    key.set(['key8'])
+    TestBed.flushEffects()
+
+    expect(spy).toHaveBeenCalledTimes(2)
+
+    flush()
+  }))
+
+  it('should only run query once enabled is set to true', fakeAsync(() => {
+    const spy = vi.fn(simpleFetcher)
+    const enabled = signal(false)
+
+    const query = TestBed.runInInjectionContext(() => {
+      return injectQuery(() => ({
+        queryKey: ['key9'],
+        queryFn: spy,
+        enabled: enabled(),
+      }))
+    })
+
+    expect(spy).not.toHaveBeenCalled()
+    expect(query.status()).toBe('pending')
+
+    enabled.set(true)
+    TestBed.flushEffects()
+    flush()
+    expect(spy).toHaveBeenCalledTimes(1)
+    expect(query.status()).toBe('success')
+  }))
+
+  it('should properly execute dependant queries', fakeAsync(() => {
+    const query1 = TestBed.runInInjectionContext(() => {
+      return injectQuery(() => ({
+        queryKey: ['dependant1'],
+        queryFn: simpleFetcher,
+      }))
+    })
+
+    const dependentQueryFn = vi.fn().mockImplementation(delayedFetcher(1000))
+
+    const query2 = TestBed.runInInjectionContext(() => {
+      return injectQuery(
+        computed(() => ({
+          queryKey: ['dependant2'],
+          queryFn: dependentQueryFn,
+          enabled: !!query1.data(),
+        })),
+      )
+    })
+
+    expect(query1.data()).toStrictEqual(undefined)
+    expect(query2.fetchStatus()).toStrictEqual('idle')
+    expect(dependentQueryFn).not.toHaveBeenCalled()
+
+    tick()
+    TestBed.flushEffects()
+
+    expect(query1.data()).toStrictEqual('Some data')
+    // expect(query2().fetchStatus).toStrictEqual('fetching') // TODO: is this working correctly?
+
+    flush()
+
+    expect(query2.fetchStatus()).toStrictEqual('idle')
+    expect(query2.status()).toStrictEqual('success')
+    expect(dependentQueryFn).toHaveBeenCalledTimes(1)
+    expect(dependentQueryFn).toHaveBeenCalledWith(
+      expect.objectContaining({ queryKey: ['dependant2'] }),
+    )
+  }))
+
+  it('should use the current value for the queryKey when refetch is called', fakeAsync(() => {
+    const fetchFn = vi.fn()
+    const keySignal = signal('key11')
+
+    const query = TestBed.runInInjectionContext(() => {
+      return injectQuery(() => ({
+        queryKey: ['key10', keySignal()],
+        queryFn: fetchFn,
+        enabled: false,
+      }))
+    })
+
+    expect(fetchFn).not.toHaveBeenCalled()
+
+    query.refetch().then(() => {
+      expect(fetchFn).toHaveBeenCalledTimes(1)
+      expect(fetchFn).toHaveBeenCalledWith(
+        expect.objectContaining({
+          queryKey: ['key10', 'key11'],
+        }),
+      )
+    })
+
+    flush()
+
+    keySignal.set('key12')
+
+    TestBed.flushEffects()
+
+    query.refetch().then(() => {
+      expect(fetchFn).toHaveBeenCalledTimes(2)
+      expect(fetchFn).toHaveBeenCalledWith(
+        expect.objectContaining({
+          queryKey: ['key10', 'key12'],
+        }),
+      )
+    })
+
+    flush()
+  }))
+
+  it('should set state to error when queryFn returns reject promise', fakeAsync(() => {
+    const query = TestBed.runInInjectionContext(() => {
+      return injectQuery(() => ({
+        retry: false,
+        queryKey: ['key13'],
+        queryFn: rejectFetcher,
+      }))
+    })
+
+    expect(query.status()).toBe('pending')
+
+    flush()
+
+    expect(query.status()).toBe('error')
+  }))
+
+  it('should not update signal when notifyOnChangeProps is set without the changed property being in notifyOnChangeProps', fakeAsync(() => {
+    const query = TestBed.runInInjectionContext(() => {
+      return injectQuery(() => ({
+        queryKey: ['key14'],
+        queryFn: simpleFetcher,
+        notifyOnChangeProps: 'all',
+      }))
+    })
+
+    flush()
+
+    expect(query.status()).toBe('success')
+  }))
+})

package/src/tests/test-utils.ts

@@ -0,0 +1,37 @@
+export function simpleFetcher(): Promise<string> {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      return resolve('Some data')
+    }, 0)
+  })
+}
+
+export function delayedFetcher(timeout = 0): () => Promise<string> {
+  return () =>
+    new Promise((resolve) => {
+      setTimeout(() => {
+        return resolve('Some data')
+      }, timeout)
+    })
+}
+
+export function getSimpleFetcherWithReturnData(returnData: unknown) {
+  return () =>
+    new Promise((resolve) => setTimeout(() => resolve(returnData), 0))
+}
+
+export function rejectFetcher(): Promise<Error> {
+  return new Promise((_, reject) => {
+    setTimeout(() => {
+      return reject(new Error('Some error'))
+    }, 0)
+  })
+}
+
+export function successMutator<T>(param: T): Promise<T> {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      return resolve(param)
+    }, 0)
+  })
+}

package/src/types.ts

@@ -0,0 +1,136 @@
+import type { Signal } from '@angular/core'
+
+import type {
+  DefaultError,
+  DefinedQueryObserverResult,
+  InfiniteQueryObserverOptions,
+  InfiniteQueryObserverResult,
+  MutateFunction,
+  MutationObserverOptions,
+  MutationObserverResult,
+  QueryKey,
+  QueryObserverOptions,
+  QueryObserverResult,
+} from '@tanstack/query-core'
+
+/** Options for createBaseQuery */
+export type CreateBaseQueryOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+> = QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>
+
+/** Result from createBaseQuery */
+export type CreateBaseQueryResult<
+  TData = unknown,
+  TError = DefaultError,
+  State = QueryObserverResult<TData, TError>,
+> = {
+  [K in keyof State]: State[K] extends Function ? State[K] : Signal<State[K]>
+}
+/** Result from createBaseQuery */
+
+/** Options for createQuery */
+export type CreateQueryOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+> = CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>
+
+/** Result from createQuery */
+export type CreateQueryResult<
+  TData = unknown,
+  TError = DefaultError,
+> = CreateBaseQueryResult<TData, TError>
+
+/** Options for createInfiniteQuery */
+export type CreateInfiniteQueryOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
+> = InfiniteQueryObserverOptions<
+  TQueryFnData,
+  TError,
+  TData,
+  TQueryData,
+  TQueryKey,
+  TPageParam
+>
+
+/** Result from createInfiniteQuery */
+export type CreateInfiniteQueryResult<
+  TData = unknown,
+  TError = DefaultError,
+> = Signal<InfiniteQueryObserverResult<TData, TError>>
+
+/** Options for createBaseQuery with initialData */
+export type DefinedCreateBaseQueryResult<
+  TData = unknown,
+  TError = DefaultError,
+  DefinedQueryObserver = DefinedQueryObserverResult<TData, TError>,
+> = {
+  [K in keyof DefinedQueryObserver]: DefinedQueryObserver[K] extends Function
+    ? DefinedQueryObserver[K]
+    : Signal<DefinedQueryObserver[K]>
+}
+
+/** Options for createQuery with initialData */
+export type DefinedCreateQueryResult<
+  TData = unknown,
+  TError = DefaultError,
+> = DefinedCreateBaseQueryResult<TData, TError>
+
+/** Options for createMutation */
+export type CreateMutationOptions<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = void,
+  TContext = unknown,
+> = Omit<
+  MutationObserverOptions<TData, TError, TVariables, TContext>,
+  '_defaulted' | 'variables'
+>
+
+export type CreateMutateFunction<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = void,
+  TContext = unknown,
+> = (
+  ...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>
+) => void
+
+export type CreateMutateAsyncFunction<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = void,
+  TContext = unknown,
+> = MutateFunction<TData, TError, TVariables, TContext>
+
+export type CreateBaseMutationResult<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = unknown,
+  TContext = unknown,
+> = Override<
+  MutationObserverResult<TData, TError, TVariables, TContext>,
+  { mutate: CreateMutateFunction<TData, TError, TVariables, TContext> }
+> & {
+  mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TContext>
+}
+
+/** Result from createMutation */
+export type CreateMutationResult<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = unknown,
+  TContext = unknown,
+> = Signal<CreateBaseMutationResult<TData, TError, TVariables, TContext>>
+
+type Override<A, B> = { [K in keyof A]: K extends keyof B ? B[K] : A[K] }