src: update one is just a computed field

src/database_interface.go

@@ -12,7 +12,6 @@ type DatabaseInterface interface {
 	// FindMany should return p.First + 1 nodes, or p.Last + 1 nodes, so goke can compute `hasNextPage` and `hasPreviousPage`
 	FindMany(ctx context.Context, p FindManyParams, hook TransformDocument) ([]Map, error)
 	InsertMany(ctx context.Context, p InsertManyParams, hook TransformDocument) (NodesMutationPayload, error)
-	UpdateOne(ctx context.Context, p UpdateParams, hook TransformDocument) (NodeMutationPayload, error)
 	UpdateMany(ctx context.Context, p UpdateParams, hook TransformDocument) (NodesMutationPayload, error)
 	DeleteMany(ctx context.Context, p DeleteManyParams, hook TransformDocument) (NodesMutationPayload, error)
 }

src/fakedata/fakedata.go

@@ -54,7 +54,7 @@ func (self *FakeDatabaseFunctions) FindMany(ctx context.Context, p goke.FindMany
 	if err != nil {
 		return nil, err
 	}
-	nodes, err = goke.FilterDocuments(nodes, hook)
+	nodes, err = goke.FilterDocuments(nodes, hook) // TODO filtering after will potentially remove documents, making the limit lower than the query one
 	if err != nil {
 		return nil, err
 	}
@@ -101,64 +101,11 @@ func (self *FakeDatabaseFunctions) InsertMany(ctx context.Context, p goke.Insert
 	}, nil
 }
 
