@tanstack/angular-query-experimental 5.34.1 → 5.35.0

package/src/inject-mutation-state.ts

@@ -1,97 +0,0 @@
-import {
-  DestroyRef,
-  NgZone,
-  effect,
-  inject,
-  signal,
-  untracked,
-} from '@angular/core'
-import {
-  type DefaultError,
-  type Mutation,
-  type MutationCache,
-  type MutationFilters,
-  type MutationState,
-  notifyManager,
-  replaceEqualDeep,
-} from '@tanstack/query-core'
-import { assertInjector } from './util/assert-injector/assert-injector'
-import { injectQueryClient } from './inject-query-client'
-import { lazySignalInitializer } from './util/lazy-signal-initializer/lazy-signal-initializer'
-import type { Injector, Signal } from '@angular/core'
-
-type MutationStateOptions<TResult = MutationState> = {
-  filters?: MutationFilters
-  select?: (
-    mutation: Mutation<unknown, DefaultError, unknown, unknown>,
-  ) => TResult
-}
-
-function getResult<TResult = MutationState>(
-  mutationCache: MutationCache,
-  options: MutationStateOptions<TResult>,
-): Array<TResult> {
-  return mutationCache
-    .findAll(options.filters)
-    .map(
-      (mutation): TResult =>
-        (options.select
-          ? options.select(
-              mutation as Mutation<unknown, DefaultError, unknown, unknown>,
-            )
-          : mutation.state) as TResult,
-    )
-}
-
-export interface InjectMutationStateOptions {
-  injector?: Injector
-}
-
-export function injectMutationState<TResult = MutationState>(
-  mutationStateOptionsFn: () => MutationStateOptions<TResult> = () => ({}),
-  options?: InjectMutationStateOptions,
-): Signal<Array<TResult>> {
-  return assertInjector(injectMutationState, options?.injector, () => {
-    const destroyRef = inject(DestroyRef)
-    const queryClient = injectQueryClient()
-    const ngZone = inject(NgZone)
-
-    const mutationCache = queryClient.getMutationCache()
-
-    return lazySignalInitializer((injector) => {
-      const result = signal<Array<TResult>>(
-        getResult(mutationCache, mutationStateOptionsFn()),
-      )
-
-      effect(
-        () => {
-          const mutationStateOptions = mutationStateOptionsFn()
-          untracked(() => {
-            // Setting the signal from an effect because it's both 'computed' from options()
-            // and needs to be set imperatively in the mutationCache listener.
-            result.set(getResult(mutationCache, mutationStateOptions))
-          })
-        },
-        { injector },
-      )
-
-      const unsubscribe = mutationCache.subscribe(
-        notifyManager.batchCalls(() => {
-          const nextResult = replaceEqualDeep(
-            result(),
-            getResult(mutationCache, mutationStateOptionsFn()),
-          )
-          if (result() !== nextResult) {
-            ngZone.run(() => {
-              result.set(nextResult)
-            })
-          }
-        }),
-      )
-
-      destroyRef.onDestroy(unsubscribe)
-
-      return result
-    })
-  })
-}

package/src/inject-mutation.ts

