@tanstack/angular-query-experimental 5.34.1 → 5.35.0

package/src/__tests__/util/lazy-init/lazy-init.test.ts

@@ -1,126 +0,0 @@
-import { describe, expect, test } from 'vitest'
-import {
-  ChangeDetectionStrategy,
-  Component,
-  type WritableSignal,
-  computed,
-  effect,
-  input,
-  signal,
-} from '@angular/core'
-import { TestBed } from '@angular/core/testing'
-import { flushQueue, setFixtureSignalInputs } from '../../test-utils'
-import { lazyInit } from '../../../util/lazy-init/lazy-init'
-
-describe('lazyInit', () => {
-  test('should init lazily in next tick when not accessing manually', async () => {
-    const mockFn = vi.fn()
-
-    TestBed.runInInjectionContext(() => {
-      lazyInit(() => {
-        mockFn()
-        return {
-          data: signal(true),
-        }
-      })
-    })
-
-    expect(mockFn).not.toHaveBeenCalled()
-
-    await new Promise(setImmediate)
-
-    expect(mockFn).toHaveBeenCalled()
-  })
-
-  test('should init eagerly accessing manually', async () => {
-    const mockFn = vi.fn()
-
-    TestBed.runInInjectionContext(() => {
-      const lazySignal = lazyInit(() => {
-        mockFn()
-        return {
-          data: signal(true),
-        }
-      })
-
-      lazySignal.data()
-
-      console.log(lazySignal)
-    })
-
-    expect(mockFn).toHaveBeenCalled()
-  })
-
-  test('should init lazily and only once', async () => {
-    const initCallFn = vi.fn()
-    const registerDataValue = vi.fn<[number]>()
-
-    let value!: { data: WritableSignal<number> }
-    const outerSignal = signal(0)
-
-    TestBed.runInInjectionContext(() => {
-      value = lazyInit(() => {
-        initCallFn()
-
-        void outerSignal()
-
-        return { data: signal(0) }
-      })
-
-      effect(() => registerDataValue(value.data()))
-    })
-
-    value.data()
-
-    await flushQueue()
-
-    expect(outerSignal).toBeDefined()
-
-    expect(initCallFn).toHaveBeenCalledTimes(1)
-
-    outerSignal.set(1)
-    await flushQueue()
-    outerSignal.set(2)
-    await flushQueue()
-    value.data.set(4)
-    await flushQueue()
-
-    expect(initCallFn).toHaveBeenCalledTimes(1)
-    expect(registerDataValue).toHaveBeenCalledTimes(2)
-  })
-
-  test('should support required signal input', async () => {
-    @Component({
-      standalone: true,
-      template: `{{ call }} - {{ lazySignal.data() }}`,
-      changeDetection: ChangeDetectionStrategy.OnPush,
-    })
-    class Test {
-      readonly title = input.required<string>()
-      call = 0
-
-      lazySignal = lazyInit(() => {
-        this.call++
-        return {
-          data: computed(() => this.title()),
-        }
-      })
-    }
-
-    const fixture = TestBed.createComponent(Test)
-
-    setFixtureSignalInputs(fixture, { title: 'newValue' })
-    expect(fixture.debugElement.nativeElement.textContent).toBe('0 - newValue')
-    await flushQueue()
-
-    setFixtureSignalInputs(fixture, { title: 'updatedValue' })
-    expect(fixture.debugElement.nativeElement.textContent).toBe(
-      '1 - updatedValue',
-    )
-
-    setFixtureSignalInputs(fixture, { title: 'newUpdatedValue' })
-    expect(fixture.debugElement.nativeElement.textContent).toBe(
-      '1 - newUpdatedValue',
-    )
-  })
-})

package/src/__tests__/util/lazy-signal-initializer/lazy-signal-initializer.test.ts

