.env.example

@@ -1,2 +0,0 @@
-DATABASE_URL="postgres://user:password@localhost/termcloud"
-PORT="8080"

.gitignore

@@ -1,4 +1,3 @@
 build
 uploads
 .env*
-!.env.example

Makefile

@@ -1,24 +1,8 @@
 BINARY = termcloud
-ADMIN_BINARY = termcloud-admin
 
 build: clean
 	go build -o build/${BINARY} cmd/${BINARY}/main.go
-	go build -o build/${ADMIN_BINARY} cmd/admin/main.go
-
-run: build
-	./build/${BINARY}
-
-admin: build
-	./build/${ADMIN_BINARY} $(ARGS)
-
-dev:
-	DATABASE_URL="postgres://user:password@localhost/termcloud?sslmode=disable" go run cmd/${BINARY}/main.go
 
 clean:
 	go clean ./...
 	rm -rf build
-
-test:
-	go test ./...
-
-.PHONY: build run admin dev clean test

README.md

@@ -1,75 +1,3 @@
-# Termcloud
+# Termcord
 
-A simple file storage service with user buckets and usage limits.
+im just bored, this isnt gonna go anywhere.
-
-## Setup
-
-1. Set up PostgreSQL database and run the schema:
-
-```bash
-psql -d termcloud -f internal/db/schema.sql
-```
-
-2. Set environment variables:
-
-```bash
-# .env.example
-DATABASE_URL="postgres://user:password@localhost/termcloud"
-PORT="8080"
-```
-
-3. Build and run:
-
-```bash
-make build
-make run
-```
-
-## Usage
-
-### Create a user and get API key:
-
-```bash
-make admin ARGS="create-user mai sakurajima@waifu.club 5"
-```
-
-### API Endpoints
-
-All API endpoints require `X-API-Key` header.
-
-**Buckets:**
-
-- `GET /api/v1/buckets` - List user buckets
-- `POST /api/v1/buckets` - Create bucket `{"name": "my-bucket"}`
-- `DELETE /api/v1/buckets/:bucket` - Delete bucket
-
-**Objects:**
-
-- `GET /api/v1/buckets/:bucket/objects` - List objects in bucket
-- `PUT /api/v1/buckets/:bucket/objects/*` - Upload file (multipart form with "file" field)
-- `GET /api/v1/buckets/:bucket/objects/*` - Download file
-- `DELETE /api/v1/buckets/:bucket/objects/*` - Delete file
-
-**User Info:**
-
-- `GET /api/v1/user` - Get user info and usage stats
-
-### Example Usage
-
-```bash
-# Create bucket
-curl -X POST http://localhost:8080/api/v1/buckets \
-  -H "X-API-Key: your-api-key" \
-  -H "Content-Type: application/json" \
-  -d '{"name": "my-files"}'
-
-# Upload file
-curl -X PUT http://localhost:8080/api/v1/buckets/my-files/objects/test.txt \
-  -H "X-API-Key: your-api-key" \
-  -F "file=@test.txt"
-
-# Download file
-curl http://localhost:8080/api/v1/buckets/my-files/objects/test.txt \
-  -H "X-API-Key: your-api-key" \
-  -o downloaded.txt
-```

cmd/admin/main.go

