fix(angular-query): fix injectInfiniteQuery to narrow type

examples/angular/infinite-query-with-max-pages/src/app/components/example.component.html

@@ -4,9 +4,11 @@ <h3>4 projects per page</h3>
  <h3>3 pages max</h3>
  @if (query.isPending()) {
  <p>Loading...</p>
- } @else if (query.isError()) {
+ }
+ @if (query.isError()) {
  <span>Error: {{ query.error().message }}</span>
- } @else {
+ }
+ @if (query.isSuccess()) {
  <div>
  <button
  (click)="query.fetchPreviousPage()"

packages/angular-query-experimental/src/__tests__/inject-infinite-query.test-d.ts

@@ -23,20 +23,121 @@ describe('injectInfiniteQuery', () => {
  vi.useRealTimers()
  })
 
- test('should narrow type after isSuccess', () => {
- const query = TestBed.runInInjectionContext(() => {
- return injectInfiniteQuery(() => ({
- queryKey: ['infiniteQuery'],
- queryFn: ({ pageParam }) =>
- sleep(0).then(() => 'data on page ' + pageParam),
- initialPageParam: 0,
- getNextPageParam: () => 12,
- }))
+ describe('without initialData', () => {
+ test('should narrow type after isSuccess', () => {
+ const query = TestBed.runInInjectionContext(() => {
+ return injectInfiniteQuery(() => ({
+ queryKey: ['infiniteQuery'],
+ queryFn: ({ pageParam }) =>
+ sleep(0).then(() => 'data on page ' + pageParam),
+ initialPageParam: 0,
+ getNextPageParam: () => 12,
+ }))
+ })
+
+ if (query.isSuccess()) {
+ const data = query.data()
+ expectTypeOf(data).toEqualTypeOf<InfiniteData<string, unknown>>()
+ }
+ })
+
+ test('should narrow type after isPending', () => {
+ const query = TestBed.runInInjectionContext(() => {
+ return injectInfiniteQuery(() => ({
+ queryKey: ['infiniteQuery'],
+ queryFn: ({ pageParam }) =>
+ sleep(0).then(() => 'data on page ' + pageParam),
+ initialPageParam: 0,
+ getNextPageParam: () => 12,
+ }))
+ })
+
+ if (query.isPending()) {
+ const data = query.data()
+ expectTypeOf(data).toEqualTypeOf<undefined>()
+ }
+ })
+
+ test('should narrow type after isError', () => {
+ const query = TestBed.runInInjectionContext(() => {
+ return injectInfiniteQuery(() => ({
+ queryKey: ['infiniteQuery'],
+ queryFn: ({ pageParam }) =>
+ sleep(0).then(() => 'data on page ' + pageParam),
+ initialPageParam: 0,
+ getNextPageParam: () => 12,
+ }))
+ })
+
+ if (query.isError()) {
+ const error = query.error()
+ expectTypeOf(error).toEqualTypeOf<Error>()
+ }
+ })
+ })
+
+ describe('with initialData', () => {
+ test('should narrow type after isSuccess', () => {
+ const query = TestBed.runInInjectionContext(() => {
+ return injectInfiniteQuery(() => ({
+ queryKey: ['infiniteQuery'],
+ queryFn: ({ pageParam }) =>
+ sleep(0).then(() => 'data on page ' + pageParam),
+ initialPageParam: 0,
+ getNextPageParam: () => 12,
+ initialData: {
+ pageParams: [0, 1],
+ pages: ['page 0 data', 'page 1 data'],
+ },
+ }))
+ })
+
+ if (query.isSuccess()) {
+ const data = query.data()
+ expectTypeOf(data).toEqualTypeOf<InfiniteData<string, unknown>>()
+ }
+ })
+
+ test('should narrow type after isPending', () => {
+ const query = TestBed.runInInjectionContext(() => {
+ return injectInfiniteQuery(() => ({
+ queryKey: ['infiniteQuery'],
+ queryFn: ({ pageParam }) =>
+ sleep(0).then(() => 'data on page ' + pageParam),
+ initialPageParam: 0,
+ getNextPageParam: () => 12,
+ initialData: {
+ pageParams: [0, 1],
+ pages: ['page 0 data', 'page 1 data'],
+ },
+ }))
+ })
+
+ if (query.isPending()) {
+ const data = query.data()
+ expectTypeOf(data).toEqualTypeOf<InfiniteData<string, unknown>>()
+ }
  })
 
- if (query.isSuccess()) {
- const data = query.data()
- expectTypeOf(data).toEqualTypeOf<InfiniteData<string, unknown>>()
- }
+ test('should narrow type after isError', () => {
+ const query = TestBed.runInInjectionContext(() => {
+ return injectInfiniteQuery(() => ({
+ queryKey: ['infiniteQuery'],
+ queryFn: ({ pageParam }) =>
+ sleep(0).then(() => 'data on page ' + pageParam),
+ initialPageParam: 0,
+ getNextPageParam: () => 12,
+ initialData: {
+ pageParams: [0, 1],
+ pages: ['page 0 data', 'page 1 data'],
+ },
+ }))
+ })
+
+ if (query.isError()) {
+ const error = query.error()
+ expectTypeOf(error).toEqualTypeOf<Error>()
+ }
+ })
  })
 })

packages/angular-query-experimental/src/__tests__/inject-query.test-d.ts

@@ -105,6 +105,16 @@ describe('initialData', () => {
  expectTypeOf(query.data).toEqualTypeOf<Signal<{ wow: boolean }>>()
  }
  })
+ it('error should be defined when query is error', () => {
+ const query = injectQuery(() => ({
+ queryKey: ['key'],
+ queryFn: () => ({ wow: true }),
+ initialData: { wow: true },
+ }))
+ if (query.isError()) {
+ expectTypeOf(query.error).toEqualTypeOf<Signal<Error>>()
+ }
+ })
  })
 
  describe('structuralSharing', () => {

packages/angular-query-experimental/src/inject-infinite-query.ts

@@ -121,5 +121,5 @@ export function injectInfiniteQuery(
  injectInfiniteQueryFn,
  InfiniteQueryObserver as typeof QueryObserver,
  ),
- )
+ ) as unknown as CreateInfiniteQueryResult
 }

