feat: Allow users to add Views

cli/cli.go

@@ -63,6 +63,11 @@ func NewDefraCommand(cfg *config.Config) *cobra.Command {
 		schema_migrate,
 	)
 
+	view := MakeViewCommand()
+	view.AddCommand(
+		MakeViewAddCommand(),
+	)
+
 	index := MakeIndexCommand()
 	index.AddCommand(
 		MakeIndexCreateCommand(),
@@ -98,6 +103,7 @@ func NewDefraCommand(cfg *config.Config) *cobra.Command {
 		MakeDumpCommand(),
 		MakeRequestCommand(),
 		schema,
+		view,
 		index,
 		p2p,
 		backup,

cli/errors.go

@@ -27,6 +27,7 @@ var (
 	ErrNoLensConfig             = errors.New("lens config cannot be empty")
 	ErrInvalidLensConfig        = errors.New("invalid lens configuration")
 	ErrSchemaVersionNotOfSchema = errors.New(errSchemaVersionNotOfSchema)
+	ErrViewAddMissingArgs       = errors.New("please provide a base query and output SDL for this view")
 )
 
 func NewErrInvalidLensConfig(inner error) error {

cli/view.go

@@ -0,0 +1,25 @@
+// Copyright 2023 Democratized Data Foundation
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+package cli
+
+import (
+	"github.com/spf13/cobra"
+)
+
+func MakeViewCommand() *cobra.Command {
+	var cmd = &cobra.Command{
+		Use:   "view",
+		Short: "Manage views within a running DefraDB instance",
+		Long:  "Manage (add) views withing a running DefraDB instance",
+	}
+
+	return cmd
+}

cli/view_add.go

@@ -0,0 +1,43 @@
+// Copyright 2023 Democratized Data Foundation
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+package cli
+
+import "github.com/spf13/cobra"
+
+func MakeViewAddCommand() *cobra.Command {
+	var cmd = &cobra.Command{
+		Use:   "add [query] [sdl]",
+		Short: "Add new view",
+		Long: `Add new database view.
+
+Example: add from an argument string:
+  defradb client view add 'Foo { name, ...}' 'type Foo { ... }'
+
+Learn more about the DefraDB GraphQL Schema Language on https://docs.source.network.`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			store := mustGetStoreContext(cmd)
+
+			if len(args) != 2 {
+				return ErrViewAddMissingArgs
+			}
+
+			query := args[0]
+			sdl := args[1]
+
+			defs, err := store.AddView(cmd.Context(), query, sdl)
+			if err != nil {
+				return err
+			}
+			return writeJSON(cmd, defs)
+		},
+	}
+	return cmd
+}

client/db.go

@@ -123,6 +123,34 @@ type Store interface {
 	// It will return an error if the provided schema version ID does not exist.
 	SetDefaultSchemaVersion(context.Context, string) error
 
+	// AddView creates a new Defra View.
+	//
+	// It takes a GQL query string, for example:
+	//
+	// Author {
+	//	 name
+	//	 books {
+	//	   name
+	//	 }
+	// }
+	//
+	//
+	// A GQL SDL that matches its output type must also be provided.  There can only be one `type` declaration,
+	// any nested objects must be declared as embedded/schema-only types using the `interface` keyword.
+	// Relations must only be specified on the parent side of the relationship.  For example:
+	//
+	// type AuthorView {
+	//   name: String
+	//   books: [BookView]
+	// }
+	// interface BookView {
+	//   name: String
+	// }
+	//
+	// It will return the collection definitions of the types defined in the SDL if successful, otherwise an error
+	// will be returned.  This function does not execute the given query.
+	AddView(ctx context.Context, gqlQuery string, sdl string) ([]CollectionDefinition, error)
+
 	// SetMigration sets the migration for the given source-destination schema version IDs. Is equivalent to
 	// calling `LensRegistry().SetMigration(ctx, cfg)`.
 	//

client/descriptions.go

@@ -12,6 +12,8 @@ package client
 
 import (
 	"fmt"
+
+	"github.com/sourcenetwork/defradb/client/request"
 )
 
 // CollectionDescription describes a Collection and all its associated metadata.
@@ -30,6 +32,13 @@ type CollectionDescription struct {
 	// The ID of the schema version that this collection is at.
 	SchemaVersionID string
 
+	// BaseQuery contains the base query of this view, if this collection is a view.
+	//
+	// The query will be saved, and then may be accessed by other actors on demand.  Actor defined
+	// aggregates, filters and other logic (such as LensVM transforms) will execute on top of this
+	// base query before the result is returned to the actor.
+	BaseQuery *request.Select
+
 	// Indexes contains the secondary indexes that this Collection has.
 	Indexes []IndexDescription
 }

client/request/select.go

@@ -11,6 +11,8 @@
 package request
 
 import (
+	"encoding/json"
+
 	"github.com/sourcenetwork/immutable"
 )
 
@@ -107,3 +109,88 @@ func (s *Select) validateGroupBy() []error {
 
 	return result
 }
+
+// selectJson is a private object used for handling json deserialization
+// of `Select` objects.
+type selectJson struct {
+	Field
+	DocKeys     immutable.Option[[]string]
+	CID         immutable.Option[string]
+	Root        SelectionType
+	Limit       immutable.Option[uint64]
+	Offset      immutable.Option[uint64]
+	OrderBy     immutable.Option[OrderBy]
+	GroupBy     immutable.Option[GroupBy]
+	Filter      immutable.Option[Filter]
+	ShowDeleted bool
+
+	// Properties above this line match the `Select` object and
+	// are deserialized using the normal/default logic.
+	// Properties below this line require custom logic in `UnmarshalJSON`
+	// in order to be deserialized correctly.
+
+	Fields []map[string]json.RawMessage
+}
+
+func (s *Select) UnmarshalJSON(bytes []byte) error {
+	var selectMap selectJson
+	err := json.Unmarshal(bytes, &selectMap)
+	if err != nil {
+		return err
+	}
+
+	s.Field = selectMap.Field
+	s.DocKeys = selectMap.DocKeys
+	s.CID = selectMap.CID
+	s.Root = selectMap.Root
+	s.Limit = selectMap.Limit
+	s.Offset = selectMap.Offset
+	s.OrderBy = selectMap.OrderBy
+	s.GroupBy = selectMap.GroupBy
+	s.Filter = selectMap.Filter
+	s.ShowDeleted = selectMap.ShowDeleted
+	s.Fields = make([]Selection, len(selectMap.Fields))
+
+	for i, field := range selectMap.Fields {
+		fieldJson, err := json.Marshal(field)
+		if err != nil {
+			return err
+		}
+
+		var fieldValue Selection
+		// We detect which concrete type each `Selection` object is by detecting
+		// non-nillable fields, if the key is present it must be of that type.
+		// They must be non-nillable as nil values may have their keys omitted from
+		// the json. This also relies on the fields being unique.  We may wish to change
+		// this later to custom-serialize with a `_type` property.
+		if _, ok := field["Root"]; ok {
+			// This must be a Select, as only the `Select` type has a `Root` field
+			var fieldSelect Select
+			err := json.Unmarshal(fieldJson, &fieldSelect)
+			if err != nil {
+				return err
+			}
+			fieldValue = &fieldSelect
+		} else if _, ok := field["Targets"]; ok {
+			// This must be an Aggregate, as only the `Aggregate` type has a `Targets` field
+			var fieldAggregate Aggregate
+			err := json.Unmarshal(fieldJson, &fieldAggregate)
+			if err != nil {
+				return err
+			}
+			fieldValue = &fieldAggregate
+		} else {
+			// This must be a Field
+			var fieldField Field
+			err := json.Unmarshal(fieldJson, &fieldField)
+			if err != nil {
+				return err
+			}
+			fieldValue = &fieldField
+		}
+
+		s.Fields[i] = fieldValue
+	}
+
+	return nil
+}

db/errors.go

@@ -87,6 +87,7 @@ const (
 	errOneOneAlreadyLinked                string = "target document is already linked to another document"
 	errIndexDoesNotMatchName              string = "the index used does not match the given name"
 	errCanNotIndexNonUniqueField          string = "can not create doc that violates unique index"
+	errInvalidViewQuery                   string = "the query provided is not valid as a View"
 )
 
 var (
@@ -165,6 +166,7 @@ var (
 	ErrExpectedJSONArray                  = errors.New(errExpectedJSONArray)
 	ErrOneOneAlreadyLinked                = errors.New(errOneOneAlreadyLinked)
 	ErrIndexDoesNotMatchName              = errors.New(errIndexDoesNotMatchName)
+	ErrInvalidViewQuery                   = errors.New(errInvalidViewQuery)
 )
 
 // NewErrFieldOrAliasToFieldNotExist returns an error indicating that the given field or an alias field does not exist.
@@ -641,3 +643,18 @@ func NewErrCanNotIndexNonUniqueField(dockey, fieldName string, value any) error
 		errors.NewKV("Field value", value),
 	)
 }
+
+func NewErrInvalidViewQueryCastFailed(query string) error {
+	return errors.New(
+		errInvalidViewQuery,
+		errors.NewKV("Query", query),
+		errors.NewKV("Reason", "Internal errror, cast failed"),
+	)
+}
+
+func NewErrInvalidViewQueryMissingQuery() error {
+	return errors.New(
+		errInvalidViewQuery,
+		errors.NewKV("Reason", "No query provided"),
+	)
+}

db/txn_db.go

@@ -378,6 +378,30 @@ func (db *explicitTxnDB) SetMigration(ctx context.Context, cfg client.LensConfig
 	return db.lensRegistry.SetMigration(ctx, cfg)
 }
 
+func (db *implicitTxnDB) AddView(ctx context.Context, query string, sdl string) ([]client.CollectionDefinition, error) {
+	txn, err := db.NewTxn(ctx, false)
+	if err != nil {
+		return nil, err
+	}
+	defer txn.Discard(ctx)
+
+	defs, err := db.addView(ctx, txn, query, sdl)
+	if err != nil {
+		return nil, err
+	}
+
+	err = txn.Commit(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return defs, nil
+}
+
+func (db *explicitTxnDB) AddView(ctx context.Context, query string, sdl string) ([]client.CollectionDefinition, error) {
+	return db.addView(ctx, db.txn, query, sdl)
+}
+
 // BasicImport imports a json dataset.
 // filepath must be accessible to the node.
 func (db *implicitTxnDB) BasicImport(ctx context.Context, filepath string) error {