WIP: deployed syncing

.dockerignore

···
+# Exclude everything by default
+*
+
+# Then explicitly include only what's needed
+
+# Include Go files and modules
+!go.mod
+!go.sum
+!server/
+!db/
+
+# For the frontend
+!mast-react-vite/src/
+!mast-react-vite/public/
+!mast-react-vite/index.html
+!mast-react-vite/package.json
+!mast-react-vite/package-lock.json
+!mast-react-vite/*.config.js
+!mast-react-vite/*.config.ts
+
+# Keep excluding node_modules even with the include patterns above
+**/node_modules
+
+# Exclude common large/unnecessary files
+**/.git
+**/.gitignore
+**/.DS_Store
+**/dist
+**/build
+**/*.log
+**/*.test.*
+**/*.spec.*
+**/*.tmp
+**/.env*
+**/.vscode
+**/.idea

Dockerfile

···
-# Dockerfile
+# Base builder
+FROM golang:1.21-alpine AS base
+WORKDIR /app
+RUN apk add --no-cache gcc musl-dev
+COPY go.mod go.sum ./
+RUN go mod download
+COPY db/crsqlite.so ./db/
 
-# Step 1: Use a Node.js image to build the app
-FROM node:18 as builder
-
-# Set working directory inside the container
+# Frontend builder
+FROM node:18-alpine AS frontend-builder
 WORKDIR /app
-
-# Copy package.json and package-lock.json
-COPY ./mast-react-vite/package*.json ./
-
-# Install dependencies
+COPY ./mast-react-vite/package.json ./mast-react-vite/package-lock.json ./
 RUN npm install
