CI / lint-backend (push) Failing after 1m39s
CI / lint-mobile (push) Canceled after 11m8s
CI / test-backend (push) Canceled after 0s
CI / test-mobile (push) Canceled after 0s
CI / build-backend (push) Canceled after 0s
CI / docker (push) Canceled after 0s
374 lines
12 KiB
Go
374 lines
12 KiB
Go
package service
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"mime/multipart"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/kazier/backend/repository"
|
|
)
|
|
|
|
// ErrFileTooLarge signals an upload above MaxFileSize.
|
|
var ErrFileTooLarge = errors.New("file too large")
|
|
|
|
// ErrInvalidUpload signals a rejected upload (display name or path component).
|
|
// Handlers map it to 400 INVALID_REQUEST (never 500).
|
|
var ErrInvalidUpload = errors.New("invalid upload name")
|
|
|
|
// FileDTO serializes exactly as mobile/api/types.ts FileDto.
|
|
type FileDTO struct {
|
|
ID string `json:"id"`
|
|
Name string `json:"name"`
|
|
Size int64 `json:"size"`
|
|
MimeType string `json:"mimeType,omitempty"`
|
|
FolderID string `json:"folderId,omitempty"`
|
|
Tags []string `json:"tags,omitempty"`
|
|
CreatedAt string `json:"createdAt,omitempty"`
|
|
UpdatedAt string `json:"updatedAt,omitempty"`
|
|
}
|
|
|
|
// FolderDTO serializes exactly as mobile/api/types.ts FolderDto.
|
|
type FolderDTO struct {
|
|
ID string `json:"id"`
|
|
Name string `json:"name"`
|
|
ParentID string `json:"parentId,omitempty"`
|
|
}
|
|
|
|
// Resources holds the business logic for files/folders list-get-delete-upload,
|
|
// always scoped by the requesting USER (resources.user_id after 000007).
|
|
type Resources struct {
|
|
Repo *repository.Resources
|
|
Repository *repository.Repository
|
|
UploadDir string
|
|
MaxFileSize int64
|
|
}
|
|
|
|
func NewResources(repo *repository.Repository, uploadDir string, maxFileSize int64) *Resources {
|
|
return &Resources{
|
|
Repo: repo.Resources,
|
|
Repository: repo,
|
|
UploadDir: uploadDir,
|
|
MaxFileSize: maxFileSize,
|
|
}
|
|
}
|
|
|
|
var (
|
|
extensionPattern = regexp.MustCompile(`^[a-z0-9]{1,10}$`)
|
|
idPattern = regexp.MustCompile(`^[0-9a-f]{32}$`)
|
|
)
|
|
|
|
// allowedMimeTypes whitelists client-declared Content-Types (parameters
|
|
// stripped, lowercased) ; anything absent falls back to
|
|
// application/octet-stream (cf. FEEDBACK A16).
|
|
var allowedMimeTypes = map[string]struct{}{
|
|
"application/octet-stream": {},
|
|
"application/pdf": {},
|
|
"application/json": {},
|
|
"application/zip": {},
|
|
"text/plain": {},
|
|
"text/csv": {},
|
|
"text/markdown": {},
|
|
"image/png": {},
|
|
"image/jpeg": {},
|
|
"image/gif": {},
|
|
"image/webp": {},
|
|
"audio/mpeg": {},
|
|
"video/mp4": {},
|
|
}
|
|
|
|
// sanitizeExtension normalise l'extension issue du filename client (cf.
|
|
// FEEDBACK #5) : lowercase, [a-z0-9]{1,10}, sinon "" (pas de suffixe).
|
|
func sanitizeExtension(filename string) string {
|
|
ext := strings.ToLower(strings.TrimPrefix(filepath.Ext(filename), "."))
|
|
if !extensionPattern.MatchString(ext) {
|
|
return ""
|
|
}
|
|
return ext
|
|
}
|
|
|
|
// sanitizeFileName nettoie le nom stocké (cf. FEEDBACK A16) : TrimSpace,
|
|
// cap 255, rejet vide / slash / backslash / retour ligne. Le nom n'est
|
|
// qu'une métadonnée (jamais un composant de chemin), mais on le verrouille
|
|
// quand même pour casser toute confusion downstream.
|
|
func sanitizeFileName(name string) (string, error) {
|
|
n := strings.TrimSpace(name)
|
|
if n == "" || len(n) > 255 || strings.ContainsAny(n, "/\\\x00\n\r") {
|
|
return "", ErrInvalidUpload
|
|
}
|
|
return n, nil
|
|
}
|
|
|
|
func sanitizeMimeType(mime string) string {
|
|
m := strings.ToLower(strings.TrimSpace(mime))
|
|
if i := strings.IndexByte(m, ';'); i >= 0 {
|
|
m = strings.TrimSpace(m[:i])
|
|
}
|
|
if m == "" || len(m) > 128 {
|
|
return "application/octet-stream"
|
|
}
|
|
if _, ok := allowedMimeTypes[m]; !ok {
|
|
return "application/octet-stream"
|
|
}
|
|
return m
|
|
}
|
|
|
|
func (s *Resources) ListFiles(ownerID, folderID string, page, pageSize int, sort, order string) ([]FileDTO, int, error) {
|
|
rows, total, err := s.Repo.ListFilesVisible(ownerID, folderID, pageSize, (page-1)*pageSize, sort, order)
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
files := make([]FileDTO, 0, len(rows))
|
|
for _, row := range rows {
|
|
files = append(files, toFileDTO(row))
|
|
}
|
|
return files, total, nil
|
|
}
|
|
|
|
func (s *Resources) GetFile(ownerID, id string) (FileDTO, error) {
|
|
row, err := s.Repo.GetFileVisible(ownerID, id)
|
|
if err != nil {
|
|
return FileDTO{}, err
|
|
}
|
|
return toFileDTO(row), nil
|
|
}
|
|
|
|
// FileOcrDTO is the payload of GET /files/:id/ocr: the server-computed OCR
|
|
// extract of the resource, readable by its owner and by grantees (viewer+).
|
|
type FileOcrDTO struct {
|
|
Text string `json:"text"`
|
|
UpdatedAt string `json:"updatedAt,omitempty"`
|
|
}
|
|
|
|
// GetFileOcr returns the OCR text of a file the user can see (viewer+, own or
|
|
// shared). Absent text → Text empty ("") with 200 (the caller decides).
|
|
func (s *Resources) GetFileOcr(ownerID, id string) (FileOcrDTO, error) {
|
|
row, err := s.Repo.GetFileVisible(ownerID, id)
|
|
if err != nil {
|
|
return FileOcrDTO{}, err
|
|
}
|
|
return FileOcrDTO{
|
|
Text: row.OcrText,
|
|
UpdatedAt: row.UpdatedAt.UTC().Format(time.RFC3339),
|
|
}, nil
|
|
}
|
|
|
|
func (s *Resources) DeleteFile(ownerID, id string) (string, error) {
|
|
return s.Repo.DeleteFile(ownerID, id)
|
|
}
|
|
|
|
func (s *Resources) ListRootFolders(ownerID string) ([]FolderDTO, error) {
|
|
rows, err := s.Repo.ListRootFoldersVisible(ownerID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
folders := make([]FolderDTO, 0, len(rows))
|
|
for _, row := range rows {
|
|
folders = append(folders, FolderDTO{ID: row.ID, Name: row.Name, ParentID: row.ParentID})
|
|
}
|
|
return folders, nil
|
|
}
|
|
|
|
func (s *Resources) SearchFiles(ownerID, q string, page, pageSize int) ([]FileDTO, int, error) {
|
|
rows, total, err := s.Repo.SearchFilesVisible(ownerID, q, pageSize, (page-1)*pageSize)
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
files := make([]FileDTO, 0, len(rows))
|
|
for _, row := range rows {
|
|
files = append(files, toFileDTO(row))
|
|
}
|
|
return files, total, nil
|
|
}
|
|
|
|
// Upload persists the multipart-sourced file under UploadDir/<user> and
|
|
// records its metadata, returning the FileDTO. The physical file is removed
|
|
// if metadata persistence fails (e.g. name conflict).
|
|
//
|
|
// When resourceID is non-empty the upload TARGETS an existing file owned by
|
|
// the user (metadata-only resource from the outbox, or a previously uploaded
|
|
// file): the bytes are written under UploadDir/<user>/<resourceID>.<ext> and
|
|
// only the physical metadata (size/mime/extension) is refreshed — never a
|
|
// rename, never a move, never a duplicate row. Unknown / foreign resource →
|
|
// repo.ErrNotFound.
|
|
func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID, resourceID string) (FileDTO, error) {
|
|
// Garde anti-traversal : seuls des IDs 32-hex (ou générés) deviennent des
|
|
// composants de chemin. ownerID vient de l'auth mais on ne lui fait pas
|
|
// confiance aveuglément ; resourceID fourni par le client est déjà
|
|
// pré-validé côté handler (404), ici on rejete en NotFound/400 pareil.
|
|
if strings.ContainsAny(ownerID, "/\\\x00\n\r") || strings.Contains(ownerID, "..") {
|
|
return FileDTO{}, ErrInvalidUpload
|
|
}
|
|
targetExisting := resourceID != ""
|
|
if targetExisting {
|
|
if !idPattern.MatchString(resourceID) {
|
|
return FileDTO{}, repository.ErrNotFound
|
|
}
|
|
if _, err := s.Repo.GetFile(ownerID, resourceID); err != nil {
|
|
return FileDTO{}, err
|
|
}
|
|
} else {
|
|
var err error
|
|
resourceID, err = repository.NewIDErr()
|
|
if err != nil {
|
|
return FileDTO{}, err
|
|
}
|
|
}
|
|
|
|
name, err := sanitizeFileName(file.Filename)
|
|
if err != nil {
|
|
return FileDTO{}, err
|
|
}
|
|
extension := sanitizeExtension(file.Filename)
|
|
destDir := filepath.Join(s.UploadDir, ownerID)
|
|
if err := os.MkdirAll(destDir, 0o700); err != nil {
|
|
return FileDTO{}, fmt.Errorf("create upload dir: %w", err)
|
|
}
|
|
// MkdirAll respecte umask et ne touche pas aux dirs préexistants : on
|
|
// enforce 0700 explicitement (cf. FEEDBACK A4).
|
|
if err := os.Chmod(destDir, 0o700); err != nil {
|
|
return FileDTO{}, fmt.Errorf("chmod upload dir: %w", err)
|
|
}
|
|
|
|
destName := resourceID
|
|
if extension != "" {
|
|
destName = resourceID + "." + extension
|
|
}
|
|
destPath := filepath.Join(destDir, destName)
|
|
|
|
// Mémorise les anciens physiques pour cleanup post-succès (changement d'ext).
|
|
// Note : Glob(id.*) ne matche pas le fichier sans extension, on traite le
|
|
// chemin nu séparément (cf. FEEDBACK #6).
|
|
oldMatches, _ := filepath.Glob(filepath.Join(destDir, resourceID+".*"))
|
|
barePath := filepath.Join(destDir, resourceID)
|
|
if barePath != destPath {
|
|
if _, err := os.Stat(barePath); err == nil {
|
|
oldMatches = append(oldMatches, barePath)
|
|
}
|
|
}
|
|
|
|
written, err := copyMultipartAtomic(file, destDir, destPath, s.MaxFileSize)
|
|
if err != nil {
|
|
return FileDTO{}, err
|
|
}
|
|
|
|
mimeType := sanitizeMimeType(file.Header.Get("Content-Type"))
|
|
var extPtr *string
|
|
if extension != "" {
|
|
extPtr = &extension
|
|
}
|
|
if targetExisting {
|
|
err = s.Repo.UpdatePhysical(ownerID, resourceID, written, &mimeType, extPtr)
|
|
} else {
|
|
err = s.Repo.InsertFile(ownerID, resourceID, name, folderID, written, &mimeType, extPtr)
|
|
}
|
|
if err != nil {
|
|
// Best-effort : supprime le nouveau fichier sauf s'il préexistait à l'identique.
|
|
stillOld := false
|
|
for _, m := range oldMatches {
|
|
if m == destPath {
|
|
stillOld = true
|
|
break
|
|
}
|
|
}
|
|
if !stillOld {
|
|
_ = os.Remove(destPath)
|
|
}
|
|
return FileDTO{}, err
|
|
}
|
|
// Succès : supprime les anciens suffixes orphelins (stale bytes, cf. #6).
|
|
for _, m := range oldMatches {
|
|
if m != destPath && strings.HasPrefix(filepath.Base(m), resourceID+".") {
|
|
_ = os.Remove(m)
|
|
}
|
|
}
|
|
|
|
row, err := s.Repo.GetFile(ownerID, resourceID)
|
|
if err != nil {
|
|
// Lecture post-insert en échec : au moins logguer (cf. FEEDBACK #6).
|
|
// Sur création on tente en plus de retirer le fichier pour ne pas
|
|
// laisser d'orphelin (le client retry → NAME_CONFLICT → re-upload
|
|
// ciblé). Sur re-upload ciblé on ne touche à rien (données existantes).
|
|
log.Printf("upload: GetFile(%s) failed after persist: %v", resourceID, err)
|
|
if !targetExisting {
|
|
_ = os.Remove(destPath)
|
|
}
|
|
return FileDTO{}, err
|
|
}
|
|
return toFileDTO(row), nil
|
|
}
|
|
|
|
// copyMultipartAtomic écrit vers un temp dans destDir (0600) avec limite
|
|
// stricte maxSize+1 (header file.Size non fiable, cf. A2), fsync + rename
|
|
// atomique (cf. A3). Retourne les octets réellement écrits.
|
|
func copyMultipartAtomic(file *multipart.FileHeader, destDir, destPath string, maxSize int64) (int64, error) {
|
|
src, err := file.Open()
|
|
if err != nil {
|
|
return 0, fmt.Errorf("open multipart file: %w", err)
|
|
}
|
|
defer src.Close()
|
|
|
|
// Temp dans le même répertoire (même filesystem → rename atomique),
|
|
// pattern .tmp-<base>-* (cf. FEEDBACK A3). Jamais d'overwrite direct.
|
|
tmp, err := os.CreateTemp(destDir, ".tmp-"+filepath.Base(destPath)+".*")
|
|
if err != nil {
|
|
return 0, fmt.Errorf("create tmp file: %w", err)
|
|
}
|
|
tmpName := tmp.Name()
|
|
// En cas d'échec avant rename, nettoyer le temp.
|
|
success := false
|
|
defer func() {
|
|
if !success {
|
|
_ = os.Remove(tmpName)
|
|
}
|
|
}()
|
|
if err := tmp.Chmod(0o600); err != nil {
|
|
tmp.Close()
|
|
return 0, fmt.Errorf("chmod tmp file: %w", err)
|
|
}
|
|
|
|
limited := io.LimitReader(src, maxSize+1)
|
|
written, err := io.Copy(tmp, limited)
|
|
if err != nil {
|
|
tmp.Close()
|
|
return 0, fmt.Errorf("copy upload: %w", err)
|
|
}
|
|
if written > maxSize {
|
|
tmp.Close()
|
|
return 0, ErrFileTooLarge
|
|
}
|
|
if err := tmp.Sync(); err != nil {
|
|
tmp.Close()
|
|
return 0, fmt.Errorf("fsync upload: %w", err)
|
|
}
|
|
if err := tmp.Close(); err != nil {
|
|
return 0, fmt.Errorf("close upload: %w", err)
|
|
}
|
|
if err := os.Rename(tmpName, destPath); err != nil {
|
|
return 0, fmt.Errorf("commit upload: %w", err)
|
|
}
|
|
if err := os.Chmod(destPath, 0o600); err != nil {
|
|
return 0, fmt.Errorf("chmod upload: %w", err)
|
|
}
|
|
success = true
|
|
return written, nil
|
|
}
|
|
|
|
func toFileDTO(row repository.FileRow) FileDTO {
|
|
return FileDTO{
|
|
ID: row.ID,
|
|
Name: row.Name,
|
|
Size: row.Size,
|
|
MimeType: row.MimeType,
|
|
FolderID: row.FolderID,
|
|
CreatedAt: row.CreatedAt.UTC().Format(time.RFC3339),
|
|
UpdatedAt: row.UpdatedAt.UTC().Format(time.RFC3339),
|
|
}
|
|
}
|