upload handler

backend/handlers/upload.go

@@ -6,20 +6,20 @@ import (
     "database/sql"
     "encoding/hex"
     "io"
-    "mime/multipart"
     "net/http"
     "time"
 
     "github.com/gin-gonic/gin"
     "github.com/google/uuid"
-    "github.com/minio/minio-go/v7"
-	"github.com/lib/pq"
+    "github.com/lib/pq"
+    "github.com/SCGR-1/promptaid-backend/internal/storage"
 )
 
+
 // wire this in main.go: r.POST("/maps", deps.UploadMap)
 type UploadDeps struct {
     DB       *sql.DB
-    Storage  *minio.Client
+    Storage  storage.ObjectStore
     Bucket   string
     RegionOK map[string]bool // in‑memory lookup, seeded at start
     // same for SourceOK, CategoryOK, CountryOK
@@ -53,7 +53,12 @@ func (d *UploadDeps) UploadMap(c *gin.Context) {
     // repeat for source / category / countries…
 
     // ---- 3. Read file + hash it ----------------------------------------
-    buf, _ := io.ReadAll(file)
+    var buf []byte
+	buf, err = io.ReadAll(file)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "read failed"})
+		return
+	}
     sha := sha256.Sum256(buf)
     shaHex := hex.EncodeToString(sha[:])
 
@@ -61,15 +66,16 @@ func (d *UploadDeps) UploadMap(c *gin.Context) {
     objKey := "maps/" + time.Now().Format("2006/01/02/") + shaHex + ".png"
 
     // ---- 4. Upload to object storage -----------------------------------
-    _, err = d.Storage.PutObject(
-        c, d.Bucket, objKey,
-        bytes.NewReader(buf), int64(len(buf)),
-        minio.PutObjectOptions{ContentType: fileHdr.Header.Get("Content-Type")},
-    )
-    if err != nil {
-        c.JSON(http.StatusInternalServerError, gin.H{"error": "storage failed"})
-        return
-    }
+	ctx := c.Request.Context()
+	if err := d.Storage.Put(
+		ctx, objKey,
+		bytes.NewReader(buf), int64(len(buf)),
+		fileHdr.Header.Get("Content-Type"),
+	); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "storage failed"})
+		return
+	}
+
 
     // ---- 5. Insert into maps -------------------------------------------
     mapID := uuid.New()

backend/internal/storage/local.go

@@ -0,0 +1,36 @@
+package storage
+
+import (
+	"context"
+	"io"
+	"os"
+	"path/filepath"
+	"time"
+)
+
+type LocalStore struct{ root string }
+
+func NewLocalStore(root string) *LocalStore { return &LocalStore{root: root} }
+
+func (l *LocalStore) Put(_ context.Context, key string, r io.Reader, _ int64, _ string) error {
+	full := filepath.Join(l.root, key)
+	if err := os.MkdirAll(filepath.Dir(full), 0o755); err != nil {
+		return err
+	}
+	f, err := os.Create(full)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	_, err = io.Copy(f, r)
+	return err
+}
+
+func (l *LocalStore) Link(_ context.Context, key string, _ time.Duration) (string, error) {
+	// Served by Gin static handler: router.Static("/static", "./uploads")
+	return "/static/" + key, nil
+}
+
+func (l *LocalStore) Root() string {
+	return l.root
+}

backend/internal/storage/s3.go

@@ -0,0 +1,40 @@
+package storage
+
+import (
+	"context"
+	"time"
+	"io"
+
+	"github.com/minio/minio-go/v7"
+	"github.com/minio/minio-go/v7/pkg/credentials"
+)
+
+type S3Store struct {
+	cli    *minio.Client
+	bucket string
+}
+
+func NewS3Store(endpoint, accessKey, secretKey, bucket string, useSSL bool) (*S3Store, error) {
+	cli, err := minio.New(endpoint, &minio.Options{
+		Creds:  credentials.NewStaticV4(accessKey, secretKey, ""),
+		Secure: useSSL,
+	})
+	if err != nil {
+		return nil, err
+	}
+	return &S3Store{cli: cli, bucket: bucket}, nil
+}
+
+func (s *S3Store) Put(ctx context.Context, key string, r io.Reader, size int64, ctype string) error {
+	_, err := s.cli.PutObject(ctx, s.bucket, key, r, size,
+		minio.PutObjectOptions{ContentType: ctype})
+	return err
+}
+
+func (s *S3Store) Link(ctx context.Context, key string, ttl time.Duration) (string, error) {
+	u, err := s.cli.PresignedGetObject(ctx, s.bucket, key, ttl, nil)
+	if err != nil {
+		return "", err
+	}
+	return u.String(), nil
+}

