refactor: introduce internal/domain/ layer, rename model.go → entity.go
Move all business-logic packages from internal/ root into internal/domain/: auth, cuisine, diary, dish, home, ingredient, language, menu, product, recipe, recognition, recommendation, savedrecipe, tag, units, user Rename model.go → entity.go in packages that hold domain entities: diary, dish, home, ingredient, menu, product, recipe, savedrecipe, user Update all import paths accordingly (adapters, infra/server, cmd/server, tests). No logic changes. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
dbastrikin
370
backend/internal/domain/dish/repository.go
Normal file
370
backend/internal/domain/dish/repository.go
Normal file
@@ -0,0 +1,370 @@
|
||||
package dish
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
|
||||
"github.com/food-ai/backend/internal/infra/locale"
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
// Repository handles persistence for dishes and their recipes.
|
||||
type Repository struct {
|
||||
pool *pgxpool.Pool
|
||||
}
|
||||
|
||||
// NewRepository creates a new Repository.
|
||||
func NewRepository(pool *pgxpool.Pool) *Repository {
|
||||
return &Repository{pool: pool}
|
||||
}
|
||||
|
||||
// GetByID returns a dish with all its tag slugs and recipe variants.
|
||||
// Text is resolved for the language in ctx (English fallback).
|
||||
// Returns nil, nil if not found.
|
||||
func (r *Repository) GetByID(ctx context.Context, id string) (*Dish, error) {
|
||||
lang := locale.FromContext(ctx)
|
||||
|
||||
const q = `
|
||||
SELECT d.id,
|
||||
d.cuisine_slug, d.category_slug,
|
||||
COALESCE(dt.name, d.name) AS name,
|
||||
COALESCE(dt.description, d.description) AS description,
|
||||
d.image_url, d.avg_rating, d.review_count,
|
||||
d.created_at, d.updated_at
|
||||
FROM dishes d
|
||||
LEFT JOIN dish_translations dt ON dt.dish_id = d.id AND dt.lang = $2
|
||||
WHERE d.id = $1`
|
||||
|
||||
row := r.pool.QueryRow(ctx, q, id, lang)
|
||||
dish, err := scanDish(row)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return nil, nil
|
||||
}
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("get dish %s: %w", id, err)
|
||||
}
|
||||
|
||||
if err := r.loadTags(ctx, dish); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := r.loadRecipes(ctx, dish, lang); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return dish, nil
|
||||
}
|
||||
|
||||
// List returns all dishes with tag slugs (no recipe variants).
|
||||
// Text is resolved for the language in ctx.
|
||||
func (r *Repository) List(ctx context.Context) ([]*Dish, error) {
|
||||
lang := locale.FromContext(ctx)
|
||||
|
||||
const q = `
|
||||
SELECT d.id,
|
||||
d.cuisine_slug, d.category_slug,
|
||||
COALESCE(dt.name, d.name) AS name,
|
||||
COALESCE(dt.description, d.description) AS description,
|
||||
d.image_url, d.avg_rating, d.review_count,
|
||||
d.created_at, d.updated_at
|
||||
FROM dishes d
|
||||
LEFT JOIN dish_translations dt ON dt.dish_id = d.id AND dt.lang = $1
|
||||
ORDER BY d.updated_at DESC`
|
||||
|
||||
rows, err := r.pool.Query(ctx, q, lang)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("list dishes: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var dishes []*Dish
|
||||
for rows.Next() {
|
||||
d, err := scanDish(rows)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("scan dish: %w", err)
|
||||
}
|
||||
dishes = append(dishes, d)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Load tags for each dish.
|
||||
for _, d := range dishes {
|
||||
if err := r.loadTags(ctx, d); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
return dishes, nil
|
||||
}
|
||||
|
||||
// Create creates a new dish + recipe row from a CreateRequest.
|
||||
// Returns the recipe ID to be used in menu_items or user_saved_recipes.
|
||||
func (r *Repository) Create(ctx context.Context, req CreateRequest) (recipeID string, err error) {
|
||||
tx, err := r.pool.BeginTx(ctx, pgx.TxOptions{})
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("begin tx: %w", err)
|
||||
}
|
||||
defer tx.Rollback(ctx) //nolint:errcheck
|
||||
|
||||
// Resolve cuisine slug (empty string → NULL).
|
||||
cuisineSlug := nullableStr(req.CuisineSlug)
|
||||
|
||||
// Insert dish.
|
||||
var dishID string
|
||||
err = tx.QueryRow(ctx, `
|
||||
INSERT INTO dishes (cuisine_slug, name, description, image_url)
|
||||
VALUES ($1, $2, NULLIF($3,''), NULLIF($4,''))
|
||||
RETURNING id`,
|
||||
cuisineSlug, req.Name, req.Description, req.ImageURL,
|
||||
).Scan(&dishID)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("insert dish: %w", err)
|
||||
}
|
||||
|
||||
// Insert tags.
|
||||
for _, slug := range req.Tags {
|
||||
if _, err := tx.Exec(ctx,
|
||||
`INSERT INTO dish_tags (dish_id, tag_slug) VALUES ($1, $2) ON CONFLICT DO NOTHING`,
|
||||
dishID, slug,
|
||||
); err != nil {
|
||||
return "", fmt.Errorf("insert dish tag %s: %w", slug, err)
|
||||
}
|
||||
}
|
||||
|
||||
// Insert recipe.
|
||||
source := req.Source
|
||||
if source == "" {
|
||||
source = "ai"
|
||||
}
|
||||
difficulty := nullableStr(req.Difficulty)
|
||||
prepTime := nullableInt(req.PrepTimeMin)
|
||||
cookTime := nullableInt(req.CookTimeMin)
|
||||
servings := nullableInt(req.Servings)
|
||||
calories := nullableFloat(req.Calories)
|
||||
protein := nullableFloat(req.Protein)
|
||||
fat := nullableFloat(req.Fat)
|
||||
carbs := nullableFloat(req.Carbs)
|
||||
|
||||
err = tx.QueryRow(ctx, `
|
||||
INSERT INTO recipes (dish_id, source, difficulty, prep_time_min, cook_time_min, servings,
|
||||
calories_per_serving, protein_per_serving, fat_per_serving, carbs_per_serving)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
|
||||
RETURNING id`,
|
||||
dishID, source, difficulty, prepTime, cookTime, servings,
|
||||
calories, protein, fat, carbs,
|
||||
).Scan(&recipeID)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("insert recipe: %w", err)
|
||||
}
|
||||
|
||||
// Insert recipe_ingredients.
|
||||
for i, ing := range req.Ingredients {
|
||||
if _, err := tx.Exec(ctx, `
|
||||
INSERT INTO recipe_ingredients (recipe_id, name, amount, unit_code, is_optional, sort_order)
|
||||
VALUES ($1, $2, $3, NULLIF($4,''), $5, $6)`,
|
||||
recipeID, ing.Name, ing.Amount, ing.Unit, ing.IsOptional, i,
|
||||
); err != nil {
|
||||
return "", fmt.Errorf("insert ingredient %d: %w", i, err)
|
||||
}
|
||||
}
|
||||
|
||||
// Insert recipe_steps.
|
||||
for _, s := range req.Steps {
|
||||
num := s.Number
|
||||
if num <= 0 {
|
||||
num = 1
|
||||
}
|
||||
if _, err := tx.Exec(ctx, `
|
||||
INSERT INTO recipe_steps (recipe_id, step_number, timer_seconds, description)
|
||||
VALUES ($1, $2, $3, $4)`,
|
||||
recipeID, num, s.TimerSeconds, s.Description,
|
||||
); err != nil {
|
||||
return "", fmt.Errorf("insert step %d: %w", num, err)
|
||||
}
|
||||
}
|
||||
|
||||
if err := tx.Commit(ctx); err != nil {
|
||||
return "", fmt.Errorf("commit: %w", err)
|
||||
}
|
||||
return recipeID, nil
|
||||
}
|
||||
|
||||
// loadTags fills d.Tags with the slugs from dish_tags.
|
||||
func (r *Repository) loadTags(ctx context.Context, d *Dish) error {
|
||||
rows, err := r.pool.Query(ctx,
|
||||
`SELECT tag_slug FROM dish_tags WHERE dish_id = $1 ORDER BY tag_slug`, d.ID)
|
||||
if err != nil {
|
||||
return fmt.Errorf("load tags for dish %s: %w", d.ID, err)
|
||||
}
|
||||
defer rows.Close()
|
||||
for rows.Next() {
|
||||
var slug string
|
||||
if err := rows.Scan(&slug); err != nil {
|
||||
return err
|
||||
}
|
||||
d.Tags = append(d.Tags, slug)
|
||||
}
|
||||
return rows.Err()
|
||||
}
|
||||
|
||||
// loadRecipes fills d.Recipes with all recipe variants for the dish,
|
||||
// including their relational ingredients and steps.
|
||||
func (r *Repository) loadRecipes(ctx context.Context, d *Dish, lang string) error {
|
||||
rows, err := r.pool.Query(ctx, `
|
||||
SELECT r.id, r.dish_id, r.source, r.difficulty,
|
||||
r.prep_time_min, r.cook_time_min, r.servings,
|
||||
r.calories_per_serving, r.protein_per_serving, r.fat_per_serving,
|
||||
r.carbs_per_serving, r.fiber_per_serving,
|
||||
rt.notes,
|
||||
r.created_at, r.updated_at
|
||||
FROM recipes r
|
||||
LEFT JOIN recipe_translations rt ON rt.recipe_id = r.id AND rt.lang = $2
|
||||
WHERE r.dish_id = $1
|
||||
ORDER BY r.created_at DESC`, d.ID, lang)
|
||||
if err != nil {
|
||||
return fmt.Errorf("load recipes for dish %s: %w", d.ID, err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
for rows.Next() {
|
||||
rec, err := scanRecipe(rows)
|
||||
if err != nil {
|
||||
return fmt.Errorf("scan recipe: %w", err)
|
||||
}
|
||||
d.Recipes = append(d.Recipes, *rec)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Load ingredients and steps for each recipe.
|
||||
for i := range d.Recipes {
|
||||
if err := r.loadIngredients(ctx, &d.Recipes[i], lang); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := r.loadSteps(ctx, &d.Recipes[i], lang); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// loadIngredients fills rec.Ingredients from recipe_ingredients.
|
||||
func (r *Repository) loadIngredients(ctx context.Context, rec *Recipe, lang string) error {
|
||||
rows, err := r.pool.Query(ctx, `
|
||||
SELECT ri.id, ri.ingredient_id,
|
||||
COALESCE(rit.name, ri.name) AS name,
|
||||
ri.amount, ri.unit_code, ri.is_optional, ri.sort_order
|
||||
FROM recipe_ingredients ri
|
||||
LEFT JOIN recipe_ingredient_translations rit
|
||||
ON rit.ri_id = ri.id AND rit.lang = $2
|
||||
WHERE ri.recipe_id = $1
|
||||
ORDER BY ri.sort_order`, rec.ID, lang)
|
||||
if err != nil {
|
||||
return fmt.Errorf("load ingredients for recipe %s: %w", rec.ID, err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
for rows.Next() {
|
||||
var ing RecipeIngredient
|
||||
if err := rows.Scan(
|
||||
&ing.ID, &ing.IngredientID, &ing.Name,
|
||||
&ing.Amount, &ing.UnitCode, &ing.IsOptional, &ing.SortOrder,
|
||||
); err != nil {
|
||||
return fmt.Errorf("scan ingredient: %w", err)
|
||||
}
|
||||
rec.Ingredients = append(rec.Ingredients, ing)
|
||||
}
|
||||
return rows.Err()
|
||||
}
|
||||
|
||||
// loadSteps fills rec.Steps from recipe_steps.
|
||||
func (r *Repository) loadSteps(ctx context.Context, rec *Recipe, lang string) error {
|
||||
rows, err := r.pool.Query(ctx, `
|
||||
SELECT rs.id, rs.step_number,
|
||||
COALESCE(rst.description, rs.description) AS description,
|
||||
rs.timer_seconds, rs.image_url
|
||||
FROM recipe_steps rs
|
||||
LEFT JOIN recipe_step_translations rst
|
||||
ON rst.step_id = rs.id AND rst.lang = $2
|
||||
WHERE rs.recipe_id = $1
|
||||
ORDER BY rs.step_number`, rec.ID, lang)
|
||||
if err != nil {
|
||||
return fmt.Errorf("load steps for recipe %s: %w", rec.ID, err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
for rows.Next() {
|
||||
var s RecipeStep
|
||||
if err := rows.Scan(
|
||||
&s.ID, &s.StepNumber, &s.Description, &s.TimerSeconds, &s.ImageURL,
|
||||
); err != nil {
|
||||
return fmt.Errorf("scan step: %w", err)
|
||||
}
|
||||
rec.Steps = append(rec.Steps, s)
|
||||
}
|
||||
return rows.Err()
|
||||
}
|
||||
|
||||
// --- scan helpers ---
|
||||
|
||||
type scannable interface {
|
||||
Scan(dest ...any) error
|
||||
}
|
||||
|
||||
func scanDish(s scannable) (*Dish, error) {
|
||||
var d Dish
|
||||
err := s.Scan(
|
||||
&d.ID, &d.CuisineSlug, &d.CategorySlug,
|
||||
&d.Name, &d.Description, &d.ImageURL,
|
||||
&d.AvgRating, &d.ReviewCount,
|
||||
&d.CreatedAt, &d.UpdatedAt,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
d.Tags = []string{}
|
||||
return &d, nil
|
||||
}
|
||||
|
||||
func scanRecipe(s scannable) (*Recipe, error) {
|
||||
var rec Recipe
|
||||
err := s.Scan(
|
||||
&rec.ID, &rec.DishID, &rec.Source, &rec.Difficulty,
|
||||
&rec.PrepTimeMin, &rec.CookTimeMin, &rec.Servings,
|
||||
&rec.CaloriesPerServing, &rec.ProteinPerServing, &rec.FatPerServing,
|
||||
&rec.CarbsPerServing, &rec.FiberPerServing,
|
||||
&rec.Notes,
|
||||
&rec.CreatedAt, &rec.UpdatedAt,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
rec.Ingredients = []RecipeIngredient{}
|
||||
rec.Steps = []RecipeStep{}
|
||||
return &rec, nil
|
||||
}
|
||||
|
||||
// --- null helpers ---
|
||||
|
||||
func nullableStr(s string) *string {
|
||||
if s == "" {
|
||||
return nil
|
||||
}
|
||||
return &s
|
||||
}
|
||||
|
||||
func nullableInt(n int) *int {
|
||||
if n <= 0 {
|
||||
return nil
|
||||
}
|
||||
return &n
|
||||
}
|
||||
|
||||
func nullableFloat(f float64) *float64 {
|
||||
if f <= 0 {
|
||||
return nil
|
||||
}
|
||||
return &f
|
||||
}
|
||||
Reference in New Issue
Block a user