first commit

backend/internal/handlers/document.go

@@ -0,0 +1,144 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/M1ngdaXie/realtime-collab/internal/models"
+	"github.com/M1ngdaXie/realtime-collab/internal/store"
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
+
+  type DocumentHandler struct {
+  	store *store.Store
+  }
+
+  func NewDocumentHandler(s *store.Store) *DocumentHandler {
+  	return &DocumentHandler{store: s}
+  }
+
+  // CreateDocument creates a new document
+  func (h *DocumentHandler) CreateDocument(c *gin.Context) {
+  	var req models.CreateDocumentRequest
+  	if err := c.ShouldBindJSON(&req); err != nil {
+  		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+  		return
+  	}
+
+  	// Validate document type
+  	if req.Type != models.DocumentTypeEditor && req.Type != models.DocumentTypeKanban {
+  		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid document type"})
+  		return
+  	}
+
+  	doc, err := h.store.CreateDocument(req.Name, req.Type)
+  	if err != nil {
+  		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+  		return
+  	}
+
+  	c.JSON(http.StatusCreated, doc)
+  }
+
+  // ListDocuments returns all documents
+  func (h *DocumentHandler) ListDocuments(c *gin.Context) {
+  	documents, err := h.store.ListDocuments()
+  	if err != nil {
+  		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+  		return
+  	}
+
+  	if documents == nil {
+  		documents = []models.Document{}
+  	}
+
+  	c.JSON(http.StatusOK, models.DocumentListResponse{
+  		Documents: documents,
+  		Total:     len(documents),
+  	})
+  }
+
+  // GetDocument returns a single document
+  func (h *DocumentHandler) GetDocument(c *gin.Context) {
+  	idStr := c.Param("id")
+  	id, err := uuid.Parse(idStr)
+  	if err != nil {
+  		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid document ID"})
+  		return
+  	}
+
+  	doc, err := h.store.GetDocument(id)
+  	if err != nil {
+  		c.JSON(http.StatusNotFound, gin.H{"error": "document not found"})
+  		return
+  	}
+
+  	c.JSON(http.StatusOK, doc)
+  }
+
+  // GetDocumentState returns the Yjs state for a document
+  func (h *DocumentHandler) GetDocumentState(c *gin.Context) {
+  	idStr := c.Param("id")
+  	id, err := uuid.Parse(idStr)
+  	if err != nil {
+  		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid document ID"})
+  		return
+  	}
+
+  	doc, err := h.store.GetDocument(id)
+  	if err != nil {
+  		c.JSON(http.StatusNotFound, gin.H{"error": "document not found"})
+  		return
+  	}
+
+  	// Return binary state
+  	if doc.YjsState == nil {
+  		c.Data(http.StatusOK, "application/octet-stream", []byte{})
+  		return
+  	}
+
+  	c.Data(http.StatusOK, "application/octet-stream", doc.YjsState)
+  }
+
+  // UpdateDocumentState updates the Yjs state for a document
+  func (h *DocumentHandler) UpdateDocumentState(c *gin.Context) {
+  	idStr := c.Param("id")
+  	id, err := uuid.Parse(idStr)
+  	if err != nil {
+  		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid document ID"})
+  		return
+  	}
+
+  	// Read binary body
+  	state, err := c.GetRawData()
+  	if err != nil {
+  		c.JSON(http.StatusBadRequest, gin.H{"error": "failed to read request body"})
+  		return
+  	}
+
+  	err = h.store.UpdateDocumentState(id, state)
+  	if err != nil {
+  		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+  		return
+  	}
+
+  	c.JSON(http.StatusOK, gin.H{"message": "state updated successfully"})
+  }
+
+  // DeleteDocument deletes a document
+  func (h *DocumentHandler) DeleteDocument(c *gin.Context) {
+  	idStr := c.Param("id")
+  	id, err := uuid.Parse(idStr)
+  	if err != nil {
+  		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid document ID"})
+  		return
+  	}
+
+  	err = h.store.DeleteDocument(id)
+  	if err != nil {
+  		c.JSON(http.StatusNotFound, gin.H{"error": "document not found"})
+  		return
+  	}
+
+  	c.JSON(http.StatusOK, gin.H{"message": "document deleted successfully"})
+  }

