Initial implementation of saving models

README.md

@@ -14,7 +14,7 @@ from couchbase.cluster import Cluster
 
 from couch_potato.couch_potato import CouchPotato
 from couch_potato.model import KeyGenerator
-from couch_potato.fields import String
+from couch_potato.fields import String, Integer
 
 cluster = Cluster(
     'couchbase://localhost',
@@ -27,8 +27,14 @@ class UserModel(couch_potato.Model):
     __key_generator__ = KeyGenerator("User::{name}")
 
     name = String()
+    age = Integer()
 
 if __name__ == "__main__":
+    # Get the model from the database
     a: UserModel = UserModel.get(name="test")
-    print(a.name)
+    print(a.name, a.age)
+    # Update one of the instance attributes, and save the model
+    a.age = 30
+    a.save()
+
 ```

couch-potato/_model.py

@@ -20,6 +20,7 @@ def __new__(cls, name, bases, dct):
 
             # Set up internal attributes on the class defn
             # 1. Set the __fields__ attribute on the class
+            # TODO: Validate that field names do not conflict with reserved named
             fields: Dict[str, Field] = dict()
             for name, attr in dct.items():
                 if isinstance(attr, Field):

couch-potato/_types.py

@@ -22,8 +22,9 @@ class BucketBind:
 class Field(metaclass=ABCMeta):
     __type__: Type
 
-    def __init__(self, nullable: bool = True):
+    def __init__(self, nullable: bool = True, read_only: bool = False):
         self._nullable = nullable
+        self._read_only = read_only
 
     @classmethod
     def ensure_type(cls, value: Any):
@@ -32,6 +33,7 @@ def ensure_type(cls, value: Any):
                             f"{cls.__type__} but got {type(value)}")
 
     def serialize(self, value):
+        self.ensure_type(value)
         return value
 
     def deserialize(self, value):

couch-potato/errors.py

@@ -8,3 +8,7 @@ class FieldNotFound(ModelError):
 
 class ModelAttributeError(ModelError):
     pass
+
+
+class ReadOnlyError(ModelError):
+    pass

couch-potato/model.py

@@ -1,10 +1,11 @@
 from string import Formatter
-from typing import Any, TypeVar, Type
+from typing import TypeVar, Type
 
 from couchbase.collection import Collection
+from couchbase.options import InsertOptions, ReplaceOptions
 from couchbase.scope import Scope
 
-from errors import ModelAttributeError, FieldNotFound
+from errors import ModelAttributeError, FieldNotFound, ReadOnlyError
 
 T = TypeVar('T', bound='BaseModel')
 
@@ -26,6 +27,7 @@ class BaseModel:
     __scope__: str = Scope.default_name()
     __collection__: str = Collection.default_name()
     __key_generator__: KeyGenerator
+    __read_only__: bool = False
 
     def __init__(self, **kwargs):
         for key, value in kwargs.items():
@@ -84,3 +86,47 @@ def from_json(cls: Type[T], **kwargs) -> T:
         # Create an instance of the class
         instance = cls(**kwargs)
         return instance
+
+    # TODO: Add kwargs for supporting InsertOptions and ReplaceOptions,
+    #  such as timeout and expiry
+    def save(self):
+        # TODO: Move this logic inside of a __setattr__, so that any attempt to
+        #  modify fields on the model is rejected and cannot actually modify state
+        if self.__read_only__:
+            raise ReadOnlyError("Cannot save read-only model")
+
+        if not hasattr(self, "__fields__"):
+            raise Exception("Unable to save model, as no fields defined")
+
+        serialized = self.to_json()
+        doc_key = self.__key_generator__.generate(**{
+            key: getattr(self, key) for key in self.__key_generator__.format_keys
+        })
+
+        if hasattr(self, "__cas__"):
+            # Updating the document
+            # Update the raw dictionary with the values of the fields
+            # defined in the model, but leave everything else which not
+            # a defined field as it was
+            raw_doc = getattr(self, "__raw__", {})
+            for key, value in serialized.items():
+                raw_doc[key] = value
+            serialized = raw_doc
+            options = ReplaceOptions(cas=self.__cas__)
+            # TODO: What happens if the key for this document changes?
+            mutation_result = self.bind().replace(doc_key, serialized, options)
+        else:
+            # Inserting the document
+            options = InsertOptions()
+            mutation_result = self.bind().insert(doc_key, serialized, options)
+        # Set the class attributes updated to the values in the mutation result, so that this
+        # instance can then be reused without needing to fetch again
+        setattr(self, "__raw__", serialized)
+        setattr(self, "__cas__", mutation_result.cas)
+        setattr(self, "__key__", mutation_result.key)
+
+    def to_json(self) -> dict:
+        ret = {}
+        for key, field in self.__fields__.items():
+            ret[key] = field.serialize(getattr(self, key))
+        return ret