@@ -1,80 +0,0 @@
-package main
-
-import (
-	"context"
-	"crypto/rand"
-	"encoding/hex"
-	"fmt"
-	"log"
-	"os"
-
-	"git.keircn.com/keiran/termcloud/internal/db"
-)
-
-func generateAPIKey() string {
-	bytes := make([]byte, 32)
-	if _, err := rand.Read(bytes); err != nil {
-		log.Fatalf("Failed to generate API key: %v", err)
-	}
-	return hex.EncodeToString(bytes)
-}
-
-func main() {
-	if len(os.Args) < 2 {
-		fmt.Println("Usage: termcloud-admin <command> [args...]")
-		fmt.Println("Commands:")
-		fmt.Println("  create-user <username> <email> [storage_limit_gb]")
-		fmt.Println("  list-users")
-		return
-	}
-
-	ctx := context.Background()
-	pool, err := db.NewPool(ctx)
-	if err != nil {
-		log.Fatalf("Failed to create database pool: %v", err)
-	}
-	defer db.ClosePool(pool)
-
-	bucketService := db.NewBucketService(pool)
-
-	switch os.Args[1] {
-	case "create-user":
-		if len(os.Args) < 4 {
-			fmt.Println("Usage: create-user <username> <email> [storage_limit_gb]")
-			return
-		}
-
-		username := os.Args[2]
-		email := os.Args[3]
-		storageLimit := int64(1) * 1024 * 1024 * 1024
-
-		if len(os.Args) >= 5 {
-			var limitGB int64
-			if _, err := fmt.Sscanf(os.Args[4], "%d", &limitGB); err != nil {
-				fmt.Printf("Invalid storage limit: %v\n", err)
-				return
-			}
-			storageLimit = limitGB * 1024 * 1024 * 1024
-		}
-
-		apiKey := generateAPIKey()
-		user, err := bucketService.CreateUser(ctx, username, email, apiKey, storageLimit)
-		if err != nil {
-			fmt.Printf("Failed to create user: %v\n", err)
-			return
-		}
-
-		fmt.Printf("Created user:\n")
-		fmt.Printf("  ID: %d\n", user.ID)
-		fmt.Printf("  Username: %s\n", user.Username)
-		fmt.Printf("  Email: %s\n", user.Email)
-		fmt.Printf("  API Key: %s\n", apiKey)
-		fmt.Printf("  Storage Limit: %d GB\n", user.StorageLimitBytes/1024/1024/1024)
-
-	case "list-users":
-		fmt.Println("List users functionality not yet implemented")
-
-	default:
-		fmt.Printf("Unknown command: %s\n", os.Args[1])
-	}
-}

cmd/termcloud/main.go