backend/internal/handlers/websocket.go

@@ -0,0 +1,59 @@
+package handlers
+
+import (
+	"log"
+	"net/http"
+
+	"github.com/M1ngdaXie/realtime-collab/internal/hub"
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+	"github.com/gorilla/websocket"
+)
+
+
+var upgrader = websocket.Upgrader{
+  	ReadBufferSize:  1024,
+  	WriteBufferSize: 1024,
+  	CheckOrigin: func(r *http.Request) bool {
+  		// Allow all origins for development
+  		// TODO: Restrict in production
+  		return true
+  	},
+}
+
+ type WebSocketHandler struct {
+  	hub *hub.Hub
+  }
+
+  func NewWebSocketHandler(h *hub.Hub) *WebSocketHandler {
+  	return &WebSocketHandler{hub: h}
+  }
+
+  func (wsh *WebSocketHandler) HandleWebSocket(c *gin.Context){
+	roomID := c.Param("roomId")
+
+	if(roomID == ""){
+		c.JSON(http.StatusBadRequest, gin.H{"error": "roomId is required"})
+		return
+	}
+	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to upgrade to WebSocket"})
+		return
+	}
+    
+		// Create a new client
+  	clientID := uuid.New().String()
+  	client := hub.NewClient(clientID, conn, wsh.hub, roomID)
+
+  	// Register client with hub
+  	wsh.hub.Register <- client
+
+  	// Start read and write pumps in separate goroutines
+  	go client.WritePump()
+  	go client.ReadPump()
+
+  	log.Printf("WebSocket connection established for client %s in room %s", clientID, roomID)
+  }
+
+  

backend/internal/hub/hub.go

@@ -0,0 +1,164 @@
+package hub
+
+import (
+	"log"
+	"sync"
+
+	"github.com/gorilla/websocket"
+)
+
+type Message struct {
+	RoomID  string
+	Data	[]byte
+	sender  *Client
+}
+
+type Client struct {
+	ID    string
+	Conn  *websocket.Conn
+	send chan []byte
+	hub    *Hub
+	roomID string
+}
+type Room struct {
+	ID 	string
+	clients map[*Client]bool
+	mu sync.RWMutex
+}
+
+type Hub struct {
+	rooms 	map[string]*Room
+	mu		sync.RWMutex
+	Register   chan *Client // Exported
+  	Unregister chan *Client // Exported
+  	Broadcast  chan *Message // Exported
+}
+func NewHub() *Hub {
+	return &Hub{
+		rooms:      make(map[string]*Room),
+		Register:   make(chan *Client),
+		Unregister: make(chan *Client),
+		Broadcast:  make(chan *Message),
+	}
+}
+
+func (h *Hub) Run() {
+	for {
+		select {
+		case client := <-h.Register:
+			h.registerClient(client)
+		case client := <-h.Unregister:
+			h.unregisterClient(client)
+		case message := <-h.Broadcast:
+			h.broadcastMessage(message)
+		}
+	}
+}
+
+func (h *Hub) registerClient(client *Client) {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+
+	room, exists := h.rooms[client.roomID]
+	if !exists {
+		room = &Room{
+			ID:      client.roomID,
+			clients: make(map[*Client]bool),
+		}
+		h.rooms[client.roomID] = room
+		log.Printf("Created new room with ID: %s", client.roomID)
+	}
+	room.mu.Lock()
+	room.clients[client] = true
+	room.mu.Unlock()
+	log.Printf("Client %s joined room %s (total clients: %d)", client.ID, client.roomID, len(room.clients))
+}
+func (h *Hub) unregisterClient(client *Client) {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+
+	room, exists := h.rooms[client.roomID]
+	if !exists {
+		log.Printf("Room %s does not exist for client %s", client.roomID, client.ID)
+		return
+	}
+	room.mu.Lock()
+	if _, ok := room.clients[client]; ok {
+		delete(room.clients, client)
+		close(client.send)
+		log.Printf("Client %s disconnected from room %s", client.ID, client.roomID)
+	}
+
+	room.mu.Unlock()
+	log.Printf("Client %s left room %s (total clients: %d)", client.ID, client.roomID, len(room.clients))
+
+	if len(room.clients) == 0 {
+		delete(h.rooms, client.roomID)
+		log.Printf("Deleted empty room with ID: %s", client.roomID)
+	}
+}
+func (h *Hub) broadcastMessage(message *Message) {
+	h.mu.RLock()
+	room, exists := h.rooms[message.RoomID]
+	h.mu.RUnlock()
+	if !exists {
+		log.Printf("Room %s does not exist for broadcasting", message.RoomID)
+		return
+	}
+
+	room.mu.RLock()
+	defer room.mu.RUnlock()
+	for client := range room.clients {
+		if client != message.sender {
+			select {
+			case client.send <- message.Data:
+			default:
+				log.Printf("Failed to send to client %s (channel full)", client.ID)
+			}
+		}
+	}
+}
+
+func (c *Client) ReadPump() {
+	defer func() {
+		c.hub.Unregister <- c
+		c.Conn.Close()
+	}()
+	for {
+		messageType, message, err := c.Conn.ReadMessage()
+		if err != nil {
+			log.Printf("Error reading message from client %s: %v", c.ID, err)
+			break
+		}
+		if messageType == websocket.BinaryMessage {
+			c.hub.Broadcast <- &Message{
+				RoomID: c.roomID,
+				Data:   message,
+				sender: c,
+			}
+		}
+	}
+}
+
+func (c *Client) WritePump() {
+	defer func() {
+		c.Conn.Close()
+	}()
+	for message := range c.send {
+		err := c.Conn.WriteMessage(websocket.BinaryMessage, message)
+		if err != nil {
+			log.Printf("Error writing message to client %s: %v", c.ID, err)
+			break
+		}
+	}
+}
+
+func NewClient(id string, conn *websocket.Conn, hub *Hub, roomID string) *Client {
+	return &Client{
+		ID:     id,
+		Conn:   conn,
+		send:   make(chan []byte, 256),
+		hub:    hub,
+		roomID: roomID,
+	}
+}

