@tanstack/angular-query-experimental 5.84.0 → 5.84.2

package/src/inject-queries.ts

@@ -1,271 +0,0 @@
-import {
-  QueriesObserver,
-  QueryClient,
-  notifyManager,
-} from '@tanstack/query-core'
-import {
-  DestroyRef,
-  Injector,
-  NgZone,
-  assertInInjectionContext,
-  computed,
-  effect,
-  inject,
-  runInInjectionContext,
-  signal,
-} from '@angular/core'
-import { injectIsRestoring } from './inject-is-restoring'
-import type { Signal } from '@angular/core'
-import type {
-  DefaultError,
-  OmitKeyof,
-  QueriesObserverOptions,
-  QueriesPlaceholderDataFunction,
-  QueryFunction,
-  QueryKey,
-  QueryObserverOptions,
-  QueryObserverResult,
-  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
-
-// Widen the type of the symbol to enable type inference even if skipToken is not immutable.
-type SkipTokenForUseQueries = symbol
-
-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>
-                      | SkipTokenForUseQueries
-                    select: (data: any) => infer TData
-                    throwOnError?: ThrowOnError<any, infer TError, any, any>
-                  }
-                ? QueryObserverOptionsForCreateQueries<
-                    TQueryFnData,
-                    unknown extends TError ? DefaultError : TError,
-                    unknown extends TData ? TQueryFnData : TData,
-                    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<infer TQueryFnData, any>
-                      | SkipTokenForUseQueries
-                    select: (data: any) => infer TData
-                    throwOnError?: ThrowOnError<any, infer TError, any, any>
-                  }
-                ? QueryObserverResult<
-                    unknown extends TData ? TQueryFnData : TData,
-                    unknown extends TError ? DefaultError : TError
-                  >
-                : // Fallback
-                  QueryObserverResult
-
-/**
- * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
- * @public
- */
-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
- * @public
- */
-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>
-
-/**
- * @param root0
- * @param root0.queries
- * @param root0.combine
- * @param injector
- * @param injector
- * @public
- */
-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> {
-  !injector && assertInInjectionContext(injectQueries)
-  return runInInjectionContext(injector ?? inject(Injector), () => {
-    const destroyRef = inject(DestroyRef)
-    const ngZone = inject(NgZone)
-    const queryClient = inject(QueryClient)
-    const isRestoring = injectIsRestoring()
-
-    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 = isRestoring()
-          ? 'isRestoring'
-          : 'optimistic'
-
-        return defaultedOptions as QueryObserverOptions
-      })
-    })
-
-    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>,
-      )
-    })
-
-    const [, getCombinedResult] = observer.getOptimisticResult(
-      defaultedQueries(),
-      (options as QueriesObserverOptions<TCombinedResult>).combine,
-    )
-
-    const result = signal(getCombinedResult() as any)
-
-    effect(() => {
-      const unsubscribe = isRestoring()
-        ? () => undefined
-        : ngZone.runOutsideAngular(() =>
-            observer.subscribe(notifyManager.batchCalls(result.set)),
-          )
-      destroyRef.onDestroy(unsubscribe)
-    })
-
-    return result
-  })
-}

package/src/inject-query-client.ts

@@ -1,23 +0,0 @@
-import { Injector, inject } from '@angular/core'
-import { QueryClient } from '@tanstack/query-core'
-import type { InjectOptions } from '@angular/core'
-
-/**
- * Injects a `QueryClient` instance and allows passing a custom injector.
- * @param injectOptions - Type of the options argument to inject and optionally a custom injector.
- * @returns The `QueryClient` instance.
- * @public
- * @deprecated Use `inject(QueryClient)` instead.
- * If you need to get a `QueryClient` from a custom injector, use `injector.get(QueryClient)`.
- *
- *
- * **Example**
- * ```ts
- * const queryClient = injectQueryClient();
- * ```
- */
-export function injectQueryClient(
-  injectOptions: InjectOptions & { injector?: Injector } = {},
-) {
-  return (injectOptions.injector ?? inject(Injector)).get(QueryClient)
-}