-func (self *FakeDatabaseFunctions) UpdateOne(ctx context.Context, p goke.UpdateParams, hook goke.TransformDocument) (goke.NodeMutationPayload, error) {
-	db, err := self.Init(ctx)
-	payload := goke.NodeMutationPayload{
-		Returning:     nil,
-		AffectedCount: 0,
-	}
-	if err != nil {
-		return payload, err
-	}
-
-	// TODO this step of checking could be skipped if there are no guards
-	nodes, err := self.FindMany(ctx, goke.FindManyParams{
-		Collection: p.Collection,
-		Limit:      1,
-		Where:      p.Where,
-	}, hook)
-	if err != nil {
-		return payload, err
-	}
-	if len(nodes) == 0 {
-		return payload, nil
-	}
-
-	// make sure we update the document we checked with the hook
-	where := goke.ExtendWhereMatch(
-		p.Where,
-		map[string]goke.Filter{
-			"_id": {
-				Eq: nodes[0]["_id"],
-			},
-		},
-	)
-	match := mongodb.MakeMongodbMatch(where)
-
-	opts := options.FindOneAndUpdate()
-	opts.SetReturnDocument(options.After)
-	testutil.PrettyPrint(p)
-
-	res := db.Collection(p.Collection).FindOneAndUpdate(ctx, match, bson.M{"$set": p.Set}, opts)
-	if res.Err() == mongo.ErrNoDocuments {
-		println("no docs to update")
-		return payload, nil
-	} else if res.Err() != nil {
-		return payload, err
-	}
-	data := goke.Map{}
-	err = res.Decode(&data)
-	if err != nil {
-		return payload, err
-	}
-	return goke.NodeMutationPayload{
-		AffectedCount: 1,
-		Returning:     data,
-	}, nil
-}
-
 // first updateMany documents, then query again the documents and return them, all inside a transaction that prevents other writes happen before the query
 func (self *FakeDatabaseFunctions) UpdateMany(ctx context.Context, p goke.UpdateParams, hook goke.TransformDocument) (goke.NodesMutationPayload, error) {
+	if p.Limit == 0 {
+		p.Limit = math.MaxInt16
+	}
 	db, err := self.Init(ctx)
 	payload := goke.NodesMutationPayload{
 		Returning:     nil,
@@ -190,7 +137,6 @@ func (self *FakeDatabaseFunctions) UpdateMany(ctx context.Context, p goke.Update
 
 		res := db.Collection(p.Collection).FindOneAndUpdate(ctx, match, bson.M{"$set": p.Set}, opts)
 		if res.Err() == mongo.ErrNoDocuments {
-			println("no docs to update")
 			return payload, nil
 		} else if res.Err() != nil {
 			return payload, err

src/fields/update_one.go

@@ -4,7 +4,6 @@ import (
 	"github.com/graphql-go/graphql"
 	"github.com/mitchellh/mapstructure"
 	goke "github.com/remorses/goke/src"
-	"github.com/remorses/goke/src/testutil"
 	"github.com/remorses/goke/src/types"
 )
 
@@ -23,6 +22,7 @@ func UpdateOne(p CreateFieldParams) (*graphql.Field, error) {
 		args := params.Args
 		opts := goke.UpdateParams{
 			Collection: p.Collection,
+			Limit:      1,
 		}
 		err := mapstructure.Decode(args, &opts)
 		if err != nil {
@@ -35,7 +35,7 @@ func UpdateOne(p CreateFieldParams) (*graphql.Field, error) {
 			}
 			opts.Where = where
 		}
-		res, err := p.Config.DatabaseFunctions.UpdateOne(
+		res, err := p.Config.DatabaseFunctions.UpdateMany(
 			params.Context,
 			opts,
 			func(document goke.Map) (goke.Map, error) {
@@ -47,11 +47,20 @@ func UpdateOne(p CreateFieldParams) (*graphql.Field, error) {
 				})
 			},
 		)
-		println(testutil.Pretty(res))
+		// println(testutil.Pretty(res))
 		if err != nil {
 			return nil, err
 		}
-		return res, nil
+		if len(res.Returning) == 0 {
+			return goke.NodeMutationPayload{
+				AffectedCount: res.AffectedCount,
+			}, nil
+		}
+
+		return goke.NodeMutationPayload{
+			AffectedCount: res.AffectedCount,
+			Returning:     res.Returning[0],
+		}, nil
 	}
 
 	// if err != nil {

src/firestore/firestore.go

@@ -93,25 +93,10 @@ func (self *FirestoreDatabaseFunctions) InsertMany(ctx context.Context, p goke.I
 	return payload, nil
 }
 
-func (self *FirestoreDatabaseFunctions) UpdateOne(ctx context.Context, p goke.UpdateParams, hook goke.TransformDocument) (goke.NodeMutationPayload, error) {
-	res, err := self.updateMany(ctx, p, hook, 1)
-	payload := goke.NodeMutationPayload{}
-	if err != nil {
-		return payload, err
-	}
-	if len(res.Returning) == 0 {
-		return payload, nil
-	}
-	payload.Returning = res.Returning[0]
-	payload.AffectedCount = 1
-	return payload, nil
-}
-
 func (self *FirestoreDatabaseFunctions) UpdateMany(ctx context.Context, p goke.UpdateParams, hook goke.TransformDocument) (goke.NodesMutationPayload, error) {
-	return self.updateMany(ctx, p, hook, math.MaxInt16)
-}
-
-func (self *FirestoreDatabaseFunctions) updateMany(ctx context.Context, p goke.UpdateParams, hook goke.TransformDocument, count int) (goke.NodesMutationPayload, error) {
+	if p.Limit == 0 {
+		p.Limit = math.MaxInt16
+	}
 	db, err := self.Init(ctx)
 	payload := goke.NodesMutationPayload{}
 	if err != nil {
@@ -126,7 +111,7 @@ func (self *FirestoreDatabaseFunctions) updateMany(ctx context.Context, p goke.U
 	iter := query.Documents(ctx)
 	defer iter.Stop()
 	// TODO use batching for firestore's updateMany
-	for payload.AffectedCount < count {
+	for payload.AffectedCount < p.Limit {
 		doc, err := iter.Next()
 		if err == iterator.Done {
 			break

src/mongodb/mongodb.go

@@ -102,67 +102,14 @@ func (self *MongodbDatabaseFunctions) InsertMany(ctx context.Context, p goke.Ins
 	}, nil
 }
 
-func (self *MongodbDatabaseFunctions) UpdateOne(ctx context.Context, p goke.UpdateParams, hook goke.TransformDocument) (goke.NodeMutationPayload, error) {
-	db, err := self.Init(ctx)
-	payload := goke.NodeMutationPayload{
-		Returning:     nil,
-		AffectedCount: 0,
-	}
-	if err != nil {
-		return payload, err
-	}
-
-	// TODO this step of checking could be skipped if there are no guards
-	nodes, err := self.FindMany(ctx, goke.FindManyParams{
-		Collection: p.Collection,
-		Limit:      1,
-		Where:      p.Where,
-	}, hook)
-	if err != nil {
-		return payload, err
-	}
-	if len(nodes) == 0 {
-		return payload, nil
-	}
-
-	// make sure we update the document we checked with the hook
-	where := goke.ExtendWhereMatch(
-		p.Where,
-		map[string]goke.Filter{
-			"_id": {
-				Eq: nodes[0]["_id"],
-			},
-		},
-	)
-	match := MakeMongodbMatch(where)
-
-	opts := options.FindOneAndUpdate()
-	opts.SetReturnDocument(options.After)
-	testutil.PrettyPrint(p)
-
-	res := db.Collection(p.Collection).FindOneAndUpdate(ctx, match, bson.M{"$set": p.Set}, opts)
-	if res.Err() == mongo.ErrNoDocuments {
-		println("no docs to update")
-		return payload, nil
-	} else if res.Err() != nil {
-		return payload, err
-	}
-	data := goke.Map{}
-	err = res.Decode(&data)
-	if err != nil {
-		return payload, err
-	}
-	return goke.NodeMutationPayload{
-		AffectedCount: 1,
-		Returning:     data,
-	}, nil
-}
-
 // first updateMany documents, then query again the documents and return them, all inside a transaction that prevents other writes happen before the query
 func (self *MongodbDatabaseFunctions) UpdateMany(ctx context.Context, p goke.UpdateParams, hook goke.TransformDocument) (goke.NodesMutationPayload, error) {
+	if p.Limit == 0 {
+		p.Limit = math.MaxInt16
+	}
 	db, err := self.Init(ctx)
 	payload := goke.NodesMutationPayload{
-		Returning:     nil,
+		Returning:     nil, // TODO maybe list should be allocated to not return null
 		AffectedCount: 0,
 	}
 	if err != nil {
@@ -191,7 +138,6 @@ func (self *MongodbDatabaseFunctions) UpdateMany(ctx context.Context, p goke.Upd
 
 		res := db.Collection(p.Collection).FindOneAndUpdate(ctx, match, bson.M{"$set": p.Set}, opts)
 		if res.Err() == mongo.ErrNoDocuments {
-			println("no docs to update")
 			return payload, nil
 		} else if res.Err() != nil {
 			return payload, err