fix(core): improve resource generics and params typing

suraj · suraj · commit 1370f6ed8e0e · 2026-04-15T18:43:53.000+05:30
Allow single generic usage when params are not defined and prevent
accessing params in loader when not provided.

- add the test cases of all scenario and edge cases
diff --git a/packages/core/rxjs-interop/test/rx_resource_spec.ts b/packages/core/rxjs-interop/test/rx_resource_spec.ts
@@ -9,7 +9,7 @@
 import {of, Observable, BehaviorSubject, throwError} from 'rxjs';
 import {TestBed} from '../../testing';
 import {timeout} from '@angular/private/testing';
-import {ApplicationRef, Injector, signal} from '../../src/core';
+import {ApplicationRef, Injector, ResourceRef, signal} from '../../src/core';
 import {rxResource} from '../src';
 
 describe('rxResource()', () => {
@@ -116,6 +116,163 @@ describe('rxResource()', () => {
   });
 });
 
+describe('types', () => {
+  it('should type stream params as null when params option is omitted', () => {
+    rxResource({
+      stream: ({params}) => {
+        const _null: null = params;
+        // @ts-expect-error - params is null, not string
+        const _str: string = params;
+        return of('');
+      },
+      injector: TestBed.inject(Injector),
+    });
+  });
+
+  it('should type stream params correctly when params is provided', () => {
+    rxResource({
+      params: () => 'foo',
+      stream: ({params}) => {
+        const _str: string = params;
+        // @ts-expect-error - params is string, not null
+        const _null: null = params;
+        return of('');
+      },
+      injector: TestBed.inject(Injector),
+    });
+  });
+
+  it('should type stream params as null with explicit single generic', () => {
+    rxResource<string>({
+      stream: ({params}) => {
+        const _null: null = params;
+        // @ts-expect-error - params is null, not string
+        const _str: string = params;
+        return of('');
+      },
+      injector: TestBed.inject(Injector),
+    });
+  });
+  it('should exclude undefined from stream params when params can return undefined', () => {
+    const condition = signal(true);
+    rxResource({
+      params: () => (condition() ? 'foo' : undefined),
+      stream: ({params}) => {
+        // params should be string, not string | undefined
+        const _str: string = params;
+        return of('');
+      },
+      injector: TestBed.inject(Injector),
+    });
+  });
+  it('should type stream params as nullable when params option is potentially undefined', () => {
+    function getParams(): (() => string) | undefined {
+      return undefined;
+    }
+    rxResource({
+      params: getParams(),
+      stream: ({params}) => {
+        const _nullable: string | null = params;
+        // @ts-expect-error - params could be null
+        const _str: string = params;
+        return of('');
+      },
+      injector: TestBed.inject(Injector),
+    });
+  });
+  it('should type stream params as nullable with two explicit generics and no params', () => {
+    rxResource<string, string>({
+      stream: ({params}) => {
+        const _nullable: string | null = params;
+        // @ts-expect-error - params could be null since params option is not provided
+        const _str: string = params;
+        return of('');
+      },
+      injector: TestBed.inject(Injector),
+    });
+  });
+
+  it('should type stream params as nullable with two explicit generics and params: undefined', () => {
+    rxResource<string, string>({
+      params: undefined,
+      stream: ({params}) => {
+        const _nullable: string | null = params;
+        // @ts-expect-error - params could be null since params is undefined
+        const _str: string = params;
+        return of('');
+      },
+      injector: TestBed.inject(Injector),
+    });
+  });
+
+  it('should narrow hasValue() when the value can be undefined', () => {
+    const result: ResourceRef<number | undefined> = rxResource({
+      params: () => 1,
+      stream: ({params}) => of(params),
+      injector: TestBed.inject(Injector),
+    });
+    if (result.hasValue()) {
+      const _value: number = result.value();
+    } else if (result.isLoading()) {
+      // @ts-expect-error
+      const _value: number = result.value();
+    } else if (result.error()) {
+    }
+    const readonly = result.asReadonly();
+    if (readonly.hasValue()) {
+      const _value: number = readonly.value();
+    } else if (readonly.isLoading()) {
+      // @ts-expect-error
+      const _value: number = readonly.value();
+    } else if (readonly.error()) {
+    }
+  });
+
+  it('should not narrow hasValue() when a default value is provided', () => {
+    const result: ResourceRef<number> = rxResource({
+      params: () => 1,
+      stream: ({params}) => of(params),
+      injector: TestBed.inject(Injector),
+      defaultValue: 0,
+    });
+    if (result.hasValue()) {
+      const _value: number = result.value();
+    } else if (result.isLoading()) {
+      const _value: number = result.value();
+    } else if (result.error()) {
+    }
+    const readonly = result.asReadonly();
+    if (readonly.hasValue()) {
+      const _value: number = readonly.value();
+    } else if (readonly.isLoading()) {
+      const _value: number = readonly.value();
+    } else if (readonly.error()) {
+    }
+  });
+
+  it('should not narrow hasValue() when the resource type is unknown', () => {
+    const result: ResourceRef<unknown> = rxResource({
+      params: () => 1 as unknown,
+      stream: ({params}) => of(params),
+      injector: TestBed.inject(Injector),
+      defaultValue: 0,
+    });
+    if (result.hasValue()) {
+      const _value: unknown = result.value();
+    } else if (result.isLoading()) {
+      const _value: unknown = result.value();
+    } else if (result.error()) {
+    }
+    const readonly = result.asReadonly();
+    if (readonly.hasValue()) {
+      const _value: unknown = readonly.value();
+    } else if (readonly.isLoading()) {
+      const _value: unknown = readonly.value();
+    } else if (readonly.error()) {
+    }
+  });
+});
+
 async function waitFor(fn: () => boolean): Promise<void> {
   while (!fn()) {
     await timeout(1);
diff --git a/packages/core/src/resource/resource.ts b/packages/core/src/resource/resource.ts
@@ -452,20 +452,13 @@ export class ResourceImpl<T, R> extends BaseWritableResource<T> implements Resou
       // reactive. This avoids any confusion with signals tracking or not tracking depending on
       // which side of the `await` they are.
       const stream = await untracked(() => {
-        const requestValue = extRequest.request as R;
-        const loaderParams = (
-          requestValue === undefined
-            ? {
-                abortSignal,
-                previous: {status: previousStatus},
-              }
-            : {
-                params: requestValue,
-                abortSignal,
-                previous: {status: previousStatus},
-              }
-        ) as SafeLoaderParams<R>;
-        return this.loaderFn(loaderParams);
+        return this.loaderFn({
+          params: extRequest.request as Exclude<R, undefined>,
+          abortSignal,
+          previous: {
+            status: previousStatus,
+          },
+        } as ResourceLoaderParams<R>);
       });
 
       // If this request has been aborted, or the current request no longer
diff --git a/packages/core/test/resource/resource_spec.ts b/packages/core/test/resource/resource_spec.ts
@@ -1019,6 +1019,112 @@ describe('resource', () => {
   });
 });
 
