Creating observable that emits null is deprecated in v7?

[theodorejb]

I have a method like this in my project:

getCurrentUserOrNull(): Observable<User | null> {
    return this.getCurrentUser()
        .pipe(
            catchError(() => of(null)),
        );
}

After installing RxJS 7.0.0-beta.10, there is now a deprecation notice saying "of is deprecated: The scheduler argument is deprecated, use scheduled." Is this a spurious warning since I'm not actually using a scheduler, or is the creation of observables that emit null/undefined values actually being deprecated? If the warning is spurious, is there a way to avoid triggering it for a single null value like this before RxJS 7 is finalized?

[kwonoj]

I don't think emitting null itself is deprecated. Not sure if we have known issues, @cartant maybe aware?

[cartant]

I don't think emitting null itself is deprecated.

Nope, it's definitely not. But whether or not it's interpreted as a scheduler probably depends on the TypeScript settings. Are strictNullChecks enabled? IMO, TypeScript should never be used without that setting being enabled.

The deprecations are something that still need work before the next version is released. This is also a good example of why the deprecation messages that are used ATM are not good enough - they confuse people. IMO, we need to get the messages sorted out and have them include links to documentation pages that explain the reasoning, etc.

[kwonoj]

Sounds good and sounds like it's under umbrella issue around 7-related typing todos.

p.s unrelated note but I like new discussions having reply support 😍

[cartant]

Also, if strictNullChecks is the issue, I think we'll have to say that we don't support it being specified as false, as - in addition to the spurious deprecation - the inferred type will wrong, too:

rxjs/src/internal/observable/of.ts

Line 9 in 7bbd37f

export function of(scheduler: SchedulerLike): Observable<never>;

It would be inferred as Observable<never> instead of Observable<null>.

[benlesh]

I see. This is an issue with the type thinking null was a scheduler. I was going to say, the runtime behavior should not be like this at all. Maybe we should have dtslint tests for this?

[cartant]

I don't think we can have 'smart' types and also support strictNullChecks: false.

[Raiondesu]

I think the problem here is due to the overloads ordering for the of function:

rxjs/src/internal/observable/of.ts

Lines 7 to 70 in 4dd7118

	/** @deprecated The scheduler argument is deprecated, use scheduled. Details: https://rxjs.dev/deprecations/scheduler-argument */
	export function of(scheduler: SchedulerLike): Observable<never>;
	/** @deprecated The scheduler argument is deprecated, use scheduled. Details: https://rxjs.dev/deprecations/scheduler-argument */
	export function of<T>(a: T, scheduler: SchedulerLike): Observable<T>;
	/** @deprecated The scheduler argument is deprecated, use scheduled. Details: https://rxjs.dev/deprecations/scheduler-argument */
	export function of<T, T2>(a: T, b: T2, scheduler: SchedulerLike): Observable<T | T2>;
	/** @deprecated The scheduler argument is deprecated, use scheduled. Details: https://rxjs.dev/deprecations/scheduler-argument */
	export function of<T, T2, T3>(a: T, b: T2, c: T3, scheduler: SchedulerLike): Observable<T | T2 | T3>;
	/** @deprecated The scheduler argument is deprecated, use scheduled. Details: https://rxjs.dev/deprecations/scheduler-argument */
	export function of<T, T2, T3, T4>(a: T, b: T2, c: T3, d: T4, scheduler: SchedulerLike): Observable<T | T2 | T3 | T4>;
	/** @deprecated The scheduler argument is deprecated, use scheduled. Details: https://rxjs.dev/deprecations/scheduler-argument */
	export function of<T, T2, T3, T4, T5>(a: T, b: T2, c: T3, d: T4, e: T5, scheduler: SchedulerLike): Observable<T | T2 | T3 | T4 | T5>;
	/** @deprecated The scheduler argument is deprecated, use scheduled. Details: https://rxjs.dev/deprecations/scheduler-argument */
	export function of<T, T2, T3, T4, T5, T6>(
	a: T,
	b: T2,
	c: T3,
	d: T4,
	e: T5,
	f: T6,
	scheduler: SchedulerLike
	): Observable<T | T2 | T3 | T4 | T5 | T6>;
	/** @deprecated The scheduler argument is deprecated, use scheduled. Details: https://rxjs.dev/deprecations/scheduler-argument */
	export function of<T, T2, T3, T4, T5, T6, T7>(
	a: T,
	b: T2,
	c: T3,
	d: T4,
	e: T5,
	f: T6,
	g: T7,
	scheduler: SchedulerLike
	): Observable<T | T2 | T3 | T4 | T5 | T6 | T7>;
	/** @deprecated The scheduler argument is deprecated, use scheduled. Details: https://rxjs.dev/deprecations/scheduler-argument */
	export function of<T, T2, T3, T4, T5, T6, T7, T8>(
	a: T,
	b: T2,
	c: T3,
	d: T4,
	e: T5,
	f: T6,
	g: T7,
	h: T8,
	scheduler: SchedulerLike
	): Observable<T | T2 | T3 | T4 | T5 | T6 | T7 | T8>;
	/** @deprecated The scheduler argument is deprecated, use scheduled. Details: https://rxjs.dev/deprecations/scheduler-argument */
	export function of<T, T2, T3, T4, T5, T6, T7, T8, T9>(
	a: T,
	b: T2,
	c: T3,
	d: T4,
	e: T5,
	f: T6,
	g: T7,
	h: T8,
	i: T9,
	scheduler: SchedulerLike
	): Observable<T | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9>;
	export function of(): Observable<never>;
	/** @deprecated remove in v8. Do not use generic arguments directly, allow inference or cast with `as` */
	export function of<T>(): Observable<T>;
	export function of<T>(value: T): Observable<T>;
	export function of<A extends readonly unknown[]>(...args: A): Observable<ValueFromArray<A>>;

TypeScript tries to apply overloads in order, from top to bottom.
When presented with null as an argument, it picks the first matching overload, which in this case seems to be the first one with the scheduler parameter.

This is a problem not only with of but with a lot of other functions that have deprecations and generics.
Many have deprecated overloads at the top, which makes TS consider them first (they should be moved to the bottom!), others do not have "general" overloads (pipe lacks an overload for variable amount of arguments).