@@ -1,109 +0,0 @@
-import {
-  DestroyRef,
-  Injector,
-  NgZone,
-  computed,
-  effect,
-  inject,
-  runInInjectionContext,
-  signal,
-} from '@angular/core'
-import { MutationObserver, notifyManager } from '@tanstack/query-core'
-import { assertInjector } from './util/assert-injector/assert-injector'
-import { signalProxy } from './signal-proxy'
-import { injectQueryClient } from './inject-query-client'
-import { noop, shouldThrowError } from './util'
-
-import { lazyInit } from './util/lazy-init/lazy-init'
-import type {
-  DefaultError,
-  MutationObserverResult,
-  QueryClient,
-} from '@tanstack/query-core'
-import type {
-  CreateMutateFunction,
-  CreateMutationOptions,
-  CreateMutationResult,
-} from './types'
-
-export function injectMutation<
-  TData = unknown,
-  TError = DefaultError,
-  TVariables = void,
-  TContext = unknown,
->(
-  options: (
-    client: QueryClient,
-  ) => CreateMutationOptions<TData, TError, TVariables, TContext>,
-  injector?: Injector,
-): CreateMutationResult<TData, TError, TVariables, TContext> {
-  return assertInjector(injectMutation, injector, () => {
-    const queryClient = injectQueryClient()
-    const currentInjector = inject(Injector)
-    const destroyRef = inject(DestroyRef)
-    const ngZone = inject(NgZone)
-
-    return lazyInit(() =>
-      runInInjectionContext(currentInjector, () => {
-        const observer = new MutationObserver<
-          TData,
-          TError,
-          TVariables,
-          TContext
-        >(queryClient, options(queryClient))
-        const mutate: CreateMutateFunction<
-          TData,
-          TError,
-          TVariables,
-          TContext
-        > = (variables, mutateOptions) => {
-          observer.mutate(variables, mutateOptions).catch(noop)
-        }
-
-        effect(() => {
-          observer.setOptions(options(queryClient))
-        })
-
-        const result = signal(observer.getCurrentResult())
-
-        const unsubscribe = observer.subscribe(
-          notifyManager.batchCalls(
-            (
-              state: MutationObserverResult<
-                TData,
-                TError,
-                TVariables,
-                TContext
-              >,
-            ) => {
-              ngZone.run(() => {
-                if (
-                  state.isError &&
-                  shouldThrowError(observer.options.throwOnError, [state.error])
-                ) {
-                  throw state.error
-                }
-                result.set(state)
-              })
-            },
-          ),
-        )
-
-        destroyRef.onDestroy(unsubscribe)
-
-        const resultSignal = computed(() => ({
-          ...result(),
-          mutate,
-          mutateAsync: result().mutate,
-        }))
-
-        return signalProxy(resultSignal) as unknown as CreateMutationResult<
-          TData,
-          TError,
-          TVariables,
-          TContext
-        >
-      }),
-    )
-  })
-}

package/src/inject-queries.ts

