implement Scylla database

api/api.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"net/http"
 
+	"git.dubyatp.xyz/chat-api-server/db"
 	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/chi/v5/middleware"
 	"github.com/go-chi/docgen"
@@ -14,6 +15,10 @@ import (
 var routes = flag.Bool("routes", false, "Generate API route documentation")
 
 func Start() {
+
+	db.InitScyllaDB()
+	defer db.CloseScyllaDB()
+
 	flag.Parse()
 
 	r := chi.NewRouter()

api/db.go

@@ -3,275 +3,168 @@ package api
 import (
 	"errors"
 	"fmt"
-	"time"
 
-	"git.dubyatp.xyz/chat-api-server/fake_db"
+	"git.dubyatp.xyz/chat-api-server/db"
+	"github.com/gocql/gocql"
 )
 
 func dbGetUser(id string) (*User, error) {
-	data := fake_db.ExecDB("users")
-	if data == nil {
-		return nil, errors.New("failed to load users database")
+	query := `SELECT id, name, password FROM users WHERE id = ?`
+	var user User
+	err := db.Session.Query(query, id).Scan(&user.ID, &user.Name, &user.Password)
+	if err == gocql.ErrNotFound {
+		return nil, errors.New("User not found")
+	} else if err != nil {
+		return nil, fmt.Errorf("failed to query user: %v", err)
 	}
-
-	users := data["users"].([]interface{})
-	for _, u := range users {
-		user := u.(map[string]interface{})
-		if user["ID"].(string) == id {
-			return &User{
-				ID:       user["ID"].(string),
-				Name:     user["Name"].(string),
-				Password: user["Password"].(string),
-			}, nil
-		}
-	}
-	return nil, errors.New("User not found")
+	return &user, nil
 }
 
 func dbGetUserByName(username string) (*User, error) {
-	data := fake_db.ExecDB("users")
-	if data == nil {
-		return nil, errors.New("failed to load users database")
+
+	query := `SELECT id, name, password FROM users WHERE name = ? ALLOW FILTERING`
+	var user User
+	err := db.Session.Query(query, username).Scan(&user.ID, &user.Name, &user.Password)
+	if err == gocql.ErrNotFound {
+		return nil, errors.New("User not found")
+	} else if err != nil {
+		return nil, fmt.Errorf("failed to query user: %v", err)
 	}
 
-	users := data["users"].([]interface{})
-	for _, u := range users {
-		user := u.(map[string]interface{})
-		if user["Name"].(string) == username {
-			return &User{
-				ID:       user["ID"].(string),
-				Name:     user["Name"].(string),
-				Password: user["Password"].(string),
-			}, nil
-		}
-	}
-	return nil, errors.New("User not found")
+	return &user, nil
 }
 
 func dbGetAllUsers() ([]*User, error) {
-	data := fake_db.ExecDB("users")
-	if data == nil {
-		return nil, errors.New("failed to load users database")
+	query := `SELECT id, name, password FROM users`
+	iter := db.Session.Query(query).Iter()
+	defer iter.Close()
+
+	var users []*User
+	for {
+		user := &User{}
+		if !iter.Scan(&user.ID, &user.Name, &user.Password) {
+			break
+		}
+		users = append(users, user)
 	}
 
-	users := data["users"].([]interface{})
-	var result []*User
-	for _, u := range users {
-		user := u.(map[string]interface{})
-		result = append(result, &User{
-			ID:   user["ID"].(string),
-			Name: user["Name"].(string),
-		})
+	if err := iter.Close(); err != nil {
+		return nil, fmt.Errorf("failed to iterate users: %v", err)
 	}
-	if len(result) == 0 {
+
+	if len(users) == 0 {
 		return nil, errors.New("no users found")
 	}
-	return result, nil
+
+	return users, nil
 }
 
 func dbGetMessage(id string) (*Message, error) {
-	data := fake_db.ExecDB("messages")
-	if data == nil {
-		return nil, errors.New("failed to load messages database")
+	query := `SELECT id, body, edited, timestamp, userid FROM messages WHERE id = ?`
+	var message Message
+	err := db.Session.Query(query, id).Scan(
+		&message.ID,
+		&message.Body,
+		&message.Edited,
+		&message.Timestamp,
+		&message.UserID)
+	if err == gocql.ErrNotFound {
+		return nil, errors.New("Message not found")
+	} else if err != nil {
+		return nil, fmt.Errorf("failed to query message: %v", err)
 	}
 
-	messages := data["messages"].([]interface{})
-	for _, m := range messages {
-		message := m.(map[string]interface{})
-		if message["ID"].(string) == id {
-			timestamp, err := time.Parse(time.RFC3339, message["Timestamp"].(string))
-			if err != nil {
-				return nil, fmt.Errorf("failed to parse timestamp: %v", err)
-			}
-			editedStr, ok := message["Edited"].(string)
-			var edited time.Time
-			if ok && editedStr != "" {
-				var err error
-				edited, err = time.Parse(time.RFC3339, editedStr)
-				if err != nil {
-					return nil, fmt.Errorf("failed to parse edited timestamp: %v", err)
-				}
-			}
-			return &Message{
-				ID:        message["ID"].(string),
-				UserID:    message["UserID"].(string),
-				Body:      message["Body"].(string),
-				Timestamp: timestamp,
-				Edited:    edited,
-			}, nil
-		}
-	}
-	return nil, errors.New("Message not found")
+	return &message, nil
 }
 
 func dbGetAllMessages() ([]*Message, error) {
-	data := fake_db.ExecDB("messages")
-	//println(data)
-	if data == nil {
-		return nil, errors.New("failed to load messages database")
+	query := `SELECT id, body, edited, timestamp, userid FROM messages`
+	iter := db.Session.Query(query).Iter()
+	defer iter.Close()
+
+	var messages []*Message
+	for {
+		message := &Message{}
+		if !iter.Scan(
+			&message.ID,
+			&message.Body,
+			&message.Edited,
+			&message.Timestamp,
+			&message.UserID) {
+			break
+		}
+		messages = append(messages, message)
 	}
 
-	messages := data["messages"].([]interface{})
-	var result []*Message
-	for _, m := range messages {
-		message := m.(map[string]interface{})
-		timestamp, err := time.Parse(time.RFC3339, message["Timestamp"].(string))
-		if err != nil {
-			return nil, fmt.Errorf("failed to parse timestamp: %v", err)
-		}
-		editedStr, ok := message["Edited"].(string)
-		var edited time.Time
-		if ok && editedStr != "" {
-			var err error
-			edited, err = time.Parse(time.RFC3339, editedStr)
-			if err != nil {
-				return nil, fmt.Errorf("failed to parse edited timestamp: %v", err)
-			}
-		}
-		result = append(result, &Message{
-			ID:        message["ID"].(string),
-			UserID:    message["UserID"].(string),
-			Body:      message["Body"].(string),
-			Timestamp: timestamp,
-			Edited:    edited,
-		})
+	if err := iter.Close(); err != nil {
+		return nil, fmt.Errorf("failed to iterate messages: %v", err)
 	}
-	if len(result) == 0 {
+
+	if len(messages) == 0 {
 		return nil, errors.New("no messages found")
 	}
-	return result, nil
+
+	return messages, nil
 }
 
 func dbAddUser(user *User) error {
-	currentData := fake_db.ExecDB("users")
-	if currentData == nil {
-		return fmt.Errorf("error reading users database")
+	query := `INSERT INTO users (id, name, password) VALUES (?, ?, ?)`
+	err := db.Session.Query(query, user.ID, user.Name, user.Password).Exec()
+	if err != nil {
+		return fmt.Errorf("failed to add user: %v", err)
 	}
-
-	users, ok := currentData["users"].([]interface{})
-	if !ok {
-		return fmt.Errorf("users data is in an unexpected format")
-	}
-
-	dbUser := map[string]interface{}{
-		"ID":       user.ID,
-		"Name":     user.Name,
-		"Password": user.Password,
-	}
-
-	users = append(users, dbUser)
-	return fake_db.WriteDB("users", users)
+	return nil
 }
 
 func dbAddMessage(message *Message) error {
-	currentData := fake_db.ExecDB("messages")
-	if currentData == nil {
-		return fmt.Errorf("error reading messages database")
+	query := `INSERT INTO messages (id, body, edited, timestamp, userid)
+			  VALUES (?, ?, ?, ?, ?)`
+	err := db.Session.Query(query,
+		message.ID,
+		message.Body,
+		nil,
+		message.Timestamp,
+		message.UserID).Exec()
+	if err != nil {
+		return fmt.Errorf("failed to add message: %v", err)
 	}
-
-	messages, ok := currentData["messages"].([]interface{})
-	if !ok {
-		return fmt.Errorf("messages data is in an unexpected format")
-	}
-
-	var edited interface{}
-	if message.Edited.IsZero() {
-		edited = nil // Set to nil if Edited is the zero value
-	} else {
-		edited = message.Edited.Format(time.RFC3339)
-	}
-
-	dbMessage := map[string]interface{}{
-		"ID":        message.ID,
-		"UserID":    message.UserID, // JSON numbers are float64
-		"Body":      message.Body,
-		"Timestamp": message.Timestamp.Format(time.RFC3339),
-		"Edited":    edited,
-	}
-
-	messages = append(messages, dbMessage)
-	return fake_db.WriteDB("messages", messages)
+	return nil
 }
 
 func dbUpdateMessage(updatedMessage *Message) error {
-	currentData := fake_db.ExecDB("messages")
-	if currentData == nil {
-		return fmt.Errorf("error reading messages database")
+	var edited interface{}
+	if updatedMessage.Edited.IsZero() {
+		edited = nil
+	} else {
+		edited = updatedMessage.Edited
 	}
 
-	messages, ok := currentData["messages"].([]interface{})
-	if !ok {
-		return fmt.Errorf("messages data is in an unexpected format")
+	query := `UPDATE messages
+			  SET body = ?, edited = ?, timestamp = ?
+			  WHERE ID = ?`
+
+	err := db.Session.Query(query,
+		updatedMessage.Body,
+		edited,
+		updatedMessage.Timestamp,
+		updatedMessage.ID).Exec()
+
+	if err != nil {
+		return fmt.Errorf("failed to update message: %v", err)
 	}
 
-	var updatedMessages []interface{}
-	found := false
+	return nil
 
-	for _, m := range messages {
-		message, ok := m.(map[string]interface{})
-		if !ok {
-			continue
-		}
-
-		if messageID, ok := message["ID"].(string); ok && messageID == updatedMessage.ID {
-			found = true
-
-			var edited interface{}
-			if updatedMessage.Edited.IsZero() {
-				edited = nil // Set to nil if Edited is the zero value
-			} else {
-				edited = updatedMessage.Edited.Format(time.RFC3339)
-			}
-
-			message = map[string]interface{}{
-				"ID":        updatedMessage.ID,
-				"UserID":    updatedMessage.UserID,
-				"Body":      updatedMessage.Body,
-				"Timestamp": updatedMessage.Timestamp.Format(time.RFC3339),
-				"Edited":    edited,
-			}
-		}
-		updatedMessages = append(updatedMessages, message)
-	}
-
-	if !found {
-		return fmt.Errorf("message with ID %s not found", updatedMessage.ID)
-	}
-
-	return fake_db.WriteDB("messages", updatedMessages)
 }
 
 func dbDeleteMessage(id string) error {
-	currentData := fake_db.ExecDB("messages")
-	if currentData == nil {
-		return fmt.Errorf("error reading messages database")
+	query := `DELETE FROM messages WHERE ID = ?`
+
+	err := db.Session.Query(query, id).Exec()
+
+	if err != nil {
+		return fmt.Errorf("failed to delete message: %v", err)
 	}
 
-	messages, ok := currentData["messages"].([]interface{})
-	if !ok {
-		return fmt.Errorf("messages data is in an unexpected format")
-	}
-
-	var updatedMessages []interface{}
-	found := false
-
-	for _, m := range messages {
-		message, ok := m.(map[string]interface{})
-		if !ok {
-			continue
-		}
-
-		if messageID, ok := message["ID"].(string); ok && messageID == id {
-			found = true
-			continue
-		}
-
-		updatedMessages = append(updatedMessages, message)
-	}
-
-	if !found {
-		return fmt.Errorf("message with ID %s not found", id)
-	}
-
-	return fake_db.WriteDB("messages", updatedMessages)
+	return nil
 }

api/message.go

@@ -65,7 +65,8 @@ func EditMessage(w http.ResponseWriter, r *http.Request) {
 	}
 
 	message.Body = body
-	message.Edited = time.Now()
+	editedTime := time.Now()
+	message.Edited = &editedTime
 
 	err = dbUpdateMessage(message)
 	if err != nil {
@@ -85,7 +86,7 @@ func DeleteMessage(w http.ResponseWriter, r *http.Request) {
 		render.Render(w, r, ErrNotFound)
 		return
 	}
-	dbDeleteMessage(message.ID)
+	dbDeleteMessage(message.ID.String())
 	if err := render.Render(w, r, NewMessageResponse(message)); err != nil {
 		render.Render(w, r, ErrRender(err))
 		return
@@ -104,8 +105,8 @@ func ListMessages(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func newMessageID() string {
-	return "msg_" + uuid.New().String()
+func newMessageID() uuid.UUID {
+	return uuid.New()
 }
 
 func NewMessage(w http.ResponseWriter, r *http.Request) {
@@ -135,7 +136,6 @@ func NewMessage(w http.ResponseWriter, r *http.Request) {
 		UserID:    user.ID,
 		Body:      body,
 		Timestamp: time.Now(),
-		Edited:    time.Time{},
 	}
 
 	err = dbAddMessage(&msg)
@@ -150,11 +150,11 @@ func NewMessage(w http.ResponseWriter, r *http.Request) {
 type messageKey struct{}
 
 type Message struct {
-	ID        string    `json:"id"`
-	UserID    string    `json:"user_id"`
-	Body      string    `json:"body"`
-	Timestamp time.Time `json:"timestamp"`
-	Edited    time.Time `json:"edited"`
+	ID        uuid.UUID  `json:"id"`
+	UserID    uuid.UUID  `json:"user_id"`
+	Body      string     `json:"body"`
+	Timestamp time.Time  `json:"timestamp"`
+	Edited    *time.Time `json:"edited"`
 }
 
 type MessageRequest struct {
@@ -175,8 +175,8 @@ type MessageResponse struct {
 
 func (m MessageResponse) MarshalJSON() ([]byte, error) {
 	type OrderedMessageResponse struct {
-		ID        string       `json:"id"`
-		UserID    string       `json:"user_id"`
+		ID        uuid.UUID    `json:"id"`
+		UserID    uuid.UUID    `json:"user_id"`
 		Body      string       `json:"body"`
 		Timestamp string       `json:"timestamp"`
 		Edited    *string      `json:"edited,omitempty"` // Use a pointer to allow null values
@@ -185,7 +185,7 @@ func (m MessageResponse) MarshalJSON() ([]byte, error) {
 	}
 
 	var edited *string
-	if !m.Message.Edited.IsZero() { // Check if Edited is not the zero value
+	if m.Message.Edited != nil { // Check if Edited is not the zero value
 		editedStr := m.Message.Edited.Format(time.RFC3339)
 		edited = &editedStr
 	}

api/response.go

@@ -10,7 +10,7 @@ func NewMessageResponse(message *Message) *MessageResponse {
 	resp := &MessageResponse{Message: message}
 
 	if resp.User == nil {
-		if user, _ := dbGetUser(resp.UserID); user != nil {
+		if user, _ := dbGetUser(resp.UserID.String()); user != nil {
 			resp.User = NewUserPayloadResponse(user)
 		}
 	}

api/user.go

@@ -89,8 +89,8 @@ func ListUsers(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func newUserID() string {
-	return "user_" + uuid.New().String()
+func newUserID() uuid.UUID {
+	return uuid.New()
 }
 
 func NewUser(w http.ResponseWriter, r *http.Request) {
@@ -130,9 +130,9 @@ func NewUser(w http.ResponseWriter, r *http.Request) {
 type userKey struct{}
 
 type User struct {
-	ID       string `json:"id"`
-	Name     string `json:"name"`
-	Password string `json:"-"`
+	ID       uuid.UUID `json:"id"`
+	Name     string    `json:"name"`
+	Password string    `json:"-"`
 }
 
 type UserPayload struct {