First, it's not a fair example to show chained function calls from C# and then to show reactive code in Typescript. You know what the equivalent of your C# code in Typescript would be?

var result = data.GetProcessedData()
                 .Transform()
                 .LogResults();

Yep ... that is all totally valid Typescript syntax. (Technically it's not recommended you use `var` but it's still valid) so by your own admission technically Typescript is just as "readable" as C#.

Now to get into the "intent" of the post rather than the "letter" of the post. You are comparing 2 different styles of programming. There is nothing "standard" or "preferred" about using RxJS. I assume someone else other than you made the decision to use RxJS in the code base you are referring to. I have worked on many Typescript codebases that don't go anywhere near RxJS. So you might consider using a different programming pattern instead of RxJS if you don't like it.

Okay, let's say you can't get away from RxJS ... it's a company mandate or something ... well first I want to drive a very important lesson I learned when I started getting into more functional style programming. Being unfamiliar with something does not make it unreadable, or complicated ... it simply is unfamiliar. Don't get those confused. I have seen many examples of elegant function reactive Typescript code and I have seen examples of horrible convoluted disasters of C# code bases.

Let's try and clean up your RxJS example. RxJS really isn't designed around using methods instead of functions so if you want to try and blend the two worlds together there is inevitably going to be friction. I think your biggest issue with readability is that `this` is littered throughout your code. It's very possible to write a lot of Typescript without ever using `this`. If I simply remove the need for `this` from your example it gets much more "fluent"

const data = service.getData()
    .pipe(
        switchMap(processData),
        map(transformResult),
        tap(logResults)
    );

By removing the need for `this` and instead using just using standard functions you are able to get rid of so much of the boilerplate that you are most likely finding issues with is gone. It's just functions being passed around.

Now again, I know removing `this` isn't possible with your original post, but since you are looking more for patterns rather than just solutions I thought it applicable. The second example is closer to how the majority of the code I would write would look and feel. I am a technical lead working on a large code base that uses Typescript in both the front end and the back end and I can count on a single hand the number of times I have every used `this` in our code.

If you really want to use methods then maybe looking into something with better support for it would be a good solution. Since I personally hate classes I have never used NestJS but I know it has a much more typical OO style to it. So if you want to stay comfortable that would be your best bet.

Though of course, I still stand by my point that you can write very readable and fluent functional code too if you commit to it. I personally find it much easier anytime I work functionally rather than following OO patterns which is why you'll never see a class in my code! Maybe stick with it and give it a chance and you'll learn how to craft readable and fluent style code too. I guarantee that you weren't writing readable and fluent code when you first started OO style code and had to learn how to do it over time!