Dataloader Alternatives

Reviews and mentions

• Clojure-server to Clojure-server communication library
  reddit.com/r/Clojure | 2021-09-17
• To GraphQL or not to GraphQL? Pros and Cons
  dev.to | 2021-09-13

  This is also related to the N+1 problem, where nested queries make the number of database requests explode. If you want to learn more about this problem, I recommend this video and checking out dataloader, a library released by Facebook to help with batching queries and solving this problem.

• Graph QL query involving more content
  reddit.com/r/graphql | 2021-09-08

  i think DataLoader is what you want https://github.com/graphql/dataloader

• GraphQL - Diving Deep
  dev.to | 2021-07-29

  While GraphQL is really promising and helpful, you have to understand that like any technology or framework, it does come with its own set of problems, most of which have already been addressed. For instance you might have heard about the N+1 problem, lack of caching, Query cost and complexity and so on and these have been addressed by some projects like the Dataloader, Persisted Queries, Caching and more which you can setup depending on your needs.

• GraphQL - Usecase and Architecture
  dev.to | 2021-07-29

  You might also want to look at how you minimize the amount of calls you make to the main database. Do you need caching and have it setup? Have you addressed the N+1 problem with Dataloader?

• The Workflow
  dev.to | 2021-07-29

  This is where you setup things like batching and also solve N+1 problems with something like a dataloader, setup caching with something like Redis or even an LRU cache to act as a proxy for the frequently accessed data whenever and wherever possible, optimizing the network chatter by using something like persisted queries, optimize your resolvers by retrieving as much data as possible from the parent resolvers, setting up pagination to limit the results returned, setting up things like query complexity to control the level of nesting and computation performed, rate-limiting in the gateway to avoid things like DDOS and so on.

• Do resolvers cause a lot of extra database transactions?
  reddit.com/r/graphql | 2021-06-30

  What you are looking for is dataloader.

• GraphQL Dataloader
  dev.to | 2021-06-17

  For more information about Caching, please visit the GraphQL DataLoader GitHub page.

• I built an open-source Reddit/Discord hybrid using React, TailwindCSS, and GraphQL!
  reddit.com/r/reactjs | 2021-06-08

  Make sure you don't have any N+1 issues. If you are using FieldResolvers to make database requests, use dataloader (https://github.com/graphql/dataloader)

• Advanced Promises in Javascript (Dataloader Pattern) - Mike Alche
  reddit.com/r/javascript | 2021-03-28

  This looks like the same approach to what the graphql DataLoader does!

• Edge Computing
  news.ycombinator.com | 2021-03-24

  > ... and microservices is one example of how to do it.

  The fundamental problem is where the data resides. Microservices are well understood today, but taking them to the edge isn't; there isn't a path to do that for typical apps. So most microservices which are being used at the edge are doing caching/transcoding/resizing etc.

  > Latency is key for some important applications like self-driving cars and industrial automation

  They keep compute on-vehicle or on-prem. For data services (not media delivery), latency is:

  a) either supremely important to be fully local (vehicles, automation)

  b) or it doesn't matter enough to be on a 3rd party edge network. The diminishing returns in typical apps is what the article is alluding to.

  > not really to make some queries in GraphQL

  You're misrepresenting what I said - and it seems deliberate.

  I mentioned GraphQL as one of the attempts to solve latency issues in typical apps.

  For example, some apps use graphql/dataloader[1] because it can "coalesce all individual loads which occur within a single frame of execution before calling your batch function with all requested keys. This ensures no additional latency while capturing many related requests into a single batch."

  So in typical apps, there isn't a big benefit to putting general compute on the edge - because the network calls are chunky and not chatty, and their data is centralized. GraphQL (along with libs/frameworks) being one way to turn chatty into chunky.

  [1]: https://github.com/graphql/dataloader

• How to share data between sibling resolvers
  reddit.com/r/graphql | 2021-03-07

  What you're looking for here is a dataloader: https://github.com/graphql/dataloader#caching

• Hitting data transfer limits with atlas mongodb free tier. 10gb in just a few days???
  reddit.com/r/mongodb | 2021-02-22
• news.ycombinator.com | 2021-02-22

  I think for one thing you can’t really do joins, because as you say there are too many combinations so it’s impossible to optimize everything.

  Instead you have to try to query each data type separately. So you get a query for users. You do an SQL call and gather up a bunch of requests for offices, and then you do a single request to your office backend.

  That means you’re doing all your queries after the first one by ID. So you have to have some way to “pre-join” your tables. You can do this either by optimistically joining your data to everything around it (query the node plus all of its edges) or you need to store your edges in your data model (which I have to assume is what FB does).

  In the end your resolvers need to be using some standardized way of grabbing objects by is (or edge), something like https://github.com/graphql/dataloader

  Whether it’s possible to do this efficiently I don’t know. At my last job we messed it up, and then we started applying a strategy like I described above, but then I switched jobs.

  Would love to hear from others who have dealt with the same challenges.

• Migrating from REST to GraphQL
  dev.to | 2021-02-15

  A major downside to GraphQL can be the server-side overfetching, or n+1 problem. Because GraphQL doesn't know exactly how data is structured in the database, it cannot optimize for redundant requests in the graph tree. However, the GraphQL DataLoader library is here to solve exactly that. It determines any data that's already been fetched and caches for use in any sub-query to follow.