Comprehensive comparison for Database technology in Software Development applications

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"time"

	"github.com/dgraph-io/dgo/v210"
	"github.com/dgraph-io/dgo/v210/protos/api"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

// Project represents a software project in the database
type Project struct {
	UID         string      `json:"uid,omitempty"`
	Name        string      `json:"name,omitempty"`
	Description string      `json:"description,omitempty"`
	Repository  string      `json:"repository,omitempty"`
	CreatedAt   time.Time   `json:"created_at,omitempty"`
	Owner       *Developer  `json:"owner,omitempty"`
	Contributors []*Developer `json:"contributors,omitempty"`
	Issues      []*Issue    `json:"issues,omitempty"`
	DgraphType  []string    `json:"dgraph.type,omitempty"`
}

// Developer represents a software developer
type Developer struct {
	UID        string   `json:"uid,omitempty"`
	Username   string   `json:"username,omitempty"`
	Email      string   `json:"email,omitempty"`
	DgraphType []string `json:"dgraph.type,omitempty"`
}

// Issue represents a project issue
type Issue struct {
	UID        string   `json:"uid,omitempty"`
	Title      string   `json:"title,omitempty"`
	Status     string   `json:"status,omitempty"`
	Priority   string   `json:"priority,omitempty"`
	Assignee   *Developer `json:"assignee,omitempty"`
	DgraphType []string `json:"dgraph.type,omitempty"`
}

func main() {
	conn, err := grpc.Dial("localhost:9080", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		log.Fatal("Failed to connect to Dgraph:", err)
	}
	defer conn.Close()

	dgraphClient := dgo.NewDgraphClient(api.NewDgraphClient(conn))

	if err := setupSchema(dgraphClient); err != nil {
		log.Fatal("Schema setup failed:", err)
	}

	projectUID, err := createProjectWithTeam(dgraphClient)
	if err != nil {
		log.Fatal("Failed to create project:", err)
	}

	if err := queryProjectDetails(dgraphClient, projectUID); err != nil {
		log.Fatal("Failed to query project:", err)
	}
}

func setupSchema(client *dgo.Dgraph) error {
	ctx := context.Background()
	schema := `
		type Project {
			name: string
			description: string
			repository: string
			created_at: datetime
			owner: uid
			contributors: [uid]
			issues: [uid]
		}
		type Developer {
			username: string
			email: string
		}
		type Issue {
			title: string
			status: string
			priority: string
			assignee: uid
		}
		name: string @index(term) .
		username: string @index(hash) @upsert .
		email: string @index(exact) @upsert .
		status: string @index(exact) .
		priority: string @index(exact) .
		created_at: datetime @index(day) .
	`
	return client.Alter(ctx, &api.Operation{Schema: schema})
}

func createProjectWithTeam(client *dgo.Dgraph) (string, error) {
	ctx := context.Background()
	txn := client.NewTxn()
	defer txn.Discard(ctx)

	// Create developers
	owner := Developer{
		Username:   "alice_dev",
		Email:      "[email protected]",
		DgraphType: []string{"Developer"},
	}

	contributor := Developer{
		Username:   "bob_dev",
		Email:      "[email protected]",
		DgraphType: []string{"Developer"},
	}

	// Create issue
	issue := Issue{
		Title:      "Implement authentication module",
		Status:     "open",
		Priority:   "high",
		Assignee:   &contributor,
		DgraphType: []string{"Issue"},
	}

	// Create project with relationships
	project := Project{
		Name:         "E-Commerce Platform",
		Description:  "Modern microservices-based e-commerce strategies",
		Repository:   "https://github.com/example/ecommerce",
		CreatedAt:    time.Now(),
		Owner:        &owner,
		Contributors: []*Developer{&contributor},
		Issues:       []*Issue{&issue},
		DgraphType:   []string{"Project"},
	}

	projectJSON, err := json.Marshal(project)
	if err != nil {
		return "", fmt.Errorf("marshal error: %w", err)
	}

	mu := &api.Mutation{
		SetJson:   projectJSON,
		CommitNow: true,
	}

	assigned, err := txn.Mutate(ctx, mu)
	if err != nil {
		return "", fmt.Errorf("mutation error: %w", err)
	}

	projectUID := assigned.Uids["blank-0"]
	log.Printf("Successfully created project with UID: %s", projectUID)
	return projectUID, nil
}

func queryProjectDetails(client *dgo.Dgraph, projectUID string) error {
	ctx := context.Background()
	txn := client.NewReadOnlyTxn()
	defer txn.Discard(ctx)

	query := fmt.Sprintf(`
		query getProject($projectID: string) {
			project(func: uid($projectID)) {
				uid
				name
				description
				repository
				created_at
				owner {
					uid
					username
					email
				}
				contributors {
					uid
					username
					email
				}
				issues {
					uid
					title
					status
					priority
					assignee {
						username
					}
				}
			}
		}
	`)

	variables := map[string]string{"$projectID": projectUID}
	resp, err := txn.QueryWithVars(ctx, query, variables)
	if err != nil {
		return fmt.Errorf("query error: %w", err)
	}

	type Root struct {
		Project []Project `json:"project"`
	}

	var result Root
	if err := json.Unmarshal(resp.Json, &result); err != nil {
		return fmt.Errorf("unmarshal error: %w", err)
	}

	if len(result.Project) == 0 {
		return fmt.Errorf("project not found")
	}

	projectData, _ := json.MarshalIndent(result.Project[0], "", "  ")
	log.Printf("Project Details:\n%s", string(projectData))
	return nil
}