@@ -1,11 +1,6 @@
 package main
 
 import (
-	"context"
-	"log"
-	"os"
-
-	"git.keircn.com/keiran/termcloud/internal/db"
 	"git.keircn.com/keiran/termcloud/internal/handlers"
 	"github.com/labstack/echo/v4"
 	"github.com/labstack/echo/v4/middleware"
@@ -13,50 +8,21 @@ import (
 )
 
 func main() {
-	ctx := context.Background()
-
-	pool, err := db.NewPool(ctx)
-	if err != nil {
-		log.Fatalf("Failed to create database pool: %v", err)
-	}
-	defer db.ClosePool(pool)
-
-	bucketService := db.NewBucketService(pool)
-	h := handlers.NewHandlers(bucketService)
-
 	e := echo.New()
 
 	e.Use(middleware.BodyLimit("100M"))
 	e.Use(middleware.CORSWithConfig(middleware.CORSConfig{
 		AllowOrigins: []string{"*"},
-		AllowMethods: []string{echo.GET, echo.POST, echo.PUT, echo.DELETE},
+		AllowMethods: []string{echo.GET, echo.POST},
-		AllowHeaders: []string{"*"},
 	}))
 	e.Use(middleware.GzipWithConfig(middleware.GzipConfig{
 		Level: 5,
 	}))
 	e.Use(middleware.RateLimiter(middleware.NewRateLimiterMemoryStore(rate.Limit(20))))
+	e.Static("/uploads", "uploads")
 
-	e.Static("/storage", "storage")
+	e.GET("/", handlers.RootHandler)
+	e.POST("/upload", handlers.UploadHandler)
 
-	e.GET("/", h.RootHandler)
+	e.Logger.Fatal(e.Start(":8080"))
-
-	api := e.Group("/api/v1")
-	api.Use(h.AuthMiddleware)
-
-	api.GET("/user", h.GetUserInfoHandler)
-	api.GET("/buckets", h.ListBucketsHandler)
-	api.POST("/buckets", h.CreateBucketHandler)
-	api.DELETE("/buckets/:bucket", h.DeleteBucketHandler)
-	api.GET("/buckets/:bucket/objects", h.ListObjectsHandler)
-	api.PUT("/buckets/:bucket/objects/*", h.UploadObjectHandler)
-	api.GET("/buckets/:bucket/objects/*", h.GetObjectHandler)
-	api.DELETE("/buckets/:bucket/objects/*", h.DeleteObjectHandler)
-
-	port := os.Getenv("PORT")
-	if port == "" {
-		port = "8080"
-	}
-
-	e.Logger.Fatal(e.Start(":" + port))
 }

internal/db/bucket.go

@@ -1,306 +0,0 @@
-package db
-
-import (
-	"context"
-	"crypto/md5"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-type User struct {
-	ID                int64     `json:"id"`
-	Username          string    `json:"username"`
-	Email             string    `json:"email"`
-	APIKey            string    `json:"apiKey,omitempty"`
-	StorageLimitBytes int64     `json:"storageLimitBytes"`
-	CreatedAt         time.Time `json:"createdAt"`
-}
-
-type Bucket struct {
-	ID               int64     `json:"id"`
-	Name             string    `json:"name"`
-	OwnerID          int64     `json:"ownerId"`
-	StorageUsedBytes int64     `json:"storageUsedBytes"`
-	CreatedAt        time.Time `json:"createdAt"`
-}
-
-type Object struct {
-	ID             int64             `json:"id"`
-	BucketID       int64             `json:"bucketId"`
-	Key            string            `json:"key"`
-	SizeBytes      int64             `json:"sizeBytes"`
-	ContentType    string            `json:"contentType"`
-	LastModified   time.Time         `json:"lastModified"`
-	VersionID      string            `json:"versionId"`
-	MD5Checksum    string            `json:"md5Checksum"`
-	CustomMetadata map[string]string `json:"customMetadata"`
-}
-
-type BucketService struct {
-	pool *pgxpool.Pool
-}
-
-func NewBucketService(pool *pgxpool.Pool) *BucketService {
-	return &BucketService{pool: pool}
-}
-
-func (s *BucketService) CreateUser(ctx context.Context, username, email, apiKey string, storageLimit int64) (*User, error) {
-	var user User
-	err := s.pool.QueryRow(ctx, `
-		INSERT INTO users (username, email, api_key, storage_limit_bytes) 
-		VALUES ($1, $2, $3, $4) 
-		RETURNING id, username, email, storage_limit_bytes, created_at`,
-		username, email, apiKey, storageLimit).Scan(
-		&user.ID, &user.Username, &user.Email, &user.StorageLimitBytes, &user.CreatedAt)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create user: %w", err)
-	}
-	return &user, nil
-}
-
-func (s *BucketService) GetUserByAPIKey(ctx context.Context, apiKey string) (*User, error) {
-	var user User
-	err := s.pool.QueryRow(ctx, `
-		SELECT id, username, email, api_key, storage_limit_bytes, created_at 
-		FROM users WHERE api_key = $1`,
-		apiKey).Scan(&user.ID, &user.Username, &user.Email, &user.APIKey, &user.StorageLimitBytes, &user.CreatedAt)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get user by API key: %w", err)
-	}
-	return &user, nil
-}
-
-func (s *BucketService) CreateBucket(ctx context.Context, name string, ownerID int64) (*Bucket, error) {
-	var bucket Bucket
-	err := s.pool.QueryRow(ctx, `
-		INSERT INTO buckets (name, owner_id) 
-		VALUES ($1, $2) 
-		RETURNING id, name, owner_id, storage_used_bytes, created_at`,
-		name, ownerID).Scan(
-		&bucket.ID, &bucket.Name, &bucket.OwnerID, &bucket.StorageUsedBytes, &bucket.CreatedAt)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create bucket: %w", err)
-	}
-	return &bucket, nil
-}
-
-func (s *BucketService) GetUserBuckets(ctx context.Context, ownerID int64) ([]Bucket, error) {
-	rows, err := s.pool.Query(ctx, `
-		SELECT id, name, owner_id, storage_used_bytes, created_at 
-		FROM buckets WHERE owner_id = $1 ORDER BY created_at DESC`,
-		ownerID)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get user buckets: %w", err)
-	}
-	defer rows.Close()
-
-	var buckets []Bucket
-	for rows.Next() {
-		var bucket Bucket
-		err := rows.Scan(&bucket.ID, &bucket.Name, &bucket.OwnerID, &bucket.StorageUsedBytes, &bucket.CreatedAt)
-		if err != nil {
-			return nil, fmt.Errorf("failed to scan bucket: %w", err)
-		}
-		buckets = append(buckets, bucket)
-	}
-	return buckets, nil
-}
-
-func (s *BucketService) GetBucket(ctx context.Context, bucketName string, ownerID int64) (*Bucket, error) {
-	var bucket Bucket
-	err := s.pool.QueryRow(ctx, `
-		SELECT id, name, owner_id, storage_used_bytes, created_at 
-		FROM buckets WHERE name = $1 AND owner_id = $2`,
-		bucketName, ownerID).Scan(
-		&bucket.ID, &bucket.Name, &bucket.OwnerID, &bucket.StorageUsedBytes, &bucket.CreatedAt)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get bucket: %w", err)
-	}
-	return &bucket, nil
-}
-
-func (s *BucketService) DeleteBucket(ctx context.Context, bucketName string, ownerID int64) error {
-	bucket, err := s.GetBucket(ctx, bucketName, ownerID)
-	if err != nil {
-		return err
-	}
-
-	objects, err := s.ListObjects(ctx, bucket.ID)
-	if err != nil {
-		return fmt.Errorf("failed to list objects for deletion: %w", err)
-	}
-
-	for _, obj := range objects {
-		if err := os.Remove(filepath.Join("storage", bucketName, obj.Key)); err != nil {
-			continue
-		}
-	}
-
-	os.RemoveAll(filepath.Join("storage", bucketName))
-
-	_, err = s.pool.Exec(ctx, "DELETE FROM buckets WHERE name = $1 AND owner_id = $2", bucketName, ownerID)
-	if err != nil {
-		return fmt.Errorf("failed to delete bucket: %w", err)
-	}
-	return nil
-}
-
-func (s *BucketService) UploadObject(ctx context.Context, bucketID int64, key string, size int64, contentType string, content io.Reader) (*Object, error) {
-	bucket, err := s.getBucketByID(ctx, bucketID)
-	if err != nil {
-		return nil, err
-	}
-
-	user, err := s.getUserByID(ctx, bucket.OwnerID)
-	if err != nil {
-		return nil, err
-	}
-
-	if bucket.StorageUsedBytes+size > user.StorageLimitBytes {
-		return nil, fmt.Errorf("storage limit exceeded")
-	}
-
-	bucketDir := filepath.Join("storage", bucket.Name)
-	if err := os.MkdirAll(bucketDir, 0755); err != nil {
-		return nil, fmt.Errorf("failed to create bucket directory: %w", err)
-	}
-
-	filePath := filepath.Join(bucketDir, key)
-	file, err := os.Create(filePath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create file: %w", err)
-	}
-	defer file.Close()
-
-	hasher := md5.New()
-	writer := io.MultiWriter(file, hasher)
-
-	if _, err := io.Copy(writer, content); err != nil {
-		os.Remove(filePath)
-		return nil, fmt.Errorf("failed to write file: %w", err)
-	}
-
-	md5Sum := fmt.Sprintf("%x", hasher.Sum(nil))
-
-	var object Object
-	err = s.pool.QueryRow(ctx, `
-		INSERT INTO objects (bucket_id, key, size_bytes, content_type, md5_checksum) 
-		VALUES ($1, $2, $3, $4, $5) 
-		ON CONFLICT (bucket_id, key) 
-		DO UPDATE SET size_bytes = $3, content_type = $4, md5_checksum = $5, last_modified = NOW()
-		RETURNING id, bucket_id, key, size_bytes, content_type, last_modified, md5_checksum`,
-		bucketID, key, size, contentType, md5Sum).Scan(
-		&object.ID, &object.BucketID, &object.Key, &object.SizeBytes, &object.ContentType, &object.LastModified, &object.MD5Checksum)
-	if err != nil {
-		os.Remove(filePath)
-		return nil, fmt.Errorf("failed to create object record: %w", err)
-	}
-
-	return &object, nil
-}
-
-func (s *BucketService) ListObjects(ctx context.Context, bucketID int64) ([]Object, error) {
-	rows, err := s.pool.Query(ctx, `
-		SELECT id, bucket_id, key, size_bytes, content_type, last_modified, 
-			   COALESCE(version_id, ''), COALESCE(md5_checksum, '') 
-		FROM objects WHERE bucket_id = $1 ORDER BY last_modified DESC`,
-		bucketID)
-	if err != nil {
-		return nil, fmt.Errorf("failed to list objects: %w", err)
-	}
-	defer rows.Close()
-
-	var objects []Object
-	for rows.Next() {
-		var object Object
-		err := rows.Scan(&object.ID, &object.BucketID, &object.Key, &object.SizeBytes,
-			&object.ContentType, &object.LastModified, &object.VersionID, &object.MD5Checksum)
-		if err != nil {
-			return nil, fmt.Errorf("failed to scan object: %w", err)
-		}
-		objects = append(objects, object)
-	}
-	return objects, nil
-}
-
-func (s *BucketService) GetObject(ctx context.Context, bucketID int64, key string) (*Object, error) {
-	var object Object
-	err := s.pool.QueryRow(ctx, `
-		SELECT id, bucket_id, key, size_bytes, content_type, last_modified, 
-			   COALESCE(version_id, ''), COALESCE(md5_checksum, '') 
-		FROM objects WHERE bucket_id = $1 AND key = $2`,
-		bucketID, key).Scan(
-		&object.ID, &object.BucketID, &object.Key, &object.SizeBytes,
-		&object.ContentType, &object.LastModified, &object.VersionID, &object.MD5Checksum)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get object: %w", err)
-	}
-	return &object, nil
-}
-
-func (s *BucketService) DeleteObject(ctx context.Context, bucketID int64, key string) error {
-	bucket, err := s.getBucketByID(ctx, bucketID)
-	if err != nil {
-		return err
-	}
-
-	filePath := filepath.Join("storage", bucket.Name, key)
-	if err := os.Remove(filePath); err != nil && !os.IsNotExist(err) {
-		return fmt.Errorf("failed to remove file: %w", err)
-	}
-
-	_, err = s.pool.Exec(ctx, "DELETE FROM objects WHERE bucket_id = $1 AND key = $2", bucketID, key)
-	if err != nil {
-		return fmt.Errorf("failed to delete object record: %w", err)
-	}
-	return nil
-}
-
-func (s *BucketService) GetObjectFile(ctx context.Context, bucketName, key string, ownerID int64) (*os.File, error) {
-	bucket, err := s.GetBucket(ctx, bucketName, ownerID)
-	if err != nil {
-		return nil, err
-	}
-
-	_, err = s.GetObject(ctx, bucket.ID, key)
-	if err != nil {
-		return nil, err
-	}
-
-	filePath := filepath.Join("storage", bucketName, key)
-	file, err := os.Open(filePath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to open file: %w", err)
-	}
-	return file, nil
-}
-
-func (s *BucketService) getBucketByID(ctx context.Context, bucketID int64) (*Bucket, error) {
-	var bucket Bucket
-	err := s.pool.QueryRow(ctx, `
-		SELECT id, name, owner_id, storage_used_bytes, created_at 
-		FROM buckets WHERE id = $1`,
-		bucketID).Scan(
-		&bucket.ID, &bucket.Name, &bucket.OwnerID, &bucket.StorageUsedBytes, &bucket.CreatedAt)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get bucket by ID: %w", err)
-	}
-	return &bucket, nil
-}
-
-func (s *BucketService) getUserByID(ctx context.Context, userID int64) (*User, error) {
-	var user User
-	err := s.pool.QueryRow(ctx, `
-		SELECT id, username, email, storage_limit_bytes, created_at 
-		FROM users WHERE id = $1`,
-		userID).Scan(&user.ID, &user.Username, &user.Email, &user.StorageLimitBytes, &user.CreatedAt)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get user by ID: %w", err)
-	}
-	return &user, nil
-}

