@tanstack/angular-query-experimental 5.60.0 → 5.60.3

package/src/signal-proxy.ts

@@ -0,0 +1,46 @@
+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.
+ * @returns A proxy object with the same fields as the input object, but with each field wrapped in a `Computed` signal.
+ */
+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

@@ -0,0 +1,12 @@
+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(),
+)

package/src/types.ts

@@ -0,0 +1,328 @@
+/* istanbul ignore file */
+
+import type {
+  DefaultError,
+  DefinedInfiniteQueryObserverResult,
+  DefinedQueryObserverResult,
+  InfiniteQueryObserverOptions,
+  InfiniteQueryObserverResult,
+  MutateFunction,
+  MutationObserverOptions,
+  MutationObserverResult,
+  OmitKeyof,
+  Override,
+  QueryKey,
+  QueryObserverOptions,
+  QueryObserverResult,
+} from '@tanstack/query-core'
+import type { Signal } from '@angular/core'
+import type { MapToSignals } from './signal-proxy'
+
+/**
+ * @public
+ */
+export interface CreateBaseQueryOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+> extends QueryObserverOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryData,
+    TQueryKey
+  > {}
+
+/**
+ * @public
+ */
+export interface CreateQueryOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+> extends OmitKeyof<
+    CreateBaseQueryOptions<
+      TQueryFnData,
+      TError,
+      TData,
+      TQueryFnData,
+      TQueryKey
+    >,
+    'suspense'
+  > {}
+
+/**
+ * @public
+ */
+type CreateStatusBasedQueryResult<
+  TStatus extends QueryObserverResult['status'],
+  TData = unknown,
+  TError = DefaultError,
+> = Extract<QueryObserverResult<TData, TError>, { status: TStatus }>
+
+/**
+ * @public
+ */
+export interface BaseQueryNarrowing<TData = unknown, TError = DefaultError> {
+  isSuccess: (
+    this: CreateBaseQueryResult<TData, TError>,
+  ) => this is CreateBaseQueryResult<
+    TData,
+    TError,
+    CreateStatusBasedQueryResult<'success', TData, TError>
+  >
+  isError: (
+    this: CreateBaseQueryResult<TData, TError>,
+  ) => this is CreateBaseQueryResult<
+    TData,
+    TError,
+    CreateStatusBasedQueryResult<'error', TData, TError>
+  >
+  isPending: (
+    this: CreateBaseQueryResult<TData, TError>,
+  ) => this is CreateBaseQueryResult<
+    TData,
+    TError,
+    CreateStatusBasedQueryResult<'pending', TData, TError>
+  >
+}
+
+/**
+ * @public
+ */
+export interface CreateInfiniteQueryOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
+> extends OmitKeyof<
+    InfiniteQueryObserverOptions<
+      TQueryFnData,
+      TError,
+      TData,
+      TQueryData,
+      TQueryKey,
+      TPageParam
+    >,
+    'suspense'
+  > {}
+
+/**
+ * @public
+ */
+export type CreateBaseQueryResult<
+  TData = unknown,
+  TError = DefaultError,
+  TState = QueryObserverResult<TData, TError>,
+> = BaseQueryNarrowing<TData, TError> &
+  MapToSignals<OmitKeyof<TState, keyof BaseQueryNarrowing, 'safely'>>
+
+/**
+ * @public
+ */
+export type CreateQueryResult<
+  TData = unknown,
+  TError = DefaultError,
+> = CreateBaseQueryResult<TData, TError>
+
+/**
+ * @public
+ */
+export type DefinedCreateQueryResult<
+  TData = unknown,
+  TError = DefaultError,
+  TDefinedQueryObserver = DefinedQueryObserverResult<TData, TError>,
+> = MapToSignals<TDefinedQueryObserver>
+
+/**
+ * @public
+ */
+export type CreateInfiniteQueryResult<
+  TData = unknown,
+  TError = DefaultError,
+> = MapToSignals<InfiniteQueryObserverResult<TData, TError>>
+
+/**
+ * @public
+ */
+export type DefinedCreateInfiniteQueryResult<
+  TData = unknown,
+  TError = DefaultError,
+  TDefinedInfiniteQueryObserver = DefinedInfiniteQueryObserverResult<
+    TData,
+    TError
+  >,
+> = MapToSignals<TDefinedInfiniteQueryObserver>
+
+/**
+ * @public
+ */
+export interface CreateMutationOptions<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = void,
+  TContext = unknown,
+> extends OmitKeyof<
+    MutationObserverOptions<TData, TError, TVariables, TContext>,
+    '_defaulted'
+  > {}
+
+/**
+ * @public
+ */
+export type CreateMutateFunction<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = void,
+  TContext = unknown,
+> = (
+  ...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>
+) => void
+
+/**
+ * @public
+ */
+export type CreateMutateAsyncFunction<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = void,
+  TContext = unknown,
+> = MutateFunction<TData, TError, TVariables, TContext>
+
+/**
+ * @public
+ */
+export type CreateBaseMutationResult<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = unknown,
+  TContext = unknown,
+> = Override<
+  MutationObserverResult<TData, TError, TVariables, TContext>,
+  { mutate: CreateMutateFunction<TData, TError, TVariables, TContext> }
+> & {
+  mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TContext>
+}
+
+/**
+ * @public
+ */
+type CreateStatusBasedMutationResult<
+  TStatus extends CreateBaseMutationResult['status'],
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = unknown,
+  TContext = unknown,
+> = Extract<
+  CreateBaseMutationResult<TData, TError, TVariables, TContext>,
+  { status: TStatus }
+>
+
+type SignalFunction<T extends () => any> = T & Signal<ReturnType<T>>
+
+/**
+ * @public
+ */
+export interface BaseMutationNarrowing<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = unknown,
+  TContext = unknown,
+> {
+  isSuccess: SignalFunction<
+    (
+      this: CreateMutationResult<TData, TError, TVariables, TContext>,
+    ) => this is CreateMutationResult<
+      TData,
+      TError,
+      TVariables,
+      TContext,
+      CreateStatusBasedMutationResult<
+        'success',
+        TData,
+        TError,
+        TVariables,
+        TContext
+      >
+    >
+  >
+  isError: SignalFunction<
+    (
+      this: CreateMutationResult<TData, TError, TVariables, TContext>,
+    ) => this is CreateMutationResult<
+      TData,
+      TError,
+      TVariables,
+      TContext,
+      CreateStatusBasedMutationResult<
+        'error',
+        TData,
+        TError,
+        TVariables,
+        TContext
+      >
+    >
+  >
+  isPending: SignalFunction<
+    (
+      this: CreateMutationResult<TData, TError, TVariables, TContext>,
+    ) => this is CreateMutationResult<
+      TData,
+      TError,
+      TVariables,
+      TContext,
+      CreateStatusBasedMutationResult<
+        'pending',
+        TData,
+        TError,
+        TVariables,
+        TContext
+      >
+    >
+  >
+  isIdle: SignalFunction<
+    (
+      this: CreateMutationResult<TData, TError, TVariables, TContext>,
+    ) => this is CreateMutationResult<
+      TData,
+      TError,
+      TVariables,
+      TContext,
+      CreateStatusBasedMutationResult<
+        'idle',
+        TData,
+        TError,
+        TVariables,
+        TContext
+      >
+    >
+  >
+}
+
+/**
+ * @public
+ */
+export type CreateMutationResult<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = unknown,
+  TContext = unknown,
+  TState = CreateStatusBasedMutationResult<
+    CreateBaseMutationResult['status'],
+    TData,
+    TError,
+    TVariables,
+    TContext
+  >,
+> = BaseMutationNarrowing<TData, TError, TVariables, TContext> &
+  MapToSignals<OmitKeyof<TState, keyof BaseMutationNarrowing, 'safely'>>
+
+/**
+ * @public
+ */
+export type NonUndefinedGuard<T> = T extends undefined ? never : T

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

