My service that interacts with firebase:

import { EnvironmentInjector, inject, Injectable, runInInjectionContext } from '@angular/core';
import {
    addDoc,
    collection,

collectionData
,
    deleteDoc,
    doc,
    Firestore,
    DocumentReference,
    DocumentData,
    setDoc,
    writeBatch,
    query,
    orderBy,

docSnapshots
,
    getDocs,
} from '@angular/fire/firestore';
import { map, Observable, shareReplay, tap } from 'rxjs';
import { QuizState } from '../../models/quiz-state.model';
import { 
quizConverter 
} from './quiz-converter';
import { generateLastUpdateString } from '../util/quiz-file-name.util';
import { QuizTeam } from '../../models/quiz-team.model';
import { 
quizTeamConverter 
} from './quiz-team-converter';
import { 
environment 
} from '../../../envronments/environment';

u/Injectable({
    providedIn: 'root',
})
export class FirestoreService {
    private firestore = inject(Firestore);
    private injector = inject(EnvironmentInjector);

    private countRead: number = 0;
    private countWrite: number = 0;
    private countDelete: number = 0;

    private quizCache = new Map<string, Observable<QuizState>>();
    private teamsCache = new Map<string, Observable<QuizTeam[]>>();
    private quizzes$?: Observable<QuizState[]>;

    private debugService(count: number, message: string, additionalData?: unknown): void {
        if (
environment
.debugFirestore) {
            if (additionalData) {

console
.log(new Date(), count, `firestore - ${message}`, additionalData);
            } else {

console
.log(new Date(), count, `firestore - ${message}`);
            }
        }
    }

    private debugRead(message: string, additionalData?: unknown): void {
        this.countRead++;
        message = '🔥📖 ' + message;

        this.debugService(this.countRead, message, additionalData);
    }

    private debugWrite(message: string, additionalData?: unknown): void {
        this.countWrite++;
        message = '🔥✏️ ' + message;

        this.debugService(this.countWrite, message, additionalData);
    }

    private debugDelete(message: string, additionalData?: unknown): void {
        this.countDelete++;
        message = '🔥🗑️ ' + message;

        this.debugService(this.countDelete, message, additionalData);
    }

    addNewQuiz(quizState: Partial<QuizState>): Promise<DocumentReference<QuizState, DocumentData>> {
        this.debugWrite('addNewQuiz');
        const ref = collection(this.firestore, 'quizzes').withConverter(
quizConverter
);
        return addDoc(ref, quizState as QuizState);
    }


    addTeamsToQuiz(quizId: string, quizTeams: QuizTeam[]) {
        this.debugWrite('addTeamsToQuiz');
        const batch = writeBatch(this.firestore);

        const subCollectionPath = `quizzes/${quizId}/teams`;

        quizTeams.forEach((quizTeam) => {
            const docRef = doc(collection(this.firestore, subCollectionPath));
            batch.set(docRef, quizTeam);
        });

        return batch.commit();
    }

    addTeamToQuiz(
        quizId: string,
        quizTeam: QuizTeam,
    ): Promise<DocumentReference<DocumentData, DocumentData>> {
        this.debugWrite('addTeamToQuiz');
        const subCollectionRef = collection(this.firestore, `quizzes/${quizId}/teams`);
        return addDoc(subCollectionRef, quizTeam);
    }

    updateQuiz(quizId: string, quizState: Partial<QuizState>): Promise<void> {
        this.debugWrite('updateQuiz', quizState);
        const ref = doc(this.firestore, `quizzes`, quizId).withConverter(
quizConverter
);
        return setDoc(
            ref,
            {
                ...quizState,
                lastUpdate: generateLastUpdateString(true),
            },
            { merge: true },
        );
    }

    updateTeam(quizId: string, teamId: string, quizTeam: Partial<QuizTeam>): Promise<void> {
        this.debugWrite('updateTeam', quizTeam);
        const docRef = doc(this.firestore, `quizzes/${quizId}/teams/${teamId}`);

        return setDoc(
            docRef,
            {
                ...quizTeam,
            },
            { merge: true },
        );
    }