backend/internal/storage/storage.go

@@ -0,0 +1,16 @@
+package storage
+
+import (
+	"context"
+	"time"
+	"io"
+)
+
+// ObjectStore is a minimal interface for saving and later linking to blobs.
+type ObjectStore interface {
+	// Put permanently stores the object under key.
+	Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) error
+
+	// Link returns a URL valid for roughly ttl (ignored by LocalStore).
+	Link(ctx context.Context, key string, ttl time.Duration) (string, error)
+}

backend/main.go

@@ -1,14 +1,71 @@
 package main
 
 import (
-    "net/http"
-    "github.com/gin-gonic/gin"
+	"database/sql"
+	"log"
+	"os"
+
+	"github.com/gin-gonic/gin"
+	_ "github.com/lib/pq"
+
+	"github.com/SCGR-1/promptaid-backend/internal/storage"
+    "github.com/SCGR-1/promptaid-backend/handlers"
 )
 
+type Config struct {
+    S3Bucket  string
+    UploadDir string
+}
+
+func loadConfig() Config {
+    return Config{
+        S3Bucket:  os.Getenv("S3_BUCKET"),
+        UploadDir: os.Getenv("UPLOAD_DIR"),
+    }
+}
+
+
 func main() {
-    r := gin.Default()
-    r.GET("/health", func(c *gin.Context) {
-        c.JSON(http.StatusOK, gin.H{"status": "ok"})
-    })
-    r.Run()
+	
+    cfg := loadConfig()
+
+    // ---- 1. connect DB  ----
+	db, err := sql.Open("postgres", os.Getenv("DATABASE_URL"))
+	if err != nil { log.Fatal(err) }
+
+	// ---- 2. choose storage driver ----
+	var store storage.ObjectStore
+	switch os.Getenv("STORAGE_DRIVER") {
+	case "s3":
+		store, err = storage.NewS3Store(
+			os.Getenv("S3_ENDPOINT"),
+			os.Getenv("S3_KEY"),
+			os.Getenv("S3_SECRET"),
+			os.Getenv("S3_BUCKET"),
+			os.Getenv("S3_SSL") == "true",
+		)
+		if err != nil { log.Fatal(err) }
+	default: // local
+		uploadDir := os.Getenv("UPLOAD_DIR")
+		if uploadDir == "" { uploadDir = "./uploads" }
+		store = storage.NewLocalStore(uploadDir)
+	}
+
+    uploadDeps := handlers.UploadDeps{
+        DB:       db,
+        Storage:  store,
+        Bucket:   cfg.S3Bucket,
+        RegionOK: make(map[string]bool),
+    }
+
+	// ---- 3. build server ----
+	r := gin.Default()
+
+	if l, ok := store.(*storage.LocalStore); ok {
+		r.Static("/static", l.Root()) // add Root() getter or hardcode "./uploads"
+	}
+
+    r.POST("/maps", uploadDeps.UploadMap)
+
+	log.Fatal(r.Run(":8080"))
 }

backend/server/server.go

@@ -0,0 +1,15 @@
+package server //
+
+import (
+    "database/sql"
+    "github.com/SCGR-1/promptaid-backend/internal/storage"
+)
+
+type Server struct {
+	db    *sql.DB
+	store storage.ObjectStore
+}
+
+func NewServer(db *sql.DB, store storage.ObjectStore) *Server {
+	return &Server{db: db, store: store}
+}