@@ -0,0 +1,74 @@
+/* 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,
+  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.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

@@ -0,0 +1,81 @@
+/* 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 {Function} fn - the Function to pass in `assertInInjectionContext`
+ * @param {Injector | undefined | null} injector - the optional "custom" Injector
+ * @param {Runner} runner - the runner fn
+ * @returns {ReturnType<Runner>} 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 {Function} fn - the Function to pass in `assertInInjectionContext`
+ * @param {Injector | undefined | null} 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
+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)
+}

package/src/util/index.ts

@@ -0,0 +1,13 @@
+export function shouldThrowError<T extends (...args: Array<any>) => boolean>(
+  throwError: boolean | T | undefined,
+  params: Parameters<T>,
+): boolean {
+  // Allow throwError function to override throwing behavior on a per-error basis
+  if (typeof throwError === 'function') {
+    return throwError(...params)
+  }
+
+  return !!throwError
+}
+
+export function noop() {}

package/src/util/is-dev-mode/is-dev-mode.ts

@@ -0,0 +1,3 @@
+// Re-export for mocking in tests
+
+export { isDevMode } from '@angular/core'

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

@@ -0,0 +1,34 @@
+import { untracked } from '@angular/core'
+
+export function lazyInit<T extends object>(initializer: () => T): T {
+  let object: T | null = null
+
+  const initializeObject = () => {
+    if (!object) {
+      object = untracked(() => initializer())
+    }
+  }
+
+  queueMicrotask(() => initializeObject())
+
+  return new Proxy<T>({} as T, {
+    get(_, prop, receiver) {
+      initializeObject()
+      return Reflect.get(object as T, prop, receiver)
+    },
+    has(_, prop) {
+      initializeObject()
+      return Reflect.has(object as T, prop)
+    },
+    ownKeys() {
+      initializeObject()
+      return Reflect.ownKeys(object as T)
+    },
+    getOwnPropertyDescriptor() {
+      return {
+        enumerable: true,
+        configurable: true,
+      }
+    },
+  })
+}

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

@@ -0,0 +1,23 @@
+import { Injector, computed, inject, untracked } from '@angular/core'
+import type { Signal } from '@angular/core'
+
+type SignalInitializerFn<T> = (injector: Injector) => Signal<T>
+
+export function lazySignalInitializer<T>(
+  initializerFn: SignalInitializerFn<T>,
+) {
+  const injector = inject(Injector)
+
+  let source: Signal<T> | null = null
+
+  const unwrapSignal = () => {
+    if (!source) {
+      source = untracked(() => initializerFn(injector))
+    }
+    return source()
+  }
+
+  queueMicrotask(() => unwrapSignal())
+
+  return computed(unwrapSignal)
+}