Knowing when to wait before fetching about dataloader HOT 2 CLOSED

I think there is missing information in order to do this programmatically, but also some bad corner cases to solve.

The primary question here - the missing information - is how long photoLoader should wait to run it's batch. To avoid latency, DataLoader's answer to this question is "until the call stack unwinds", but we could make a different decision if we wanted to. Maybe the right thing to do if batching is really that valuable is always add 100ms of latency because in aggregate the opportunity to batch will make that latency worth it. Waiting 100ms maybe catches the second call to photoLoader after userLoader returns.

That's probably not the best we can do in this scenario though. Adding latency atop an already expensive operation is probably not the best user experience, and maybe userLoader only takes 2ms so 100ms of latency was an awful choice, or maybe it takes 102ms in which case we spent the cost but got no benefit. Also, this mechanism would have us wait another 100ms after the second call to photoLoader just in case there are any other calls, even though we know there won't be based on reading this example, so it's more wasted latency.

Another way to solve this might be explicitly declaring that you want to wait for another call to load() but you just don't have the ids yet. In this example we could maybe declare that the call is coming. DataLoader just cares about what in frame of execution the call to load() occurs. If we can ensure that something is called on the loader instance in that frame, then we have enough info to know to wait to coalesce a batch.

Maybe: waitFor(Promise<any>): void

async function loadUserPhotos(userId) {
  let userPromise = userLoader.load(userId);
  photoLoader.waitFor(userPromise);
  let user = await userPromise;
  let photos = await photoLoader.loadMany(user.photoIds);
  return photos;
}

Or maybe: load(K | Promise<K>): Promise<V>

async function loadUserPhotos(userId) {
  let photos = await photoLoader.loadMany(loadUserPhotoIDs(userId));
  return photos;
}

async loadUserPhotoIDs(userId) {
  let user = await userLoader.load(userId);
  return user.photoIds;
}

Thoughts?

from dataloader.

(Now I don't remember what actual situation I was pondering that prompted me to file this issue.)

I like the waitFor idea, though I wonder if that requires a breach of encapsulation in the general case. The photo loader might live at a relatively low level of the stack, but this sequence of fetches might be coordinated at a higher level.

The load(promise) API feels less intuitive and clunkier at a first glance, but it might have the potential to accommodate this use case if this structure was idiomatic and fetching was always performed bottom-up. Ultimately it seems like this also can't work in every case because your first fetch could determine whether you want to do a second fetch at all.

Both good ideas though; thank you! I suppose there's probably no magic bullet. :)

from dataloader.