refac: decouple persistence and image storage behind driver registries

internal/infrastructure/persistence/repositories/articleRepository.go

@@ -126,7 +126,7 @@ func (a *ArticleRepository) Delete(id uint32) error {
 
 func (a *ArticleRepository) FindByBodyContaining(filename string) ([]domain.Article, error) {
 	var entityArticles []entity.Article
-	err := a.db.Model(&entity.Article{}).Where("instr(body, ?) > 0", filename).Order("id asc").Find(&entityArticles).Error
+	err := a.db.Model(&entity.Article{}).Where("body LIKE ? ESCAPE '!'", containsPattern(filename)).Order("id asc").Find(&entityArticles).Error
 	if err != nil {
 		return nil, err
 	}

internal/infrastructure/persistence/repositories/imageBackfill.go

@@ -1,77 +0,0 @@
-package persistence
-
-import (
-	entity "RenewCMS/internal/infrastructure/persistence/models"
-	"bytes"
-	"crypto/sha256"
-	"encoding/hex"
-	stdimage "image"
-	"os"
-	"path/filepath"
-
-	_ "golang.org/x/image/webp"
-	_ "image/jpeg"
-	_ "image/png"
-
-	"gorm.io/gorm"
-)
-
-var extensionContentTypes = map[string]string{
-	".png":  "image/png",
-	".jpg":  "image/jpeg",
-	".jpeg": "image/jpeg",
-	".webp": "image/webp",
-	".svg":  "image/svg+xml",
-}
-
-func BackfillImageMetadata(db *gorm.DB, uploadDir string) error {
-	var pending []entity.Image
-	err := db.Where("filename = '' OR filename IS NULL").Order("id asc").Find(&pending).Error
-	if err != nil {
-		return err
-	}
-
-	for _, row := range pending {
-		metadata, ok := readStoredImage(uploadDir, row.Path)
-		if !ok {
-			continue
-		}
-		err := db.Model(&entity.Image{}).Where("id = ?", row.ID).UpdateColumns(metadata).Error
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func readStoredImage(uploadDir string, storedPath string) (map[string]any, bool) {
-	fileName := filepath.Base(storedPath)
-	contentType, known := extensionContentTypes[filepath.Ext(fileName)]
-	if !known {
-		return nil, false
-	}
-
-	data, err := os.ReadFile(filepath.Join(uploadDir, fileName))
-	if err != nil {
-		return nil, false
-	}
-
-	width, height := 0, 0
-	if contentType != "image/svg+xml" {
-		config, _, err := stdimage.DecodeConfig(bytes.NewReader(data))
-		if err != nil {
-			return nil, false
-		}
-		width, height = config.Width, config.Height
-	}
-
-	checksum := sha256.Sum256(data)
-	return map[string]any{
-		"filename":     fileName,
-		"size":         int64(len(data)),
-		"content_type": contentType,
-		"width":        width,
-		"height":       height,
-		"sha256":       hex.EncodeToString(checksum[:]),
-	}, true
-}

internal/infrastructure/persistence/repositories/imageRepository.go

@@ -4,67 +4,24 @@ import (
 	domain "RenewCMS/internal/domain/image"
 	"RenewCMS/internal/infrastructure/persistence/mappers"
 	entity "RenewCMS/internal/infrastructure/persistence/models"
-	"errors"
-	"io"
-	"os"
-	"path/filepath"
 	"strings"
 
-	"github.com/google/uuid"
 	"gorm.io/gorm"
 )
 
-const uploadedImagesURLPrefix = "/static/uploadedImages/"
-
 type ImageRepository struct {
-	db        *gorm.DB
-	uploadDir string
+	db *gorm.DB
 }
 
-func NewImageRepository(db *gorm.DB, uploadDir string) *ImageRepository {
-	return &ImageRepository{db, uploadDir}
+func NewImageRepository(db *gorm.DB) *ImageRepository {
+	return &ImageRepository{db}
 }
 
-var contentTypeExtensions = map[string]string{
-	"image/png":     ".png",
-	"image/jpeg":    ".jpeg",
-	"image/webp":    ".webp",
-	"image/svg+xml": ".svg",
-}
-
-func (i ImageRepository) Create(input domain.ImageInput) (domain.Image, error) {
-	fileBytes, err := io.ReadAll(input.Content)
-	if err != nil {
-		return domain.Image{}, err
-	}
-
-	err = os.MkdirAll(i.uploadDir, 0755)
-	if err != nil {
-		return domain.Image{}, err
-	}
-
-	newName := uuid.NewString() + contentTypeExtensions[input.ContentType]
-	finalPath := filepath.Join(i.uploadDir, newName)
-	err = os.WriteFile(finalPath, fileBytes, 0666)
-	if err != nil {
-		return domain.Image{}, err
-	}
-
-	model := mappers.ImageToModel(domain.Image{
-		Path:         uploadedImagesURLPrefix + newName,
-		Filename:     input.Filename,
-		Size:         input.Size,
-		ContentType:  input.ContentType,
-		Width:        input.Width,
-		Height:       input.Height,
-		SHA256:       input.SHA256,
-		UploadedByID: input.UploadedByID,
-	})
+func (i ImageRepository) Create(image domain.Image) (domain.Image, error) {
+	model := mappers.ImageToModel(image)
 	if err := i.db.Create(&model).Error; err != nil {
-		_ = os.Remove(finalPath)
 		return domain.Image{}, err
 	}
-
 	return mappers.ImageToDomain(model), nil
 }
 
@@ -78,24 +35,13 @@ func (i ImageRepository) Get(id uint32) (domain.Image, error) {
 }
 
 func (i ImageRepository) Delete(id uint32) error {
-	var model entity.Image
-	err := i.db.First(&model, id).Error
-	if err != nil {
-		return mapNotFoundErr(err, domain.ErrImageNotFound)
-	}
-
-	err = os.Remove(filepath.Join(i.uploadDir, filepath.Base(model.Path)))
-	if err != nil && !errors.Is(err, os.ErrNotExist) {
-		return err
-	}
-
-	return i.db.Delete(&entity.Image{}, id).Error
+	return deleteOrNotFound(i.db.Delete(&entity.Image{}, id), domain.ErrImageNotFound)
 }
 
 func (i ImageRepository) List(query domain.SearchQuery) ([]domain.Image, error) {
 	statement := i.db.Model(&entity.Image{})
 	if query.Search != "" {
-		statement = statement.Where("instr(lower(filename), ?) > 0", strings.ToLower(query.Search))
+		statement = statement.Where("LOWER(filename) LIKE ? ESCAPE '!'", containsPattern(strings.ToLower(query.Search)))
 	}
 	if query.Hash != "" {
 		statement = statement.Where("sha256 = ?", query.Hash)
@@ -171,4 +117,24 @@ func imagesToDomain(models []entity.Image) []domain.Image {
 	return images
 }
 
+func (i ImageRepository) ListMissingMetadata() ([]domain.Image, error) {
+	var models []entity.Image
+	err := i.db.Where("filename = '' OR filename IS NULL").Order("id asc").Find(&models).Error
+	if err != nil {
+		return nil, err
+	}
+	return imagesToDomain(models), nil
+}
+
+func (i ImageRepository) UpdateMetadata(id uint32, metadata domain.Metadata) error {
+	return i.db.Model(&entity.Image{}).Where("id = ?", id).UpdateColumns(map[string]any{
+		"filename":     metadata.Filename,
+		"size":         metadata.Size,
+		"content_type": metadata.ContentType,
+		"width":        metadata.Width,
+		"height":       metadata.Height,
+		"sha256":       metadata.SHA256,
+	}).Error
+}
+
 var _ domain.Repository = &ImageRepository{}

internal/infrastructure/persistence/repositories/notFound.go

@@ -2,6 +2,7 @@ package persistence
 
 import (
 	"errors"
+	"strings"
 
 	"gorm.io/gorm"
 )
@@ -22,3 +23,8 @@ func deleteOrNotFound(result *gorm.DB, sentinel error) error {
 	}
 	return nil
 }
+
+func containsPattern(fragment string) string {
+	escaped := strings.NewReplacer("!", "!!", "%", "!%", "_", "!_").Replace(fragment)
+	return "%" + escaped + "%"
+}

internal/infrastructure/persistence/repositories/userRoleBackfill.go

@@ -1,33 +0,0 @@
-package persistence
-
-import (
-	domainUser "RenewCMS/internal/domain/user"
-	entity "RenewCMS/internal/infrastructure/persistence/models"
-
-	"gorm.io/gorm"
-)
-
-func BackfillUserRoles(db *gorm.DB) error {
-	return db.Transaction(func(tx *gorm.DB) error {
-		var firstUser entity.User
-		result := tx.Where("role = ''").Order("id asc").Limit(1).Find(&firstUser)
-		if result.Error != nil {
-			return result.Error
-		}
-		if result.RowsAffected == 0 {
-			return nil
-		}
-
-		var lowest entity.User
-		if err := tx.Order("id asc").First(&lowest).Error; err != nil {
-			return err
-		}
-		if lowest.Role == "" {
-			if err := tx.Model(&entity.User{}).Where("id = ?", lowest.ID).Update("role", string(domainUser.RoleOwner)).Error; err != nil {
-				return err
-			}
-		}
-
-		return tx.Model(&entity.User{}).Where("role = ''").Update("role", string(domainUser.RoleAdmin)).Error
-	})
-}