package/src/inject-query.ts

@@ -1,230 +0,0 @@
-import { QueryObserver } from '@tanstack/query-core'
-import {
-  Injector,
-  assertInInjectionContext,
-  inject,
-  runInInjectionContext,
-} from '@angular/core'
-import { createBaseQuery } from './create-base-query'
-import type { DefaultError, QueryKey } from '@tanstack/query-core'
-import type {
-  CreateQueryOptions,
-  CreateQueryResult,
-  DefinedCreateQueryResult,
-} from './types'
-import type {
-  DefinedInitialDataOptions,
-  UndefinedInitialDataOptions,
-} from './query-options'
-
-export interface InjectQueryOptions {
-  /**
-   * The `Injector` in which to create the query.
-   *
-   * If this is not provided, the current injection context will be used instead (via `inject`).
-   */
-  injector?: Injector
-}
-
-/**
- * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
- *
- * **Basic example**
- * ```ts
- * class ServiceOrComponent {
- *   query = injectQuery(() => ({
- *     queryKey: ['repoData'],
- *     queryFn: () =>
- *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),
- *   }))
- * }
- * ```
- *
- * Similar to `computed` from Angular, the function passed to `injectQuery` will be run in the reactive context.
- * In the example below, the query will be automatically enabled and executed when the filter signal changes
- * to a truthy value. When the filter signal changes back to a falsy value, the query will be disabled.
- *
- * **Reactive example**
- * ```ts
- * class ServiceOrComponent {
- *   filter = signal('')
- *
- *   todosQuery = injectQuery(() => ({
- *     queryKey: ['todos', this.filter()],
- *     queryFn: () => fetchTodos(this.filter()),
- *     // Signals can be combined with expressions
- *     enabled: !!this.filter(),
- *   }))
- * }
- * ```
- * @param injectQueryFn - A function that returns query options.
- * @param options - Additional configuration
- * @returns The query result.
- * @public
- * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
- */
-export function injectQuery<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  injectQueryFn: () => DefinedInitialDataOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey
-  >,
-  options?: InjectQueryOptions,
-): DefinedCreateQueryResult<TData, TError>
-
-/**
- * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
- *
- * **Basic example**
- * ```ts
- * class ServiceOrComponent {
- *   query = injectQuery(() => ({
- *     queryKey: ['repoData'],
- *     queryFn: () =>
- *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),
- *   }))
- * }
- * ```
- *
- * Similar to `computed` from Angular, the function passed to `injectQuery` will be run in the reactive context.
- * In the example below, the query will be automatically enabled and executed when the filter signal changes
- * to a truthy value. When the filter signal changes back to a falsy value, the query will be disabled.
- *
- * **Reactive example**
- * ```ts
- * class ServiceOrComponent {
- *   filter = signal('')
- *
- *   todosQuery = injectQuery(() => ({
- *     queryKey: ['todos', this.filter()],
- *     queryFn: () => fetchTodos(this.filter()),
- *     // Signals can be combined with expressions
- *     enabled: !!this.filter(),
- *   }))
- * }
- * ```
- * @param injectQueryFn - A function that returns query options.
- * @param options - Additional configuration
- * @returns The query result.
- * @public
- * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
- */
-export function injectQuery<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  injectQueryFn: () => UndefinedInitialDataOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey
-  >,
-  options?: InjectQueryOptions,
-): CreateQueryResult<TData, TError>
-
-/**
- * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
- *
- * **Basic example**
- * ```ts
- * class ServiceOrComponent {
- *   query = injectQuery(() => ({
- *     queryKey: ['repoData'],
- *     queryFn: () =>
- *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),
- *   }))
- * }
- * ```
- *
- * Similar to `computed` from Angular, the function passed to `injectQuery` will be run in the reactive context.
- * In the example below, the query will be automatically enabled and executed when the filter signal changes
- * to a truthy value. When the filter signal changes back to a falsy value, the query will be disabled.
- *
- * **Reactive example**
- * ```ts
- * class ServiceOrComponent {
- *   filter = signal('')
- *
- *   todosQuery = injectQuery(() => ({
- *     queryKey: ['todos', this.filter()],
- *     queryFn: () => fetchTodos(this.filter()),
- *     // Signals can be combined with expressions
- *     enabled: !!this.filter(),
- *   }))
- * }
- * ```
- * @param injectQueryFn - A function that returns query options.
- * @param options - Additional configuration
- * @returns The query result.
- * @public
- * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
- */
-export function injectQuery<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  injectQueryFn: () => CreateQueryOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey
-  >,
-  options?: InjectQueryOptions,
-): CreateQueryResult<TData, TError>
-
-/**
- * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
- *
- * **Basic example**
- * ```ts
- * class ServiceOrComponent {
- *   query = injectQuery(() => ({
- *     queryKey: ['repoData'],
- *     queryFn: () =>
- *       this.#http.get<Response>('https://api.github.com/repos/tanstack/query'),
- *   }))
- * }
- * ```
- *
- * Similar to `computed` from Angular, the function passed to `injectQuery` will be run in the reactive context.
- * In the example below, the query will be automatically enabled and executed when the filter signal changes
- * to a truthy value. When the filter signal changes back to a falsy value, the query will be disabled.
- *
- * **Reactive example**
- * ```ts
- * class ServiceOrComponent {
- *   filter = signal('')
- *
- *   todosQuery = injectQuery(() => ({
- *     queryKey: ['todos', this.filter()],
- *     queryFn: () => fetchTodos(this.filter()),
- *     // Signals can be combined with expressions
- *     enabled: !!this.filter(),
- *   }))
- * }
- * ```
- * @param injectQueryFn - A function that returns query options.
- * @param options - Additional configuration
- * @returns The query result.
- * @public
- * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
- */
-export function injectQuery(
-  injectQueryFn: () => CreateQueryOptions,
-  options?: InjectQueryOptions,
-) {
-  !options?.injector && assertInInjectionContext(injectQuery)
-  return runInInjectionContext(options?.injector ?? inject(Injector), () =>
-    createBaseQuery(injectQueryFn, QueryObserver),
-  ) as unknown as CreateQueryResult
-}

