@tanstack/angular-query-experimental 5.34.2 → 5.35.1

package/src/__tests__/inject-query.test.ts

@@ -1,349 +0,0 @@
-import {
-  Component,
-  Injectable,
-  computed,
-  inject,
-  input,
-  signal,
-} from '@angular/core'
-import { TestBed, fakeAsync, flush, tick } from '@angular/core/testing'
-import { QueryClient } from '@tanstack/query-core'
-import { describe, expect, vi } from 'vitest'
-import { injectQuery } from '../inject-query'
-import { provideAngularQuery } from '../providers'
-import {
-  delayedFetcher,
-  getSimpleFetcherWithReturnData,
-  rejectFetcher,
-  setSignalInputs,
-  simpleFetcher,
-} from './test-utils'
-
-describe('injectQuery', () => {
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [provideAngularQuery(new QueryClient())],
-    })
-  })
-
-  test('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()
-  }))
-
-  test('should resolve to success and update signal: injectQuery()', 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)
-  }))
-
-  test('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' })
-  }))
-
-  test('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()
-  }))
-
-  test('should only run query once enabled signal 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')
-  }))
-
-  test('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')
-
-    flush()
-
-    expect(query2.fetchStatus()).toStrictEqual('idle')
-    expect(query2.status()).toStrictEqual('success')
-    expect(dependentQueryFn).toHaveBeenCalledTimes(1)
-    expect(dependentQueryFn).toHaveBeenCalledWith(
-      expect.objectContaining({ queryKey: ['dependant2'] }),
-    )
-  }))
-
-  test('should use the current value for the queryKey when refetch is called', fakeAsync(() => {
-    const fetchFn = vi.fn(simpleFetcher)
-    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()
-  }))
-
-  describe('throwOnError', () => {
-    test('should evaluate throwOnError when query is expected to throw', fakeAsync(() => {
-      const boundaryFn = vi.fn()
-      TestBed.runInInjectionContext(() => {
-        return injectQuery(() => ({
-          queryKey: ['key12'],
-          queryFn: rejectFetcher,
-          throwOnError: boundaryFn,
-        }))
-      })
-
-      flush()
-
-      expect(boundaryFn).toHaveBeenCalledTimes(1)
-      expect(boundaryFn).toHaveBeenCalledWith(
-        Error('Some error'),
-        expect.objectContaining({
-          state: expect.objectContaining({ status: 'error' }),
-        }),
-      )
-    }))
-
-    test('should throw when throwOnError is true', fakeAsync(() => {
-      TestBed.runInInjectionContext(() => {
-        return injectQuery(() => ({
-          queryKey: ['key13'],
-          queryFn: rejectFetcher,
-          throwOnError: true,
-        }))
-      })
-
-      expect(() => {
-        flush()
-      }).toThrowError('Some error')
-      flush()
-    }))
-
-    test('should throw when throwOnError function returns true', fakeAsync(() => {
-      TestBed.runInInjectionContext(() => {
-        return injectQuery(() => ({
-          queryKey: ['key14'],
-          queryFn: rejectFetcher,
-          throwOnError: () => true,
-        }))
-      })
-
-      expect(() => {
-        flush()
-      }).toThrowError('Some error')
-      flush()
-    }))
-  })
-
-  test('should set state to error when queryFn returns reject promise', fakeAsync(() => {
-    const query = TestBed.runInInjectionContext(() => {
-      return injectQuery(() => ({
-        retry: false,
-        queryKey: ['key15'],
-        queryFn: rejectFetcher,
-      }))
-    })
-
-    expect(query.status()).toBe('pending')
-
-    flush()
-
-    expect(query.status()).toBe('error')
-  }))
-
-  test('should render with required signal inputs', fakeAsync(async () => {
-    @Component({
-      selector: 'app-fake',
-      template: `{{ query.data() }}`,
-      standalone: true,
-    })
-    class FakeComponent {
-      name = input.required<string>()
-
-      query = injectQuery(() => ({
-        queryKey: ['fake', this.name()],
-        queryFn: () => Promise.resolve(this.name()),
-      }))
-    }
-
-    const fixture = TestBed.createComponent(FakeComponent)
-    setSignalInputs(fixture.componentInstance, {
-      name: 'signal-input-required-test',
-    })
-
-    flush()
-    fixture.detectChanges()
-
-    expect(fixture.debugElement.nativeElement.textContent).toEqual(
-      'signal-input-required-test',
-    )
-  }))
-
-  test('should run options in injection context', fakeAsync(async () => {
-    @Injectable()
-    class FakeService {
-      getData(name: string) {
-        return Promise.resolve(name)
-      }
-    }
-
-    @Component({
-      selector: 'app-fake',
-      template: `{{ query.data() }}`,
-      standalone: true,
-      providers: [FakeService],
-    })
-    class FakeComponent {
-      name = signal<string>('test name')
-
-      query = injectQuery(() => {
-        const service = inject(FakeService)
-
-        return {
-          queryKey: ['fake', this.name()],
-          queryFn: () => {
-            return service.getData(this.name())
-          },
-        }
-      })
-    }
-
-    const fixture = TestBed.createComponent(FakeComponent)
-    flush()
-    fixture.detectChanges()
-
-    expect(fixture.componentInstance.query.data()).toEqual('test name')
-
-    fixture.componentInstance.name.set('test name 2')
-    fixture.detectChanges()
-    flush()
-
-    expect(fixture.componentInstance.query.data()).toEqual('test name 2')
-  }))
-})

