refactor: Conceptually clarify schema vs query-language (#924)

* Conceptually split up query-language from schema

A later commit will remove this function from the Parser type, so please dont comment on that :) Performance is not an issue here either, so the wastage is not really an issue in the short/medium-term

* Remove schema definition from parser

core/parser.go

@@ -27,14 +27,6 @@ type SchemaDefinition struct {
 	Body []byte
 }
 
-type Schema struct {
-	// The individual declarations of types defined by this schema.
-	Definitions []SchemaDefinition
-
-	// The collection descriptions created from/defined by this schema.
-	Descriptions []client.CollectionDescription
-}
-
 // Parser represents the object responsible for handling stuff specific to
 // a query language.  This includes schema and query parsing, and introspection.
 type Parser interface {
@@ -48,5 +40,5 @@ type Parser interface {
 	Parse(request string) (*request.Request, []error)
 
 	// Adds the given schema to this parser's model.
-	AddSchema(ctx context.Context, schema string) (*Schema, error)
+	AddSchema(ctx context.Context, schema string) error
 }

db/schema.go

@@ -13,26 +13,34 @@ package db
 import (
 	"context"
 
+	"github.com/graphql-go/graphql/language/ast"
 	dsq "github.com/ipfs/go-datastore/query"
 
+	"github.com/sourcenetwork/defradb/client"
 	"github.com/sourcenetwork/defradb/core"
+	"github.com/sourcenetwork/defradb/query/graphql/schema"
 )
 
 // LoadSchema takes the provided schema in SDL format, and applies it to the database,
 // and creates the necessary collections, query types, etc.
 func (db *db) AddSchema(ctx context.Context, schemaString string) error {
-	schema, err := db.parser.AddSchema(ctx, schemaString)
+	err := db.parser.AddSchema(ctx, schemaString)
 	if err != nil {
 		return err
 	}
 
-	for _, desc := range schema.Descriptions {
+	collectionDescriptions, schemaDefinitions, err := createDescriptions(ctx, schemaString)
+	if err != nil {
+		return err
+	}
+
+	for _, desc := range collectionDescriptions {
 		if _, err := db.CreateCollection(ctx, desc); err != nil {
 			return err
 		}
 	}
 
-	return db.saveSchema(ctx, schema)
+	return db.saveSchema(ctx, schemaDefinitions)
 }
 
 func (db *db) loadSchema(ctx context.Context) error {
@@ -50,17 +58,53 @@ func (db *db) loadSchema(ctx context.Context) error {
 		sdl += "\n" + string(buf)
 	}
 
-	_, err = db.parser.AddSchema(ctx, sdl)
-	return err
+	return db.parser.AddSchema(ctx, sdl)
 }
 
-func (db *db) saveSchema(ctx context.Context, schema *core.Schema) error {
+func (db *db) saveSchema(ctx context.Context, schemaDefinitions []core.SchemaDefinition) error {
 	// save each type individually
-	for _, def := range schema.Definitions {
+	for _, def := range schemaDefinitions {
 		key := core.NewSchemaKey(def.Name)
 		if err := db.systemstore().Put(ctx, key.ToDS(), def.Body); err != nil {
 			return err
 		}
 	}
 	return nil
 }
+
+func createDescriptions(
+	ctx context.Context,
+	schemaString string,
+) ([]client.CollectionDescription, []core.SchemaDefinition, error) {
+	// We should not be using this package at all here, and should not be doing most of what this package does
+	// Rework: https://github.com/sourcenetwork/defradb/issues/923
+	schemaManager, err := schema.NewSchemaManager()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	types, astdoc, err := schemaManager.Generator.FromSDL(ctx, schemaString)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	colDesc, err := schemaManager.Generator.CreateDescriptions(types)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	definitions := make([]core.SchemaDefinition, len(astdoc.Definitions))
+	for i, astDefinition := range astdoc.Definitions {
+		objDef, isObjDef := astDefinition.(*ast.ObjectDefinition)
+		if !isObjDef {
+			continue
+		}
+
+		definitions[i] = core.SchemaDefinition{
+			Name: objDef.Name.Value,
+			Body: objDef.Loc.Source.Body[objDef.Loc.Start:objDef.Loc.End],
+		}
+	}
+
+	return colDesc, definitions, nil
+}

query/graphql/parser.go

@@ -21,7 +21,6 @@ import (
 	"github.com/sourcenetwork/defradb/query/graphql/schema"
 
 	gql "github.com/graphql-go/graphql"
-	"github.com/graphql-go/graphql/language/ast"
 	gqlp "github.com/graphql-go/graphql/language/parser"
 	"github.com/graphql-go/graphql/language/source"
 )
@@ -96,32 +95,7 @@ func (p *parser) Parse(request string) (*request.Request, []error) {
 	return query, nil
 }
 
-func (p *parser) AddSchema(ctx context.Context, schema string) (*core.Schema, error) {
-	types, astdoc, err := p.schemaManager.Generator.FromSDL(ctx, schema)
-	if err != nil {
-		return nil, err
-	}
-
-	colDesc, err := p.schemaManager.Generator.CreateDescriptions(types)
-	if err != nil {
-		return nil, err
-	}
-
-	definitions := make([]core.SchemaDefinition, len(astdoc.Definitions))
-	for i, astDefinition := range astdoc.Definitions {
-		objDef, isObjDef := astDefinition.(*ast.ObjectDefinition)
-		if !isObjDef {
-			continue
-		}
-
-		definitions[i] = core.SchemaDefinition{
-			Name: objDef.Name.Value,
-			Body: objDef.Loc.Source.Body[objDef.Loc.Start:objDef.Loc.End],
-		}
-	}
-
-	return &core.Schema{
-		Definitions:  definitions,
-		Descriptions: colDesc,
-	}, nil
+func (p *parser) AddSchema(ctx context.Context, schema string) error {
+	_, _, err := p.schemaManager.Generator.FromSDL(ctx, schema)
+	return err
 }

tests/bench/query/planner/utils.go

@@ -97,7 +97,7 @@ func buildParser(
 	if err != nil {
 		return nil, err
 	}
-	_, err = parser.AddSchema(ctx, schema)
+	err = parser.AddSchema(ctx, schema)
 	if err != nil {
 		return nil, err
 	}