Prototype

.gitignore

@@ -1,9 +1,13 @@
+.idea
+.DS_Store
+
 # Binaries for programs and plugins
 *.exe
 *.exe~
 *.dll
 *.so
 *.dylib
+data-endpoints
 
 # Test binary, built with `go test -c`
 *.test

config/naming.go

@@ -0,0 +1,58 @@
+package config
+
+import "github.com/iancoleman/strcase"
+
+type NamingConvention interface {
+	// ToCQLColumn converts a GraphQL/REST name to a CQL column name.
+	ToCQLColumn(name string) string
+
+	// ToCQLColumn converts a GraphQL/REST name to a CQL table name.
+	ToCQLTable(name string) string
+
+	// ToGraphQLField converts a CQL name (typically a column name) to a GraphQL field name.
+	ToGraphQLField(name string) string
+
+	// ToGraphQLOperation converts a CQL name (typically a table name) to a GraphQL operation name.
+	ToGraphQLOperation(prefix string, name string) string
+
+	// ToGraphQLType converts a CQL name (typically a table name) to a GraphQL type name.
+	ToGraphQLType(name string) string
+
+	// ToGraphQLEnumValue converts a CQL name to a GraphQL enumeration value name.
+	ToGraphQLEnumValue(name string) string
+}
+
+type defaultNaming struct{}
+
+// Default naming implementation.
+var DefaultNaming = &defaultNaming{}
+
+func (n *defaultNaming) ToCQLColumn(name string) string {
+	// TODO: Fix numbers: "Table2" or "table2" --> "table_2"
+	return strcase.ToSnake(name)
+}
+
+func (n *defaultNaming) ToCQLTable(name string) string {
+	// TODO: Fix numbers: "Table2" or "table2" --> "table_2"
+	return strcase.ToSnake(name)
+}
+
+func (n *defaultNaming) ToGraphQLField(name string) string {
+	return strcase.ToLowerCamel(name)
+}
+
+func (n *defaultNaming) ToGraphQLOperation(prefix string, name string) string {
+	if prefix == "" {
+		return strcase.ToLowerCamel(name)
+	} else {
+		return strcase.ToLowerCamel(prefix) + strcase.ToCamel(name)
+	}
+}
+
+func (n *defaultNaming) ToGraphQLType(name string) string {
+	return strcase.ToCamel(name)
+}
+
+func (n *defaultNaming) ToGraphQLEnumValue(name string) string {
+	return strcase.ToCamel(name)
+}

data.json

@@ -0,0 +1,14 @@
+{
+  "1": {
+    "id": "1",
+    "name": "Dan"
+  },
+  "2": {
+    "id": "2",
+    "name": "Lee"
+  },
+  "3": {
+    "id": "3",
+    "name": "Nick"
+  }
+}

db/db.go

