[cloud_firestore] A way to nest collections in type safe way

[stargazing-dino]

Hello ! The new WithConverter is great. However I'm currently trying to find a good way to nest a WithConverterCollectionReference<T> on an instance of WithConverterQueryDocumentSnapshot<T> without the use of extensions.

For example, say I have a profile collection reference:

final profilesRef =
    _instance.collection(_CollectionIds.profiles).withConverter<Profile>(
          fromFirestore: (snapshot, _) => Profile.fromJson(snapshot.data()!),
          toFirestore: (profile, _) => profile.toJson(),
        );

Profiles can have the sub collection badges of type <UserBadge>. I can make an extension for the type WithConverterQueryDocumentSnapshot<Profile> so that I can get the specific collection like this:

extension ProfileExtension on WithConverterQueryDocumentSnapshot<Profile> {
  WithConverterCollectionReference<UserBadge> get userBadgesRef {
    return _instance
        .collection(
          '${_CollectionIds.profiles}/$id/${_CollectionIds.userBadges}',
        )
        .withConverter<UserBadge>(
          fromFirestore: (snapshot, _) => UserBadge.fromJson(snapshot.data()!),
          toFirestore: (userBadge, _) => userBadge.toJson(),
        );
  }
}

That's great but I don't really think extensions methods are all that useful. Also, with further nested sub collections, the above only gets crazier. Here is an example of collection several layers nested.

extension InteractionExtension
    on WithConverterQueryDocumentSnapshot<Interaction> {
  WithConverterCollectionReference<Option> get optionsRef {
    final modulesRef =
        reference.parent as WithConverterCollectionReference<Module>;
    final lessonRef = modulesRef as WithConverterCollectionReference<Lesson>;
    final courseRef =
        lessonRef.parent as WithConverterCollectionReference<Course>;

    return _instance
        .collection(
          '${_CollectionIds.courses}/${courseRef.id}/${_CollectionIds.lessons}'
          '/${lessonRef.id}/${_CollectionIds.modules}/${modulesRef.id}'
          '/${_CollectionIds.interactions}/$id/${_CollectionIds.options}',
        )
        .withConverter<Option>(
          fromFirestore: (snapshot, _) => Option.fromJson(snapshot.data()!),
          toFirestore: (option, _) => option.toJson(),
        );
  }
}

It doesn't look very good and it relies on a lot of iffy string concatenation.

It'd be great if we were given a way to add CollectionRefs to a DocumentRef so that we could index into a subcollection via a document. Soomething like this (off the top of my head) where the sub collection _usersBadgesRef's collection would start from the location of a child document

final _userBadgesRef =
    _instance.collection(_CollectionIds.userBadges).withConverter<UserBadge>(
          fromFirestore: (snapshot, _) => UserBadge.fromJson(snapshot.data()!),
          toFirestore: (userBadge, _) => userBadge.toJson(),
        );

final profilesRef = _instance
    .collection(_CollectionIds.profiles)
    .withConverter<Profile>(
      fromFirestore: (snapshot, _) => Profile.fromJson(snapshot.data()!),
      toFirestore: (profile, _) => profile.toJson(),
    )
    .withSubCollection(_userBadgesRef);

cc @rrousselGit

[rrousselGit]

That's something I've been thinking about too.

What I had in mind is:

final movies = firestore.collection('movies').withConverter<Movie>(...);

final movieReviews = movies.subCollection('review').withConverter<Review>(...);

final reviewComments = movieReviews.subCollection('comments').withConverter<Comment>(...);

void main() async {
  List<DocumentSnapshot<Review>> starWarsReviews = await movieReview(movies.doc('star-wars'))
      .get().then((s) => s.docs);

  List<DocumentSnapshot<Review>> metacriticStarWarsComments = await reviewComments(movieReview(movies.doc('star-wars')))
      .get().then((s) => s.docs);

}

[stargazing-dino]

I like it, I think it's an intuitive API.

I think this line is wrong though as movieReviews would returna a collectionRef and wouldn't a subCollection call require a parameter of document?

List<DocumentSnapshot<Review>> metacriticStarWarsComments = await reviewComments(movieReview(movies.doc('star-wars')))
      .get().then((s) => s.docs);

// ->

List<DocumentSnapshot<Review>> metacriticStarWarsComments = await reviewComments(movieReview(movies.doc('star-wars')).doc('ebert'))
    .get().then((s) => s.docs);

In any case, I do like it.

An alternative I thought would be to have a transformer on a CollectionReference that would give you the CollectionRef and allow you to wrap it in your own whatever class

class MovieDocumentRef extends WithConverterDocumentReference<Movie> {
  CustomDocumentRef(WithConverterDocumentReference<Movie> ref) : super.fromRef(ref);

  late final commentsRef = collection('reviews').withConverter<Review>(
    fromFirestore: (snapshot, _) => Review.fromJson(snapshot.data()!),
    toFirestore: (review, _) => review.toJson(),
  );
}

final moviesRef = _instance
    .collection('movies')
    .withConverter<Movie>(
      fromFirestore: (snapshot, _) => Movie.fromJson(snapshot.data()!),
      toFirestore: (movie, _) => movie.toJson(),
    )
    .transform<MovieDocumentRef>(
      (collectionRef) => MovieDocumentRef(collectionRef),
    );

But that would require hooking up a publicly accessable constructor which I know might not be ideal (also it relies on new late syntax which might throw people off), so I still prefer your method.

*edit: on second though, that transform method would be pointless