Move DDL to "_schema" sub-path

Author: mpenick

cmd/server.go

@@ -15,9 +15,11 @@ import (
 	log2 "log"
 	"net/http"
 	"os"
+	"path"
 )
 
 const defaultGraphQLPath = "/graphql"
+const defaultGraphQLSchemaPath = "_schema" // Sub-path under graphql-path
 const defaultRESTPath = "/todo"
 
 // Environment variables prefixed with "ENDPOINT_" can override settings e.g. "ENDPOINT_HOSTS"
@@ -116,6 +118,7 @@ func Execute() {
 	// GraphQL specific flags
 	flags.Bool("start-graphql", true, "start the GraphQL endpoint")
 	flags.String("graphql-path", defaultGraphQLPath, "path for the GraphQL endpoint")
+	flags.String("graphql-schema-path", defaultGraphQLSchemaPath, "sub-path for the GraphQL schema management")
 	flags.Int("graphql-port", 8080, "port for the GraphQL endpoint")
 
 	// REST specific flags
@@ -154,13 +157,6 @@ func createEndpoint() *endpoint.DataEndpoint {
 		WithExcludedKeyspaces(viper.GetStringSlice("excluded-keyspaces")).
 		WithSchemaUpdateInterval(updateInterval)
 
-	supportedOps := viper.GetStringSlice("operations")
-	ops, err := config.Ops(supportedOps...)
-	if err != nil {
-		logger.Fatal("invalid supported operation", "operations", supportedOps, "error", err)
-	}
-	cfg.WithSupportedOperations(ops)
-
 	endpoint, err := cfg.NewEndpoint()
 	if err != nil {
 		logger.Fatal("unable create new endpoint",
@@ -175,12 +171,12 @@ func addGraphQLRoutes(router *httprouter.Router, endpoint *endpoint.DataEndpoint
 	var err error
 
 	singleKeyspace := viper.GetString("keyspace")
-	path := viper.GetString("graphql-path")
+	rootPath := viper.GetString("graphql-path")
 
 	if singleKeyspace != "" {
-		routes, err = endpoint.RoutesKeyspaceGraphQL(path, singleKeyspace)
+		routes, err = endpoint.RoutesKeyspaceGraphQL(rootPath, singleKeyspace)
 	} else {
-		routes, err = endpoint.RoutesGraphQL(path)
+		routes, err = endpoint.RoutesGraphQL(rootPath)
 	}
 
 	if err != nil {
@@ -191,6 +187,24 @@ func addGraphQLRoutes(router *httprouter.Router, endpoint *endpoint.DataEndpoint
 	for _, route := range routes {
 		router.Handler(route.Method, route.Pattern, route.Handler)
 	}
+
+	supportedOps := viper.GetStringSlice("operations")
+	ops, err := config.Ops(supportedOps...)
+	if err != nil {
+		logger.Fatal("invalid supported operation", "operations", supportedOps, "error", err)
+	}
+
+	routes, err = endpoint.RoutesSchemaManagementGraphQL(
+		path.Join(rootPath, viper.GetString("graphql-schema-path")), ops)
+
+	if err != nil {
+		logger.Fatal("unable to generate graphql schema routes",
+			"error", err)
+	}
+
+	for _, route := range routes {
+		router.Handler(route.Method, route.Pattern, route.Handler)
+	}
 }
 
 func addRESTRoutes(router *httprouter.Router, endpoint *endpoint.DataEndpoint) {

config/config.go

@@ -9,7 +9,6 @@ type Config interface {
 	ExcludedKeyspaces() []string
 	SchemaUpdateInterval() time.Duration
 	Naming() NamingConventionFn
-	SupportedOperations() Operations
 	UseUserOrRoleAuth() bool
 	Logger() log.Logger
 }

config/mocks.go

@@ -19,7 +19,6 @@ func (o *ConfigMock) Default() *ConfigMock {
 	o.On("ExcludedKeyspaces").Return([]string{"system"})
 	o.On("SchemaUpdateInterval").Return(10 * time.Second)
 	o.On("Naming").Return(NamingConventionFn(NewDefaultNaming))
-	o.On("SupportedOperations").Return(Operations(0))
 	o.On("UseUserOrRoleAuth").Return(false)
 	o.On("Logger").Return(log.NewZapLogger(zap.NewExample()))
 	return o
@@ -40,11 +39,6 @@ func (o *ConfigMock) Naming() NamingConventionFn {
 	return args.Get(0).(NamingConventionFn)
 }
 
-func (o *ConfigMock) SupportedOperations() Operations {
-	args := o.Called()
-	return args.Get(0).(Operations)
-}
-
 func (o *ConfigMock) UseUserOrRoleAuth() bool {
 	args := o.Called()
 	return args.Get(0).(bool)

config/operations.go renamed to config/schema_operations.go

@@ -4,28 +4,28 @@ import (
 	"fmt"
 )
 
-type Operations int
+type SchemaOperations int
 
 const (
-	TableCreate Operations = 1 << iota
+	TableCreate SchemaOperations = 1 << iota
 	TableDrop
 	TableAlterAdd
 	TableAlterDrop
 	KeyspaceCreate
 	KeyspaceDrop
 )
 
-func Ops(ops ...string) (Operations, error) {
-	var o Operations
+func Ops(ops ...string) (SchemaOperations, error) {
+	var o SchemaOperations
 	err := o.Add(ops...)
 	return o, err
 }
 
-func (o *Operations) Set(ops Operations) { *o |= ops; }
-func (o *Operations) Clear(ops Operations) { *o &= ^ops; }
-func (o Operations) IsSupported(ops Operations) bool { return o & ops != 0; }
+func (o *SchemaOperations) Set(ops SchemaOperations)             { *o |= ops; }
+func (o *SchemaOperations) Clear(ops SchemaOperations)           { *o &= ^ops; }
+func (o SchemaOperations) IsSupported(ops SchemaOperations) bool { return o & ops != 0; }
 
-func (o *Operations) Add(ops ...string) error {
+func (o *SchemaOperations) Add(ops ...string) error {
 	for _, op := range ops {
 		switch op {
 		case "TableCreate":

config/operations_test.go renamed to config/schema_operations_test.go

@@ -6,9 +6,9 @@ import (
 )
 
 func TestOperationsSetAndClear(t *testing.T) {
-	var op Operations
+	var op SchemaOperations
 
-	assert.Equal(t, op, Operations(0))
+	assert.Equal(t, op, SchemaOperations(0))
 	assert.False(t, op.IsSupported(TableCreate))
 
 	op.Set(TableCreate | TableDrop)
@@ -21,9 +21,9 @@ func TestOperationsSetAndClear(t *testing.T) {
 }
 
 func TestOperationsAdd(t *testing.T) {
-	var op Operations
+	var op SchemaOperations
 
-	assert.Equal(t, op, Operations(0))
+	assert.Equal(t, op, SchemaOperations(0))
 
 	op.Add("TableCreate", "TableDrop", "TableAlterAdd", "TableAlterDrop", "KeyspaceCreate", "KeyspaceDrop")
 	assert.True(t, op.IsSupported(TableCreate))

db/keyspace.go

@@ -14,7 +14,8 @@ func (db *Db) CreateKeyspace(name string, dcReplicas map[string]int, options *Qu
 		dcs += fmt.Sprintf("%s'%s': %d", comma, name, replicas)
 	}
 
-	query := fmt.Sprintf("CREATE KEYSPACE %s WITH REPLICATION  = { 'class': 'NetworkTopologyStrategy', %s }", name, dcs)
+	query := fmt.Sprintf("CREATE KEYSPACE %s WITH REPLICATION  = { 'class': 'NetworkTopologyStrategy', %s }",
+		Escape(name), dcs)
 
 	err := db.session.Execute(query, options)
 

db/table.go

@@ -67,7 +67,8 @@ func (db *Db) CreateTable(info *CreateTableInfo, options *QueryOptions) (bool, e
 		}
 	}
 
-	query := fmt.Sprintf("CREATE TABLE %s.%s (%sPRIMARY KEY (%s))", info.Keyspace, info.Table, columns, primaryKeys)
+	query := fmt.Sprintf("CREATE TABLE %s.%s (%sPRIMARY KEY (%s))",
+		Escape(info.Keyspace), Escape(info.Table), columns, primaryKeys)
 
 	if clusteringOrder != "" {
 		query += fmt.Sprintf(" WITH CLUSTERING ORDER BY (%s)", clusteringOrder)
@@ -78,7 +79,8 @@ func (db *Db) CreateTable(info *CreateTableInfo, options *QueryOptions) (bool, e
 }
 
 func (db *Db) AlterTableAdd(info *AlterTableAddInfo, options *QueryOptions) (bool, error) {
-	query := fmt.Sprintf("ALTER TABLE %s.%s ADD(", info.Keyspace, info.Table)
+	query := fmt.Sprintf("ALTER TABLE %s.%s ADD(",
+		Escape(info.Keyspace), Escape(info.Table))
 	for i, c := range info.ToAdd {
 		if i > 0 {
 			query += ", "
@@ -91,14 +93,16 @@ func (db *Db) AlterTableAdd(info *AlterTableAddInfo, options *QueryOptions) (boo
 }
 
 func (db *Db) AlterTableDrop(info *AlterTableDropInfo, options *QueryOptions) (bool, error) {
-	query := fmt.Sprintf("ALTER TABLE %s.%s DROP ", info.Keyspace, info.Table)
+	query := fmt.Sprintf("ALTER TABLE %s.%s DROP ",
+		Escape(info.Keyspace), Escape(info.Table))
 	query += strings.Join(info.ToDrop, ", ")
 	err := db.session.Execute(query, options)
 	return err == nil, err
 }
 
 func (db *Db) DropTable(info *DropTableInfo, options *QueryOptions) (bool, error) {
-	query := fmt.Sprintf("DROP TABLE %s.%s", info.Table, info.Keyspace)
+	query := fmt.Sprintf("DROP TABLE %s.%s",
+		Escape(info.Table), Escape(info.Keyspace))
 	err := db.session.Execute(query, options)
 	return err == nil, err
 }

db/utils.go

@@ -0,0 +1,97 @@
+package db
+
+import (
+	"strings"
+	"unicode/utf8"
+)
+
+var reservedKeywords =  map[string]bool{
+	"add": true,
+	"allow": true,
+	"alter": true,
+	"and": true,
+	"any": true,
+	"apply": true,
+	"asc": true,
+	"authorize": true,
+	"batch": true,
+	"begin": true,
+	"by": true,
+	"columnfamily": true,
+	"create": true,
+	"delete": true,
+	"desc": true,
+	"drop": true,
+	"each_quorum": true,
+	"from": true,
+	"grant": true,
+	"in": true,
+	"index": true,
+	"inet": true,
+	"infinity": true,
+	"insert": true,
+	"into": true,
+	"keyspace": true,
+	"keyspaces": true,
+	"limit": true,
+	"local_one": true,
+	"local_quorum": true,
+	"modify": true,
+	"nan": true,
+	"norecursive": true,
+	"of": true,
+	"on": true,
+	"one": true,
+	"order": true,
+	"password": true,
+	"primary": true,
+	"quorum": true,
+	"rename": true,
+	"revoke": true,
+	"schema": true,
+	"select": true,
+	"set": true,
+	"table": true,
+	"to": true,
+	"token": true,
+	"three": true,
+	"truncate": true,
+	"two": true,
+	"unlogged": true,
+	"update": true,
+	"use": true,
+	"using": true,
+	"where": true,
+	"with": true,
+}
+
+func Escape(id string) string {
+	if NeedsDoubleQuotes(id) {
+		return Quote(id)
+	}
+	return id
+}
+
+func Quote(s string) string {
+	return "\"" + s + "\""
+}
+
+func NeedsDoubleQuotes(s string) bool {
+	if s == "" {
+		return false
+	}
+	c, _ := utf8.DecodeRuneInString(s)
+	if !(c >= 'a' && c <= 'z') {
+		return true
+	}
+	for _, c = range s[1:] {
+		if !((c >= '0' && c <= '9') || (c == '_') || (c >= 'a' && c <= 'z')) {
+			return true
+		}
+	}
+	return IsReservedCQLKeyword(s)
+}
+
+func IsReservedCQLKeyword(s string) bool {
+	return reservedKeywords[strings.ToLower(s)]
+}

endpoint/endpoint.go

@@ -10,15 +10,17 @@ import (
 )
 
 const DefaultSchemaUpdateDuration = 10 * time.Second
+const DefaultSchemaManagementPath = "_schema"
 
 type DataEndpointConfig struct {
 	dbHosts           []string
 	dbUsername        string
 	dbPassword        string
 	ksExcluded        []string
+	managementPath    string
 	updateInterval    time.Duration
 	naming            config.NamingConventionFn
-	supportedOps      config.Operations
+	supportedOps      config.SchemaOperations
 	useUserOrRoleAuth bool
 	logger            log.Logger
 }
@@ -35,10 +37,6 @@ func (cfg DataEndpointConfig) Naming() config.NamingConventionFn {
 	return cfg.naming
 }
 
-func (cfg DataEndpointConfig) SupportedOperations() config.Operations {
-	return cfg.supportedOps
-}
-
 func (cfg DataEndpointConfig) UseUserOrRoleAuth() bool {
 	return cfg.useUserOrRoleAuth
 }
@@ -62,11 +60,6 @@ func (cfg *DataEndpointConfig) WithNaming(naming config.NamingConventionFn) *Dat
 	return cfg
 }
 
-func (cfg *DataEndpointConfig) WithSupportedOperations(supportedOps config.Operations) *DataEndpointConfig {
-	cfg.supportedOps = supportedOps
-	return cfg
-}
-
 func (cfg *DataEndpointConfig) WithUseUserOrRoleAuth(useUserOrRowAuth bool) *DataEndpointConfig {
 	cfg.useUserOrRoleAuth = useUserOrRowAuth
 	return cfg
@@ -124,3 +117,7 @@ func (e *DataEndpoint) RoutesGraphQL(pattern string) ([]graphql.Route, error) {
 func (e *DataEndpoint) RoutesKeyspaceGraphQL(pattern string, ksName string) ([]graphql.Route, error) {
 	return e.graphQLRouteGen.RoutesKeyspace(pattern, ksName)
 }
+
+func (e *DataEndpoint) RoutesSchemaManagementGraphQL(pattern string, ops config.SchemaOperations) ([]graphql.Route, error) {
+	return e.graphQLRouteGen.RoutesSchemaManagement(pattern, ops)
+}