backend/internal/models/document.go

@@ -0,0 +1,38 @@
+package models
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+type DocumentType string
+
+const (
+	DocumentTypeEditor DocumentType = "editor"
+	DocumentTypeKanban DocumentType = "kanban"
+)
+
+type Document struct {
+		ID        uuid.UUID    `json:"id"`
+  	Name      string       `json:"name"`
+  	Type      DocumentType `json:"type"`
+  	YjsState  []byte       `json:"-"` // Don't expose binary data in JSON
+  	CreatedAt time.Time    `json:"created_at"`
+  	UpdatedAt time.Time    `json:"updated_at"`
+}
+
+type CreateDocumentRequest struct {
+  	Name string       `json:"name" binding:"required"`
+  	Type DocumentType `json:"type" binding:"required"`
+  }
+
+  type UpdateStateRequest struct {
+  	State []byte `json:"state" binding:"required"`
+  }
+
+  type DocumentListResponse struct {
+  	Documents []Document `json:"documents"`
+  	Total     int        `json:"total"`
+  }
+

backend/internal/store/postgres.go

@@ -0,0 +1,164 @@
+package store
+
+import (
+	"database/sql"
+	"fmt"
+	"time"
+
+	"github.com/M1ngdaXie/realtime-collab/internal/models"
+	"github.com/google/uuid"
+	_ "github.com/lib/pq" // PostgreSQL driver
+)
+
+type Store struct{
+	db *sql.DB
+}
+
+func NewStore(databaseUrl string) (*Store, error) {
+	db, error := sql.Open("postgres", databaseUrl)
+	if error != nil {
+		return nil, error
+	}
+	if err := db.Ping(); err != nil {
+  		return nil, fmt.Errorf("failed to ping database: %w", err)
+  	}
+	db.SetMaxOpenConns(25)
+  	db.SetMaxIdleConns(5)
+  	db.SetConnMaxLifetime(5 * time.Minute)
+	return &Store{db: db}, nil
+}
+
+func (s *Store) Close() error {
+  	return s.db.Close()
+  }
+
+func (s *Store) CreateDocument(name string, docType models.DocumentType) (*models.Document, error) {
+	doc := &models.Document{
+		ID:        uuid.New(),
+		Name:      name,
+		Type:      docType,
+		YjsState:  []byte{},
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+	query := `
+  		INSERT INTO documents (id, name, type, created_at, updated_at)
+  		VALUES ($1, $2, $3, $4, $5)
+  		RETURNING id, name, type, created_at, updated_at
+	`
+	err := s.db.QueryRow(query,
+		doc.ID, 
+		doc.Name, 
+		doc.Type, 
+		doc.CreatedAt, 
+		doc.UpdatedAt,
+
+	).Scan(&doc.ID, &doc.Name, &doc.Type, &doc.CreatedAt, &doc.UpdatedAt)
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to create document: %w", err)
+	}
+	return doc, nil
+}
+
+ // GetDocument retrieves a document by ID
+  func (s *Store) GetDocument(id uuid.UUID) (*models.Document, error) {
+  	doc := &models.Document{}
+
+  	query := `
+  		SELECT id, name, type, yjs_state, created_at, updated_at
+  		FROM documents
+  		WHERE id = $1
+  	`
+
+  	err := s.db.QueryRow(query, id).Scan(
+  		&doc.ID,
+  		&doc.Name,
+  		&doc.Type,
+  		&doc.YjsState,
+  		&doc.CreatedAt,
+  		&doc.UpdatedAt,
+  	)
+
+  	if err == sql.ErrNoRows {
+  		return nil, fmt.Errorf("document not found")
+  	}
+  	if err != nil {
+  		return nil, fmt.Errorf("failed to get document: %w", err)
+  	}
+
+  	return doc, nil
+  }
+
+
+ // ListDocuments retrieves all documents
+ func (s *Store) ListDocuments() ([]models.Document, error) {
+  	query := `
+  		SELECT id, name, type, created_at, updated_at
+  		FROM documents
+  		ORDER BY created_at DESC
+  	`
+
+  	rows, err := s.db.Query(query)
+  	if err != nil {
+  		return nil, fmt.Errorf("failed to list documents: %w", err)
+  	}
+  	defer rows.Close()
+
+  	var documents []models.Document
+  	for rows.Next() {
+  		var doc models.Document
+  		err := rows.Scan(&doc.ID, &doc.Name, &doc.Type, &doc.CreatedAt, &doc.UpdatedAt)
+  		if err != nil {
+  			return nil, fmt.Errorf("failed to scan document: %w", err)
+  		}
+  		documents = append(documents, doc)
+  	}
+
+  	return documents, nil
+  }
+
+ func (s *Store) UpdateDocumentState(id uuid.UUID, state []byte) error {
+  	query := `
+  		UPDATE documents
+  		SET yjs_state = $1, updated_at = $2
+  		WHERE id = $3
+  	`
+
+  	result, err := s.db.Exec(query, state, time.Now(), id)
+  	if err != nil {
+  		return fmt.Errorf("failed to update document state: %w", err)
+  	}
+
+  	rowsAffected, err := result.RowsAffected()
+  	if err != nil {
+  		return fmt.Errorf("failed to get rows affected: %w", err)
+  	}
+
+  	if rowsAffected == 0 {
+  		return fmt.Errorf("document not found")
+  	}
+
+  	return nil
+  }
+
+ func (s *Store) DeleteDocument(id uuid.UUID) error {
+  	query := `DELETE FROM documents WHERE id = $1`
+
+  	result, err := s.db.Exec(query, id)
+  	if err != nil {
+  		return fmt.Errorf("failed to delete document: %w", err)
+  	}
+
+  	rowsAffected, err := result.RowsAffected()
+  	if err != nil {
+  		return fmt.Errorf("failed to get rows affected: %w", err)
+  	}
+
+  	if rowsAffected == 0 {
+  		return fmt.Errorf("document not found")
+  	}
+
+  	return nil
+  }
+