@@ -1,260 +0,0 @@
-import { QueriesObserver, notifyManager } from '@tanstack/query-core'
-import { DestroyRef, computed, effect, inject, signal } from '@angular/core'
-import { assertInjector } from './util/assert-injector/assert-injector'
-import { injectQueryClient } from './inject-query-client'
-import type { Injector, Signal } from '@angular/core'
-import type {
-  DefaultError,
-  OmitKeyof,
-  QueriesObserverOptions,
-  QueriesPlaceholderDataFunction,
-  QueryFunction,
-  QueryKey,
-  QueryObserverOptions,
-  QueryObserverResult,
-  SkipToken,
-  ThrowOnError,
-} from '@tanstack/query-core'
-
-// This defines the `CreateQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
-// `placeholderData` function does not have a parameter
-type QueryObserverOptionsForCreateQueries<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
-> = OmitKeyof<
-  QueryObserverOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,
-  'placeholderData'
-> & {
-  placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>
-}
-
-// Avoid TS depth-limit error in case of large array literal
-type MAXIMUM_DEPTH = 20
-
-type GetOptions<T> =
-  // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }
-  T extends {
-    queryFnData: infer TQueryFnData
-    error?: infer TError
-    data: infer TData
-  }
-    ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData>
-    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
-      ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError>
-      : T extends { data: infer TData; error?: infer TError }
-        ? QueryObserverOptionsForCreateQueries<unknown, TError, TData>
-        : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]
-          T extends [infer TQueryFnData, infer TError, infer TData]
-          ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData>
-          : T extends [infer TQueryFnData, infer TError]
-            ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError>
-            : T extends [infer TQueryFnData]
-              ? QueryObserverOptionsForCreateQueries<TQueryFnData>
-              : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided
-                T extends {
-                    queryFn?:
-                      | QueryFunction<infer TQueryFnData, infer TQueryKey>
-                      | SkipToken
-                    select: (data: any) => infer TData
-                    throwOnError?: ThrowOnError<any, infer TError, any, any>
-                  }
-                ? QueryObserverOptionsForCreateQueries<
-                    TQueryFnData,
-                    TError,
-                    TData,
-                    TQueryKey
-                  >
-                : T extends {
-                      queryFn?:
-                        | QueryFunction<infer TQueryFnData, infer TQueryKey>
-                        | SkipToken
-                      throwOnError?: ThrowOnError<any, infer TError, any, any>
-                    }
-                  ? QueryObserverOptionsForCreateQueries<
-                      TQueryFnData,
-                      TError,
-                      TQueryFnData,
-                      TQueryKey
-                    >
-                  : // Fallback
-                    QueryObserverOptionsForCreateQueries
-
-type GetResults<T> =
-  // Part 1: responsible for mapping explicit type parameter to function result, if object
-  T extends { queryFnData: any; error?: infer TError; data: infer TData }
-    ? QueryObserverResult<TData, TError>
-    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
-      ? QueryObserverResult<TQueryFnData, TError>
-      : T extends { data: infer TData; error?: infer TError }
-        ? QueryObserverResult<TData, TError>
-        : // Part 2: responsible for mapping explicit type parameter to function result, if tuple
-          T extends [any, infer TError, infer TData]
-          ? QueryObserverResult<TData, TError>
-          : T extends [infer TQueryFnData, infer TError]
-            ? QueryObserverResult<TQueryFnData, TError>
-            : T extends [infer TQueryFnData]
-              ? QueryObserverResult<TQueryFnData>
-              : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided
-                T extends {
-                    queryFn?: QueryFunction<unknown, any>
-                    select: (data: any) => infer TData
-                    throwOnError?: ThrowOnError<any, infer TError, any, any>
-                  }
-                ? QueryObserverResult<
-                    TData,
-                    unknown extends TError ? DefaultError : TError
-                  >
-                : T extends {
-                      queryFn?: QueryFunction<infer TQueryFnData, any>
-                      throwOnError?: ThrowOnError<any, infer TError, any, any>
-                    }
-                  ? QueryObserverResult<
-                      TQueryFnData,
-                      unknown extends TError ? DefaultError : TError
-                    >
-                  : // Fallback
-                    QueryObserverResult
-
-/**
- * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
- */
-export type QueriesOptions<
-  T extends Array<any>,
-  TResult extends Array<any> = [],
-  TDepth extends ReadonlyArray<number> = [],
-> = TDepth['length'] extends MAXIMUM_DEPTH
-  ? Array<QueryObserverOptionsForCreateQueries>
-  : T extends []
-    ? []
-    : T extends [infer Head]
-      ? [...TResult, GetOptions<Head>]
-      : T extends [infer Head, ...infer Tail]
-        ? QueriesOptions<
-            [...Tail],
-            [...TResult, GetOptions<Head>],
-            [...TDepth, 1]
-          >
-        : ReadonlyArray<unknown> extends T
-          ? T
-          : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!
-            // use this to infer the param types in the case of Array.map() argument
-            T extends Array<
-                QueryObserverOptionsForCreateQueries<
-                  infer TQueryFnData,
-                  infer TError,
-                  infer TData,
-                  infer TQueryKey
-                >
-              >
-            ? Array<
-                QueryObserverOptionsForCreateQueries<
-                  TQueryFnData,
-                  TError,
-                  TData,
-                  TQueryKey
-                >
-              >
-            : // Fallback
-              Array<QueryObserverOptionsForCreateQueries>
-
-/**
- * QueriesResults reducer recursively maps type param to results
- */
-export type QueriesResults<
-  T extends Array<any>,
-  TResult extends Array<any> = [],
-  TDepth extends ReadonlyArray<number> = [],
-> = TDepth['length'] extends MAXIMUM_DEPTH
-  ? Array<QueryObserverResult>
-  : T extends []
-    ? []
-    : T extends [infer Head]
-      ? [...TResult, GetResults<Head>]
-      : T extends [infer Head, ...infer Tail]
-        ? QueriesResults<
-            [...Tail],
-            [...TResult, GetResults<Head>],
-            [...TDepth, 1]
-          >
-        : T extends Array<
-              QueryObserverOptionsForCreateQueries<
-                infer TQueryFnData,
-                infer TError,
-                infer TData,
-                any
-              >
-            >
-          ? // Dynamic-size (homogenous) CreateQueryOptions array: map directly to array of results
-            Array<
-              QueryObserverResult<
-                unknown extends TData ? TQueryFnData : TData,
-                unknown extends TError ? DefaultError : TError
-              >
-            >
-          : // Fallback
-            Array<QueryObserverResult>
-
-export function injectQueries<
-  T extends Array<any>,
-  TCombinedResult = QueriesResults<T>,
->(
-  {
-    queries,
-    ...options
-  }: {
-    queries: Signal<[...QueriesOptions<T>]>
-    combine?: (result: QueriesResults<T>) => TCombinedResult
-  },
-  injector?: Injector,
-): Signal<TCombinedResult> {
-  return assertInjector(injectQueries, injector, () => {
-    const queryClient = injectQueryClient()
-    const destroyRef = inject(DestroyRef)
-
-    const defaultedQueries = computed(() => {
-      return queries().map((opts) => {
-        const defaultedOptions = queryClient.defaultQueryOptions(opts)
-        // Make sure the results are already in fetching state before subscribing or updating options
-        defaultedOptions._optimisticResults = 'optimistic'
-
-        return defaultedOptions as QueryObserverOptions<
-          unknown,
-          Error,
-          unknown,
-          unknown,
-          QueryKey
-        >
-      })
-    })
-
-    const observer = new QueriesObserver<TCombinedResult>(
-      queryClient,
-      defaultedQueries(),
-      options as QueriesObserverOptions<TCombinedResult>,
-    )
-
-    // Do not notify on updates because of changes in the options because
-    // these changes should already be reflected in the optimistic result.
-    effect(() => {
-      observer.setQueries(
-        defaultedQueries(),
-        options as QueriesObserverOptions<TCombinedResult>,
-        { listeners: false },
-      )
-    })
-
-    const [, getCombinedResult] = observer.getOptimisticResult(
-      defaultedQueries(),
-      (options as QueriesObserverOptions<TCombinedResult>).combine,
-    )
-
-    const result = signal(getCombinedResult() as any)
-
-    const unsubscribe = observer.subscribe(notifyManager.batchCalls(result.set))
-    destroyRef.onDestroy(unsubscribe)
-
-    return result
-  })
-}

