paliad/internal/services/storage.go

// Package services — Supabase Storage client for Paliad document uploads.
//
// Paliad uses Supabase Storage (youpc instance) for the PDF blobs backing
// paliad.dokumente rows. Writes require the service-role key; the anon key
// used for auth is not enough. If SUPABASE_SERVICE_KEY is unset at startup,
// NewStorageClient returns nil and handlers respond with 501.
package services

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"time"
)

// ErrStorageDisabled is returned when handlers invoke a storage-backed
// operation but SUPABASE_SERVICE_KEY was unset at startup.
var ErrStorageDisabled = errors.New("document storage not configured")

// StorageClient is a thin wrapper around the Supabase Storage REST API.
// A nil pointer is a valid "disabled" state; callers check for it.
type StorageClient struct {
	baseURL    string
	serviceKey string
	httpClient *http.Client
}

// NewStorageClient returns a ready-to-use client, or nil if either baseURL
// or serviceKey is empty. Handlers treat nil as "storage not configured".
func NewStorageClient(baseURL, serviceKey string) *StorageClient {
	if baseURL == "" || serviceKey == "" {
		return nil
	}
	return &StorageClient{
		baseURL:    baseURL,
		serviceKey: serviceKey,
		httpClient: &http.Client{Timeout: 60 * time.Second},
	}
}

// Upload writes a single object to the given bucket/path. Existing objects
// at the path are replaced (x-upsert: true). contentType is required.
func (s *StorageClient) Upload(ctx context.Context, bucket, path, contentType string, data io.Reader) error {
	if s == nil {
		return ErrStorageDisabled
	}
	url := fmt.Sprintf("%s/storage/v1/object/%s/%s", s.baseURL, bucket, path)

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, data)
	if err != nil {
		return fmt.Errorf("creating upload request: %w", err)
	}
	req.Header.Set("Authorization", "Bearer "+s.serviceKey)
	req.Header.Set("Content-Type", contentType)
	req.Header.Set("x-upsert", "true")

	resp, err := s.httpClient.Do(req)
	if err != nil {
		return fmt.Errorf("uploading to storage: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
		body, _ := io.ReadAll(resp.Body)
		return fmt.Errorf("storage upload failed (status %d): %s", resp.StatusCode, string(body))
	}
	return nil
}

// Download fetches an object. The caller must close the returned ReadCloser.
func (s *StorageClient) Download(ctx context.Context, bucket, path string) (io.ReadCloser, string, error) {
	if s == nil {
		return nil, "", ErrStorageDisabled
	}
	url := fmt.Sprintf("%s/storage/v1/object/%s/%s", s.baseURL, bucket, path)

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
	if err != nil {
		return nil, "", fmt.Errorf("creating download request: %w", err)
	}
	req.Header.Set("Authorization", "Bearer "+s.serviceKey)

	resp, err := s.httpClient.Do(req)
	if err != nil {
		return nil, "", fmt.Errorf("downloading from storage: %w", err)
	}
	if resp.StatusCode != http.StatusOK {
		resp.Body.Close()
		if resp.StatusCode == http.StatusNotFound {
			return nil, "", fmt.Errorf("storage object not found")
		}
		body, _ := io.ReadAll(resp.Body)
		return nil, "", fmt.Errorf("storage download failed (status %d): %s", resp.StatusCode, string(body))
	}
	return resp.Body, resp.Header.Get("Content-Type"), nil
}

// Delete removes the given paths from a bucket (Supabase accepts an array).
func (s *StorageClient) Delete(ctx context.Context, bucket string, paths []string) error {
	if s == nil {
		return ErrStorageDisabled
	}
	url := fmt.Sprintf("%s/storage/v1/object/%s", s.baseURL, bucket)

	body, err := json.Marshal(map[string][]string{"prefixes": paths})
	if err != nil {
		return fmt.Errorf("marshaling delete request: %w", err)
	}
	req, err := http.NewRequestWithContext(ctx, http.MethodDelete, url, bytes.NewReader(body))
	if err != nil {
		return fmt.Errorf("creating delete request: %w", err)
	}
	req.Header.Set("Authorization", "Bearer "+s.serviceKey)
	req.Header.Set("Content-Type", "application/json")

	resp, err := s.httpClient.Do(req)
	if err != nil {
		return fmt.Errorf("deleting from storage: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusNoContent {
		respBody, _ := io.ReadAll(resp.Body)
		return fmt.Errorf("storage delete failed (status %d): %s", resp.StatusCode, string(respBody))
	}
	return nil
}