packages/angular-query-experimental/src/inject-query.ts

@@ -222,5 +222,5 @@ export function injectQuery(
  !options?.injector && assertInInjectionContext(injectQuery)
  return runInInjectionContext(options?.injector ?? inject(Injector), () =>
  createBaseQuery(injectQueryFn, QueryObserver),
- ) as unknown as CreateQueryResult
+ ) as unknown as CreateQueryResult | DefinedCreateQueryResult
 }

packages/angular-query-experimental/src/types.ts

@@ -52,29 +52,45 @@ type CreateStatusBasedQueryResult<
  TStatus extends QueryObserverResult['status'],
  TData = unknown,
  TError = DefaultError,
-> = Extract<QueryObserverResult<TData, TError>, { status: TStatus }>
+ TState = QueryObserverResult<TData, TError>,
+> = Extract<TState, { status: TStatus }>
 
-export interface BaseQueryNarrowing<TData = unknown, TError = DefaultError> {
+type CreateNarrowQueryResult<
+ TData = unknown,
+ TError = DefaultError,
+ TState = QueryObserverResult<TData, TError>,
+ TNarrowState = TState,
+> = BaseQueryNarrowing<TData, TError, TState> &
+ MapToSignals<OmitKeyof<TNarrowState, keyof BaseQueryNarrowing, 'safely'>>
+
+export interface BaseQueryNarrowing<
+ TData = unknown,
+ TError = DefaultError,
+ TState = QueryObserverResult<TData, TError>,
+> {
  isSuccess: (
  this: CreateBaseQueryResult<TData, TError>,
- ) => this is CreateBaseQueryResult<
+ ) => this is CreateNarrowQueryResult<
  TData,
  TError,
- CreateStatusBasedQueryResult<'success', TData, TError>
+ TState,
+ CreateStatusBasedQueryResult<'success', TData, TError, TState>
  >
  isError: (
  this: CreateBaseQueryResult<TData, TError>,
- ) => this is CreateBaseQueryResult<
+ ) => this is CreateNarrowQueryResult<
  TData,
  TError,
- CreateStatusBasedQueryResult<'error', TData, TError>
+ TState,
+ CreateStatusBasedQueryResult<'error', TData, TError, TState>
  >
  isPending: (
  this: CreateBaseQueryResult<TData, TError>,
- ) => this is CreateBaseQueryResult<
+ ) => this is CreateNarrowQueryResult<
  TData,
  TError,
- CreateStatusBasedQueryResult<'pending', TData, TError>
+ TState,
+ CreateStatusBasedQueryResult<'pending', TData, TError, TState>
  >
 }
 
@@ -99,7 +115,7 @@ export type CreateBaseQueryResult<
  TData = unknown,
  TError = DefaultError,
  TState = QueryObserverResult<TData, TError>,
-> = BaseQueryNarrowing<TData, TError> &
+> = BaseQueryNarrowing<TData, TError, TState> &
  MapToSignals<OmitKeyof<TState, keyof BaseQueryNarrowing, 'safely'>>
 
 export type CreateQueryResult<
@@ -111,23 +127,22 @@ export type DefinedCreateQueryResult<
  TData = unknown,
  TError = DefaultError,
  TState = DefinedQueryObserverResult<TData, TError>,
-> = BaseQueryNarrowing<TData, TError> &
+> = BaseQueryNarrowing<TData, TError, TState> &
  MapToSignals<OmitKeyof<TState, keyof BaseQueryNarrowing, 'safely'>>
 
 export type CreateInfiniteQueryResult<
  TData = unknown,
  TError = DefaultError,
-> = BaseQueryNarrowing<TData, TError> &
- MapToSignals<InfiniteQueryObserverResult<TData, TError>>
+ TState = InfiniteQueryObserverResult<TData, TError>,
+> = BaseQueryNarrowing<TData, TError, TState> &
+ MapToSignals<OmitKeyof<TState, keyof BaseQueryNarrowing, 'safely'>>
 
 export type DefinedCreateInfiniteQueryResult<
  TData = unknown,
  TError = DefaultError,
- TDefinedInfiniteQueryObserver = DefinedInfiniteQueryObserverResult<
- TData,
- TError
- >,
-> = MapToSignals<TDefinedInfiniteQueryObserver>
+ TState = DefinedInfiniteQueryObserverResult<TData, TError>,
+> = BaseQueryNarrowing<TData, TError, TState> &
+ MapToSignals<OmitKeyof<TState, keyof BaseQueryNarrowing, 'safely'>>
 
 export interface CreateMutationOptions<
  TData = unknown,