@@ -1,130 +0,0 @@
-import { describe, expect, test } from 'vitest'
-import {
-  Component,
-  type Signal,
-  type WritableSignal,
-  effect,
-  input,
-  signal,
-} from '@angular/core'
-import { TestBed } from '@angular/core/testing'
-import { lazySignalInitializer } from '../../../util/lazy-signal-initializer/lazy-signal-initializer'
-import { flushQueue, setFixtureSignalInputs } from '../../test-utils'
-
-describe('lazySignalInitializer', () => {
-  test('should init lazily in next tick when not accessing manually', async () => {
-    const mockFn = vi.fn()
-
-    TestBed.runInInjectionContext(() => {
-      lazySignalInitializer(() => {
-        mockFn()
-        return signal(true)
-      })
-    })
-
-    expect(mockFn).not.toHaveBeenCalled()
-
-    await new Promise(setImmediate)
-
-    expect(mockFn).toHaveBeenCalled()
-  })
-
-  test('should init eagerly accessing manually', async () => {
-    const mockFn = vi.fn()
-
-    TestBed.runInInjectionContext(() => {
-      const lazySignal = lazySignalInitializer(() => {
-        mockFn()
-        return signal(true)
-      })
-
-      lazySignal()
-    })
-
-    expect(mockFn).toHaveBeenCalled()
-  })
-
-  test('should init lazily and only once', async () => {
-    const initCallFn = vi.fn()
-    const registerEffectValue = vi.fn<[number]>()
-
-    let value!: Signal<number>
-    const outerSignal = signal(0)
-    let innerSignal!: WritableSignal<number>
-
-    TestBed.runInInjectionContext(() => {
-      value = lazySignalInitializer(() => {
-        initCallFn()
-        innerSignal = signal(0)
-
-        void outerSignal()
-
-        return innerSignal
-      })
-
-      effect(() => registerEffectValue(value()))
-    })
-
-    value()
-
-    await flushQueue()
-
-    expect(outerSignal).toBeDefined()
-    expect(innerSignal).toBeDefined()
-
-    expect(initCallFn).toHaveBeenCalledTimes(1)
-
-    innerSignal.set(1)
-    await flushQueue()
-    outerSignal.set(2)
-    await flushQueue()
-
-    expect(initCallFn).toHaveBeenCalledTimes(1)
-    expect(registerEffectValue).toHaveBeenCalledTimes(2)
-  })
-
-  test('should init lazily', async () => {
-    @Component({
-      standalone: true,
-      template: `{{ subscribed }}`,
-    })
-    class Test {
-      subscribed = false
-
-      lazySignal = lazySignalInitializer(() => {
-        this.subscribed = true
-        return signal('value')
-      })
-    }
-
-    const fixture = TestBed.createComponent(Test)
-    const { debugElement } = fixture
-    fixture.detectChanges()
-
-    expect(debugElement.nativeElement.textContent).toBe('false')
-
-    await new Promise(setImmediate)
-
-    fixture.detectChanges()
-
-    expect(debugElement.nativeElement.textContent).toBe('true')
-  })
-
-  test('should support required signal input', () => {
-    @Component({
-      standalone: true,
-      template: `{{ subscribed }}`,
-    })
-    class Test {
-      readonly title = input.required<string>()
-      subscribed = false
-
-      lazySignal = lazySignalInitializer(() => {
-        return signal(this.title())
-      })
-    }
-
-    const fixture = TestBed.createComponent(Test)
-    setFixtureSignalInputs(fixture, { title: 'newValue' })
-  })
-})

package/src/create-base-query.ts