package/src/mutation-options.ts

@@ -1,60 +0,0 @@
-import type {
-  DefaultError,
-  MutationObserverOptions,
-  OmitKeyof,
-} from '@tanstack/query-core'
-
-/**
- * Allows to share and re-use mutation options in a type-safe way.
- *
- * **Example**
- *
- * ```ts
- * export class QueriesService {
- *   private http = inject(HttpClient);
- *
- *   updatePost(id: number) {
- *     return mutationOptions({
- *       mutationFn: (post: Post) => Promise.resolve(post),
- *       mutationKey: ["updatePost", id],
- *       onSuccess: (newPost) => {
- *         //           ^? newPost: Post
- *         this.queryClient.setQueryData(["posts", id], newPost);
- *       },
- *     });
- *   }
- * }
- *
- * queries = inject(QueriesService)
- * idSignal = new Signal(0);
- * mutation = injectMutation(() => this.queries.updatePost(this.idSignal()))
- *
- * mutation.mutate({ title: 'New Title' })
- * ```
- * @param options - The mutation options.
- * @returns Mutation options.
- * @public
- */
-export function mutationOptions<
-  TData = unknown,
-  TError = DefaultError,
-  TVariables = void,
-  TContext = unknown,
->(
-  options: MutationObserverOptions<TData, TError, TVariables, TContext>,
-): CreateMutationOptions<TData, TError, TVariables, TContext> {
-  return options
-}
-
-/**
- * @public
- */
-export interface CreateMutationOptions<
-  TData = unknown,
-  TError = DefaultError,
-  TVariables = void,
-  TContext = unknown,
-> extends OmitKeyof<
-    MutationObserverOptions<TData, TError, TVariables, TContext>,
-    '_defaulted'
-  > {}