package/src/__tests__/query-options.test-d.ts

@@ -1,127 +0,0 @@
-import { assertType, describe, expectTypeOf } from 'vitest'
-import { QueryClient } from '@tanstack/query-core'
-import { dataTagSymbol } from '@tanstack/query-core'
-import { queryOptions } from '../query-options'
-import { injectQuery } from '../inject-query'
-import type { Signal } from '@angular/core'
-
-describe('queryOptions', () => {
-  test('should not allow excess properties', () => {
-    return queryOptions({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve(5),
-      // @ts-expect-error this is a good error, because stallTime does not exist!
-      stallTime: 1000,
-    })
-  })
-
-  test('should infer types for callbacks', () => {
-    return queryOptions({
-      queryKey: ['key'],
-      queryFn: () => Promise.resolve(5),
-      staleTime: 1000,
-      select: (data) => {
-        expectTypeOf(data).toEqualTypeOf<number>()
-      },
-    })
-  })
-})
-
-test('should work when passed to injectQuery', () => {
-  const options = queryOptions({
-    queryKey: ['key'],
-    queryFn: () => Promise.resolve(5),
-  })
-
-  const { data } = injectQuery(() => options)
-  expectTypeOf(data).toEqualTypeOf<Signal<number | undefined>>()
-})
-
-test('should work when passed to fetchQuery', () => {
-  const options = queryOptions({
-    queryKey: ['key'],
-    queryFn: () => Promise.resolve(5),
-  })
-
-  const data = new QueryClient().fetchQuery(options)
-  assertType<Promise<number>>(data)
-})
-
-test('should tag the queryKey with the result type of the QueryFn', () => {
-  const { queryKey } = queryOptions({
-    queryKey: ['key'],
-    queryFn: () => Promise.resolve(5),
-  })
-  assertType<number>(queryKey[dataTagSymbol])
-})
-
-test('should tag the queryKey even if no promise is returned', () => {
-  const { queryKey } = queryOptions({
-    queryKey: ['key'],
-    queryFn: () => 5,
-  })
-  assertType<number>(queryKey[dataTagSymbol])
-})
-
-test('should tag the queryKey with unknown if there is no queryFn', () => {
-  const { queryKey } = queryOptions({
-    queryKey: ['key'],
-  })
-
-  assertType<unknown>(queryKey[dataTagSymbol])
-})
-
-test('should tag the queryKey with the result type of the QueryFn if select is used', () => {
-  const { queryKey } = queryOptions({
-    queryKey: ['key'],
-    queryFn: () => Promise.resolve(5),
-    select: (data) => data.toString(),
-  })
-
-  assertType<number>(queryKey[dataTagSymbol])
-})
-
-test('should return the proper type when passed to getQueryData', () => {
-  const { queryKey } = queryOptions({
-    queryKey: ['key'],
-    queryFn: () => Promise.resolve(5),
-  })
-
-  const queryClient = new QueryClient()
-  const data = queryClient.getQueryData(queryKey)
-
-  expectTypeOf(data).toEqualTypeOf<number | undefined>()
-})
-
-test('should properly type updaterFn when passed to setQueryData', () => {
-  const { queryKey } = queryOptions({
-    queryKey: ['key'],
-    queryFn: () => Promise.resolve(5),
-  })
-
-  const queryClient = new QueryClient()
-  const data = queryClient.setQueryData(queryKey, (prev) => {
-    expectTypeOf(prev).toEqualTypeOf<number | undefined>()
-    return prev
-  })
-
-  expectTypeOf(data).toEqualTypeOf<number | undefined>()
-})
-
-test('should properly type value when passed to setQueryData', () => {
-  const { queryKey } = queryOptions({
-    queryKey: ['key'],
-    queryFn: () => Promise.resolve(5),
-  })
-
-  const queryClient = new QueryClient()
-
-  // @ts-expect-error value should be a number
-  queryClient.setQueryData(queryKey, '5')
-  // @ts-expect-error value should be a number
-  queryClient.setQueryData(queryKey, () => '5')
-
-  const data = queryClient.setQueryData(queryKey, 5)
-
-  expectTypeOf(data).toEqualTypeOf<number | undefined>()
-})