package/src/inject-query-client.ts

@@ -1,7 +0,0 @@
-import { createNoopInjectionToken } from './util/create-injection-token/create-injection-token'
-import type { QueryClient } from '@tanstack/query-core'
-
-const [injectQueryClient, provideQueryClient, QUERY_CLIENT] =
-  createNoopInjectionToken<QueryClient>('QueryClientToken')
-
-export { injectQueryClient, provideQueryClient, QUERY_CLIENT }

package/src/inject-query.ts

@@ -1,68 +0,0 @@
-import { QueryObserver } from '@tanstack/query-core'
-import { runInInjectionContext } from '@angular/core'
-import { assertInjector } from './util/assert-injector/assert-injector'
-import { injectQueryClient } from './inject-query-client'
-import { createBaseQuery } from './create-base-query'
-import type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'
-import type { Injector } from '@angular/core'
-import type {
-  CreateQueryOptions,
-  CreateQueryResult,
-  DefinedCreateQueryResult,
-} from './types'
-import type {
-  DefinedInitialDataOptions,
-  UndefinedInitialDataOptions,
-} from './query-options'
-
-export function injectQuery<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  options: (
-    client: QueryClient,
-  ) => UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
-  injector?: Injector,
-): CreateQueryResult<TData, TError>
-
-export function injectQuery<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  options: (
-    client: QueryClient,
-  ) => DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
-  injector?: Injector,
-): DefinedCreateQueryResult<TData, TError>
-
-export function injectQuery<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  options: (
-    client: QueryClient,
-  ) => CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-  injector?: Injector,
-): CreateQueryResult<TData, TError>
-
-export function injectQuery(
-  options: (client: QueryClient) => CreateQueryOptions,
-  injector?: Injector,
-) {
-  const assertedInjector = assertInjector(injectQuery, injector)
-  return assertInjector(injectQuery, injector, () => {
-    const queryClient = injectQueryClient()
-    return createBaseQuery(
-      (client) =>
-        runInInjectionContext(assertedInjector, () => options(client)),
-      QueryObserver,
-      queryClient,
-    )
-  })
-}