@@ -1,116 +0,0 @@
-import {
-  DestroyRef,
-  Injector,
-  NgZone,
-  computed,
-  effect,
-  inject,
-  runInInjectionContext,
-  signal,
-  untracked,
-} from '@angular/core'
-import { notifyManager } from '@tanstack/query-core'
-import { signalProxy } from './signal-proxy'
-import { shouldThrowError } from './util'
-import { lazyInit } from './util/lazy-init/lazy-init'
-import type {
-  QueryClient,
-  QueryKey,
-  QueryObserver,
-  QueryObserverResult,
-} from '@tanstack/query-core'
-import type { CreateBaseQueryOptions, CreateBaseQueryResult } from './types'
-
-/**
- * Base implementation for `injectQuery` and `injectInfiniteQuery`.
- */
-export function createBaseQuery<
-  TQueryFnData,
-  TError,
-  TData,
-  TQueryData,
-  TQueryKey extends QueryKey,
->(
-  options: (
-    client: QueryClient,
-  ) => CreateBaseQueryOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryData,
-    TQueryKey
-  >,
-  Observer: typeof QueryObserver,
-  queryClient: QueryClient,
-): CreateBaseQueryResult<TData, TError> {
-  const injector = inject(Injector)
-  const ngZone = inject(NgZone)
-
-  return lazyInit(() => {
-    return runInInjectionContext(injector, () => {
-      const destroyRef = inject(DestroyRef)
-      /**
-       * Signal that has the default options from query client applied
-       * computed() is used so signals can be inserted into the options
-       * making it reactive. Wrapping options in a function ensures embedded expressions
-       * are preserved and can keep being applied after signal changes
-       */
-      const defaultedOptionsSignal = computed(() => {
-        const defaultedOptions = queryClient.defaultQueryOptions(
-          options(queryClient),
-        )
-        defaultedOptions._optimisticResults = 'optimistic'
-        return defaultedOptions
-      })
-
-      const observer = new Observer<
-        TQueryFnData,
-        TError,
-        TData,
-        TQueryData,
-        TQueryKey
-      >(queryClient, defaultedOptionsSignal())
-
-      const resultSignal = signal(
-        observer.getOptimisticResult(defaultedOptionsSignal()),
-      )
-
-      effect(() => {
-        const defaultedOptions = defaultedOptionsSignal()
-        observer.setOptions(defaultedOptions, {
-          // Do not notify on updates because of changes in the options because
-          // these changes should already be reflected in the optimistic result.
-          listeners: false,
-        })
-        untracked(() => {
-          resultSignal.set(observer.getOptimisticResult(defaultedOptions))
-        })
-      })
-
-      // observer.trackResult is not used as this optimization is not needed for Angular
-      const unsubscribe = observer.subscribe(
-        notifyManager.batchCalls(
-          (state: QueryObserverResult<TData, TError>) => {
-            ngZone.run(() => {
-              if (
-                state.isError &&
-                !state.isFetching &&
-                // !isRestoring() && // todo: enable when client persistence is implemented
-                shouldThrowError(observer.options.throwOnError, [
-                  state.error,
-                  observer.getCurrentQuery(),
-                ])
-              ) {
-                throw state.error
-              }
-              resultSignal.set(state)
-            })
-          },
-        ),
-      )
-      destroyRef.onDestroy(unsubscribe)
-
-      return signalProxy(resultSignal) as CreateBaseQueryResult<TData, TError>
-    })
-  })
-}

package/src/index.ts

@@ -1,28 +0,0 @@
-/* istanbul ignore file */
-
-// Re-export core
-export * from '@tanstack/query-core'
-
-export * from './types'
-
-export type {
-  DefinedInitialDataOptions,
-  UndefinedInitialDataOptions,
-} from './query-options'
-export { queryOptions } from './query-options'
-
-export { infiniteQueryOptions } from './infinite-query-options'
-
-export * from './inject-infinite-query'
-export * from './inject-is-fetching'
-export * from './inject-is-mutating'
-export * from './inject-mutation'
-export * from './inject-mutation-state'
-export * from './inject-queries'
-export * from './inject-query'
-export {
-  injectQueryClient,
-  provideQueryClient,
-  QUERY_CLIENT,
-} from './inject-query-client'
-export { provideAngularQuery } from './providers'

package/src/infinite-query-options.ts

