Hey everyone! I just wanted to thank you for the advice from my last post. We decided to stick with Promises for one-off tasks and use Observables for streams, which has simplified things quite a bit. But now that our backend is gaining real-time features, we're finding ourselves mixing the two. Sometimes we fetch data with Promises and then turn that into a stream, or we wait for an event before resolving the Promise. The issue is that responses can sometimes come in *before* the event gets triggered, or the Promise just resolves by itself while we're left waiting. It feels like we're constantly battling the async nature of our code! Has anyone else experienced this? How do you keep everything in sync? We've tried using `Promise.race`, event emitters, and RxJS chains, but it's still pretty messy. I'd love to hear any quick patterns or mistakes to avoid that you've encountered in real projects. A short example or a tip that worked for you would be fantastic! Thanks a lot for your help!
1 Answer
One approach is to encapsulate the logic. Your function shouldn't reveal whether it uses a fetch before opening a stream. The consumer should just deal with the stream. Open the stream immediately within your function, and as values from your fetch come in, propagate them through the stream. If the Promise fails, let the outer stream emit an error without the caller's knowledge about the internal workings. It makes lifecycle management cleaner for you.
We're trying that approach too, where we start the stream inside the function. But we sometimes struggle with clean error handling. When the inner Promise rejects, we want the outer Observable to error out gracefully, but it doesn't always go that smoothly. We usually use `from()` to convert the Promise and `catchError()` for rejections, but we occasionally miss something. Any tips on using `defer()` versus `from()` or handling errors effectively would be super helpful!