-
-# Copy the rest of the app’s source code
-COPY ./mast-react-vite/ .
-
-# Build the app
+COPY ./mast-react-vite/src ./src
+COPY ./mast-react-vite/public ./public 
+COPY ./mast-react-vite/index.html ./
+COPY ./mast-react-vite/*.config.js ./mast-react-vite/*.config.ts ./
 RUN npm run build
 
+# Server builder
+FROM base AS server-builder
+WORKDIR /app
+COPY server/main.go server/auth.go server/auth.db server/test.go ./server/
+RUN CGO_ENABLED=1 go build -o /app/bin/server ./server/main.go ./server/auth.go
 
-# Step 2: Use an Nginx image to serve the static files
-FROM nginx:alpine
-
-# Copy the build files from the builder stage to the Nginx web directory
-COPY --from=builder /app/dist /usr/share/nginx/html
-
-# Expose port 80
+# Frontend stage
+FROM nginx:alpine AS frontend
+COPY --from=frontend-builder /app/dist /usr/share/nginx/html
+RUN mkdir -p /usr/share/nginx/html/db
+COPY --from=base /app/db/crsqlite.so /usr/share/nginx/html/db/crsqlite.so
 EXPOSE 80
+CMD ["nginx", "-g", "daemon off;"]
 
-# Start Nginx server
-CMD ["nginx", "-g", "daemon off;"]
+# Server stage
+FROM alpine:latest AS server
+WORKDIR /app
+RUN apk add --no-cache ca-certificates
+COPY --from=server-builder /app/bin/server /app/
+COPY --from=base /app/db/ /app/db/
+RUN mkdir -p /app/rooms
+EXPOSE 8080
+CMD ["/app/server"]

fly.server.toml

···
+# fly.toml file for the Go server
+app = "mast-server"
+kill_signal = "SIGINT"
+kill_timeout = 5
+primary_region = "sea"
+
+[build]
+  dockerfile = "Dockerfile"
+  build-target = "server"
+
+[env]
+
+[http_service]
+  internal_port = 8080
+  force_https = true
+  auto_stop_machines = true
+  auto_start_machines = true
+  min_machines_running = 0
+  processes = ["app"]
+
+[mounts]
+  source = "server_data"
+  destination = "/app/rooms"

fly.toml

···
 primary_region = 'sea'
 
 [build]
+  dockerfile = "Dockerfile"
+  build-target = "frontend"
+
+[env]
 
 [http_service]
   internal_port = 80

mast-react-vite/src/hooks/use-sync.ts

···
   useEffect(() => {
     if (!worker) return;
     
-    // Start sync
+    // Start sync with request for unsynced changes
+    console.log(`Starting sync for ${dbname} with room ${room} and requesting unsynced changes`);
     worker.postMessage({
       type: 'START_SYNC',
       dbname,
       config: {
         room: room, 
-        url: endpoint
+        url: endpoint,
+        requestUnsyncedChanges: true // Request server to send unsynced changes immediately
       }
     });
     

mast-react-vite/src/main.tsx

···
 
 // Custom sync component using your own implementation
 function CustomSyncComponent({ dbname, roomId }: { dbname: string, roomId: string }) {
-  const endpoint = `ws://localhost:8080/sync`;
+  const endpoint = process.env.NODE_ENV === 'production' 
+    ? `wss://mast-server.fly.dev/sync` 
+    : `ws://localhost:8080/sync`;
   
   const syncStats = useCustomSync({
     dbname,
···
     
     console.log("Request body:", JSON.stringify(requestBody));
     
-    const response = await fetch('http://localhost:8080/auth/register-key', {
+    const authEndpoint = process.env.NODE_ENV === 'production' 
+      ? 'https://mast-server.fly.dev/auth/register-key'
+      : 'http://localhost:8080/auth/register-key';
+    const response = await fetch(authEndpoint, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',

mast-react-vite/src/worker/sync-worker.ts

···
   room: string;
   url: string;
   isConnecting: boolean;
+  requestUnsyncedChanges?: boolean;
 }> = {};
 
 // Handle messages from the main thread
···
       const separator = wsUrl.includes('?') ? '&' : '?';
       wsUrl = `${wsUrl}${separator}room=${config.room}`;
     }
+    
+    // Store the requestUnsyncedChanges flag in the connection
+    connections[dbname].requestUnsyncedChanges = config.requestUnsyncedChanges;
     logDebug(`Connecting to WebSocket at ${wsUrl}`);
     
     const ws = new WebSocket(wsUrl);
···
       });
       
       // Initial sync - request changes from server
-      logDebug(`Sending initial pull request`);
+      logDebug(`Sending initial pull request with requestUnsyncedChanges=${connections[dbname].requestUnsyncedChanges}`);
       ws.send(JSON.stringify({
         type: "pull",
-        room: config.room
+        room: config.room,
+        requestUnsyncedChanges: connections[dbname].requestUnsyncedChanges // Request any unsynced changes from server if specified
       }));
       
       // Notify main thread of connection

server/Dockerfile

···
+# Server Dockerfile for Go application
+
+# Build stage
+FROM golang:1.21-alpine AS builder
+
+WORKDIR /app
+
+# Install build dependencies
+RUN apk add --no-cache gcc musl-dev
+
+# Copy go mod files
+COPY go.mod go.sum ./
+
+# Download dependencies
+RUN go mod download
+
+# Copy source code
+COPY server/ ./server/
+COPY db/ ./db/
+
+# Create output directory
+RUN mkdir -p /app/bin
+
+# Build the application
+RUN CGO_ENABLED=1 go build -o /app/bin/server-app ./server/main.go
+
+# Final stage
+FROM alpine:latest
+
+WORKDIR /app
+
+# Install runtime dependencies
+RUN apk add --no-cache ca-certificates
+
+# Copy binary from builder stage
+COPY --from=builder /app/bin/server-app /app/
+
+# Copy SQLite extension
+COPY --from=builder /app/db/crsqlite.so /app/db/crsqlite.so
+
+# Create directory for room databases
+RUN mkdir -p /app/rooms
+
+# Expose port
+EXPOSE 8080
+
+# Run the application
+CMD ["/app/server-app"]

server/main.go

···
 		removeClientFromRoom(roomID, conn)
 	}()
 	
-	// Send initial changes to client
-	sendInitialChanges(conn, db)
+	// We don't automatically send initial changes anymore
+	// The client will request them with a pull message that includes requestUnsyncedChanges
 	
 	// Handle incoming messages
 	for {
···
 		switch msgType {
 		case "pull":
 			// Client is requesting changes
+			log.Printf("Client in room %s requested pull", roomID)
 			changes := getChangesFromDB(db, msg)
 			response := map[string]interface{}{
 				"type": "changes",
···
 }
 
 func getChangesFromDB(db *sql.DB, msg map[string]interface{}) []map[string]interface{} {
-	// Implementation to get changes based on client's request
-	// This would typically filter based on site_id and version
+	// Check if client is requesting unsynced changes
+	requestUnsyncedChanges, _ := msg["requestUnsyncedChanges"].(bool)
+	log.Printf("Client requesting changes. Unsynced changes requested: %v", requestUnsyncedChanges)
 	
-	rows, err := db.Query("SELECT * FROM crsql_changes")
+	// Default query gets all changes
+	query := "SELECT * FROM crsql_changes"
+	
+	// If we need to send all unsynced changes, no need to filter
+	// But in a more sophisticated implementation, we could filter based on timestamps
+	// or some other mechanism to determine what's "unsynced"
+	
+	rows, err := db.Query(query)
 	if err != nil {
 		log.Println("Error querying changes:", err)
 		return nil
···
 		changes = append(changes, change)
 	}
 	
+	log.Printf("Returning %d changes to client for sync", len(changes))
 	return changes
 }