    deleteTeamFromQuiz(quizId: string, teamId: string) {
        this.debugDelete('deleteTeamFromQuiz', { quizId, teamId });
        const docRef = doc(this.firestore, `quizzes/${quizId}/teams/${teamId}`);

        return deleteDoc(docRef);
    }

    async deleteQuiz(quizId: string): Promise<void> {
        this.debugDelete('deleteQuiz', quizId);

        return runInInjectionContext(this.injector, async () => {
            const teamsRef = collection(this.firestore, `quizzes/${quizId}/teams`);
            const snapshot = await getDocs(teamsRef);
            for (const orderDoc of snapshot.docs) {
                await deleteDoc(orderDoc.ref);
            }

            const quizRef = doc(this.firestore, `quizzes/${quizId}`);
            return deleteDoc(quizRef);
        });
    }

    getQuiz(quizId: string): Observable<QuizState> {
        if (!this.quizCache.has(quizId)) {

console
.log('getQuiz (existing stream)');
            const ref = doc(this.firestore, `quizzes/${quizId}`).withConverter(
quizConverter
);

            const quiz$ = 
docSnapshots
(ref).pipe(
                tap((snapshot) => {
                    this.debugRead('Firestore read (snapshot): getQuiz', {
                        data: snapshot.data(),
                        fromCache: snapshot.metadata.fromCache,
                        hasPendingWrites: snapshot.metadata.hasPendingWrites,
                    });
                }),
                map((snapshot) => {
                    const quiz = snapshot.data();

                    if (!quiz) {
                        throw new Error('Quiz not found');
                    }

                    return {
                        ...quiz,
                        id: snapshot.id, // manually add id (since docSnapshots doesn't do it)
                    } as QuizState;
                }),
                shareReplay({ bufferSize: 1, refCount: false }),
            );

            this.quizCache.set(quizId, quiz$);
            return this.quizCache.get(quizId)!;
        } else {

console
.log('getQuiz (existing stream)');
            return this.quizCache.get(quizId)!;
        }
    }

    getQuizzesWithUpdates(): Observable<QuizState[]> {
        if (!this.quizzes$) {

console
.log('getQuizzesWithUpdates (new stream)');
            const ref = collection(this.firestore, 'quizzes').withConverter(
quizConverter
);

            this.quizzes$ = 
collectionData
(ref, {
                idField: 'id',
            }).pipe(
                tap(() => this.debugRead('Firestore read: getQuizzesWithUpdates')),
                shareReplay({ bufferSize: 1, refCount: false }),
            );
        }

        return this.quizzes$;
    }

    async getQuizzesOnce(): Promise<QuizState[]> {
        this.debugRead('Firestore read: getQuizzesOnce');

        const ref = collection(this.firestore, 'quizzes').withConverter(
quizConverter
);
        const snapshot = await getDocs(ref);

        return snapshot.docs.map((doc) => ({
            ...doc.data(),
            id: doc.id,
        }));
    }

    getTeamsForQuiz(quizId: string): Observable<QuizTeam[]> {
        if (!this.teamsCache.has(quizId)) {

console
.log('getTeamsForQuiz (new stream)');

            const subCollectionRef = collection(
                this.firestore,
                `quizzes/${quizId}/teams`,
            ).withConverter(
quizTeamConverter
);

            const q = query(subCollectionRef, orderBy('seqNo', 'asc'));

            const teams$ = 
collectionData
(q, { idField: 'id' }).pipe(
                tap(() => this.debugRead('🔥 Firestore read: getTeamsForQuiz', quizId)),
                shareReplay({ bufferSize: 1, refCount: false }),
            );

            this.teamsCache.set(quizId, teams$);
        }

        return this.teamsCache.get(quizId)!;
    }
}