breaking change: hide native client inside client type

delete.go

@@ -6,37 +6,47 @@ import (
 	"cloud.google.com/go/datastore"
 )
 
+// DeleteByKey deletes data from datastore by Key
+func (c *Client) DeleteByKey(ctx context.Context, key *datastore.Key) error {
+	return c.c.Delete(ctx, key)
+}
+
+// DeleteByKeys deletes data from datastore by Keys
+func (c *Client) DeleteByKeys(ctx context.Context, keys []*datastore.Key) error {
+	return c.c.DeleteMulti(ctx, keys)
+}
+
 // DeleteByID deletes data from datastore by IDKey
-func (client *Client) DeleteByID(ctx context.Context, kind string, id int64) error {
+func (c *Client) DeleteByID(ctx context.Context, kind string, id int64) error {
 	if id == 0 {
 		return datastore.ErrInvalidKey
 	}
-	return client.Delete(ctx, datastore.IDKey(kind, id, nil))
+	return c.c.Delete(ctx, datastore.IDKey(kind, id, nil))
 }
 
 // DeleteByStringID deletes data from datastore by IDKey
-func (client *Client) DeleteByStringID(ctx context.Context, kind string, id string) error {
+func (c *Client) DeleteByStringID(ctx context.Context, kind string, id string) error {
 	tid := parseID(id)
 	if tid == 0 {
 		return datastore.ErrInvalidKey
 	}
-	return client.Delete(ctx, datastore.IDKey(kind, tid, nil))
+	return c.c.Delete(ctx, datastore.IDKey(kind, tid, nil))
 }
 
 // DeleteByIDs deletes data from datastore by IDKeys
-func (client *Client) DeleteByIDs(ctx context.Context, kind string, ids []int64) error {
+func (c *Client) DeleteByIDs(ctx context.Context, kind string, ids []int64) error {
 	keys := make([]*datastore.Key, len(ids))
 	for i, id := range ids {
 		if id == 0 {
 			return datastore.ErrInvalidKey
 		}
 		keys[i] = datastore.IDKey(kind, id, nil)
 	}
-	return client.DeleteMulti(ctx, keys)
+	return c.c.DeleteMulti(ctx, keys)
 }
 
 // DeleteByStringIDs deletes data from datastore by IDKeys
-func (client *Client) DeleteByStringIDs(ctx context.Context, kind string, ids []string) error {
+func (c *Client) DeleteByStringIDs(ctx context.Context, kind string, ids []string) error {
 	k := kind
 	keys := make([]*datastore.Key, len(ids))
 	for i, id := range ids {
@@ -46,43 +56,43 @@ func (client *Client) DeleteByStringIDs(ctx context.Context, kind string, ids []
 		}
 		keys[i] = datastore.IDKey(k, tid, nil)
 	}
-	return client.DeleteMulti(ctx, keys)
+	return c.c.DeleteMulti(ctx, keys)
 }
 
 // DeleteByName deletes data from datastore by NameKey
-func (client *Client) DeleteByName(ctx context.Context, kind string, name string) error {
+func (c *Client) DeleteByName(ctx context.Context, kind string, name string) error {
 	if len(name) == 0 {
 		return datastore.ErrInvalidKey
 	}
-	return client.Delete(ctx, datastore.NameKey(kind, name, nil))
+	return c.c.Delete(ctx, datastore.NameKey(kind, name, nil))
 }
 
 // DeleteByNames deletes data from datastore by NameKeys
-func (client *Client) DeleteByNames(ctx context.Context, kind string, names []string) error {
+func (c *Client) DeleteByNames(ctx context.Context, kind string, names []string) error {
 	keys := make([]*datastore.Key, len(names))
 	for i, name := range names {
 		if len(name) == 0 {
 			return datastore.ErrInvalidKey
 		}
 		keys[i] = datastore.NameKey(kind, name, nil)
 	}
-	return client.DeleteMulti(ctx, keys)
+	return c.c.DeleteMulti(ctx, keys)
 }
 
 // DeleteModel deletes data by get key from model
-func (client *Client) DeleteModel(ctx context.Context, src interface{}) error {
+func (c *Client) DeleteModel(ctx context.Context, src interface{}) error {
 	key := ExtractKey(src)
 	if key == nil {
 		return datastore.ErrInvalidKey
 	}
-	return client.Delete(ctx, key)
+	return c.c.Delete(ctx, key)
 }
 
 // DeleteModels deletes data by get keys from models
-func (client *Client) DeleteModels(ctx context.Context, src interface{}) error {
+func (c *Client) DeleteModels(ctx context.Context, src interface{}) error {
 	keys := ExtractKeys(src)
 	if len(keys) == 0 {
 		return datastore.ErrInvalidKey
 	}
-	return client.DeleteMulti(ctx, keys)
+	return c.c.DeleteMulti(ctx, keys)
 }

ds.go

@@ -10,7 +10,7 @@ import (
 
 // Client type
 type Client struct {
-	*datastore.Client
+	c *datastore.Client
 }
 
 // NewClient creates new ds client which wrap datastore client
@@ -19,5 +19,5 @@ func NewClient(ctx context.Context, projectID string, opts ...option.ClientOptio
 	if err != nil {
 		return nil, err
 	}
-	return &Client{Client: client}, nil
+	return &Client{c: client}, nil
 }

ds_test.go

@@ -82,5 +82,5 @@ func prepareData(client *Client) []*datastore.Key {
 
 func removeData(client *Client) {
 	keys, _ := client.QueryKeys(ctx, "Test")
-	client.DeleteMulti(ctx, keys)
+	client.DeleteByKeys(ctx, keys)
 }

get.go

@@ -8,8 +8,8 @@ import (
 )
 
 // GetByKey retrieves model from datastore by key
-func (client *Client) GetByKey(ctx context.Context, key *datastore.Key, dst interface{}) error {
-	err := client.Get(ctx, key, dst)
+func (c *Client) GetByKey(ctx context.Context, key *datastore.Key, dst interface{}) error {
+	err := c.c.Get(ctx, key, dst)
 	SetKey(key, dst)
 	if err != nil {
 		return err
@@ -18,7 +18,7 @@ func (client *Client) GetByKey(ctx context.Context, key *datastore.Key, dst inte
 }
 
 // GetByKeys retrieves models from datastore by keys
-func (client *Client) GetByKeys(ctx context.Context, keys []*datastore.Key, dst interface{}) error {
+func (c *Client) GetByKeys(ctx context.Context, keys []*datastore.Key, dst interface{}) error {
 	// prepare slice if dst is pointer to 0 len slice
 	if rf := reflect.ValueOf(dst); rf.Kind() == reflect.Ptr {
 		rs := rf.Elem()
@@ -29,7 +29,7 @@ func (client *Client) GetByKeys(ctx context.Context, keys []*datastore.Key, dst
 		dst = rs.Interface()
 	}
 
-	err := client.GetMulti(ctx, keys, dst)
+	err := c.c.GetMulti(ctx, keys, dst)
 	SetKeys(keys, dst)
 	if err != nil {
 		return err
@@ -38,57 +38,57 @@ func (client *Client) GetByKeys(ctx context.Context, keys []*datastore.Key, dst
 }
 
 // GetByModel retrieves model from datastore by key from model
-func (client *Client) GetByModel(ctx context.Context, dst interface{}) error {
+func (c *Client) GetByModel(ctx context.Context, dst interface{}) error {
 	key := ExtractKey(dst)
-	return client.GetByKey(ctx, key, dst)
+	return c.GetByKey(ctx, key, dst)
 }
 
 // GetByModels retrieves models from datastore by keys from models
-func (client *Client) GetByModels(ctx context.Context, dst interface{}) error {
+func (c *Client) GetByModels(ctx context.Context, dst interface{}) error {
 	keys := ExtractKeys(dst)
-	return client.GetByKeys(ctx, keys, dst)
+	return c.GetByKeys(ctx, keys, dst)
 }
 
 // GetByID retrieves model from datastore by id
-func (client *Client) GetByID(ctx context.Context, kind string, id int64, dst interface{}) error {
-	return client.GetByKey(ctx, datastore.IDKey(kind, id, nil), dst)
+func (c *Client) GetByID(ctx context.Context, kind string, id int64, dst interface{}) error {
+	return c.GetByKey(ctx, datastore.IDKey(kind, id, nil), dst)
 }
 
 // GetByIDs retrieves models from datastore by ids
-func (client *Client) GetByIDs(ctx context.Context, kind string, ids []int64, dst interface{}) error {
+func (c *Client) GetByIDs(ctx context.Context, kind string, ids []int64, dst interface{}) error {
 	keys := BuildIDKeys(kind, ids)
-	return client.GetByKeys(ctx, keys, dst)
+	return c.GetByKeys(ctx, keys, dst)
 }
 
 // GetByStringID retrieves model from datastore by string id
-func (client *Client) GetByStringID(ctx context.Context, kind string, id string, dst interface{}) error {
+func (c *Client) GetByStringID(ctx context.Context, kind string, id string, dst interface{}) error {
 	tid := parseID(id)
 	if tid == 0 {
 		return datastore.ErrInvalidKey
 	}
-	return client.GetByKey(ctx, datastore.IDKey(kind, tid, nil), dst)
+	return c.GetByKey(ctx, datastore.IDKey(kind, tid, nil), dst)
 }
 
 // GetByStringIDs retrieves models from datastore by string ids
-func (client *Client) GetByStringIDs(ctx context.Context, kind string, ids []string, dst interface{}) error {
+func (c *Client) GetByStringIDs(ctx context.Context, kind string, ids []string, dst interface{}) error {
 	keys := BuildStringIDKeys(kind, ids)
-	return client.GetByKeys(ctx, keys, dst)
+	return c.GetByKeys(ctx, keys, dst)
 }
 
 // GetByName retrieves model from datastore by name
-func (client *Client) GetByName(ctx context.Context, kind string, name string, dst interface{}) error {
-	return client.GetByKey(ctx, datastore.NameKey(kind, name, nil), dst)
+func (c *Client) GetByName(ctx context.Context, kind string, name string, dst interface{}) error {
+	return c.GetByKey(ctx, datastore.NameKey(kind, name, nil), dst)
 }
 
 // GetByNames retrieves models from datastore by names
-func (client *Client) GetByNames(ctx context.Context, kind string, names []string, dst interface{}) error {
+func (c *Client) GetByNames(ctx context.Context, kind string, names []string, dst interface{}) error {
 	keys := BuildNameKeys(kind, names)
-	return client.GetByKeys(ctx, keys, dst)
+	return c.GetByKeys(ctx, keys, dst)
 }
 
 // GetByQuery retrieves model from datastore by datastore query
-func (client *Client) GetByQuery(ctx context.Context, q *datastore.Query, dst interface{}) error {
-	_, err := client.GetAll(ctx, q, dst)
+func (c *Client) GetByQuery(ctx context.Context, q *datastore.Query, dst interface{}) error {
+	_, err := c.c.GetAll(ctx, q, dst)
 	if err != nil {
 		return err
 	}

id.go

@@ -61,12 +61,12 @@ func ExtractKeys(src interface{}) []*datastore.Key {
 }
 
 // AllocateIDModel allocates id for model
-func (client *Client) AllocateIDModel(ctx context.Context, kind string, src interface{}) error {
+func (c *Client) AllocateIDModel(ctx context.Context, kind string, src interface{}) error {
 	m := src.(KeyGetSetter)
 	if m.GetKey() == nil {
 		m.SetKey(datastore.IncompleteKey(kind, nil))
 	}
-	keys, err := client.AllocateIDs(ctx, []*datastore.Key{m.GetKey()})
+	keys, err := c.c.AllocateIDs(ctx, []*datastore.Key{m.GetKey()})
 	if err != nil {
 		return err
 	}
@@ -75,7 +75,7 @@ func (client *Client) AllocateIDModel(ctx context.Context, kind string, src inte
 }
 
 // AllocateIDModels allocates id for models
-func (client *Client) AllocateIDModels(ctx context.Context, kind string, src interface{}) error {
+func (c *Client) AllocateIDModels(ctx context.Context, kind string, src interface{}) error {
 	xs := valueOf(src)
 	keys := make([]*datastore.Key, xs.Len())
 	for i := range keys {
@@ -86,7 +86,7 @@ func (client *Client) AllocateIDModels(ctx context.Context, kind string, src int
 		}
 		keys[i] = x.(KeyGetter).GetKey()
 	}
-	keys, err := client.AllocateIDs(ctx, keys)
+	keys, err := c.c.AllocateIDs(ctx, keys)
 	if err != nil {
 		return err
 	}

put.go

@@ -7,21 +7,21 @@ import (
 )
 
 // PutModel puts a model to datastore
-func (client *Client) PutModel(ctx context.Context, src interface{}) error {
+func (c *Client) PutModel(ctx context.Context, src interface{}) error {
 	x := src.(KeyGetSetter)
-	_, err := client.Put(ctx, x.GetKey(), x)
+	_, err := c.c.Put(ctx, x.GetKey(), x)
 	return err
 }
 
 // PutModels puts models to datastore
-func (client *Client) PutModels(ctx context.Context, src interface{}) error {
+func (c *Client) PutModels(ctx context.Context, src interface{}) error {
 	xs := valueOf(src)
 	keys := make([]*datastore.Key, xs.Len())
 	for i := range keys {
 		x := xs.Index(i).Interface()
 		keys[i] = x.(KeyGetter).GetKey()
 	}
-	keys, err := client.PutMulti(ctx, keys, src)
+	keys, err := c.c.PutMulti(ctx, keys, src)
 	SetKeys(keys, src)
 	return err
 }

query.go

@@ -12,39 +12,39 @@ type Query func(q *datastore.Query) *datastore.Query
 
 // Query run Get All
 // dst is *[]*Model
-func (client *Client) Query(ctx context.Context, kind string, dst interface{}, qs ...Query) error {
+func (c *Client) Query(ctx context.Context, kind string, dst interface{}, qs ...Query) error {
 	q := prepareQuery(kind, qs)
-	_, err := client.GetAll(ctx, q, dst)
+	_, err := c.c.GetAll(ctx, q, dst)
 	if err != nil {
 		return err
 	}
 	return nil
 }
 
 // QueryFirst run Get to get the first result
-func (client *Client) QueryFirst(ctx context.Context, kind string, dst interface{}, qs ...Query) error {
+func (c *Client) QueryFirst(ctx context.Context, kind string, dst interface{}, qs ...Query) error {
 	q := prepareQuery(kind, qs)
-	_, err := client.Run(ctx, q).Next(dst)
+	_, err := c.c.Run(ctx, q).Next(dst)
 	if err != nil {
 		return err
 	}
 	return nil
 }
 
 // QueryKeys queries only key
-func (client *Client) QueryKeys(ctx context.Context, kind string, qs ...Query) ([]*datastore.Key, error) {
+func (c *Client) QueryKeys(ctx context.Context, kind string, qs ...Query) ([]*datastore.Key, error) {
 	q := prepareQuery(kind, qs).KeysOnly()
-	keys, err := client.GetAll(ctx, q, nil)
+	keys, err := c.c.GetAll(ctx, q, nil)
 	if err != nil {
 		return nil, err
 	}
 	return keys, nil
 }
 
 // QueryCount counts entity
-func (client *Client) QueryCount(ctx context.Context, kind string, qs ...Query) (int, error) {
+func (c *Client) QueryCount(ctx context.Context, kind string, qs ...Query) (int, error) {
 	q := prepareQuery(kind, qs)
-	return client.Count(ctx, q)
+	return c.c.Count(ctx, q)
 }
 
 // Query Helper functions

save.go

@@ -22,11 +22,11 @@ func beforeSave(src interface{}) {
 
 // SaveModel saves model to datastore
 // if key was not set in model, will call NewKey
-func (client *Client) SaveModel(ctx context.Context, src interface{}) error {
+func (c *Client) SaveModel(ctx context.Context, src interface{}) error {
 	beforeSave(src)
 
 	x := src.(KeyGetSetter)
-	key, err := client.Put(ctx, x.GetKey(), x)
+	key, err := c.c.Put(ctx, x.GetKey(), x)
 	x.SetKey(key)
 	if err != nil {
 		return err
@@ -36,13 +36,13 @@ func (client *Client) SaveModel(ctx context.Context, src interface{}) error {
 
 // SaveModels saves models to datastore
 // see more in SaveModel
-func (client *Client) SaveModels(ctx context.Context, src interface{}) error {
+func (c *Client) SaveModels(ctx context.Context, src interface{}) error {
 	xs := valueOf(src)
 	for i := 0; i < xs.Len(); i++ {
 		x := xs.Index(i).Interface()
 		beforeSave(x)
 	}
-	err := client.PutModels(ctx, src)
+	err := c.PutModels(ctx, src)
 	if err != nil {
 		return err
 	}

tx.go

@@ -13,8 +13,8 @@ type Tx struct {
 }
 
 // RunInTx is the RunInTransaction wrapper
-func (client *Client) RunInTx(ctx context.Context, f func(tx *Tx) error, opts ...datastore.TransactionOption) (*datastore.Commit, error) {
-	return client.RunInTransaction(ctx, func(t *datastore.Transaction) error {
+func (c *Client) RunInTx(ctx context.Context, f func(tx *Tx) error, opts ...datastore.TransactionOption) (*datastore.Commit, error) {
+	return c.c.RunInTransaction(ctx, func(t *datastore.Transaction) error {
 		return f(&Tx{t})
 	})
 }