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
2026-03-15 22:12:07 +02:00
parent 6548f868c3
commit 6594013b53
58 changed files with 73 additions and 73 deletions

View File

@@ -0,0 +1,223 @@
package user
import (
"context"
"encoding/json"
"fmt"
"strings"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
)
// UserRepository defines the persistence interface for user data.
type UserRepository interface {
UpsertByFirebaseUID(ctx context.Context, uid, email, name, avatarURL string) (*User, error)
GetByID(ctx context.Context, id string) (*User, error)
Update(ctx context.Context, id string, req UpdateProfileRequest) (*User, error)
UpdateInTx(ctx context.Context, id string, profileReq UpdateProfileRequest, caloriesReq *UpdateProfileRequest) (*User, error)
SetRefreshToken(ctx context.Context, id, token string, expiresAt time.Time) error
FindByRefreshToken(ctx context.Context, token string) (*User, error)
ClearRefreshToken(ctx context.Context, id string) error
}
type Repository struct {
pool *pgxpool.Pool
}
func NewRepository(pool *pgxpool.Pool) *Repository {
return &Repository{pool: pool}
}
func (r *Repository) UpsertByFirebaseUID(ctx context.Context, uid, email, name, avatarURL string) (*User, error) {
var avatarPtr *string
if avatarURL != "" {
avatarPtr = &avatarURL
}
query := `
INSERT INTO users (firebase_uid, email, name, avatar_url)
VALUES ($1, $2, $3, $4)
ON CONFLICT (firebase_uid) DO UPDATE SET
email = EXCLUDED.email,
name = CASE WHEN users.name = '' THEN EXCLUDED.name ELSE users.name END,
avatar_url = COALESCE(EXCLUDED.avatar_url, users.avatar_url),
updated_at = now()
RETURNING id, firebase_uid, email, name, avatar_url,
height_cm, weight_kg, date_of_birth, gender, activity, goal, daily_calories,
plan, preferences, created_at, updated_at`
return r.scanUser(r.pool.QueryRow(ctx, query, uid, email, name, avatarPtr))
}
func (r *Repository) GetByID(ctx context.Context, id string) (*User, error) {
query := `
SELECT id, firebase_uid, email, name, avatar_url,
height_cm, weight_kg, date_of_birth, gender, activity, goal, daily_calories,
plan, preferences, created_at, updated_at
FROM users WHERE id = $1`
return r.scanUser(r.pool.QueryRow(ctx, query, id))
}
func (r *Repository) Update(ctx context.Context, id string, req UpdateProfileRequest) (*User, error) {
query, args := buildUpdateQuery(id, req)
if query == "" {
return r.GetByID(ctx, id)
}
return r.scanUser(r.pool.QueryRow(ctx, query, args...))
}
// buildUpdateQuery constructs a dynamic UPDATE query from the request fields.
// Returns empty string if there are no fields to update.
func buildUpdateQuery(id string, req UpdateProfileRequest) (string, []interface{}) {
setClauses := []string{}
args := []interface{}{}
argIdx := 1
if req.Name != nil {
setClauses = append(setClauses, fmt.Sprintf("name = $%d", argIdx))
args = append(args, *req.Name)
argIdx++
}
if req.HeightCM != nil {
setClauses = append(setClauses, fmt.Sprintf("height_cm = $%d", argIdx))
args = append(args, *req.HeightCM)
argIdx++
}
if req.WeightKG != nil {
setClauses = append(setClauses, fmt.Sprintf("weight_kg = $%d", argIdx))
args = append(args, *req.WeightKG)
argIdx++
}
if req.DateOfBirth != nil {
setClauses = append(setClauses, fmt.Sprintf("date_of_birth = $%d", argIdx))
args = append(args, *req.DateOfBirth)
argIdx++
}
if req.Gender != nil {
setClauses = append(setClauses, fmt.Sprintf("gender = $%d", argIdx))
args = append(args, *req.Gender)
argIdx++
}
if req.Activity != nil {
setClauses = append(setClauses, fmt.Sprintf("activity = $%d", argIdx))
args = append(args, *req.Activity)
argIdx++
}
if req.Goal != nil {
setClauses = append(setClauses, fmt.Sprintf("goal = $%d", argIdx))
args = append(args, *req.Goal)
argIdx++
}
if req.Preferences != nil {
setClauses = append(setClauses, fmt.Sprintf("preferences = $%d", argIdx))
args = append(args, string(*req.Preferences))
argIdx++
}
if req.DailyCalories != nil {
setClauses = append(setClauses, fmt.Sprintf("daily_calories = $%d", argIdx))
args = append(args, *req.DailyCalories)
argIdx++
}
if len(setClauses) == 0 {
return "", nil
}
setClauses = append(setClauses, "updated_at = now()")
query := fmt.Sprintf(`
UPDATE users SET %s
WHERE id = $%d
RETURNING id, firebase_uid, email, name, avatar_url,
height_cm, weight_kg, date_of_birth, gender, activity, goal, daily_calories,
plan, preferences, created_at, updated_at`,
strings.Join(setClauses, ", "), argIdx)
args = append(args, id)
return query, args
}
func (r *Repository) UpdateInTx(ctx context.Context, id string, profileReq UpdateProfileRequest, caloriesReq *UpdateProfileRequest) (*User, error) {
tx, err := r.pool.BeginTx(ctx, pgx.TxOptions{})
if err != nil {
return nil, fmt.Errorf("begin tx: %w", err)
}
defer tx.Rollback(ctx)
// First update: profile fields
query, args := buildUpdateQuery(id, profileReq)
if query == "" {
return nil, fmt.Errorf("no fields to update")
}
updated, err := r.scanUser(tx.QueryRow(ctx, query, args...))
if err != nil {
return nil, fmt.Errorf("update profile: %w", err)
}
// Second update: calories (if provided)
if caloriesReq != nil {
query, args = buildUpdateQuery(id, *caloriesReq)
if query != "" {
updated, err = r.scanUser(tx.QueryRow(ctx, query, args...))
if err != nil {
return nil, fmt.Errorf("update calories: %w", err)
}
}
}
if err := tx.Commit(ctx); err != nil {
return nil, fmt.Errorf("commit tx: %w", err)
}
return updated, nil
}
func (r *Repository) SetRefreshToken(ctx context.Context, id, token string, expiresAt time.Time) error {
query := `UPDATE users SET refresh_token = $2, token_expires_at = $3, updated_at = now() WHERE id = $1`
_, err := r.pool.Exec(ctx, query, id, token, expiresAt)
return err
}
func (r *Repository) FindByRefreshToken(ctx context.Context, token string) (*User, error) {
query := `
SELECT id, firebase_uid, email, name, avatar_url,
height_cm, weight_kg, date_of_birth, gender, activity, goal, daily_calories,
plan, preferences, created_at, updated_at
FROM users
WHERE refresh_token = $1 AND token_expires_at > now()`
return r.scanUser(r.pool.QueryRow(ctx, query, token))
}
func (r *Repository) ClearRefreshToken(ctx context.Context, id string) error {
query := `UPDATE users SET refresh_token = NULL, token_expires_at = NULL, updated_at = now() WHERE id = $1`
_, err := r.pool.Exec(ctx, query, id)
return err
}
type scannable interface {
Scan(dest ...interface{}) error
}
func (r *Repository) scanUser(row scannable) (*User, error) {
var u User
var prefs []byte
var dob *time.Time
err := row.Scan(
&u.ID, &u.FirebaseUID, &u.Email, &u.Name, &u.AvatarURL,
&u.HeightCM, &u.WeightKG, &dob, &u.Gender, &u.Activity, &u.Goal, &u.DailyCalories,
&u.Plan, &prefs, &u.CreatedAt, &u.UpdatedAt,
)
if err != nil {
return nil, fmt.Errorf("scan user: %w", err)
}
if dob != nil {
s := dob.Format("2006-01-02")
u.DateOfBirth = &s
}
u.Preferences = json.RawMessage(prefs)
return &u, nil
}