graphik

package main

import (
	"context"
	"fmt"
	"github.com/autom8ter/graphik-client-go"

	apipb "github.com/autom8ter/graphik/api"
	"log"
)

var client *graphik.Client

func main() {
	dogs, err := client.SearchNodes(context.Background(), &apipb.Filter{
		Gtype: "dog",
		Expressions: []string{
			`node.attributes.name.contains("Charl")`,
		},
		Limit: 1,
	})
	if err != nil {
		log.Print(err)
		return
	}
	charlie := dogs.GetNodes()[0]
	coleman, err := client.CreateNode(context.Background(), &apipb.NodeConstructor{
		Path: &apipb.Path{
			Gtype: "human",
		},
		Attributes: apipb.NewStruct(map[string]interface{}{
			"name": "Coleman",
		}),
	})
	if err != nil {
		log.Print(err)
		return
	}
	ownerEdge, err := client.CreateEdge(context.Background(), &apipb.EdgeConstructor{
		Path: &apipb.Path{
			Gtype: "owner",
		},
		Attributes: apipb.NewStruct(map[string]interface{}{
			"primary_owner": true,
		}),
		From: charlie.Path,
		To:   coleman.Path,
	})
	if err != nil {
		log.Print(err)
		return
	}
	primary := ownerEdge.Attributes.Fields["primary_owner"].GetBoolValue()
	fmt.Println(primary)
}

Output:
true

package main

import (
	"context"
	"fmt"
	"github.com/autom8ter/graphik-client-go"

	apipb "github.com/autom8ter/graphik/api"
	"log"
)

var client *graphik.Client

func main() {
	charlie, err := client.CreateNode(context.Background(), &apipb.NodeConstructor{
		Path: &apipb.Path{
			Gtype: "dog",
		},
		Attributes: apipb.NewStruct(map[string]interface{}{
			"name": "Charlie",
		}),
	})
	if err != nil {
		log.Print(err)
		return
	}
	name := charlie.Attributes.Fields["name"].GetStringValue()
	fmt.Println(name)
}

Output:
Charlie

package main

import (
	"context"
	"fmt"
	"github.com/autom8ter/graphik-client-go"
	"github.com/golang/protobuf/ptypes/empty"
	"log"
	"strings"
)

var client *graphik.Client

func main() {
	schema, err := client.GetSchema(context.Background(), &empty.Empty{})
	if err != nil {
		log.Print(err)
		return
	}
	fmt.Printf("node types: %s\n", strings.Join(schema.NodeTypes, ","))
	fmt.Printf("edge types: %s", strings.Join(schema.EdgeTypes, ","))
}

Output:
node types: dog,human,identity
edge types: owner

package main

import (
	"context"
	"fmt"
	"github.com/autom8ter/graphik-client-go"

	apipb "github.com/autom8ter/graphik/api"
	"log"
)

var client *graphik.Client

func main() {
	me, err := client.Me(context.Background(), &apipb.MeFilter{
		EdgesFrom: nil,
		EdgesTo:   nil,
	})
	if err != nil {
		log.Print(err)
		return
	}
	issuer := me.GetAttributes().GetFields()["iss"].GetStringValue() // token issuer
	fmt.Println(issuer)
}

Output:
https://accounts.google.com

package main

import (
	"context"
	"fmt"
	"github.com/autom8ter/graphik-client-go"

	apipb "github.com/autom8ter/graphik/api"
	"log"
)

var client *graphik.Client

func main() {
	dogs, err := client.SearchNodes(context.Background(), &apipb.Filter{
		Gtype: "dog",
		Expressions: []string{
			`node.attributes.name.contains("Charl")`,
		},
		Limit: 1,
	})
	if err != nil {
		log.Print(err)
		return
	}
	charlie := dogs.GetNodes()[0]
	charlie, err = client.PatchNode(context.Background(), &apipb.Patch{
		Path: charlie.Path,
		Attributes: apipb.NewStruct(map[string]interface{}{
			"weight": 25,
		}),
	})
	if err != nil {
		log.Print(err)
		return
	}
	fmt.Println(charlie.GetAttributes().GetFields()["weight"].GetNumberValue())
}

Output:
25

package main

import (
	"context"
	"fmt"
	"github.com/autom8ter/graphik-client-go"

	apipb "github.com/autom8ter/graphik/api"
	"log"
)

var client *graphik.Client

func main() {
	res, err := client.Publish(context.Background(), &apipb.OutboundMessage{
		Channel: "testing",
		Data: apipb.NewStruct(map[string]interface{}{
			"text": "hello world",
		}),
	})
	if err != nil {
		log.Print(err)
		return
	}
	fmt.Println(res.String())
}

Output:

package main

import (
	"context"
	"fmt"
	"github.com/autom8ter/graphik-client-go"

	apipb "github.com/autom8ter/graphik/api"
	"log"
)

var client *graphik.Client

func main() {
	owners, err := client.SearchEdges(context.Background(), &apipb.Filter{
		Gtype: "owner",
		Expressions: []string{
			`edge.attributes.primary_owner`,
		},
		Limit: 1,
	})
	if err != nil {
		log.Print(err)
		return
	}
	coleman := owners.GetEdges()[0]
	primary := coleman.Attributes.Fields["primary_owner"].GetBoolValue()
	fmt.Println(primary)
}

Output:
true

package main

import (
	"context"
	"fmt"
	"github.com/autom8ter/graphik-client-go"

	apipb "github.com/autom8ter/graphik/api"
	"log"
)

var client *graphik.Client

func main() {
	dogs, err := client.SearchNodes(context.Background(), &apipb.Filter{
		Gtype: "dog",
		Expressions: []string{
			`node.attributes.name.contains("Charl")`,
		},
		Limit: 1,
	})
	if err != nil {
		log.Print(err)
		return
	}
	dog := dogs.GetNodes()[0]
	name := dog.Attributes.Fields["name"].GetStringValue()
	fmt.Println(name)
}

Output:
Charlie

package main

import (
	"context"
	"fmt"
	"github.com/autom8ter/graphik-client-go"

	apipb "github.com/autom8ter/graphik/api"
	"github.com/autom8ter/machine"
	"log"
	"time"
)

var client *graphik.Client

func main() {
	m := machine.New(context.Background())
	m.Go(func(routine machine.Routine) {
		stream, err := client.Subscribe(context.Background(), &apipb.ChannelFilter{
			Channel:     "testing",
			Expressions: nil,
		})
		if err != nil {
			log.Print(err)
			return
		}
		for {
			msg, err := stream.Recv()
			if err != nil {
				log.Print(err)
				return
			}
			fmt.Println(msg.Data.GetFields()["text"].GetStringValue())
			return
		}
	})
	time.Sleep(1 * time.Second)
	_, err := client.Publish(context.Background(), &apipb.OutboundMessage{
		Channel: "testing",
		Data: apipb.NewStruct(map[string]interface{}{
			"text": "hello world",
		}),
	})
	if err != nil {
		log.Print(err)
		return
	}
	m.Wait()
}

Output:
hello world