RxJS abomination

import { Observable, of, ReplaySubject, Subject } from 'rxjs';
import { map } from 'rxjs/operators';

// Observable returns true, if the action has been successfully executed
const tryLogin = (id: number): Observable<boolean> => {
    const result = new ReplaySubject<boolean>();

    // Operation 1
    loadUserFromDB(id)
        .subscribe(
            user => {
                // Early stop 1 - true
                if (user.name === 'Sarah' || user.id === 0) {
                    result.next(true);
                    result.complete();
                    return;
                }

                // Operation 2, dependent on Operation 1
                checkMasterData(user)
                    .subscribe(
                        loginInformation => {
                            const {userId, lastLogin} = loginInformation;

                            // Early stop 2 - false
                            if (lastLogin === 'LAST_YEAR') {
                                result.next(false);
                                result.complete();
                                return;
                            }

                            // Operation 3, dependent on Operation 1 and Operation 2 's success
                            createNewUserId({attemptedUserId: userId})
                                .subscribe(
                                    // Operation N...
                                    // This function also has a similar structure to `tryLogin`
                                    newId => createAccountFromLogin(newId, result),
                                    error => result.error(error)
                                );
                        },
                        error => {
                            result.error(error);

                            // Sidenote: No idea why complete is called
                            result.complete();
                        }
                    );
            },
            error => result.error(error)
        );

    return result;
};

const createAccountFromLogin = (userId: number, result: Subject<boolean>): void => {
    // Converting Observable to Subject in these functions
    const accountResult = new ReplaySubject();

    const subscription = accountResult.subscribe(
        account => {
            setTimeout(() => {
                subscription.unsubscribe();

                if (account === undefined) {
                    result.next(false);
                    result.complete();
                } else if (account.name === 'Admin') {
                    result.next(true);
                    result.complete();
                }

                // There is some undefined behaviour at some places
                // - no result called, but let's aim for false otherwise
                else {
                    result.next(false);
                    result.complete();
                }
            });
        },
        error => {
            result.error(error);
            result.complete();
        }
    );

    // I have no words
    createNewAccount({id: userId, name: 'Test'}, accountResult);
};

const createNewAccount = (input: User, result: Subject<Account | undefined>): void => {
    // The same subject-styled something as always, this can also have hierarchy
    // just like the original function
    const subscription = createNewAccountExternal(input)
        .subscribe(
            account => {
                setTimeout(() => {
                    subscription.unsubscribe();

                    const {user} = account;
                    if (user.id < 0) {
                        result.next(undefined);
                    } else {
                        result.next(account);
                    }
                    result.complete();
                });
            },
            error => {
                result.error(error);
            }
        );
};

// External function and type, dummy operations - only declarations matter
type User = { id: number, name: string };
const loadUserFromDB = (input: number): Observable<User> =>
    of(input).pipe(map(id => ({id, name: 'Josh ' + id})));

type LoginInformation = { userId: number, lastLogin: string };
const checkMasterData = (input: User): Observable<LoginInformation> =>
    of(input).pipe(map(user => ({userId: user.id, lastLogin: 'yesterday', userAgent: 'Linux'})));

type Account = { user: User };
const createNewAccountExternal = (input: User): Observable<Account> =>
    of(input).pipe(map(user => ({user})));

const createNewUserId = (input: { attemptedUserId: number }): Observable<number> =>
    of(input.attemptedUserId + 1);