Python后端Firebase消息应用：Firestore文档类自动生成方案咨询

Great question! I've run into the exact same issue with firestore-model not handling subcollections well when building Firebase-backed Python apps. Here are a few battle-tested approaches to auto-generate Firestore-mapped classes (including subcollections) and maintain them via schema docs:

Start by building a reusable base class that handles core Firestore serialization/deserialization, then add explicit subcollection mappings to your models. This gives you full control over how subcollections are associated.

Step 1: Build the Base Model #

from typing import Dict, Type, List, Optional
import firebase_admin
from firebase_admin import firestore

db = firestore.client()

class FirestoreModel:
    # Define collection name per model
    collection_name: str
    # Map subcollection names to their corresponding model classes
    subcollections: Dict[str, Type['FirestoreModel']] = {}

    def __init__(self, doc_id: str):
        self.doc_id = doc_id

    # Auto-generate dict for Firestore (exclude doc_id since it's the document ID)
    def to_dict(self) -> Dict:
        return {k: v for k, v in self.__dict__.items() if k != "doc_id"}

    # Auto-instantiate model from Firestore document data
    @classmethod
    def from_dict(cls, doc_id: str, source: Dict) -> 'FirestoreModel':
        instance = cls(doc_id)
        for field, value in source.items():
            setattr(instance, field, value)
        return instance

    # Helper to save the model to Firestore
    def save(self):
        doc_ref = db.collection(self.collection_name).document(self.doc_id)
        doc_ref.set(self.to_dict())

    # Helper to fetch a single document by ID
    @classmethod
    def get(cls, doc_id: str) -> Optional['FirestoreModel']:
        doc = db.collection(cls.collection_name).document(doc_id).get()
        return cls.from_dict(doc_id, doc.to_dict()) if doc.exists else None

    # Helper to fetch all documents in a subcollection
    def get_subcollection(self, subcol_name: str) -> List['FirestoreModel']:
        if subcol_name not in self.subcollections:
            raise ValueError(f"Subcollection {subcol_name} not defined for {self.__class__.__name__}")
        
        subcol_model = self.subcollections[subcol_name]
        docs = db.collection(self.collection_name)\
                 .document(self.doc_id)\
                 .collection(subcol_model.collection_name)\
                 .get()
        
        return [subcol_model.from_dict(doc.id, doc.to_dict()) for doc in docs]

Step 2: Define Your Models with Subcollections #

# Child model for the Messages subcollection
class Message(FirestoreModel):
    collection_name = "Messages"

    def __init__(self, doc_id: str, text_string: str):
        super().__init__(doc_id)
        self.text_string = text_string

# Parent User model with linked Messages subcollection
class User(FirestoreModel):
    collection_name = "Users"
    subcollections = {"Messages": Message}

    def __init__(self, doc_id: str, first_name: str, last_name: str):
        super().__init__(doc_id)
        self.first_name = first_name
        self.last_name = last_name

If you want strict data validation and schema-based maintenance, use Pydantic to define your models and extend them with Firestore-specific logic. You can even auto-generate models from YAML/JSON schemas.

Step 1: Pydantic-Based Firestore Model #

from pydantic import BaseModel, Field
import firebase_admin
from firebase_admin import firestore

db = firestore.client()

class FirestorePydanticModel(BaseModel):
    doc_id: str = Field(description="Firestore document ID")

    class Config:
        orm_mode = True
        extra = "forbid"  # Block unexpected fields

    def to_firestore_dict(self) -> dict:
        return self.dict(exclude={"doc_id"})

    @classmethod
    def from_firestore(cls, doc_id: str, data: dict) -> 'FirestorePydanticModel':
        return cls(doc_id=doc_id, **data)

    def save(self):
        db.collection(self.__class__.collection_name).document(self.doc_id).set(self.to_firestore_dict())

Step 2: Define Models + Subcollection Helpers #

class Message(FirestorePydanticModel):
    collection_name = "Messages"
    text_string: str = Field(description="Content of the message")

class User(FirestorePydanticModel):
    collection_name = "Users"
    first_name: str = Field(description="User's first name")
    last_name: str = Field(description="User's last name")

    # Helper to fetch messages for this user
    @classmethod
    def get_user_messages(cls, user_id: str) -> List[Message]:
        docs = db.collection(cls.collection_name)\
                 .document(user_id)\
                 .collection(Message.collection_name)\
                 .get()
        return [Message.from_firestore(doc.id, doc.to_dict()) for doc in docs]

Step 3: Auto-Generate from Schema #

Create a YAML schema file (e.g., firestore_schema.yaml) to maintain your models:

models:
  User:
    collection_name: Users
    fields:
      first_name: str
      last_name: str
    subcollections:
      - Message
  Message:
    collection_name: Messages
    fields:
      text_string: str

Then write a simple Python script to parse this YAML and generate Pydantic model code automatically. This keeps your model definitions centralized and easy to update.

For large apps with many models, use Jinja2 templates to auto-generate all your Firestore model code from a schema. This eliminates repetitive boilerplate entirely.

Example Jinja2 Template (firestore_model_template.j2) #

from my_app.firestore_base import FirestoreModel

class {{ class_name }}(FirestoreModel):
    collection_name = "{{ collection_name }}"
    {% if subcollections %}
    subcollections = {
        {% for subcol in subcollections %}
        "{{ subcol.collection_name }}": {{ subcol.class_name }}
        {% if not loop.last %},{% endif %}
        {% endfor %}
    }
    {% endif %}

    def __init__(self, doc_id: str, {% for field in fields %}{{ field.name }}: {{ field.type }}{% if not loop.last %}, {% endif %}{% endfor %}):
        super().__init__(doc_id)
        {% for field in fields %}
        self.{{ field.name }} = {{ field.name }}
        {% endfor %}

You can then write a script to load your schema (YAML/JSON), render the template, and output ready-to-use model files.

• Custom Base Class: Best for small-to-medium apps where you want full control over subcollection logic.
• Pydantic: Ideal if you need data validation and schema-driven maintenance.
• Jinja2 Code Generation: Perfect for large apps with dozens of models, keeping your codebase DRY.

All these approaches solve the subcollection gap in tools like firestore-model and let you maintain your models via centralized schema docs.

内容的提问来源于stack exchange，提问作者Raghu N