Add support for lazy loading relations

[mammadataei]

Hi, I think it would be great if the relations support lazy loading and return the primary key of the target model instead of its data.
It will be useful while working with complex APIs that do not eager-load all the relations to generate smaller payloads.

const db = factory({
  user: {
    id: primaryKey(String),
    firstName: String,
  },
  post: {
    id: primaryKey(String),
    title: String,
    author: oneOf('user', { lazy: true }),
  },
})

const user = db.user.create({ firstName: 'John' })
const post = db.post.create({
  title: 'My journey',
  author: user,
})

db.user.findFirst({
  where: {
    id: {
      equals: porst.author,
    },
  },
})

[kettanaito]

Hey, @mammadataei. Thank you for suggesting this.

Internally, all relationships are resolved by pointers to primary keys. You are not missing on performance when using relationships.

I think I'd like to understand your use case a little better. So your intention is to implement an API that would return primary key pointers when querying data? I think you can implement that in your mock API directly. The output from data doesn't have to map to the output of your API 1-1.

rest.get('/album/:id', (req, res, ctx) => {
  const album = db.album.findFirst({
    where: { id: { equals: req.params.id } }
  })

  // "album.songs" will contain full values for each song object.
  // Let's reduce them to just pointers.
  const lazyAlbum = album.songs.map(song => ({ id: song.id }))

  return res(ctx.json({ album: lazyAlbum }))
})

I can see how this may make sense if your application expects lazy data structures and evolves them on its own.

[mammadataei]

I'm consuming a rest API that returns a huge amount of data, and due to the big payload size the backend decided not to eager-load relations, so on the client-side, we have to fetch the relations separately (and btw, this way we can cache and re-use entities too). So for testing on the client-side, we should write our mocks the way that the API works to be able to fetch each entity separately.

Currently, I'm mapping each entity to its primary key, but I thought it might be useful if @mswjs/data supports lazy relations.

[kettanaito]

Yeah, I see. I'm not sure if this particular use case requires an API change on our side. As I've said, the library shouldn't really guarantee 1-1 mapping with your backend structures because, as in your case, there may be additional logic on top, for which can't account. You should feel comfortable transforming the seeded data as your requirements demand, I see no downside to this. In other words, adding something like { lazy: true } would cost us much more internally than adding .map(entity => ({ id: entity.id }) on the usage side.

Not to say that having implementing a utility like toLazyEntity would reduce the cost as well:

import { PRIMARY_KEY } from '@mswjs/data/lib/glossary'

function toLazyEntity(entity) {
  const primaryKeyName = entity[PRIMARY_KEY]
  return { [primaryKeyName]: entity[primaryKeyName] }
}

// Usage
db.users.findMany().map(toLazyEntity)
albums.songs.map(toLazyEntity)

Now we should support custom utilities like this one. We currently don't expose internal symbols like PRIMARY_KEY, so you can't access the primary key on an arbitrary entity. Would exposing these internals help in your case?

[mammadataei]

Yeah, I think that would be great.

[kettanaito]

Exported those symbols just now.