@@ -1,94 +0,0 @@
-import type { DataTag } from '@tanstack/query-core'
-import type { InfiniteData } from '@tanstack/query-core'
-import type { CreateInfiniteQueryOptions } from './types'
-import type { DefaultError, QueryKey } from '@tanstack/query-core'
-
-export type UndefinedInitialDataInfiniteOptions<
-  TQueryFnData,
-  TError = DefaultError,
-  TData = InfiniteData<TQueryFnData>,
-  TQueryKey extends QueryKey = QueryKey,
-  TPageParam = unknown,
-> = CreateInfiniteQueryOptions<
-  TQueryFnData,
-  TError,
-  TData,
-  TQueryFnData,
-  TQueryKey,
-  TPageParam
-> & {
-  initialData?: undefined
-}
-
-type NonUndefinedGuard<T> = T extends undefined ? never : T
-
-export type DefinedInitialDataInfiniteOptions<
-  TQueryFnData,
-  TError = DefaultError,
-  TData = InfiniteData<TQueryFnData>,
-  TQueryKey extends QueryKey = QueryKey,
-  TPageParam = unknown,
-> = CreateInfiniteQueryOptions<
-  TQueryFnData,
-  TError,
-  TData,
-  TQueryFnData,
-  TQueryKey,
-  TPageParam
-> & {
-  initialData:
-    | NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>
-    | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>)
-}
-
-export function infiniteQueryOptions<
-  TQueryFnData,
-  TError = DefaultError,
-  TData = InfiniteData<TQueryFnData>,
-  TQueryKey extends QueryKey = QueryKey,
-  TPageParam = unknown,
->(
-  options: UndefinedInitialDataInfiniteOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey,
-    TPageParam
-  >,
-): UndefinedInitialDataInfiniteOptions<
-  TQueryFnData,
-  TError,
-  TData,
-  TQueryKey,
-  TPageParam
-> & {
-  queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>
-}
-
-export function infiniteQueryOptions<
-  TQueryFnData,
-  TError = DefaultError,
-  TData = InfiniteData<TQueryFnData>,
-  TQueryKey extends QueryKey = QueryKey,
-  TPageParam = unknown,
->(
-  options: DefinedInitialDataInfiniteOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey,
-    TPageParam
-  >,
-): DefinedInitialDataInfiniteOptions<
-  TQueryFnData,
-  TError,
-  TData,
-  TQueryKey,
-  TPageParam
-> & {
-  queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>
-}
-
-export function infiniteQueryOptions(options: unknown) {
-  return options
-}

package/src/inject-infinite-query.ts

@@ -1,93 +0,0 @@
-import { InfiniteQueryObserver } from '@tanstack/query-core'
-import { createBaseQuery } from './create-base-query'
-import { injectQueryClient } from './inject-query-client'
-import { assertInjector } from './util/assert-injector/assert-injector'
-import type { Injector } from '@angular/core'
-import type {
-  DefaultError,
-  InfiniteData,
-  QueryClient,
-  QueryKey,
-  QueryObserver,
-} from '@tanstack/query-core'
-import type {
-  CreateInfiniteQueryOptions,
-  CreateInfiniteQueryResult,
-  DefinedCreateInfiniteQueryResult,
-} from './types'
-import type {
-  DefinedInitialDataInfiniteOptions,
-  UndefinedInitialDataInfiniteOptions,
-} from './infinite-query-options'
-
-export function injectInfiniteQuery<
-  TQueryFnData,
-  TError = DefaultError,
-  TData = InfiniteData<TQueryFnData>,
-  TQueryKey extends QueryKey = QueryKey,
-  TPageParam = unknown,
->(
-  options: (
-    client: QueryClient,
-  ) => UndefinedInitialDataInfiniteOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey,
-    TPageParam
-  >,
-  injector?: Injector,
-): CreateInfiniteQueryResult<TData, TError>
-
-export function injectInfiniteQuery<
-  TQueryFnData,
-  TError = DefaultError,
-  TData = InfiniteData<TQueryFnData>,
-  TQueryKey extends QueryKey = QueryKey,
-  TPageParam = unknown,
->(
-  options: (
-    client: QueryClient,
-  ) => DefinedInitialDataInfiniteOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey,
-    TPageParam
-  >,
-  injector?: Injector,
-): DefinedCreateInfiniteQueryResult<TData, TError>
-
-export function injectInfiniteQuery<
-  TQueryFnData,
-  TError = DefaultError,
-  TData = InfiniteData<TQueryFnData>,
-  TQueryKey extends QueryKey = QueryKey,
-  TPageParam = unknown,
->(
-  options: (
-    client: QueryClient,
-  ) => CreateInfiniteQueryOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryFnData,
-    TQueryKey,
-    TPageParam
-  >,
-  injector?: Injector,
-): CreateInfiniteQueryResult<TData, TError>
-
-export function injectInfiniteQuery(
-  options: (client: QueryClient) => CreateInfiniteQueryOptions,
-  injector?: Injector,
-) {
-  return assertInjector(injectInfiniteQuery, injector, () => {
-    const queryClient = injectQueryClient()
-    return createBaseQuery(
-      options,
-      InfiniteQueryObserver as typeof QueryObserver,
-      queryClient,
-    )
-  })
-}