+describe('types', () => {
+  it('should type loader params as null when params option is omitted', () => {
+    resource({
+      loader: async ({params}) => {
+        const _null: null = params;
+        // @ts-expect-error - params is null, not string
+        const _str: string = params;
+        return '';
+      },
+      injector: TestBed.inject(Injector),
+    });
+  });
+
+  it('should type loader params correctly when params is provided', () => {
+    resource({
+      params: () => 'foo',
+      loader: async ({params}) => {
+        const _str: string = params;
+        // @ts-expect-error - params is string, not null
+        const _null: null = params;
+        return '';
+      },
+      injector: TestBed.inject(Injector),
+    });
+  });
+
+  it('should type loader params as null with explicit single generic', () => {
+    resource<string>({
+      loader: async ({params}) => {
+        const _null: null = params;
+        // @ts-expect-error - params is null, not string
+        const _str: string = params;
+        return '';
+      },
+      injector: TestBed.inject(Injector),
+    });
+  });
+
+  it('should type loader params as null when params is explicitly undefined', () => {
+    resource({
+      params: undefined,
+      loader: async ({params}) => {
+        const _null: null = params;
+        // @ts-expect-error - params is null, not string
+        const _str: string = params;
+        return '';
+      },
+      injector: TestBed.inject(Injector),
+    });
+  });
+
+  it('should exclude undefined from loader params when params can return undefined', () => {
+    const condition = signal(true);
+    resource({
+      params: () => (condition() ? 'foo' : undefined),
+      loader: async ({params}) => {
+        // params should be string, not string | undefined
+        const _str: string = params;
+        return '';
+      },
+      injector: TestBed.inject(Injector),
+    });
+  });
+
+  it('should type loader params as nullable when params option is potentially undefined', () => {
+    function getParams(): (() => string) | undefined {
+      return undefined;
+    }
+    resource({
+      params: getParams(),
+      loader: async ({params}) => {
+        const _nullable: string | null = params;
+        // @ts-expect-error - params could be null
+        const _str: string = params;
+        return '';
+      },
+      injector: TestBed.inject(Injector),
+    });
+  });
+
+  it('should type loader params as nullable with two explicit generics and no params', () => {
+    resource<string, string>({
+      loader: async ({params}) => {
+        const _nullable: string | null = params;
+        // @ts-expect-error - params could be null since params option is not provided
+        const _str: string = params;
+        return '';
+      },
+      injector: TestBed.inject(Injector),
+    });
+  });
+
+  it('should type loader params as nullable with two explicit generics and params: undefined', () => {
+    resource<string, string>({
+      params: undefined,
+      loader: async ({params}) => {
+        const _nullable: string | null = params;
+        // @ts-expect-error - params could be null since params is undefined
+        const _str: string = params;
+        return '';
+      },
+      injector: TestBed.inject(Injector),
+    });
+  });
+});
+
 function flushMicrotasks(): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, 0));
 }
