@tanstack/angular-query-experimental 5.74.0 → 5.74.2

package/src/inject-is-restoring.ts

@@ -7,7 +7,7 @@ import {
 } from '@angular/core'
 import type { Provider, Signal } from '@angular/core'
 
-const IsRestoring = new InjectionToken<Signal<boolean>>('IsRestoring')
+const IS_RESTORING = new InjectionToken<Signal<boolean>>('')
 
 /**
  * The `Injector` in which to create the isRestoring signal.
@@ -30,7 +30,7 @@ export function injectIsRestoring(
   !options?.injector && assertInInjectionContext(injectIsRestoring)
   const injector = options?.injector ?? inject(Injector)
   return injector.get(
-    IsRestoring,
+    IS_RESTORING,
     computed(() => false),
     { optional: true },
   )
@@ -44,7 +44,7 @@ export function injectIsRestoring(
  */
 export function provideIsRestoring(isRestoring: Signal<boolean>): Provider {
   return {
-    provide: IsRestoring,
+    provide: IS_RESTORING,
     useValue: isRestoring,
   }
 }

package/src/inject-mutation-state.ts

@@ -1,11 +1,18 @@
-import { DestroyRef, NgZone, computed, inject, signal } from '@angular/core'
+import {
+  DestroyRef,
+  Injector,
+  NgZone,
+  assertInInjectionContext,
+  computed,
+  inject,
+  signal,
+} from '@angular/core'
 import {
   QueryClient,
   notifyManager,
   replaceEqualDeep,
 } from '@tanstack/query-core'
