implement Scylla database

2025-05-17 21:45:18 -04:00
parent 252b49ae6a
commit f8a550883d
199 changed files with 71243 additions and 424 deletions
--- a/api/db.go
+++ b/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
 }