package/src/providers.ts

@@ -1,26 +0,0 @@
-import {
-  DestroyRef,
-  ENVIRONMENT_INITIALIZER,
-  inject,
-  makeEnvironmentProviders,
-} from '@angular/core'
-import { provideQueryClient } from './inject-query-client'
-import type { EnvironmentProviders } from '@angular/core'
-import type { QueryClient } from '@tanstack/query-core'
-
-export function provideAngularQuery(
-  queryClient: QueryClient,
-): EnvironmentProviders {
-  return makeEnvironmentProviders([
-    provideQueryClient(queryClient),
-    {
-      provide: ENVIRONMENT_INITIALIZER,
-      multi: true,
-      useValue: () => {
-        queryClient.mount()
-        // Unmount the query client on application destroy
-        inject(DestroyRef).onDestroy(() => queryClient.unmount())
-      },
-    },
-  ])
-}

package/src/query-options.ts

@@ -1,50 +0,0 @@
-import type { DataTag, DefaultError, QueryKey } from '@tanstack/query-core'
-import type { CreateQueryOptions } from './types'
-
-export type UndefinedInitialDataOptions<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
-> = CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
-  initialData?: undefined
-}
-
-type NonUndefinedGuard<T> = T extends undefined ? never : T
-
-export type DefinedInitialDataOptions<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
-> = CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
-  initialData:
-    | NonUndefinedGuard<TQueryFnData>
-    | (() => NonUndefinedGuard<TQueryFnData>)
-}
-
-export function queryOptions<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
-): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
-  queryKey: DataTag<TQueryKey, TQueryFnData>
-}
-
-export function queryOptions<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
-): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
-  queryKey: DataTag<TQueryKey, TQueryFnData>
-}
-
-export function queryOptions(options: unknown) {
-  return options
-}

package/src/signal-proxy.ts

@@ -1,48 +0,0 @@
-import { computed, untracked } from '@angular/core'
-import type { Signal } from '@angular/core'
-
-export type MapToSignals<T> = {
-  [K in keyof T]: T[K] extends Function ? T[K] : Signal<T[K]>
-}
-
-/**
- * Exposes fields of an object passed via an Angular `Signal` as `Computed` signals.
- *
- * Functions on the object are passed through as-is.
- *
- * @param inputSignal - `Signal` that must return an object.
- *
- */
-export function signalProxy<TInput extends Record<string | symbol, any>>(
-  inputSignal: Signal<TInput>,
-) {
-  const internalState = {} as MapToSignals<TInput>
-
-  return new Proxy<MapToSignals<TInput>>(internalState, {
-    get(target, prop) {
-      // first check if we have it in our internal state and return it
-      const computedField = target[prop]
-      if (computedField) return computedField
-
-      // then, check if it's a function on the resultState and return it
-      const targetField = untracked(inputSignal)[prop]
-      if (typeof targetField === 'function') return targetField
-
-      // finally, create a computed field, store it and return it
-      // @ts-expect-error
-      return (target[prop] = computed(() => inputSignal()[prop]))
-    },
-    has(_, prop) {
-      return !!untracked(inputSignal)[prop]
-    },
-    ownKeys() {
-      return Reflect.ownKeys(untracked(inputSignal))
-    },
-    getOwnPropertyDescriptor() {
-      return {
-        enumerable: true,
-        configurable: true,
-      }
-    },
-  })
-}

package/src/test-setup.ts

@@ -1,12 +0,0 @@
-import '@analogjs/vite-plugin-angular/setup-vitest'
-
-import {
-  BrowserDynamicTestingModule,
-  platformBrowserDynamicTesting,
-} from '@angular/platform-browser-dynamic/testing'
-import { getTestBed } from '@angular/core/testing'
-
-getTestBed().initTestEnvironment(
-  BrowserDynamicTestingModule,
-  platformBrowserDynamicTesting(),
-)