@tanstack/angular-query-experimental 5.80.8 → 5.80.10

package/src/inject-queries.ts

@@ -0,0 +1,271 @@
+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/{dist-ts/src/inject-query-client.d.ts → src/inject-query-client.ts}

@@ -1,6 +1,7 @@
-import { Injector } from '@angular/core';
-import { QueryClient } from '@tanstack/query-core';
-import type { InjectOptions } from '@angular/core';
+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.
@@ -15,7 +16,8 @@ import type { InjectOptions } from '@angular/core';
  * const queryClient = injectQueryClient();
  * ```
  */
-export declare function injectQueryClient(injectOptions?: InjectOptions & {
-    injector?: Injector;
-}): QueryClient;
-//# sourceMappingURL=inject-query-client.d.ts.map
+export function injectQueryClient(
+  injectOptions: InjectOptions & { injector?: Injector } = {},
+) {
+  return (injectOptions.injector ?? inject(Injector)).get(QueryClient)
+}

package/{dist-ts/src/inject-query.d.ts → src/inject-query.ts}

@@ -1,15 +1,31 @@
-import { Injector } from '@angular/core';
-import type { DefaultError, QueryKey } from '@tanstack/query-core';
-import type { CreateQueryOptions, CreateQueryResult, DefinedCreateQueryResult } from './types';
-import type { DefinedInitialDataOptions, UndefinedInitialDataOptions } from './query-options';
+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;
+  /**
+   * 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.
  *
@@ -47,7 +63,21 @@ export interface InjectQueryOptions {
  * @public
  * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
  */
-export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(injectQueryFn: () => DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, options?: InjectQueryOptions): DefinedCreateQueryResult<TData, TError>;
+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.
  *
@@ -85,7 +115,21 @@ export declare function injectQuery<TQueryFnData = unknown, TError = DefaultErro
  * @public
  * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
  */
-export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(injectQueryFn: () => UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, options?: InjectQueryOptions): CreateQueryResult<TData, TError>;
+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.
  *
@@ -123,5 +167,64 @@ export declare function injectQuery<TQueryFnData = unknown, TError = DefaultErro
  * @public
  * @see https://tanstack.com/query/latest/docs/framework/angular/guides/queries
  */
-export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(injectQueryFn: () => CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, options?: InjectQueryOptions): CreateQueryResult<TData, TError>;
-//# sourceMappingURL=inject-query.d.ts.map
+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/{dist-ts/src/mutation-options.d.ts → src/mutation-options.ts}

@@ -1,4 +1,9 @@
-import type { DefaultError, MutationObserverOptions, OmitKeyof } from '@tanstack/query-core';
+import type {
+  DefaultError,
+  MutationObserverOptions,
+  OmitKeyof,
+} from '@tanstack/query-core'
+
 /**
  * Allows to share and re-use mutation options in a type-safe way.
  *
@@ -30,10 +35,26 @@ import type { DefaultError, MutationObserverOptions, OmitKeyof } from '@tanstack
  * @returns Mutation options.
  * @public
  */
-export declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(options: MutationObserverOptions<TData, TError, TVariables, TContext>): CreateMutationOptions<TData, TError, TVariables, TContext>;
+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'> {
-}
-//# sourceMappingURL=mutation-options.d.ts.map
+export interface CreateMutationOptions<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = void,
+  TContext = unknown,
+> extends OmitKeyof<
+    MutationObserverOptions<TData, TError, TVariables, TContext>,
+    '_defaulted'
+  > {}