internal/db/schema.sql

@@ -28,35 +28,6 @@ CREATE TABLE IF NOT EXISTS objects (
     UNIQUE (bucket_id, key)
 );
 
-CREATE INDEX IF NOT EXISTS idx_buckets_owner_id ON buckets (owner_id);
-CREATE INDEX IF NOT EXISTS idx_users_api_key ON users (api_key);
 CREATE INDEX IF NOT EXISTS idx_objects_bucket_id_key ON objects (bucket_id, key);
 CREATE INDEX IF NOT EXISTS idx_objects_bucket_id_last_modified ON objects (bucket_id, last_modified DESC);
 CREATE INDEX IF NOT EXISTS idx_objects_custom_metadata_gin ON objects USING GIN (custom_metadata);
-
-CREATE OR REPLACE FUNCTION update_bucket_storage() RETURNS TRIGGER AS $$
-BEGIN
-    IF TG_OP = 'INSERT' THEN
-        UPDATE buckets 
-        SET storage_used_bytes = storage_used_bytes + NEW.size_bytes 
-        WHERE id = NEW.bucket_id;
-        RETURN NEW;
-    ELSIF TG_OP = 'DELETE' THEN
-        UPDATE buckets 
-        SET storage_used_bytes = storage_used_bytes - OLD.size_bytes 
-        WHERE id = OLD.bucket_id;
-        RETURN OLD;
-    ELSIF TG_OP = 'UPDATE' THEN
-        UPDATE buckets 
-        SET storage_used_bytes = storage_used_bytes + NEW.size_bytes - OLD.size_bytes 
-        WHERE id = NEW.bucket_id;
-        RETURN NEW;
-    END IF;
-    RETURN NULL;
-END;
-$$ LANGUAGE plpgsql;
-
-CREATE TRIGGER update_bucket_storage_trigger
-    AFTER INSERT OR UPDATE OR DELETE ON objects
-    FOR EACH ROW
-    EXECUTE FUNCTION update_bucket_storage();

