make data a cached property. gracefully handle missing records

django_typesense/collections.py

@@ -87,16 +87,34 @@ def __init__(
         self.fields = self.get_fields()
         self._synonyms = [synonym().data for synonym in self.synonyms]
 
-        # TODO: Make self.data a cached_property
-        if data:
-            self.data = data
-        elif obj:
-            if many:
-                self.data = list(map(self._get_object_data, obj))
-            else:
-                self.data = [self._get_object_data(obj)]
+        if data and obj:
+            raise Exception("'data' and 'obj' are mutually exclusive")
+
+        self._data = data
+        self.many = many
+        self.obj = obj
+
+    @cached_property
+    def data(self):
+        return self.get_data()
+
+    def get_data(self):
+        if self._data:
+            return self._data
+
+        if not self.obj:
+            return []
+
+        data = []
+        if self.many:
+            for _obj in self.obj:
+                if obj_data := self._get_object_data(_obj):
+                    data.append(obj_data)
         else:
-            self.data = []
+            if obj_data := self._get_object_data(self.obj):
+                data.append(obj_data)
+
+        return data
 
     @classmethod
     def get_fields(cls) -> Dict[str, TypesenseField]:
@@ -190,9 +208,14 @@ def schema_fields(self) -> list:
     def _get_object_data(self, obj):
         if self.update_fields:
             # we need the id for updates and a user can leave it out
-            update_fields = set(self.fields.keys()).intersection(set(self.update_fields))
-            update_fields.add('id')
-            fields = [self.get_field(field_name) for field_name in update_fields]
+            update_fields = set(self.fields.keys()).intersection(
+                set(self.update_fields)
+            )
+            if update_fields:
+                update_fields.add("id")
+                fields = [self.get_field(field_name) for field_name in update_fields]
+            else:
+                fields = []
         else:
             fields = self.fields.values()
 
@@ -254,7 +277,7 @@ def update_typesense_collection(self):
                 field_changes.append(field)
             else:
                 if field != existing_fields[field["name"]]:
-                    field_changes.append({"name": field['name'], "drop": True})
+                    field_changes.append({"name": field["name"], "drop": True})
                     field_changes.append(field)
 
         if field_changes:
@@ -299,24 +322,30 @@ def update(self, action_mode: str = "emplace"):
             return self._update_multiple_documents(action_mode)
 
     def _update_single_document(self, document):
-        document_id = document.pop('id')
+        document_id = document.pop("id")
 
         try:
-            return client.collections[self.schema_name].documents[document_id].update(document)
+            return (
+                client.collections[self.schema_name]
+                .documents[document_id]
+                .update(document)
+            )
         except ObjectNotFound:
-            self.create_typesense_collection()
-            document['id'] = document_id
-            return client.collections[self.schema_name].documents.upsert(document)
+            self.update_fields = []
+            # we don't want the cached data
+            return client.collections[self.schema_name].documents.upsert(
+                self.get_data()[0]
+            )
 
     def _update_multiple_documents(self, action_mode):
         try:
             return client.collections[self.schema_name].documents.import_(
                 self.data, {"action": action_mode}
             )
         except ObjectNotFound:
-            self.create_typesense_collection()
+            # we don't want the cached data
             return client.collections[self.schema_name].documents.import_(
-                self.data, {"action": action_mode}
+                self.get_data(), {"action": action_mode}
             )
 
     def create_or_update_synonyms(self):

django_typesense/signals.py

@@ -9,7 +9,7 @@ def post_save_typesense_models(sender, instance, **kwargs):
     if not issubclass(sender, TypesenseModelMixin):
         return
 
-    sender.get_collection(instance).update()
+    sender.get_collection(instance, update_fields=kwargs.get('update_fields', [])).update()
 
 
 @receiver(pre_delete)

runtests.py

@@ -4,11 +4,14 @@
 import django
 from django.conf import settings
 from django.test.utils import get_runner
+from django.core.management import call_command
 
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "tests.settings")
 
 django.setup()
 
+call_command("updatecollections")
+
 TestRunner = get_runner(settings)
 test_runner = TestRunner()
 failures = test_runner.run_tests(["tests"])