[VIEWER-DESKTOP-GO] Backend refactor

backend/miscellaneous/cypher.go

@@ -0,0 +1,40 @@
+package miscellaneous
+
+import (
+	"database/sql"
+)
+
+func CypherCall(db *sql.DB, q map[string]string, c chan<- ChannelResults) {
+	data := ChannelResults{}
+	results := []interface{}{}
+	rows, err := db.Query(q["query"])
+	if err != nil {
+		data.Err = err
+		c <- data
+		return
+	}
+	cols, _ := rows.ColumnTypes()
+	if len(cols) == 1 && cols[0].DatabaseTypeName() == "VOID" {
+		data.Msg = map[string]string{
+			"status": "success",
+		}
+		c <- data
+		return
+	}
+
+	for rows.Next() {
+		rawData := make([]any, len(cols))
+		for i := 0; i < len(cols); i++ {
+			rawData[i] = new(string)
+		}
+
+		err := rows.Scan(rawData...)
+		if err != nil {
+			data.Err = err
+			break
+		}
+		results = append(results, rawData)
+	}
+	data.Res = results
+	c <- data
+}

backend/miscellaneous/results.go

@@ -0,0 +1,7 @@
+package miscellaneous
+
+type ChannelResults struct {
+	Res any
+	Msg map[string]string
+	Err error
+}

backend/models/graph.go

@@ -10,15 +10,21 @@ type Graph struct {
 	Name string
 }
 
-func (g *Graph) GetMetaData(conn *sql.DB, v int) (*sql.Rows, error) {
+func (g *Graph) GetMetaData(conn *sql.DB, v int, dataChan chan<- *sql.Rows, errorChan chan<- error) {
 
 	defer conn.Close()
+	var data *sql.Rows
+	var err error
+
 	switch v {
 	case 11:
-		return conn.Query(db.META_DATA_11, g.Name)
+		data, err = conn.Query(db.META_DATA_11, g.Name)
 	case 12:
-		return conn.Query(db.META_DATA_12, g.Name)
+		data, err = conn.Query(db.META_DATA_12, g.Name)
 	default:
-		return nil, errors.New("unsupported version")
+		err = errors.New("unsupported version")
 	}
+
+	errorChan <- err
+	dataChan <- data
 }

backend/routes/query.go

@@ -60,7 +60,6 @@ func CypherMiddleWare(next echo.HandlerFunc) echo.HandlerFunc {
 }
 func Cypher(ctx echo.Context) error {
 	q := map[string]string{}
-	results := []interface{}{}
 	var err error
 
 	err = ctx.Bind(&q)
@@ -72,37 +71,34 @@ func Cypher(ctx echo.Context) error {
 		return ctx.JSON(400, e.JSON())
 	}
 	conn := ctx.Get("conn").(*sql.DB)
-	rows, err := conn.Query(q["query"])
-
+	c := make(chan m.ChannelResults, 1)
+	m.CypherCall(conn, q, c)
+	data := <-c
+	err = data.Err
+	res := data.Res
+	msg := data.Msg
 	if err != nil {
 		return echo.NewHTTPError(400, fmt.Sprintf("unable to process query. error: %s", err.Error()))
 	}
 
-	cols, _ := rows.ColumnTypes()
-	print("0 index val", cols[0].DatabaseTypeName())
-	if len(cols) == 1 && cols[0].DatabaseTypeName() == "VOID" {
-		return ctx.JSON(204, map[string]string{
-			"status": "success",
-		})
-	}
-	for rows.Next() {
-		data := []any{}
-		err := rows.Scan(&data)
-		if err != nil {
-			print(fmt.Sprintf("\n\nerror: %s", err.Error()))
-		}
-		results = append(results, data)
+	if _, ok := msg["status"]; ok {
+		return ctx.JSON(204, msg)
 	}
-	return ctx.JSON(200, results)
+
+	return ctx.JSON(200, res)
 }
+
 func GraphMetaData(c echo.Context) error {
+	dataChan := make(chan *sql.Rows, 1)
+	errChan := make(chan error, 1)
 
 	user := c.Get("user").(models.Connection)
 	conn := c.Get("conn").(*sql.DB)
 	graph := models.Graph{}
 	c.Bind(&graph)
 	conn.Exec(db.ANALYZE)
-	data, err := graph.GetMetaData(conn, user.Version)
+	go graph.GetMetaData(conn, user.Version, dataChan, errChan)
+	data, err := <-dataChan, <-errChan
 
 	if err != nil {
 		return echo.NewHTTPError(400, err.Error())