internal/handlers/handlers.go

@@ -1,222 +1,75 @@
 package handlers
 
 import (
-	"context"
+	"io"
-	"fmt"
+	"os"
-	"net/http"
-	"strconv"
-	"strings"
 
-	"git.keircn.com/keiran/termcloud/internal/db"
 	"github.com/labstack/echo/v4"
 )
 
-type Handlers struct {
+type FileInfo struct {
-	bucketService *db.BucketService
+	FileName string `json:"fileName"`
+	FileSize int64  `json:"fileSize"`
+	FileType string `json:"fileType"`
+	FileURL  string `json:"fileURL"`
 }
 
-func NewHandlers(bucketService *db.BucketService) *Handlers {
+func RootHandler(c echo.Context) error {
-	return &Handlers{bucketService: bucketService}
-}
-
-func (h *Handlers) RootHandler(c echo.Context) error {
 	return c.JSON(200, map[string]string{
 		"status": "😺",
 		"docs":   "https://illfillthisoutlater.com",
 	})
 }
 
-func (h *Handlers) AuthMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
+func UploadHandler(c echo.Context) error {
-	return func(c echo.Context) error {
-		apiKey := c.Request().Header.Get("X-API-Key")
-		if apiKey == "" {
-			return c.JSON(401, map[string]string{"error": "API key required"})
-		}
-
-		user, err := h.bucketService.GetUserByAPIKey(context.Background(), apiKey)
-		if err != nil {
-			return c.JSON(401, map[string]string{"error": "Invalid API key"})
-		}
-
-		c.Set("user", user)
-		return next(c)
-	}
-}
-
-func (h *Handlers) CreateBucketHandler(c echo.Context) error {
-	user := c.Get("user").(*db.User)
-
-	var req struct {
-		Name string `json:"name"`
-	}
-	if err := c.Bind(&req); err != nil {
-		return c.JSON(400, map[string]string{"error": "Invalid request body"})
-	}
-
-	if req.Name == "" {
-		return c.JSON(400, map[string]string{"error": "Bucket name is required"})
-	}
-
-	bucket, err := h.bucketService.CreateBucket(context.Background(), req.Name, user.ID)
-	if err != nil {
-		if strings.Contains(err.Error(), "duplicate key") {
-			return c.JSON(409, map[string]string{"error": "Bucket name already exists"})
-		}
-		return c.JSON(500, map[string]string{"error": "Failed to create bucket"})
-	}
-
-	return c.JSON(201, bucket)
-}
-
-func (h *Handlers) ListBucketsHandler(c echo.Context) error {
-	user := c.Get("user").(*db.User)
-
-	buckets, err := h.bucketService.GetUserBuckets(context.Background(), user.ID)
-	if err != nil {
-		return c.JSON(500, map[string]string{"error": "Failed to list buckets"})
-	}
-
-	return c.JSON(200, map[string]any{
-		"buckets": buckets,
-	})
-}
-
-func (h *Handlers) DeleteBucketHandler(c echo.Context) error {
-	user := c.Get("user").(*db.User)
-	bucketName := c.Param("bucket")
-
-	if err := h.bucketService.DeleteBucket(context.Background(), bucketName, user.ID); err != nil {
-		if strings.Contains(err.Error(), "no rows") {
-			return c.JSON(404, map[string]string{"error": "Bucket not found"})
-		}
-		return c.JSON(500, map[string]string{"error": "Failed to delete bucket"})
-	}
-
-	return c.JSON(200, map[string]string{"message": "Bucket deleted successfully"})
-}
-
-func (h *Handlers) UploadObjectHandler(c echo.Context) error {
-	user := c.Get("user").(*db.User)
-	bucketName := c.Param("bucket")
-	objectKey := c.Param("*")
-
-	bucket, err := h.bucketService.GetBucket(context.Background(), bucketName, user.ID)
-	if err != nil {
-		if strings.Contains(err.Error(), "no rows") {
-			return c.JSON(404, map[string]string{"error": "Bucket not found"})
-		}
-		return c.JSON(500, map[string]string{"error": "Failed to get bucket"})
-	}
-
 	file, err := c.FormFile("file")
 	if err != nil {
+		c.Logger().Errorf("Error retrieving file from request: %v", err)
 		return c.JSON(400, map[string]string{"error": "Failed to retrieve file"})
 	}
 
+	if file == nil {
+		c.Logger().Error("No file provided in the request")
+		return c.JSON(400, map[string]string{"error": "No file provided"})
+	}
+
 	src, err := file.Open()
 	if err != nil {
+		c.Logger().Errorf("Error opening uploaded file: %v", err)
 		return c.JSON(500, map[string]string{"error": "Failed to open file"})
 	}
 	defer src.Close()
 
-	contentType := file.Header.Get("Content-Type")
+	fileName := file.Filename
-	if contentType == "" {
+	fileSize := file.Size
-		contentType = "application/octet-stream"
+	fileType := file.Header.Get("Content-Type")
-	}
 
-	object, err := h.bucketService.UploadObject(context.Background(), bucket.ID, objectKey, file.Size, contentType, src)
+	c.Logger().Infof("Received file: %s, Size: %d bytes, Type: %s", fileName, fileSize, fileType)
+
+	err = os.MkdirAll("uploads", 0o755)
 	if err != nil {
-		if strings.Contains(err.Error(), "storage limit exceeded") {
+		c.Logger().Errorf("Error creating uploads directory: %v", err)
-			return c.JSON(413, map[string]string{"error": "Storage limit exceeded"})
+		return c.JSON(500, map[string]string{"error": "Failed to create upload directory"})
-		}
-		return c.JSON(500, map[string]string{"error": "Failed to upload object"})
 	}
 
-	return c.JSON(201, object)
+	dst, err := os.Create("uploads/" + fileName)
-}
-
-func (h *Handlers) ListObjectsHandler(c echo.Context) error {
-	user := c.Get("user").(*db.User)
-	bucketName := c.Param("bucket")
-
-	bucket, err := h.bucketService.GetBucket(context.Background(), bucketName, user.ID)
 	if err != nil {
-		if strings.Contains(err.Error(), "no rows") {
+		c.Logger().Errorf("Error creating file on server: %v", err)
-			return c.JSON(404, map[string]string{"error": "Bucket not found"})
+		return c.JSON(500, map[string]string{"error": "Failed to save file"})
-		}
+	}
-		return c.JSON(500, map[string]string{"error": "Failed to get bucket"})
+	defer dst.Close()
+
+	if _, err := io.Copy(dst, src); err != nil {
+		c.Logger().Errorf("Error saving uploaded file: %v", err)
+		return c.JSON(500, map[string]string{"error": "Failed to save file"})
 	}
 
-	objects, err := h.bucketService.ListObjects(context.Background(), bucket.ID)
+	fileURL := "http://localhost:8080/uploads/" + fileName
-	if err != nil {
-		return c.JSON(500, map[string]string{"error": "Failed to list objects"})
-	}
 
-	return c.JSON(200, map[string]any{
+	return c.JSON(200, FileInfo{
-		"objects": objects,
+		FileName: fileName,
-	})
+		FileSize: fileSize,
-}
+		FileType: fileType,
-
+		FileURL:  fileURL,
-func (h *Handlers) GetObjectHandler(c echo.Context) error {
-	user := c.Get("user").(*db.User)
-	bucketName := c.Param("bucket")
-	objectKey := c.Param("*")
-
-	file, err := h.bucketService.GetObjectFile(context.Background(), bucketName, objectKey, user.ID)
-	if err != nil {
-		if strings.Contains(err.Error(), "no rows") {
-			return c.JSON(404, map[string]string{"error": "Object not found"})
-		}
-		return c.JSON(500, map[string]string{"error": "Failed to get object"})
-	}
-	defer file.Close()
-
-	stat, err := file.Stat()
-	if err != nil {
-		return c.JSON(500, map[string]string{"error": "Failed to get file info"})
-	}
-
-	c.Response().Header().Set("Content-Length", strconv.FormatInt(stat.Size(), 10))
-	c.Response().Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", objectKey))
-
-	return c.Stream(http.StatusOK, "application/octet-stream", file)
-}
-func (h *Handlers) DeleteObjectHandler(c echo.Context) error {
-	user := c.Get("user").(*db.User)
-	bucketName := c.Param("bucket")
-	objectKey := c.Param("*")
-
-	bucket, err := h.bucketService.GetBucket(context.Background(), bucketName, user.ID)
-	if err != nil {
-		if strings.Contains(err.Error(), "no rows") {
-			return c.JSON(404, map[string]string{"error": "Bucket not found"})
-		}
-		return c.JSON(500, map[string]string{"error": "Failed to get bucket"})
-	}
-
-	if err := h.bucketService.DeleteObject(context.Background(), bucket.ID, objectKey); err != nil {
-		return c.JSON(500, map[string]string{"error": "Failed to delete object"})
-	}
-
-	return c.JSON(200, map[string]string{"message": "Object deleted successfully"})
-}
-
-func (h *Handlers) GetUserInfoHandler(c echo.Context) error {
-	user := c.Get("user").(*db.User)
-
-	buckets, err := h.bucketService.GetUserBuckets(context.Background(), user.ID)
-	if err != nil {
-		return c.JSON(500, map[string]string{"error": "Failed to get user buckets"})
-	}
-
-	var totalUsage int64
-	for _, bucket := range buckets {
-		totalUsage += bucket.StorageUsedBytes
-	}
-
-	return c.JSON(200, map[string]any{
-		"user":        user,
-		"totalUsage":  totalUsage,
-		"bucketCount": len(buckets),
 	})
 }