feat: Add Document object and change objects reference to collectionsRef

HomelessDinosaur · HomelessDinosaur · commit 30795308dc15 · 2021-07-20T15:10:23.000+10:00
diff --git a/Nitric.Sdk/Document/CollectionRef.cs b/Nitric.Sdk/Document/CollectionRef.cs
@@ -20,22 +20,14 @@ namespace Nitric.Api.Document
 {
     public class CollectionRef<T> where T : IDictionary<string, object>, new()
     {
-        private Collection collection;
+        private string name;
+        public readonly Key<T> ParentKey;
         private DocumentServiceClient documentClient;
 
-        internal CollectionRef(DocumentServiceClient documentClient, string name, GrpcKey parentKey = null)
+        internal CollectionRef(DocumentServiceClient documentClient, string name, Key<T> parentKey = null)
         {
-            this.documentClient = documentClient;
-
-            var collection = new Collection()
-            {
-                Name = name,
-            };
-            if (parentKey != null)
-            {
-                collection.Parent = parentKey;
-            }
-            this.collection = collection;
+            this.name = name;
+            this.ParentKey = parentKey;
         }
         public DocumentRef<T> Doc(string documentId)
         {
@@ -45,12 +37,24 @@ public DocumentRef<T> Doc(string documentId)
             }
             return new DocumentRef<T>(
                 this.documentClient,
-                this.collection,
+                this,
                 documentId);
         }
         public Query<T> Query()
         {
-            return new Query<T>(this.documentClient, this.collection);
+            return new Query<T>(this.documentClient, this);
+        }
+        internal Collection ToGrpcCollection()
+        {
+            var collection = new Collection()
+            {
+                Name = this.name,
+            };
+            if (this.ParentKey != null)
+            {
+                collection.Parent = this.ParentKey.ToKey();
+            }
+            return collection;
         }
     }
 }
diff --git a/Nitric.Sdk/Document/Document.cs b/Nitric.Sdk/Document/Document.cs
@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+namespace Nitric.Api.Document
+{
+    public class Document<T> where T : IDictionary<string, object>, new()
+    {
+        public DocumentRef<T> Ref { get; private set; }
+        public T Content { get; private set; }
+
+        internal Document(DocumentRef<T> documentRef, T content)
+        {
+            this.Ref = documentRef;
+            this.Content = content;
+        }
+    }
+}
diff --git a/Nitric.Sdk/Document/DocumentRef.cs b/Nitric.Sdk/Document/DocumentRef.cs
@@ -25,28 +25,31 @@ namespace Nitric.Api.Document
         const int DEPTH_LIMIT = 1;
 
         private readonly DocumentServiceClient documentClient;
-        private readonly GrpcKey key;
-        private readonly Collection collection;
+        public readonly Key<T> Key;
+        private readonly CollectionRef<T> collection;
 
         internal DocumentRef(
             DocumentServiceClient documentClient,
-            Collection collection,
+            CollectionRef<T> collection,
             string documentId)
         {
             this.documentClient = documentClient;
-            this.key = new Key(collection, documentId).ToKey();
+            this.Key = new Key<T>(collection, documentId);
             this.collection = collection;
         }
 
-        public T Get()
+        public Document<T> Get()
         {
             DocumentGetRequest request = new DocumentGetRequest();
-            request.Key = this.key;
+            request.Key = this.Key.ToKey();
 
             DocumentGetResponse response = null;
             response = this.documentClient.Get(request);
 
-            return DocumentToGeneric(response.Document.Content);
+            return new Document<T>(
+                this,
+                DocumentToGeneric(response.Document.Content)
+            );
         }
         public void Set(T value)
         {
@@ -56,7 +59,7 @@ public void Set(T value)
             }
             var request = new DocumentSetRequest
             {
-                Key = this.key,
+                Key = this.Key.ToKey(),
                 Content = Util.ObjToStruct(value),
             };
             this.documentClient.Set(request);