package/src/__tests__/signal-proxy.test.ts

@@ -1,27 +0,0 @@
-import { isSignal, signal } from '@angular/core'
-import { describe } from 'vitest'
-import { signalProxy } from '../signal-proxy'
-
-describe('signalProxy', () => {
-  const inputSignal = signal({ fn: () => 'bar', baz: 'qux' })
-  const proxy = signalProxy(inputSignal)
-
-  test('should have computed fields', () => {
-    expect(proxy.baz()).toEqual('qux')
-    expect(isSignal(proxy.baz)).toBe(true)
-  })
-
-  test('should pass through functions as-is', () => {
-    expect(proxy.fn()).toEqual('bar')
-    expect(isSignal(proxy.fn)).toBe(false)
-  })
-
-  test('supports "in" operator', () => {
-    expect('baz' in proxy).toBe(true)
-    expect('foo' in proxy).toBe(false)
-  })
-
-  test('supports "Object.keys"', () => {
-    expect(Object.keys(proxy)).toEqual(['fn', 'baz'])
-  })
-})

package/src/__tests__/test-utils.ts

@@ -1,131 +0,0 @@
-import { type InputSignal, isSignal, untracked } from '@angular/core'
-import { SIGNAL, signalSetFn } from '@angular/core/primitives/signals'
-import type { ComponentFixture } from '@angular/core/testing'
-
-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 infiniteFetcher({
-  pageParam,
-}: {
-  pageParam?: number
-}): Promise<string> {
-  return new Promise((resolve) => {
-    setTimeout(() => {
-      return resolve('data on page ' + pageParam)
-    }, 0)
-  })
-}
-
-export function successMutator<T>(param: T): Promise<T> {
-  return new Promise((resolve) => {
-    setTimeout(() => {
-      return resolve(param)
-    }, 0)
-  })
-}
-
-export function errorMutator(_parameter?: unknown): Promise<Error> {
-  return rejectFetcher()
-}
-
-// Evaluate all signals on an object and return the result
-function evaluateSignals<T extends Record<string, any>>(
-  obj: T,
-): { [K in keyof T]: ReturnType<T[K]> } {
-  const result: Partial<{ [K in keyof T]: ReturnType<T[K]> }> = {}
-
-  untracked(() => {
-    for (const key in obj) {
-      if (
-        Object.prototype.hasOwnProperty.call(obj, key) &&
-        // Only evaluate signals, not normal functions
-        isSignal(obj[key])
-      ) {
-        const func = obj[key]
-        result[key] = func()
-      }
-    }
-  })
-
-  return result as { [K in keyof T]: ReturnType<T[K]> }
-}
-
-export const expectSignals = <T extends Record<string, any>>(
-  obj: T,
-  expected: Partial<{ [K in keyof T]: ReturnType<T[K]> }>,
-): void => {
-  expect(evaluateSignals(obj)).toMatchObject(expected)
-}
-
-type ToSignalInputUpdatableMap<T> = {
-  [K in keyof T as T[K] extends InputSignal<any>
-    ? K
-    : never]: T[K] extends InputSignal<infer Value> ? Value : never
-}
-
-function componentHasSignalInputProperty<TProperty extends string>(
-  component: object,
-  property: TProperty,
-): component is { [key in TProperty]: InputSignal<unknown> } {
-  return (
-    component.hasOwnProperty(property) && (component as any)[property][SIGNAL]
-  )
-}
-
-/**
- * Set required signal input value to component fixture
- * @see https://github.com/angular/angular/issues/54013
- */
-export function setSignalInputs<T extends NonNullable<unknown>>(
-  component: T,
-  inputs: ToSignalInputUpdatableMap<T>,
-) {
-  for (const inputKey in inputs) {
-    if (componentHasSignalInputProperty(component, inputKey)) {
-      signalSetFn(component[inputKey][SIGNAL], inputs[inputKey])
-    }
-  }
-}
-
-export function setFixtureSignalInputs<T extends NonNullable<unknown>>(
-  componentFixture: ComponentFixture<T>,
-  inputs: ToSignalInputUpdatableMap<T>,
-  options: { detectChanges: boolean } = { detectChanges: true },
-) {
-  setSignalInputs(componentFixture.componentInstance, inputs)
-  if (options.detectChanges) {
-    componentFixture.detectChanges()
-  }
-}
-
-export async function flushQueue() {
-  await new Promise(setImmediate)
-}