package/src/inject-is-fetching.ts

@@ -1,39 +0,0 @@
-import { DestroyRef, NgZone, inject, signal } from '@angular/core'
-import { type QueryFilters, notifyManager } from '@tanstack/query-core'
-import { assertInjector } from './util/assert-injector/assert-injector'
-import { injectQueryClient } from './inject-query-client'
-import type { Injector, Signal } from '@angular/core'
-
-export function injectIsFetching(
-  filters?: QueryFilters,
-  injector?: Injector,
-): Signal<number> {
-  return assertInjector(injectIsFetching, injector, () => {
-    const queryClient = injectQueryClient()
-    const destroyRef = inject(DestroyRef)
-    const ngZone = inject(NgZone)
-
-    const cache = queryClient.getQueryCache()
-    // isFetching is the prev value initialized on mount *
-    let isFetching = queryClient.isFetching(filters)
-
-    const result = signal(isFetching)
-
-    const unsubscribe = cache.subscribe(
-      notifyManager.batchCalls(() => {
-        const newIsFetching = queryClient.isFetching(filters)
-        if (isFetching !== newIsFetching) {
-          // * and update with each change
-          isFetching = newIsFetching
-          ngZone.run(() => {
-            result.set(isFetching)
-          })
-        }
-      }),
-    )
-
-    destroyRef.onDestroy(unsubscribe)
-
-    return result
-  })
-}

package/src/inject-is-mutating.ts

@@ -1,39 +0,0 @@
-import { DestroyRef, NgZone, inject, signal } from '@angular/core'
-import { type MutationFilters, notifyManager } from '@tanstack/query-core'
-import { assertInjector } from './util/assert-injector/assert-injector'
-import { injectQueryClient } from './inject-query-client'
-import type { Injector, Signal } from '@angular/core'
-
-export function injectIsMutating(
-  filters?: MutationFilters,
-  injector?: Injector,
-): Signal<number> {
-  return assertInjector(injectIsMutating, injector, () => {
-    const queryClient = injectQueryClient()
-    const destroyRef = inject(DestroyRef)
-    const ngZone = inject(NgZone)
-
-    const cache = queryClient.getMutationCache()
-    // isMutating is the prev value initialized on mount *
-    let isMutating = queryClient.isMutating(filters)
-
-    const result = signal(isMutating)
-
-    const unsubscribe = cache.subscribe(
-      notifyManager.batchCalls(() => {
-        const newIsMutating = queryClient.isMutating(filters)
-        if (isMutating !== newIsMutating) {
-          // * and update with each change
-          isMutating = newIsMutating
-          ngZone.run(() => {
-            result.set(isMutating)
-          })
-        }
-      }),
-    )
-
-    destroyRef.onDestroy(unsubscribe)
-
-    return result
-  })
-}