@@ -66,7 +69,7 @@ public void Delete()
         {
             var request = new DocumentDeleteRequest
             {
-                Key = this.key,
+                Key = this.Key.ToKey(),
             };
             this.documentClient.Delete(request);
         }
@@ -83,11 +86,11 @@ public CollectionRef<T> Collection(string name)
             {
                 throw new ArgumentNullException(name);
             }
-            if (Depth(0, this.collection) >= DEPTH_LIMIT)
+            if (Depth(0, this.collection.ToGrpcCollection()) >= DEPTH_LIMIT)
             {
                 throw new NotSupportedException("Currently subcollection are only able to be nested " + DEPTH_LIMIT + "deep");
             }
-            return new CollectionRef<T>(this.documentClient, name, this.key);
+            return new CollectionRef<T>(this.documentClient, name, this.Key);
         }
 
         //Utility function to convert a struct document to its generic counterpart
diff --git a/Nitric.Sdk/Document/Key.cs b/Nitric.Sdk/Document/Key.cs
@@ -12,17 +12,18 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 using System;
+using System.Collections.Generic;
 using Collection = Nitric.Proto.Document.v1.Collection;
 using GrpcKey = Nitric.Proto.Document.v1.Key;
 
 namespace Nitric.Api.Document
 {
-    public class Key
+    public class Key<T> where T : IDictionary<string, object>, new()
     {
-        Collection collection;
-        string id;
+        public readonly CollectionRef<T> collection;
+        public readonly string id;
 
-        public Key(Collection collection, string id = null)
+        public Key(CollectionRef<T> collection, string id = null)
         {
             if (collection == null)
             {
@@ -35,7 +36,7 @@ public GrpcKey ToKey()
         {
             return new GrpcKey
             {
-                Collection = this.collection,
+                Collection = this.collection.ToGrpcCollection(),
                 Id = this.id,
             };
         }
diff --git a/Nitric.Sdk/Document/Query.cs b/Nitric.Sdk/Document/Query.cs
@@ -25,12 +25,12 @@ namespace Nitric.Api.Document
     public class Query<T> where T : IDictionary<string, object>, new()
     {
         internal DocumentServiceClient documentClient;
-        internal Collection collection;
+        internal CollectionRef<T> collection;
         internal List<Expression> expressions;
         internal object pagingToken;
         internal int limit;
 
-        internal Query(DocumentServiceClient documentClient, Collection collection)
+        internal Query(DocumentServiceClient documentClient, CollectionRef<T> collection)
         {
             this.documentClient = documentClient;
             this.collection = collection;
@@ -93,7 +93,7 @@ public override string ToString()
         internal readonly Query<T> query;
         internal readonly bool paginateAll;
         public object PagingToken { get; private set; }
-        public List<T> QueryData { get; private set; }
+        public List<Document<T>> QueryData { get; private set; }
 
         internal QueryResult(Query<T> query, bool paginateAll)
         {
@@ -110,7 +110,7 @@ internal QueryResult(Query<T> query, bool paginateAll)
         internal DocumentQueryRequest BuildDocQueryRequest(List<Expression> expressions)
         {
             var request = new DocumentQueryRequest();
-            request.Collection = this.query.collection;
+            request.Collection = this.query.collection.ToGrpcCollection();
 
             foreach (Expression expression in expressions)
             {
@@ -133,19 +133,33 @@ internal DocumentQueryRequest BuildDocQueryRequest(List<Expression> expressions)
 
         internal void LoadPageData(DocumentQueryResponse response)
         {
-            QueryData = new List<T>(response.Documents.Count);
-
+            QueryData = new List<Document<T>>(response.Documents.Count);
+            var collection = this.query.collection.ToGrpcCollection();
             foreach (var doc in response.Documents)
             {
                 var dict = Util.ObjToDict(doc.Content);
 
                 if (typeof(T).IsAssignableFrom(dict.GetType()))
                 {
-                    QueryData.Add((T)Util.DictToCollection<T>(dict));
+                    QueryData.Add(new Document<T>(
+                        new DocumentRef<T>(
+                            this.query.documentClient,
+                            this.query.collection,
+                            this.query.collection.ParentKey.id
+                        ),
+                        (T)Util.DictToCollection<T>(dict))
+                    );
                 }
                 else
                 {
-                    QueryData.Add((T)Util.DictToCollection<T>(Util.ObjToDict(dict)));
+                    QueryData.Add(new Document<T>(
+                        new DocumentRef<T>(
+                            this.query.documentClient,
+                            this.query.collection,
+                            this.query.collection.ParentKey.id
+                        ),
+                        (T)Util.DictToCollection<T>(Util.ObjToDict(dict)))
+                    );
                 }
             }
             this.PagingToken = Util.CollectionToDict(response.PagingToken);
diff --git a/Nitric.Test/Api/Document/DocumentsTest.cs b/Nitric.Test/Api/Document/DocumentsTest.cs
@@ -105,7 +105,9 @@ public void TestGetWithDictionary()
                 .Collection<Dictionary<string, object>>("test-collection")
                 .Doc("test-document");
             var response = documentRef.Get();
-            Assert.AreEqual(response["test"], "document");
+
+            Assert.AreEqual(response.Content["test"], "document");
+            Assert.AreEqual(response.Ref, documentRef);
 
             dc.Verify(t => t.Get(It.IsAny<DocumentGetRequest>(), null, null, It.IsAny<System.Threading.CancellationToken>()), Times.Once);
         }
@@ -138,7 +140,8 @@ public void TestGetWithSortedDictionary()
                 .Collection<SortedDictionary<string, object>>("test-collection")
                 .Doc("test-document");
             var response = documentRef.Get();
-            Assert.AreEqual(response["test"], "document");
+            Assert.AreEqual(response.Content["test"], "document");
+            Assert.AreEqual(response.Ref, documentRef);
 
             dc.Verify(t => t.Get(It.IsAny<DocumentGetRequest>(), null, null, It.IsAny<System.Threading.CancellationToken>()), Times.Once);
         }
@@ -444,7 +447,7 @@ public void TestFetch()
             {
                 var response = query.Fetch();
                 Assert.AreEqual(response.QueryData.Count, 1);
-                Assert.AreEqual(response.QueryData[0], "document");
+                Assert.AreEqual(response.QueryData[0].Content["test"], "document");
                 Assert.AreEqual(response.PagingToken, pagingToken);
             }
             catch (Exception)
@@ -488,7 +491,7 @@ public void TestFetchConformsToLimitOfOne()
                     .Limit(1)
                     .Fetch();
                 Assert.AreEqual(response.QueryData.Count, 1);
-                Assert.AreEqual(response.QueryData[0], "document");
+                Assert.AreEqual(response.QueryData[0].Content["test"], "document");
                 Assert.AreEqual(response.PagingToken, pagingToken);
             }
             catch (Exception)
@@ -533,7 +536,7 @@ public void TestFetchWithExpressions()
                     .Where("last_name", "==", "smith")
                     .Fetch();
                 Assert.AreEqual(response.QueryData.Count, 1);
-                Assert.AreEqual(response.QueryData[0], "document");
+                Assert.AreEqual(response.QueryData[0].Content["test"], "document");
                 Assert.AreEqual(response.PagingToken, pagingToken);
             }
             catch (Exception)
@@ -580,7 +583,7 @@ public void TestFetchWithPagingToken()
                     .PagingFrom(pagingToken)
                     .Fetch();
                 Assert.AreEqual(response.QueryData.Count, 1);
-                Assert.AreEqual(response.QueryData[0], "document");
+                Assert.AreEqual(response.QueryData[0].Content["test"], "document");
                 Assert.AreEqual(response.PagingToken, updatedPagingToken);
             }
             catch (Exception)
@@ -623,8 +626,8 @@ public void TestFetchAll()
             {
                 var response = query.FetchAll();
                 Assert.AreEqual(response.QueryData.Count, 1);
-                Assert.AreEqual(response.QueryData[0], "john smith");
-                Assert.AreEqual(response.QueryData[1], "jane doe");
+                Assert.AreEqual(response.QueryData[0].Content["0"], "john smith");
+                Assert.AreEqual(response.QueryData[1].Content["1"], "jane doe");
                 Assert.AreEqual(response.PagingToken, pagingToken);
             }
             catch (Exception)

Original file line number	Diff line number	Diff line change
`@@ -20,22 +20,14 @@ namespace Nitric.Api.Document`
`20`	`20`	`{`
`21`	`21`	`public class CollectionRef<T> where T : IDictionary<string, object>, new()`
`22`	`22`	`{`
`23`		`- private Collection collection;`
	`23`	`+ private string name;`
	`24`	`+ public readonly Key<T> ParentKey;`
`24`	`25`	`private DocumentServiceClient documentClient;`
`25`	`26`
`26`		`- internal CollectionRef(DocumentServiceClient documentClient, string name, GrpcKey parentKey = null)`
	`27`	`+ internal CollectionRef(DocumentServiceClient documentClient, string name, Key<T> parentKey = null)`
`27`	`28`	`{`
`28`		`- this.documentClient = documentClient;`
`29`		`-`
`30`		`- var collection = new Collection()`
`31`		`- {`
`32`		`- Name = name,`
`33`		`- };`
`34`		`- if (parentKey != null)`
`35`		`- {`
`36`		`- collection.Parent = parentKey;`
`37`		`- }`
`38`		`- this.collection = collection;`
	`29`	`+ this.name = name;`
	`30`	`+ this.ParentKey = parentKey;`
`39`	`31`	`}`
`40`	`32`	`public DocumentRef<T> Doc(string documentId)`
`41`	`33`	`{`
`@@ -45,12 +37,24 @@ public DocumentRef<T> Doc(string documentId)`
`45`	`37`	`}`
`46`	`38`	`return new DocumentRef<T>(`
`47`	`39`	`this.documentClient,`
`48`		`- this.collection,`
	`40`	`+ this,`
`49`	`41`	`documentId);`
`50`	`42`	`}`
`51`	`43`	`public Query<T> Query()`
`52`	`44`	`{`
`53`		`- return new Query<T>(this.documentClient, this.collection);`
	`45`	`+ return new Query<T>(this.documentClient, this);`
	`46`	`+ }`
	`47`	`+ internal Collection ToGrpcCollection()`
	`48`	`+ {`
	`49`	`+ var collection = new Collection()`
	`50`	`+ {`
	`51`	`+ Name = this.name,`
	`52`	`+ };`
	`53`	`+ if (this.ParentKey != null)`
	`54`	`+ {`
	`55`	`+ collection.Parent = this.ParentKey.ToKey();`
	`56`	`+ }`
	`57`	`+ return collection;`
`54`	`58`	`}`
`55`	`59`	`}`
`56`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,28 +25,31 @@ namespace Nitric.Api.Document`
`25`	`25`	`const int DEPTH_LIMIT = 1;`
`26`	`26`
`27`	`27`	`private readonly DocumentServiceClient documentClient;`
`28`		`- private readonly GrpcKey key;`
`29`		`- private readonly Collection collection;`
	`28`	`+ public readonly Key<T> Key;`
	`29`	`+ private readonly CollectionRef<T> collection;`
`30`	`30`
`31`	`31`	`internal DocumentRef(`
`32`	`32`	`DocumentServiceClient documentClient,`
`33`		`- Collection collection,`
	`33`	`+ CollectionRef<T> collection,`
`34`	`34`	`string documentId)`
`35`	`35`	`{`
`36`	`36`	`this.documentClient = documentClient;`
`37`		`- this.key = new Key(collection, documentId).ToKey();`
	`37`	`+ this.Key = new Key<T>(collection, documentId);`
`38`	`38`	`this.collection = collection;`
`39`	`39`	`}`
`40`	`40`
`41`		`- public T Get()`
	`41`	`+ public Document<T> Get()`
`42`	`42`	`{`
`43`	`43`	`DocumentGetRequest request = new DocumentGetRequest();`
`44`		`- request.Key = this.key;`
	`44`	`+ request.Key = this.Key.ToKey();`
`45`	`45`
`46`	`46`	`DocumentGetResponse response = null;`
`47`	`47`	`response = this.documentClient.Get(request);`
`48`	`48`
`49`		`- return DocumentToGeneric(response.Document.Content);`
	`49`	`+ return new Document<T>(`
	`50`	`+ this,`
	`51`	`+ DocumentToGeneric(response.Document.Content)`
	`52`	`+ );`
`50`	`53`	`}`
`51`	`54`	`public void Set(T value)`
`52`	`55`	`{`
`@@ -56,7 +59,7 @@ public void Set(T value)`
`56`	`59`	`}`
`57`	`60`	`var request = new DocumentSetRequest`
`58`	`61`	`{`
`59`		`- Key = this.key,`
	`62`	`+ Key = this.Key.ToKey(),`
`60`	`63`	`Content = Util.ObjToStruct(value),`
`61`	`64`	`};`
`62`	`65`	`this.documentClient.Set(request);`
`@@ -66,7 +69,7 @@ public void Delete()`
`66`	`69`	`{`
`67`	`70`	`var request = new DocumentDeleteRequest`
`68`	`71`	`{`
`69`		`- Key = this.key,`
	`72`	`+ Key = this.Key.ToKey(),`
`70`	`73`	`};`
`71`	`74`	`this.documentClient.Delete(request);`
`72`	`75`	`}`
`@@ -83,11 +86,11 @@ public CollectionRef<T> Collection(string name)`
`83`	`86`	`{`
`84`	`87`	`throw new ArgumentNullException(name);`
`85`	`88`	`}`
`86`		`- if (Depth(0, this.collection) >= DEPTH_LIMIT)`
	`89`	`+ if (Depth(0, this.collection.ToGrpcCollection()) >= DEPTH_LIMIT)`
`87`	`90`	`{`
`88`	`91`	`throw new NotSupportedException("Currently subcollection are only able to be nested " + DEPTH_LIMIT + "deep");`
`89`	`92`	`}`
`90`		`- return new CollectionRef<T>(this.documentClient, name, this.key);`
	`93`	`+ return new CollectionRef<T>(this.documentClient, name, this.Key);`
`91`	`94`	`}`
`92`	`95`
`93`	`96`	`//Utility function to convert a struct document to its generic counterpart`
Original file line number	Diff line number	Diff line change
`@@ -12,17 +12,18 @@`
`12`	`12`	`// See the License for the specific language governing permissions and`
`13`	`13`	`// limitations under the License.`
`14`	`14`	`using System;`
	`15`	`+using System.Collections.Generic;`
`15`	`16`	`using Collection = Nitric.Proto.Document.v1.Collection;`
`16`	`17`	`using GrpcKey = Nitric.Proto.Document.v1.Key;`
`17`	`18`
`18`	`19`	`namespace Nitric.Api.Document`
`19`	`20`	`{`
`20`		`- public class Key`
	`21`	`+ public class Key<T> where T : IDictionary<string, object>, new()`
`21`	`22`	`{`
`22`		`- Collection collection;`
`23`		`- string id;`
	`23`	`+ public readonly CollectionRef<T> collection;`
	`24`	`+ public readonly string id;`
`24`	`25`
`25`		`- public Key(Collection collection, string id = null)`
	`26`	`+ public Key(CollectionRef<T> collection, string id = null)`
`26`	`27`	`{`
`27`	`28`	`if (collection == null)`
`28`	`29`	`{`
`@@ -35,7 +36,7 @@ public GrpcKey ToKey()`
`35`	`36`	`{`
`36`	`37`	`return new GrpcKey`
`37`	`38`	`{`
`38`		`- Collection = this.collection,`
	`39`	`+ Collection = this.collection.ToGrpcCollection(),`
`39`	`40`	`Id = this.id,`
`40`	`41`	`};`
`41`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,12 +25,12 @@ namespace Nitric.Api.Document`
`25`	`25`	`public class Query<T> where T : IDictionary<string, object>, new()`
`26`	`26`	`{`
`27`	`27`	`internal DocumentServiceClient documentClient;`
`28`		`- internal Collection collection;`
	`28`	`+ internal CollectionRef<T> collection;`
`29`	`29`	`internal List<Expression> expressions;`
`30`	`30`	`internal object pagingToken;`
`31`	`31`	`internal int limit;`
`32`	`32`
`33`		`- internal Query(DocumentServiceClient documentClient, Collection collection)`
	`33`	`+ internal Query(DocumentServiceClient documentClient, CollectionRef<T> collection)`
`34`	`34`	`{`
`35`	`35`	`this.documentClient = documentClient;`
`36`	`36`	`this.collection = collection;`
`@@ -93,7 +93,7 @@ public override string ToString()`
`93`	`93`	`internal readonly Query<T> query;`
`94`	`94`	`internal readonly bool paginateAll;`
`95`	`95`	`public object PagingToken { get; private set; }`
`96`		`- public List<T> QueryData { get; private set; }`
	`96`	`+ public List<Document<T>> QueryData { get; private set; }`
`97`	`97`
`98`	`98`	`internal QueryResult(Query<T> query, bool paginateAll)`
`99`	`99`	`{`
`@@ -110,7 +110,7 @@ internal QueryResult(Query<T> query, bool paginateAll)`
`110`	`110`	`internal DocumentQueryRequest BuildDocQueryRequest(List<Expression> expressions)`
`111`	`111`	`{`
`112`	`112`	`var request = new DocumentQueryRequest();`
`113`		`- request.Collection = this.query.collection;`
	`113`	`+ request.Collection = this.query.collection.ToGrpcCollection();`
`114`	`114`
`115`	`115`	`foreach (Expression expression in expressions)`
`116`	`116`	`{`
`@@ -133,19 +133,33 @@ internal DocumentQueryRequest BuildDocQueryRequest(List<Expression> expressions)`
`133`	`133`
`134`	`134`	`internal void LoadPageData(DocumentQueryResponse response)`
`135`	`135`	`{`
`136`		`- QueryData = new List<T>(response.Documents.Count);`
`137`		`-`
	`136`	`+ QueryData = new List<Document<T>>(response.Documents.Count);`
	`137`	`+ var collection = this.query.collection.ToGrpcCollection();`
`138`	`138`	`foreach (var doc in response.Documents)`
`139`	`139`	`{`
`140`	`140`	`var dict = Util.ObjToDict(doc.Content);`
`141`	`141`
`142`	`142`	`if (typeof(T).IsAssignableFrom(dict.GetType()))`
`143`	`143`	`{`
`144`		`- QueryData.Add((T)Util.DictToCollection<T>(dict));`
	`144`	`+ QueryData.Add(new Document<T>(`
	`145`	`+ new DocumentRef<T>(`
	`146`	`+ this.query.documentClient,`
	`147`	`+ this.query.collection,`
	`148`	`+ this.query.collection.ParentKey.id`
	`149`	`+ ),`
	`150`	`+ (T)Util.DictToCollection<T>(dict))`
	`151`	`+ );`
`145`	`152`	`}`
`146`	`153`	`else`
`147`	`154`	`{`
`148`		`- QueryData.Add((T)Util.DictToCollection<T>(Util.ObjToDict(dict)));`
	`155`	`+ QueryData.Add(new Document<T>(`
	`156`	`+ new DocumentRef<T>(`
	`157`	`+ this.query.documentClient,`
	`158`	`+ this.query.collection,`
	`159`	`+ this.query.collection.ParentKey.id`
	`160`	`+ ),`
	`161`	`+ (T)Util.DictToCollection<T>(Util.ObjToDict(dict)))`
	`162`	`+ );`
`149`	`163`	`}`
`150`	`164`	`}`
`151`	`165`	`this.PagingToken = Util.CollectionToDict(response.PagingToken);`