-import { assertInjector } from './util/assert-injector/assert-injector'
-import type { Injector, Signal } from '@angular/core'
+import type { Signal } from '@angular/core'
 import type {
   Mutation,
   MutationCache,
@@ -58,62 +65,61 @@ export function injectMutationState<TResult = MutationState>(
   injectMutationStateFn: () => MutationStateOptions<TResult> = () => ({}),
   options?: InjectMutationStateOptions,
 ): Signal<Array<TResult>> {
-  return assertInjector(injectMutationState, options?.injector, () => {
-    const destroyRef = inject(DestroyRef)
-    const ngZone = inject(NgZone)
-    const queryClient = inject(QueryClient)
-
-    const mutationCache = queryClient.getMutationCache()
+  !options?.injector && assertInInjectionContext(injectMutationState)
+  const injector = options?.injector ?? inject(Injector)
+  const destroyRef = injector.get(DestroyRef)
+  const ngZone = injector.get(NgZone)
+  const queryClient = injector.get(QueryClient)
+  const mutationCache = queryClient.getMutationCache()
 
-    /**
-     * Computed signal that gets result from mutation cache based on passed options
-     * First element is the result, second element is the time when the result was set
-     */
-    const resultFromOptionsSignal = computed(() => {
-      return [
-        getResult(mutationCache, injectMutationStateFn()),
-        performance.now(),
-      ] as const
-    })
+  /**
+   * Computed signal that gets result from mutation cache based on passed options
+   * First element is the result, second element is the time when the result was set
+   */
+  const resultFromOptionsSignal = computed(() => {
+    return [
+      getResult(mutationCache, injectMutationStateFn()),
+      performance.now(),
+    ] as const
+  })
 
-    /**
-     * Signal that contains result set by subscriber
-     * First element is the result, second element is the time when the result was set
-     */
-    const resultFromSubscriberSignal = signal<[Array<TResult>, number] | null>(
-      null,
-    )
+  /**
+   * Signal that contains result set by subscriber
+   * First element is the result, second element is the time when the result was set
+   */
+  const resultFromSubscriberSignal = signal<[Array<TResult>, number] | null>(
+    null,
+  )
 
-    /**
-     * Returns the last result by either subscriber or options
-     */
-    const effectiveResultSignal = computed(() => {
-      const optionsResult = resultFromOptionsSignal()
-      const subscriberResult = resultFromSubscriberSignal()
-      return subscriberResult && subscriberResult[1] > optionsResult[1]
-        ? subscriberResult[0]
-        : optionsResult[0]
-    })
+  /**
+   * Returns the last result by either subscriber or options
+   */
+  const effectiveResultSignal = computed(() => {
+    const optionsResult = resultFromOptionsSignal()
+    const subscriberResult = resultFromSubscriberSignal()
+    return subscriberResult && subscriberResult[1] > optionsResult[1]
+      ? subscriberResult[0]
+      : optionsResult[0]
+  })
 
-    const unsubscribe = ngZone.runOutsideAngular(() =>
-      mutationCache.subscribe(
-        notifyManager.batchCalls(() => {
-          const [lastResult] = effectiveResultSignal()
-          const nextResult = replaceEqualDeep(
-            lastResult,
-            getResult(mutationCache, injectMutationStateFn()),
-          )
-          if (lastResult !== nextResult) {
-            ngZone.run(() => {
-              resultFromSubscriberSignal.set([nextResult, performance.now()])
-            })
-          }
-        }),
-      ),
-    )
+  const unsubscribe = ngZone.runOutsideAngular(() =>
+    mutationCache.subscribe(
+      notifyManager.batchCalls(() => {
+        const [lastResult] = effectiveResultSignal()
+        const nextResult = replaceEqualDeep(
+          lastResult,
+          getResult(mutationCache, injectMutationStateFn()),
+        )
+        if (lastResult !== nextResult) {
+          ngZone.run(() => {
+            resultFromSubscriberSignal.set([nextResult, performance.now()])
+          })
+        }
+      }),
+    ),
+  )
 
-    destroyRef.onDestroy(unsubscribe)
+  destroyRef.onDestroy(unsubscribe)
 
-    return effectiveResultSignal
-  })
+  return effectiveResultSignal
 }

package/src/inject-mutation.ts

@@ -1,6 +1,8 @@
 import {
   DestroyRef,
+  Injector,
   NgZone,
+  assertInInjectionContext,
   computed,
   effect,
   inject,
@@ -12,10 +14,8 @@ import {
   QueryClient,
   notifyManager,
 } from '@tanstack/query-core'
-import { assertInjector } from './util/assert-injector/assert-injector'
 import { signalProxy } from './signal-proxy'
 import { noop, shouldThrowError } from './util'
-import type { Injector } from '@angular/core'
 import type { DefaultError, MutationObserverResult } from '@tanstack/query-core'
 import type { CreateMutateFunction, CreateMutationResult } from './types'
 import type { CreateMutationOptions } from './mutation-options'
@@ -52,123 +52,117 @@ export function injectMutation<
   >,
   options?: InjectMutationOptions,
 ): CreateMutationResult<TData, TError, TVariables, TContext> {
-  return assertInjector(injectMutation, options?.injector, () => {
-    const destroyRef = inject(DestroyRef)
-    const ngZone = inject(NgZone)
-    const queryClient = inject(QueryClient)
-
-    /**
-     * 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 optionsSignal = computed(injectMutationFn)
-
-    const observerSignal = (() => {
-      let instance: MutationObserver<
-        TData,
-        TError,
-        TVariables,
-        TContext
-      > | null = null
-
-      return computed(() => {
-        return (instance ||= new MutationObserver(queryClient, optionsSignal()))
-      })
-    })()
+  !options?.injector && assertInInjectionContext(injectMutation)
+  const injector = options?.injector ?? inject(Injector)
+  const destroyRef = injector.get(DestroyRef)
+  const ngZone = injector.get(NgZone)
+  const queryClient = injector.get(QueryClient)
 
-    const mutateFnSignal = computed<
-      CreateMutateFunction<TData, TError, TVariables, TContext>
-    >(() => {
-      const observer = observerSignal()
-      return (variables, mutateOptions) => {
-        observer.mutate(variables, mutateOptions).catch(noop)
-      }
+  /**
+   * 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 optionsSignal = computed(injectMutationFn)
+
+  const observerSignal = (() => {
+    let instance: MutationObserver<TData, TError, TVariables, TContext> | null =
+      null
+
+    return computed(() => {
+      return (instance ||= new MutationObserver(queryClient, optionsSignal()))
     })
+  })()
+
+  const mutateFnSignal = computed<
+    CreateMutateFunction<TData, TError, TVariables, TContext>
+  >(() => {
+    const observer = observerSignal()
+    return (variables, mutateOptions) => {
+      observer.mutate(variables, mutateOptions).catch(noop)
+    }
+  })
+
+  /**
+   * Computed signal that gets result from mutation cache based on passed options
+   */
+  const resultFromInitialOptionsSignal = computed(() => {
+    const observer = observerSignal()
+    return observer.getCurrentResult()
+  })
+
+  /**
+   * Signal that contains result set by subscriber
+   */
+  const resultFromSubscriberSignal = signal<MutationObserverResult<
+    TData,
+    TError,
+    TVariables,
+    TContext
+  > | null>(null)
 
-    /**
-     * Computed signal that gets result from mutation cache based on passed options
-     */
-    const resultFromInitialOptionsSignal = computed(() => {
+  effect(
+    () => {
       const observer = observerSignal()
-      return observer.getCurrentResult()
-    })
+      const observerOptions = optionsSignal()
 
-    /**
-     * Signal that contains result set by subscriber
-     */
-    const resultFromSubscriberSignal = signal<MutationObserverResult<
-      TData,
-      TError,
-      TVariables,
-      TContext
-    > | null>(null)
-
-    effect(
-      () => {
-        const observer = observerSignal()
-        const observerOptions = optionsSignal()
-
-        untracked(() => {
-          observer.setOptions(observerOptions)
-        })
-      },
-      {
-        injector: options?.injector,
-      },
-    )
-
-    effect(
-      () => {
-        // observer.trackResult is not used as this optimization is not needed for Angular
-        const observer = observerSignal()
-
-        untracked(() => {
-          const unsubscribe = ngZone.runOutsideAngular(() =>
-            observer.subscribe(
-              notifyManager.batchCalls((state) => {
-                ngZone.run(() => {
-                  if (
-                    state.isError &&
-                    shouldThrowError(observer.options.throwOnError, [
-                      state.error,
-                    ])
-                  ) {
-                    ngZone.onError.emit(state.error)
-                    throw state.error
-                  }
-
-                  resultFromSubscriberSignal.set(state)
-                })
-              }),
-            ),
-          )
-          destroyRef.onDestroy(unsubscribe)
-        })
-      },
-      {
-        injector: options?.injector,
-      },
-    )
-
-    const resultSignal = computed(() => {
-      const resultFromSubscriber = resultFromSubscriberSignal()
-      const resultFromInitialOptions = resultFromInitialOptionsSignal()
-
-      const result = resultFromSubscriber ?? resultFromInitialOptions
-
-      return {
-        ...result,
-        mutate: mutateFnSignal(),
-        mutateAsync: result.mutate,
-      }
-    })
+      untracked(() => {
+        observer.setOptions(observerOptions)
+      })
+    },
+    {
+      injector,
+    },
+  )
+
+  effect(
+    () => {
+      // observer.trackResult is not used as this optimization is not needed for Angular
+      const observer = observerSignal()
 
-    return signalProxy(resultSignal) as CreateMutationResult<
-      TData,
-      TError,
-      TVariables,
-      TContext
-    >
+      untracked(() => {
+        const unsubscribe = ngZone.runOutsideAngular(() =>
+          observer.subscribe(
+            notifyManager.batchCalls((state) => {
+              ngZone.run(() => {
+                if (
+                  state.isError &&
+                  shouldThrowError(observer.options.throwOnError, [state.error])
+                ) {
+                  ngZone.onError.emit(state.error)
+                  throw state.error
+                }
+
+                resultFromSubscriberSignal.set(state)
+              })
+            }),
+          ),
+        )
+        destroyRef.onDestroy(unsubscribe)
+      })
+    },
+    {
+      injector,
+    },
+  )
+
+  const resultSignal = computed(() => {
+    const resultFromSubscriber = resultFromSubscriberSignal()
+    const resultFromInitialOptions = resultFromInitialOptionsSignal()
+
+    const result = resultFromSubscriber ?? resultFromInitialOptions
+
+    return {
+      ...result,
+      mutate: mutateFnSignal(),
+      mutateAsync: result.mutate,
+    }
   })
+
+  return signalProxy(resultSignal) as CreateMutationResult<
+    TData,
+    TError,
+    TVariables,
+    TContext
+  >
 }

package/src/inject-queries.ts

@@ -5,15 +5,17 @@ import {
 } from '@tanstack/query-core'
 import {
   DestroyRef,
+  Injector,
   NgZone,
+  assertInInjectionContext,
   computed,
   effect,
   inject,
+  runInInjectionContext,
   signal,
 } from '@angular/core'
-import { assertInjector } from './util/assert-injector/assert-injector'
 import { injectIsRestoring } from './inject-is-restoring'
-import type { Injector, Signal } from '@angular/core'
+import type { Signal } from '@angular/core'
 import type {
   DefaultError,
   OmitKeyof,
@@ -214,7 +216,8 @@ export function injectQueries<
   },
   injector?: Injector,
 ): Signal<TCombinedResult> {
-  return assertInjector(injectQueries, injector, () => {
+  !injector && assertInInjectionContext(injectQueries)
+  return runInInjectionContext(injector ?? inject(Injector), () => {
     const destroyRef = inject(DestroyRef)
     const ngZone = inject(NgZone)
     const queryClient = inject(QueryClient)

package/src/inject-query.ts

@@ -1,7 +1,11 @@
 import { QueryObserver } from '@tanstack/query-core'
-import { assertInjector } from './util/assert-injector/assert-injector'
+import {
+  Injector,
+  assertInInjectionContext,
+  inject,
+  runInInjectionContext,
+} from '@angular/core'
 import { createBaseQuery } from './create-base-query'
-import type { Injector } from '@angular/core'
 import type { DefaultError, QueryKey } from '@tanstack/query-core'
 import type {
   CreateQueryOptions,
@@ -219,7 +223,8 @@ export function injectQuery(
   injectQueryFn: () => CreateQueryOptions,
   options?: InjectQueryOptions,
 ) {
-  return assertInjector(injectQuery, options?.injector, () =>
+  !options?.injector && assertInInjectionContext(injectQuery)
+  return runInInjectionContext(options?.injector ?? inject(Injector), () =>
     createBaseQuery(injectQueryFn, QueryObserver),
   ) as unknown as CreateQueryResult
 }

package/src/util/assert-injector/assert-injector.test.ts

@@ -1,78 +0,0 @@
-/* eslint-disable cspell/spellchecker */
-/**
- * The code in this file is adapted from NG Extension Platform at https://ngxtension.netlify.app.
- *
- * Original Author: Chau Tran
- *
- * NG Extension Platform is an open-source project licensed under the MIT license.
- *
- * For more information about the original code, see
- * https://github.com/nartc/ngxtension-platform
- */
-/* eslint-enable */
-
-import {
-  InjectionToken,
-  Injector,
-  inject,
-  provideExperimentalZonelessChangeDetection,
-  runInInjectionContext,
-} from '@angular/core'
-import { TestBed } from '@angular/core/testing'
-import { assertInjector } from './assert-injector'
-
-describe('assertInjector', () => {
-  const token = new InjectionToken('token', {
-    factory: () => 1,
-  })
-
-  function injectDummy(injector?: Injector) {
-    injector = assertInjector(injectDummy, injector)
-    return runInInjectionContext(injector, () => inject(token))
-  }
-
-  function injectDummyTwo(injector?: Injector) {
-    return assertInjector(injectDummyTwo, injector, () => inject(token) + 1)
-  }
-
-  it('given no custom injector, when run in injection context, then return value', () => {
-    TestBed.configureTestingModule({
-      providers: [provideExperimentalZonelessChangeDetection()],
-    })
-    TestBed.runInInjectionContext(() => {
-      const value = injectDummy()
-      const valueTwo = injectDummyTwo()
-      expect(value).toEqual(1)
-      expect(valueTwo).toEqual(2)
-    })
-  })
-
-  it('given no custom injector, when run outside injection context, then throw', () => {
-    expect(() => injectDummy()).toThrowError(
-      /injectDummy\(\) can only be used within an injection context/i,
-    )
-    expect(() => injectDummyTwo()).toThrowError(
-      /injectDummyTwo\(\) can only be used within an injection context/i,
-    )
-  })
-
-  it('given a custom injector, when run in that injector context without providing number, then throw', () => {
-    expect(() => injectDummy(Injector.create({ providers: [] }))).toThrowError(
-      /No provider for InjectionToken/i,
-    )
-    expect(() =>
-      injectDummyTwo(Injector.create({ providers: [] })),
-    ).toThrowError(/No provider for InjectionToken/i)
-  })
-
-  it('given a custom injector, when run in that injector context and providing number, then return value', () => {
-    const value = injectDummy(
-      Injector.create({ providers: [{ provide: token, useValue: 2 }] }),
-    )
-    const valueTwo = injectDummyTwo(
-      Injector.create({ providers: [{ provide: token, useValue: 2 }] }),
-    )
-    expect(value).toEqual(2)
-    expect(valueTwo).toEqual(3)
-  })
-})

package/src/util/assert-injector/assert-injector.ts

@@ -1,83 +0,0 @@
-/* eslint-disable cspell/spellchecker */
-/**
- * The code in this file is adapted from NG Extension Platform at https://ngxtension.netlify.app.
- *
- * Original Author: Chau Tran
- *
- * NG Extension Platform is an open-source project licensed under the MIT license.
- *
- * For more information about the original code, see
- * https://github.com/nartc/ngxtension-platform
- */
-/* eslint-enable */
-
-import {
-  Injector,
-  assertInInjectionContext,
-  inject,
-  runInInjectionContext,
-} from '@angular/core'
-
-/**
- * `assertInjector` extends `assertInInjectionContext` with an optional `Injector`
- * After assertion, `assertInjector` runs the `runner` function with the guaranteed `Injector`
- * whether it is the default `Injector` within the current **Injection Context**
- * or the custom `Injector` that was passed in.
- * @template {() => any} Runner - Runner is a function that can return anything
- * @param fn - the Function to pass in `assertInInjectionContext`
- * @param injector - the optional "custom" Injector
- * @param runner - the runner fn
- * @returns result - returns the result of the Runner
- * @example
- * ```ts
- * function injectValue(injector?: Injector) {
- *  return assertInjector(injectValue, injector, () => 'value');
- * }
- *
- * injectValue(); // string
- * ```
- */
-export function assertInjector<TRunner extends () => any>(
-  fn: Function,
-  injector: Injector | undefined | null,
-  runner: TRunner,
-): ReturnType<TRunner>
-/**
- * `assertInjector` extends `assertInInjectionContext` with an optional `Injector`
- * After assertion, `assertInjector` returns a guaranteed `Injector` whether it is the default `Injector`
- * within the current **Injection Context** or the custom `Injector` that was passed in.
- * @param fn - the Function to pass in `assertInInjectionContext`
- * @param injector - the optional "custom" Injector
- * @returns Injector
- * @example
- * ```ts
- * function injectDestroy(injector?: Injector) {
- *  injector = assertInjector(injectDestroy, injector);
- *
- *  return runInInjectionContext(injector, () => {
- *    // code
- *  })
- * }
- * ```
- */
-export function assertInjector(
-  fn: Function,
-  injector: Injector | undefined | null,
-): Injector
-/**
- * @param fn - the Function to pass in `assertInInjectionContext`
- * @param injector - the optional "custom" Injector
- * @param runner - the runner fn
- * @returns any
- */
-export function assertInjector(
-  fn: Function,
-  injector: Injector | undefined | null,
-  runner?: () => any,
-) {
-  !injector && assertInInjectionContext(fn)
-  const assertedInjector = injector ?? inject(Injector)
-
-  if (!runner) return assertedInjector
-  return runInInjectionContext(assertedInjector, runner)
-}