MetzNet
/
graphvent
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Cleaned up GQL context

graph-rework-2
noah metz 2023-07-10 21:15:01 -06:00
parent a9431ecf73
commit e12d02eb3f
3 changed files with 135 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

209
context.go
Unescape Escape View File

@ -19,12 +19,16 @@ type NodeLoadFunc func(*Context, NodeID, []byte, NodeMap)(Node, error)
type NodeDef struct {
Load NodeLoadFunc
Type NodeType
GQLType *graphql.Object
Reflect reflect.Type
}
func NewNodeDef(type_name string, load_func NodeLoadFunc) NodeDef {
func NewNodeDef(type_name string, reflect reflect.Type, load_func NodeLoadFunc, gql_type *graphql.Object) NodeDef {
return NodeDef{
Type: NodeType(type_name),
Load: load_func,
GQLType: gql_type,
Reflect: reflect,
}
}
@ -32,181 +36,158 @@ type Context struct {
DB * badger.DB
Log Logger
Types map[uint64]NodeDef
GQL * GQLContext
GQL GQLContext
}
func (ctx * Context) RegisterNodeType(type_name string, load_func NodeLoadFunc) error {
if load_func == nil {
return fmt.Errorf("Cannot register a node without a load function")
}
def := NodeDef{
Type: NodeType(type_name),
Load: load_func,
func (ctx * Context) RebuildSchema() error {
schemaConfig := graphql.SchemaConfig{
Types: ctx.GQL.TypeList,
Query: ctx.GQL.Query,
Mutation: ctx.GQL.Mutation,
Subscription: ctx.GQL.Subscription,
}
type_hash := def.Type.Hash()
_, exists := ctx.Types[type_hash]
if exists == true {
return fmt.Errorf("Cannot register node of type %s, type already exists in context", type_name)
schema, err := graphql.NewSchema(schemaConfig)
if err != nil {
return err
}
ctx.Types[type_hash] = def
ctx.GQL.Schema = schema
return nil
}
type TypeList []graphql.Type
type ObjTypeMap map[reflect.Type]*graphql.Object
type FieldMap map[string]*graphql.Field
type GQLContext struct {
Schema graphql.Schema
ValidNodes ObjTypeMap
NodeType reflect.Type
ValidLockables ObjTypeMap
LockableType reflect.Type
ValidThreads ObjTypeMap
ThreadType reflect.Type
func (ctx * Context) AddGQLType(gql_type graphql.Type) {
ctx.GQL.TypeList = append(ctx.GQL.TypeList, gql_type)
}
func NewGQLContext(additional_types TypeList, extended_types ObjTypeMap, extended_queries FieldMap, extended_subscriptions FieldMap, extended_mutations FieldMap) (*GQLContext, error) {
type_list := TypeList{
GQLTypeSignalInput(),
func (ctx * Context) RegisterNodeType(def NodeDef) error {
if def.Load == nil {
return fmt.Errorf("Cannot register a node without a load function: %s", def.Type)
}
for _, gql_type := range(additional_types) {
type_list = append(type_list, gql_type)
if def.Reflect == nil {
return fmt.Errorf("Cannot register a node without a reflect type: %s", def.Type)
}
type_map := ObjTypeMap{}
type_map[reflect.TypeOf((*GraphNode)(nil))] = GQLTypeBaseNode()
type_map[reflect.TypeOf((*SimpleLockable)(nil))] = GQLTypeBaseLockable()
type_map[reflect.TypeOf((*SimpleThread)(nil))] = GQLTypeBaseThread()
type_map[reflect.TypeOf((*GQLThread)(nil))] = GQLTypeGQLThread()
type_map[reflect.TypeOf((*BaseSignal)(nil))] = GQLTypeSignal()
for go_t, gql_t := range(extended_types) {
type_map[go_t] = gql_t
if def.GQLType == nil {
return fmt.Errorf("Cannot register a node without a gql type: %s", def.Type)
}
valid_nodes := ObjTypeMap{}
valid_lockables := ObjTypeMap{}
valid_threads := ObjTypeMap{}
type_hash := def.Type.Hash()
_, exists := ctx.Types[type_hash]
if exists == true {
return fmt.Errorf("Cannot register node of type %s, type already exists in context", def.Type)
}
node_type := reflect.TypeOf((*Node)(nil)).Elem()
lockable_type := reflect.TypeOf((*Lockable)(nil)).Elem()
thread_type := reflect.TypeOf((*Thread)(nil)).Elem()
ctx.Types[type_hash] = def
for go_t, gql_t := range(type_map) {
if go_t.Implements(node_type) {
valid_nodes[go_t] = gql_t
}
if go_t.Implements(lockable_type) {
valid_lockables[go_t] = gql_t
if def.Reflect.Implements(ctx.GQL.NodeType) {
ctx.GQL.ValidNodes[def.Reflect] = def.GQLType
}
if go_t.Implements(thread_type) {
valid_threads[go_t] = gql_t
if def.Reflect.Implements(ctx.GQL.LockableType) {
ctx.GQL.ValidLockables[def.Reflect] = def.GQLType
}
type_list = append(type_list, gql_t)
if def.Reflect.Implements(ctx.GQL.ThreadType) {
ctx.GQL.ValidThreads[def.Reflect] = def.GQLType
}
ctx.GQL.TypeList = append(ctx.GQL.TypeList, def.GQLType)
queries := graphql.Fields{
"Self": GQLQuerySelf(),
return nil
}
for key, val := range(extended_queries) {
queries[key] = val
}
type TypeList []graphql.Type
type ObjTypeMap map[reflect.Type]*graphql.Object
type FieldMap map[string]*graphql.Field
subscriptions := graphql.Fields{
"Update": GQLSubscriptionUpdate(),
"Self": GQLSubscriptionSelf(),
}
type GQLContext struct {
Schema graphql.Schema
for key, val := range(extended_subscriptions) {
subscriptions[key] = val
}
NodeType reflect.Type
LockableType reflect.Type
ThreadType reflect.Type
mutations := graphql.Fields{
"SendUpdate": GQLMutationSendUpdate(),
}
TypeList TypeList
for key, val := range(extended_mutations) {
mutations[key] = val
ValidNodes ObjTypeMap
ValidLockables ObjTypeMap
ValidThreads ObjTypeMap
Query *graphql.Object
Mutation *graphql.Object
Subscription *graphql.Object
}
schemaConfig := graphql.SchemaConfig{
Types: type_list,
Query: graphql.NewObject(graphql.ObjectConfig{
func NewGQLContext() GQLContext {
query := graphql.NewObject(graphql.ObjectConfig{
Name: "Query",
Fields: queries,
}),
Mutation: graphql.NewObject(graphql.ObjectConfig{
Fields: graphql.Fields{},
})
mutation := graphql.NewObject(graphql.ObjectConfig{
Name: "Mutation",
Fields: mutations,
}),
Subscription: graphql.NewObject(graphql.ObjectConfig{
Name: "Subscription",
Fields: subscriptions,
}),
}
Fields: graphql.Fields{},
})
schema, err := graphql.NewSchema(schemaConfig)
if err != nil{
return nil, err
}
subscription := graphql.NewObject(graphql.ObjectConfig{
Name: "Subscription",
Fields: graphql.Fields{},
})
ctx := GQLContext{
Schema: schema,
ValidNodes: valid_nodes,
NodeType: node_type,
ValidThreads: valid_threads,
ThreadType: thread_type,
ValidLockables: valid_lockables,
LockableType: lockable_type,
Schema: graphql.Schema{},
TypeList: TypeList{},
ValidNodes: ObjTypeMap{},
NodeType: reflect.TypeOf((*Node)(nil)).Elem(),
ValidThreads: ObjTypeMap{},
ThreadType: reflect.TypeOf((*Thread)(nil)).Elem(),
ValidLockables: ObjTypeMap{},
LockableType: reflect.TypeOf((*Lockable)(nil)).Elem(),
Query: query,
Mutation: mutation,
Subscription: subscription,
}
return &ctx, nil
}
func NewContext(db * badger.DB, log Logger, extra_nodes map[string]NodeLoadFunc, types TypeList, type_map ObjTypeMap, queries FieldMap, subscriptions FieldMap, mutations FieldMap) * Context {
gql, err := NewGQLContext(types, type_map, queries, subscriptions, mutations)
if err != nil {
panic(err)
return ctx
}
func NewContext(db * badger.DB, log Logger) * Context {
ctx := &Context{
GQL: gql,
GQL: NewGQLContext(),
DB: db,
Log: log,
Types: map[uint64]NodeDef{},
}
err = ctx.RegisterNodeType("graph_node", LoadGraphNode)
err := ctx.RegisterNodeType(NewNodeDef("graph_node", reflect.TypeOf((*GraphNode)(nil)), LoadGraphNode, GQLTypeGraphNode()))
if err != nil {
panic(err)
}
err = ctx.RegisterNodeType("simple_lockable", LoadSimpleLockable)
err = ctx.RegisterNodeType(NewNodeDef("simple_lockable", reflect.TypeOf((*SimpleLockable)(nil)), LoadSimpleLockable, GQLTypeSimpleLockable()))
if err != nil {
panic(err)
}
err = ctx.RegisterNodeType("simple_thread", LoadSimpleThread)
err = ctx.RegisterNodeType(NewNodeDef("simple_thread", reflect.TypeOf((*SimpleThread)(nil)), LoadSimpleThread, GQLTypeSimpleThread()))
if err != nil {
panic(err)
}
err = ctx.RegisterNodeType("gql_thread", LoadGQLThread)
err = ctx.RegisterNodeType(NewNodeDef("gql_thread", reflect.TypeOf((*GQLThread)(nil)), LoadGQLThread, GQLTypeGQLThread()))
if err != nil {
panic(err)
}
for name, load_fn := range(extra_nodes) {
err := ctx.RegisterNodeType(name, load_fn)
ctx.AddGQLType(GQLTypeSignal())
ctx.GQL.Query.AddFieldConfig("Self", GQLQuerySelf())
ctx.GQL.Subscription.AddFieldConfig("Update", GQLSubscriptionUpdate())
ctx.GQL.Subscription.AddFieldConfig("Self", GQLSubscriptionSelf())
ctx.GQL.Mutation.AddFieldConfig("SendUpdate", GQLMutationSendUpdate())
err = ctx.RebuildSchema()
if err != nil {
panic(err)
}
}
return ctx
}

64
gql_graph.go
Unescape Escape View File

@ -28,7 +28,7 @@ func GQLInterfaceNode() *graphql.Interface {
}
if p_type.Implements(node_type) {
return GQLTypeBaseNode()
return GQLTypeGraphNode()
}
return nil
@ -74,7 +74,7 @@ func GQLInterfaceThread() *graphql.Interface {
}
if p_type.Implements(thread_type) {
return GQLTypeBaseThread()
return GQLTypeSimpleThread()
}
ctx.Log.Logf("gql", "Found no type that matches %+v: %+v", p_type, p_type.Implements(thread_type))
@ -145,7 +145,7 @@ func GQLInterfaceLockable() *graphql.Interface {
}
if p_type.Implements(lockable_type) {
return GQLTypeBaseLockable()
return GQLTypeSimpleLockable()
}
return nil
},
@ -418,10 +418,10 @@ func GQLTypeGQLThread() * graphql.Object {
return gql_type_gql_thread
}
var gql_type_base_thread *graphql.Object = nil
func GQLTypeBaseThread() * graphql.Object {
if gql_type_base_thread == nil {
gql_type_base_thread = graphql.NewObject(graphql.ObjectConfig{
var gql_type_simple_thread *graphql.Object = nil
func GQLTypeSimpleThread() * graphql.Object {
if gql_type_simple_thread == nil {
gql_type_simple_thread = graphql.NewObject(graphql.ObjectConfig{
Name: "BaseThread",
Interfaces: []*graphql.Interface{
GQLInterfaceNode(),
@ -446,48 +446,48 @@ func GQLTypeBaseThread() * graphql.Object {
},
Fields: graphql.Fields{},
})
gql_type_base_thread.AddFieldConfig("ID", &graphql.Field{
gql_type_simple_thread.AddFieldConfig("ID", &graphql.Field{
Type: graphql.String,
Resolve: GQLNodeID,
})
gql_type_base_thread.AddFieldConfig("Name", &graphql.Field{
gql_type_simple_thread.AddFieldConfig("Name", &graphql.Field{
Type: graphql.String,
Resolve: GQLLockableName,
})
gql_type_base_thread.AddFieldConfig("Children", &graphql.Field{
gql_type_simple_thread.AddFieldConfig("Children", &graphql.Field{
Type: GQLListThread(),
Resolve: GQLThreadChildren,
})
gql_type_base_thread.AddFieldConfig("Parent", &graphql.Field{
gql_type_simple_thread.AddFieldConfig("Parent", &graphql.Field{
Type: GQLInterfaceThread(),
Resolve: GQLThreadParent,
})
gql_type_base_thread.AddFieldConfig("Requirements", &graphql.Field{
gql_type_simple_thread.AddFieldConfig("Requirements", &graphql.Field{
Type: GQLListLockable(),
Resolve: GQLLockableRequirements,
})
gql_type_base_thread.AddFieldConfig("Owner", &graphql.Field{
gql_type_simple_thread.AddFieldConfig("Owner", &graphql.Field{
Type: GQLInterfaceLockable(),
Resolve: GQLLockableOwner,
})
gql_type_base_thread.AddFieldConfig("Dependencies", &graphql.Field{
gql_type_simple_thread.AddFieldConfig("Dependencies", &graphql.Field{
Type: GQLListLockable(),
Resolve: GQLLockableDependencies,
})
}
return gql_type_base_thread
return gql_type_simple_thread
}
var gql_type_base_lockable *graphql.Object = nil
func GQLTypeBaseLockable() * graphql.Object {
if gql_type_base_lockable == nil {
gql_type_base_lockable = graphql.NewObject(graphql.ObjectConfig{
var gql_type_simple_lockable *graphql.Object = nil
func GQLTypeSimpleLockable() * graphql.Object {
if gql_type_simple_lockable == nil {
gql_type_simple_lockable = graphql.NewObject(graphql.ObjectConfig{
Name: "BaseLockable",
Interfaces: []*graphql.Interface{
GQLInterfaceNode(),
@ -511,38 +511,38 @@ func GQLTypeBaseLockable() * graphql.Object {
Fields: graphql.Fields{},
})
gql_type_base_lockable.AddFieldConfig("ID", &graphql.Field{
gql_type_simple_lockable.AddFieldConfig("ID", &graphql.Field{
Type: graphql.String,
Resolve: GQLNodeID,
})
gql_type_base_lockable.AddFieldConfig("Name", &graphql.Field{
gql_type_simple_lockable.AddFieldConfig("Name", &graphql.Field{
Type: graphql.String,
Resolve: GQLLockableName,
})
gql_type_base_lockable.AddFieldConfig("Requirements", &graphql.Field{
gql_type_simple_lockable.AddFieldConfig("Requirements", &graphql.Field{
Type: GQLListLockable(),
Resolve: GQLLockableRequirements,
})
gql_type_base_lockable.AddFieldConfig("Owner", &graphql.Field{
gql_type_simple_lockable.AddFieldConfig("Owner", &graphql.Field{
Type: GQLInterfaceLockable(),
Resolve: GQLLockableOwner,
})
gql_type_base_lockable.AddFieldConfig("Dependencies", &graphql.Field{
gql_type_simple_lockable.AddFieldConfig("Dependencies", &graphql.Field{
Type: GQLListLockable(),
Resolve: GQLLockableDependencies,
})
}
return gql_type_base_lockable
return gql_type_simple_lockable
}
var gql_type_base_node *graphql.Object = nil
func GQLTypeBaseNode() * graphql.Object {
if gql_type_base_node == nil {
gql_type_base_node = graphql.NewObject(graphql.ObjectConfig{
var gql_type_simple_node *graphql.Object = nil
func GQLTypeGraphNode() * graphql.Object {
if gql_type_simple_node == nil {
gql_type_simple_node = graphql.NewObject(graphql.ObjectConfig{
Name: "BaseNode",
Interfaces: []*graphql.Interface{
GQLInterfaceNode(),
@ -565,18 +565,18 @@ func GQLTypeBaseNode() * graphql.Object {
Fields: graphql.Fields{},
})
gql_type_base_node.AddFieldConfig("ID", &graphql.Field{
gql_type_simple_node.AddFieldConfig("ID", &graphql.Field{
Type: graphql.String,
Resolve: GQLNodeID,
})
gql_type_base_node.AddFieldConfig("Name", &graphql.Field{
gql_type_simple_node.AddFieldConfig("Name", &graphql.Field{
Type: graphql.String,
Resolve: GQLLockableName,
})
}
return gql_type_base_node
return gql_type_simple_node
}
func GQLSignalFn(p graphql.ResolveParams, fn func(GraphSignal, graphql.ResolveParams)(interface{}, error))(interface{}, error) {

4
graph_test.go
Unescape Escape View File

@ -58,7 +58,7 @@ func logTestContext(t * testing.T, components []string) * Context {
t.Fatal(err)
}
return NewContext(db, NewConsoleLogger(components), map[string]NodeLoadFunc{}, TypeList{}, ObjTypeMap{}, FieldMap{}, FieldMap{}, FieldMap{})
return NewContext(db, NewConsoleLogger(components))
}
func testContext(t * testing.T) * Context {
@ -67,7 +67,7 @@ func testContext(t * testing.T) * Context {
t.Fatal(err)
}
return NewContext(db, NewConsoleLogger([]string{}), map[string]NodeLoadFunc{}, TypeList{}, ObjTypeMap{}, FieldMap{}, FieldMap{}, FieldMap{})
return NewContext(db, NewConsoleLogger([]string{}))
}
func fatalErr(t * testing.T, err error) {