Chore: Optimize Neo4J Recipe

neo4j/README.md

@@ -22,21 +22,24 @@ Ensure you have the following installed:
 ## Setup
 
 1. Clone the repository:
-    ```sh
-    git clone https://github.com/gofiber/recipes.git
-    cd recipes/neo4j
-    ```
+
+   ```sh
+   git clone https://github.com/gofiber/recipes.git
+   cd recipes/neo4j
+   ```
 
 2. Install dependencies:
-    ```sh
-    go get
-    ```
+
+   ```sh
+   go get
+   ```
 
 3. Set up your Neo4j database and update the connection string in the code.
 
 ## Running the Application
 
 1. Start the application:
+
     ```sh
     go run main.go
     ```
@@ -50,42 +53,33 @@ package main
 
 import (
     "log"
+    "net/http"  
     "github.com/gofiber/fiber/v2"
     "github.com/neo4j/neo4j-go-driver/v5/neo4j"
 )
 
 func main() {
-    // Neo4j connection
-    uri := "neo4j://localhost:7687"
-    username := "neo4j"
-    password := "password"
-    driver, err := neo4j.NewDriver(uri, neo4j.BasicAuth(username, password, ""))
+    driver, err := neo4j.NewDriver("neo4j://localhost:7687", neo4j.BasicAuth("neo4j", "password", ""))
     if err != nil {
         log.Fatal(err)
     }
-    defer driver.Close()
-
-    // Fiber instance
+    defer driver.Close()    
     app := fiber.New()
 
-    // Routes
     app.Get("/", func(c *fiber.Ctx) error {
         session := driver.NewSession(neo4j.SessionConfig{})
-        defer session.Close()
-
+        defer session.Close()   
         result, err := session.Run("RETURN 'Hello, World!'", nil)
         if err != nil {
-            return err
-        }
-
+            return c.Status(http.StatusInternalServerError).SendString(err.Error())
+        }   
         if result.Next() {
             return c.SendString(result.Record().Values[0].(string))
         }
 
-        return c.SendStatus(500)
+        return c.SendStatus(http.StatusInternalServerError)
     })
 
-    // Start server
     log.Fatal(app.Listen(":3000"))
 }
 ```

neo4j/main.go

@@ -1,9 +1,8 @@
 package main
 
 import (
-	"fmt"
 	"log"
-	"strconv"
+	"net/http"
 
 	"github.com/gofiber/fiber/v2"
 	"github.com/neo4j/neo4j-go-driver/neo4j"
@@ -17,74 +16,78 @@ type Movie struct {
 	Director string `json:"director" db:"director"`
 }
 
-// ConnectToDB makes a connection with the database
-func ConnectToDB() (neo4j.Session, neo4j.Driver, error) {
-	// define driver, session and result vars
-	var (
-		driver  neo4j.Driver
-		session neo4j.Session
-		err     error
-	)
-	// initialize driver to connect to localhost with ID and password
-	if driver, err = neo4j.NewDriver("bolt://localhost:7687", neo4j.BasicAuth("mdfaizan7", "mdfaizan7", ""),
-		func(conf *neo4j.Config) { conf.Encrypted = false }); err != nil {
-		return nil, nil, err
-	}
-	// Open a new session with write access
-	if session, err = driver.Session(neo4j.AccessModeWrite); err != nil {
-		return nil, nil, err
-	}
-	return session, driver, nil
+var driver neo4j.Driver
+
+func ConnectToDB() error {
+	var err error
+	driver, err = neo4j.NewDriver("bolt://localhost:7687", neo4j.BasicAuth("neo4j", "password", ""),
+		func(conf *neo4j.Config) { conf.Encrypted = false })
+	return err
 }
 
 func main() {
-	// connect to database
-	session, _, err := ConnectToDB()
-	if err != nil {
-		fmt.Print(err)
-		session.Close()
+	if err := ConnectToDB(); err != nil {
+		log.Fatal(err)
 	}
-	defer session.Close()
+	defer driver.Close()
 
-	// Create a Fiber app
 	app := fiber.New()
 
 	app.Post("/movie", func(c *fiber.Ctx) error {
-		movie := new(Movie)
-		if err := c.BodyParser(movie); err != nil {
-			return c.Status(400).SendString(err.Error())
+		var movie Movie
+		if err := c.BodyParser(&movie); err != nil {
+			return c.Status(http.StatusBadRequest).SendString(err.Error())
+		}
+
+		session, err := driver.Session(neo4j.AccessModeWrite)
+		if err != nil {
+			return c.Status(http.StatusInternalServerError).SendString(err.Error())
 		}
+		defer session.Close()
 
-		query := fmt.Sprintf(`CREATE (n:Movie {title:'%s', tagline:'%s', released:'%d', director:'%s' })`,
-			movie.Title, movie.Tagline, movie.Released, movie.Director)
+		query := `CREATE (n:Movie {title: $title, tagline: $tagline, released: $released, director: $director})`
+		params := map[string]any{
+			"title":    movie.Title,
+			"tagline":  movie.Tagline,
+			"released": movie.Released,
+			"director": movie.Director,
+		}
 
-		_, err := session.Run(query, nil)
+		_, err = session.Run(query, params)
 		if err != nil {
-			return err
+			return c.Status(http.StatusInternalServerError).SendString(err.Error())
 		}
 
-		return c.SendString("Movie successfully created")
+		return c.Status(http.StatusCreated).JSON(movie)
 	})
 
 	app.Get("/movie/:title", func(c *fiber.Ctx) error {
 		title := c.Params("title")
-		query := fmt.Sprintf(`MATCH (n:Movie {title:'%s'}) RETURN n.title, n.tagline, n.released, n.director`, title)
 
-		result, err := session.Run(query, nil)
+		session, err := driver.Session(neo4j.AccessModeRead)
+		if err != nil {
+			return c.Status(http.StatusInternalServerError).SendString(err.Error())
+		}
+		defer session.Close()
+
+		query := `MATCH (n:Movie {title: $title}) RETURN n.title, n.tagline, n.released, n.director`
+		result, err := session.Run(query, map[string]interface{}{"title": title})
 		if err != nil {
-			return err
+			return c.Status(http.StatusInternalServerError).SendString(err.Error())
 		}
 
-		res := &Movie{}
-		for result.Next() {
-			record := result.Record()
-			res.Title = record.GetByIndex(0).(string)
-			res.Tagline = record.GetByIndex(1).(string)
-			res.Released, _ = strconv.ParseInt(record.GetByIndex(2).(string), 10, 64)
-			res.Director = record.GetByIndex(3).(string)
+		if result.Next() {
+			values := result.Record().Values()
+			movie := Movie{
+				Title:    values[0].(string),
+				Tagline:  values[1].(string),
+				Released: values[2].(int64),
+				Director: values[3].(string),
+			}
+			return c.JSON(movie)
 		}
 
-		return c.JSON(res)
+		return c.SendStatus(http.StatusNotFound)
 	})
 
 	log.Fatal(app.Listen(":3000"))