@@ -0,0 +1,56 @@
+package db
+
+import (
+	"github.com/gocql/gocql"
+)
+
+// Db represents a connection to a db
+type Db struct {
+	session DbSession
+}
+
+// NewDb Gets a pointer to a db
+func NewDb(username string, password string, hosts ...string) (*Db, error) {
+	cluster := gocql.NewCluster(hosts...)
+
+	if username != "" && password != "" {
+		cluster.Authenticator = gocql.PasswordAuthenticator{
+			Username: username,
+			Password: password,
+		}
+	}
+
+	var (
+		session *gocql.Session
+		err     error
+	)
+
+	if session, err = cluster.CreateSession(); err != nil {
+		return nil, err
+	}
+
+	return &Db{
+		session: &GoCqlSession{ref: session},
+	}, nil
+}
+
+// Keyspace Retrieves a keyspace
+func (db *Db) Keyspace(keyspace string) (*gocql.KeyspaceMetadata, error) {
+	// We expose gocql types for now, we should wrap them in the future instead
+	return db.session.KeyspaceMetadata(keyspace)
+}
+
+// Keyspaces Retrieves all the keyspace names
+func (db *Db) Keyspaces() ([]string, error) {
+	iter, err := db.session.ExecuteIter("SELECT keyspace_name FROM system_schema.keyspaces", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	var keyspaces []string
+	for _, row := range iter.Values() {
+		keyspaces = append(keyspaces, *row["keyspace_name"].(*string))
+	}
+
+	return keyspaces, nil
+}

db/db_session.go

@@ -0,0 +1,114 @@
+package db
+
+import (
+	"encoding/hex"
+	"github.com/gocql/gocql"
+)
+
+type QueryOptions struct {
+	UserOrRole  string
+	Consistency gocql.Consistency
+}
+
+func NewQueryOptions() *QueryOptions {
+	return &QueryOptions{
+		Consistency: gocql.LocalOne,
+	}
+}
+
+func (q *QueryOptions) WithUserOrRole(userOrRole string) *QueryOptions {
+	q.UserOrRole = userOrRole
+	return q
+}
+
+func (q *QueryOptions) WithConsistency(userOrRole string) *QueryOptions {
+	q.UserOrRole = userOrRole
+	return q
+}
+
+type DbSession interface {
+	// Execute executes a statement without returning row results
+	Execute(query string, options *QueryOptions, values ...interface{}) error
+
+	// ExecuteIterSimple executes a statement and returns iterator to the result set
+	ExecuteIter(query string, options *QueryOptions, values ...interface{}) (ResultSet, error)
+
+	//TODO: Extract metadata methods from interface into another interface
+	KeyspaceMetadata(keyspaceName string) (*gocql.KeyspaceMetadata, error)
+}
+
+type ResultSet interface {
+	PageState() string
+	Values() []map[string]interface{}
+}
+
+func (r *goCqlResultIterator) PageState() string {
+	return hex.EncodeToString(r.pageState)
+}
+
+func (r *goCqlResultIterator) Values() []map[string]interface{} {
+	return r.values
+}
+
+type goCqlResultIterator struct {
+	pageState []byte
+	values    []map[string]interface{}
+}
+
+func newResultIterator(iter *gocql.Iter) (*goCqlResultIterator, error) {
+	columns := iter.Columns()
+	scanner := iter.Scanner()
+
+	items := make([]map[string]interface{}, 0)
+
+	for scanner.Next() {
+		row, err := mapScan(scanner, columns)
+		if err != nil {
+			return nil, err
+		}
+		items = append(items, row)
+	}
+
+	if err := iter.Close(); err != nil {
+		return nil, err
+	}
+
+	return &goCqlResultIterator{
+		pageState: iter.PageState(),
+		values:    items,
+	}, nil
+}
+
+type GoCqlSession struct {
+	ref *gocql.Session
+}
+
+func (db *Db) Execute(query string, options *QueryOptions, values ...interface{}) (ResultSet, error) {
+	return db.session.ExecuteIter(query, options, values...)
+}
+
+func (db *Db) ExecuteNoResult(query string, options *QueryOptions, values ...interface{}) error {
+	return db.session.Execute(query, options, values)
+}
+
+func (session *GoCqlSession) Execute(query string, options *QueryOptions, values ...interface{}) error {
+	_, err := session.ExecuteIter(query, options, values...)
+	return err
+}
+
+func (session *GoCqlSession) ExecuteIter(query string, options *QueryOptions, values ...interface{}) (ResultSet, error) {
+	q := session.ref.Query(query, values...)
+	if options != nil {
+		q.Consistency(options.Consistency)
+		if options.UserOrRole != "" {
+			q.CustomPayload(map[string][]byte{
+				"ProxyExecute": []byte(options.UserOrRole),
+			})
+		}
+	}
+	return newResultIterator(q.Iter())
+}
+
+func (session *GoCqlSession) KeyspaceMetadata(keyspaceName string) (*gocql.KeyspaceMetadata, error) {
+	return session.ref.KeyspaceMetadata(keyspaceName)
+}

db/keyspace.go

@@ -0,0 +1,31 @@
+package db
+
+import (
+	"fmt"
+)
+
+func (db *Db) CreateKeyspace(name string, dcReplicas map[string]int, options *QueryOptions) (bool, error) {
+	// TODO: Escape keyspace datacenter names?
+	dcs := ""
+	for name, replicas := range dcReplicas {
+		comma := ""
+		if len(dcs) > 0 {
+			comma = " ,"
+		}
+		dcs += fmt.Sprintf("%s'%s': %d", comma, name, replicas)
+	}
+
+	query := fmt.Sprintf("CREATE KEYSPACE %s WITH REPLICATION  = { 'class': 'NetworkTopologyStrategy', %s }", name, dcs)
+
+	err := db.session.Execute(query, options)
+
+	return err == nil, err
+}
+
+func (db *Db) DropKeyspace(name string, options *QueryOptions) (bool, error) {
+	// TODO: Escape keyspace name?
+	query := fmt.Sprintf("DROP KEYSPACE %s", name)
+	err := db.session.Execute(query, options)
+
+	return err == nil, err
+}