fix(profile): preserve and collect profile location

Author: SX110903

backend/internal/adapters/http/profile/dto.go

@@ -1,11 +1,14 @@
 package profile
 
 type UpdateProfileRequest struct {
-	Bio                 string         `json:"bio" validate:"max=500"`
-	Interests           []string       `json:"interests" validate:"max=20,dive,max=40"`
-	City                string         `json:"city" validate:"max=120"`
+	Bio       string   `json:"bio" validate:"max=500"`
+	Interests []string `json:"interests" validate:"max=20,dive,max=40"`
+	City      string   `json:"city" validate:"max=120"`
+	// Omitting both coordinates preserves the stored location. ClearLocation
+	// is the only way to remove it.
 	Latitude            *float64       `json:"latitude" validate:"omitempty,min=-90,max=90"`
 	Longitude           *float64       `json:"longitude" validate:"omitempty,min=-180,max=180"`
+	ClearLocation       bool           `json:"clear_location"`
 	Questionnaire       map[string]any `json:"questionnaire"`
 	OnboardingCompleted bool           `json:"onboarding_completed"`
 }

backend/internal/adapters/http/profile/handler.go

@@ -88,15 +88,21 @@ func (h *Handler) UpdateProfile(w http.ResponseWriter, r *http.Request) {
 		City:                h.sanitize(req.City),
 		Latitude:            req.Latitude,
 		Longitude:           req.Longitude,
+		ClearLocation:       req.ClearLocation,
 		Questionnaire:       h.sanitizeQuestionnaire(req.Questionnaire),
 		OnboardingCompleted: req.OnboardingCompleted,
 	})
 	if err != nil {
-		if errors.Is(err, applicationprofile.ErrOnboardingIncomplete) {
+		switch {
+		case errors.Is(err, applicationprofile.ErrOnboardingIncomplete):
 			writeError(w, r, http.StatusUnprocessableEntity, "ONBOARDING_INCOMPLETE", "add a bio and at least one photo before completing onboarding")
-			return
+		case errors.Is(err, domainprofile.ErrIncompleteCoordinates):
+			writeError(w, r, http.StatusBadRequest, "INCOMPLETE_COORDINATES", "latitude and longitude must be provided together and be within range")
+		case errors.Is(err, domainprofile.ErrConflictingLocation):
+			writeError(w, r, http.StatusBadRequest, "CONFLICTING_LOCATION", "coordinates and clear_location cannot be combined")
+		default:
+			writeError(w, r, http.StatusInternalServerError, "INTERNAL_ERROR", "could not update profile")
 		}
-		writeError(w, r, http.StatusInternalServerError, "INTERNAL_ERROR", "could not update profile")
 		return
 	}
 	writeJSON(w, http.StatusOK, profileResponse(*updated))

backend/internal/adapters/postgres/queries/profiles.sql

@@ -12,7 +12,13 @@ ON CONFLICT (user_id) DO UPDATE SET
     bio = EXCLUDED.bio,
     interests = EXCLUDED.interests,
     city = EXCLUDED.city,
-    location = EXCLUDED.location,
+    -- An update that carries no coordinates must preserve the stored ones;
+    -- only an explicit clear_location drops them.
+    location = CASE
+        WHEN sqlc.arg(clear_location)::boolean THEN NULL
+        WHEN EXCLUDED.location IS NULL THEN profiles.location
+        ELSE EXCLUDED.location
+    END,
     questionnaire = EXCLUDED.questionnaire,
     onboarding_completed = EXCLUDED.onboarding_completed,
     updated_at = now();

backend/internal/adapters/postgres/repositories/profile_repository.go

@@ -73,6 +73,7 @@ func (r *ProfileRepository) UpsertProfile(ctx context.Context, p *domainprofile.
 		Latitude:            latitude,
 		Questionnaire:       questionnaire,
 		OnboardingCompleted: p.OnboardingCompleted,
+		ClearLocation:       p.ClearLocation,
 	})
 }
 

backend/internal/adapters/postgres/sqlc/profiles.sql.go

@@ -19,11 +19,16 @@ var (
 )
 
 type UpdateProfileInput struct {
-	Bio                 string
-	Interests           []string
-	City                string
+	Bio       string
+	Interests []string
+	City      string
+	// Latitude/Longitude must both be set or both be nil. Leaving them nil
+	// preserves whatever is stored; ClearLocation is the only way to remove
+	// it, so a caller that simply does not know the coordinates can never
+	// erase them by accident.
 	Latitude            *float64
 	Longitude           *float64
+	ClearLocation       bool
 	Questionnaire       map[string]any
 	OnboardingCompleted bool
 }
@@ -67,6 +72,13 @@ func (s *Service) GetProfile(ctx context.Context, userID uuid.UUID) (*domainprof
 }
 
 func (s *Service) UpdateProfile(ctx context.Context, userID uuid.UUID, in UpdateProfileInput) (*domainprofile.Profile, error) {
+	if err := validateLocationIntent(in); err != nil {
+		return nil, err
+	}
+
+	// Onboarding deliberately does not require a location: forcing a browser
+	// geolocation grant to finish signing up is hostile and denial is common.
+	// A profile without coordinates simply stays out of discovery.
 	if in.OnboardingCompleted {
 		photoCount, err := s.profiles.CountActivePhotos(ctx, userID)
 		if err != nil {
@@ -82,6 +94,7 @@ func (s *Service) UpdateProfile(ctx context.Context, userID uuid.UUID, in Update
 		Bio:                 in.Bio,
 		Interests:           in.Interests,
 		City:                in.City,
+		ClearLocation:       in.ClearLocation,
 		Questionnaire:       in.Questionnaire,
 		OnboardingCompleted: in.OnboardingCompleted,
 	}
@@ -94,6 +107,22 @@ func (s *Service) UpdateProfile(ctx context.Context, userID uuid.UUID, in Update
 	return s.profiles.GetProfile(ctx, userID)
 }
 
+func validateLocationIntent(in UpdateProfileInput) error {
+	if (in.Latitude == nil) != (in.Longitude == nil) {
+		return domainprofile.ErrIncompleteCoordinates
+	}
+	if in.ClearLocation && in.Latitude != nil {
+		return domainprofile.ErrConflictingLocation
+	}
+	if in.Latitude != nil && (*in.Latitude < -90 || *in.Latitude > 90) {
+		return domainprofile.ErrIncompleteCoordinates
+	}
+	if in.Longitude != nil && (*in.Longitude < -180 || *in.Longitude > 180) {
+		return domainprofile.ErrIncompleteCoordinates
+	}
+	return nil
+}
+
 func (s *Service) GetPreferences(ctx context.Context, userID uuid.UUID) (*domainprofile.Preferences, error) {
 	return s.profiles.GetPreferences(ctx, userID)
 }

backend/internal/application/profile/service.go

@@ -43,8 +43,21 @@ func (r *fakeProfileRepo) GetProfile(_ context.Context, userID uuid.UUID) (*doma
 	return &copied, nil
 }
 
+// UpsertProfile mirrors the location semantics of the real SQL: an explicit
+// clear drops the coordinates, new coordinates replace them, and a write that
+// carries neither leaves whatever was stored untouched.
 func (r *fakeProfileRepo) UpsertProfile(_ context.Context, p *domainprofile.Profile) error {
 	copied := *p
+	switch {
+	case p.ClearLocation:
+		copied.HasLocation = false
+	case p.Location != nil:
+		copied.HasLocation = true
+	default:
+		if existing, ok := r.profiles[p.UserID]; ok {
+			copied.HasLocation = existing.HasLocation
+		}
+	}
 	r.profiles[p.UserID] = &copied
 	return nil
 }
@@ -298,6 +311,105 @@ func TestUpdateProfileRequiresBioAndPhotoToCompleteOnboarding(t *testing.T) {
 	require.ErrorIs(t, err, applicationprofile.ErrOnboardingIncomplete)
 }
 
+// --- location intent ------------------------------------------------------
+
+func coord(value float64) *float64 { return &value }
+
+// TestUpdateProfileWithoutCoordinatesPreservesStoredLocation is the
+// regression test for the bug that made every profile undiscoverable: saving
+// the profile from the UI carried no coordinates and wiped the stored ones.
+func TestUpdateProfileWithoutCoordinatesPreservesStoredLocation(t *testing.T) {
+	repo := newFakeProfileRepo()
+	svc := newService(repo, newFakeStorage(), fakeConsentChecker{})
+	userID := uuid.New()
+
+	stored, err := svc.UpdateProfile(context.Background(), userID, applicationprofile.UpdateProfileInput{
+		Bio: "con ubicación", Latitude: coord(40.4168), Longitude: coord(-3.7038),
+	})
+	require.NoError(t, err)
+	require.True(t, stored.HasLocation)
+
+	// A later save that only edits the bio must not erase the location.
+	updated, err := svc.UpdateProfile(context.Background(), userID, applicationprofile.UpdateProfileInput{
+		Bio: "bio editada sin tocar la ubicación",
+	})
+	require.NoError(t, err)
+	require.True(t, updated.HasLocation, "omitting coordinates must preserve the stored location")
+}
+
+func TestUpdateProfileClearLocationRemovesIt(t *testing.T) {
+	repo := newFakeProfileRepo()
+	svc := newService(repo, newFakeStorage(), fakeConsentChecker{})
+	userID := uuid.New()
+
+	_, err := svc.UpdateProfile(context.Background(), userID, applicationprofile.UpdateProfileInput{
+		Bio: "con ubicación", Latitude: coord(40.4168), Longitude: coord(-3.7038),
+	})
+	require.NoError(t, err)
+
+	cleared, err := svc.UpdateProfile(context.Background(), userID, applicationprofile.UpdateProfileInput{
+		Bio: "sin ubicación", ClearLocation: true,
+	})
+	require.NoError(t, err)
+	require.False(t, cleared.HasLocation)
+}
+
+func TestUpdateProfileRejectsHalfCoordinates(t *testing.T) {
+	repo := newFakeProfileRepo()
+	svc := newService(repo, newFakeStorage(), fakeConsentChecker{})
+
+	_, err := svc.UpdateProfile(context.Background(), uuid.New(), applicationprofile.UpdateProfileInput{
+		Bio: "solo latitud", Latitude: coord(40.4168),
+	})
+	require.ErrorIs(t, err, domainprofile.ErrIncompleteCoordinates)
+
+	_, err = svc.UpdateProfile(context.Background(), uuid.New(), applicationprofile.UpdateProfileInput{
+		Bio: "solo longitud", Longitude: coord(-3.7038),
+	})
+	require.ErrorIs(t, err, domainprofile.ErrIncompleteCoordinates)
+}
+
+func TestUpdateProfileRejectsOutOfRangeCoordinates(t *testing.T) {
+	repo := newFakeProfileRepo()
+	svc := newService(repo, newFakeStorage(), fakeConsentChecker{})
+
+	_, err := svc.UpdateProfile(context.Background(), uuid.New(), applicationprofile.UpdateProfileInput{
+		Bio: "latitud imposible", Latitude: coord(91), Longitude: coord(0),
+	})
+	require.ErrorIs(t, err, domainprofile.ErrIncompleteCoordinates)
+}
+
+func TestUpdateProfileRejectsCoordinatesCombinedWithClear(t *testing.T) {
+	repo := newFakeProfileRepo()
+	svc := newService(repo, newFakeStorage(), fakeConsentChecker{})
+
+	_, err := svc.UpdateProfile(context.Background(), uuid.New(), applicationprofile.UpdateProfileInput{
+		Bio: "contradictorio", Latitude: coord(40.4168), Longitude: coord(-3.7038), ClearLocation: true,
+	})
+	require.ErrorIs(t, err, domainprofile.ErrConflictingLocation)
+}
+
+// TestUpdateProfileCompletesOnboardingWithoutLocation pins the deliberate
+// decision that a location is not required to finish onboarding.
+func TestUpdateProfileCompletesOnboardingWithoutLocation(t *testing.T) {
+	repo := newFakeProfileRepo()
+	store := newFakeStorage()
+	svc := newService(repo, store, fakeConsentChecker{})
+	userID := uuid.New()
+
+	_, err := svc.CreatePhoto(context.Background(), userID, applicationprofile.NewPhotoInput{
+		MimeType: "image/png", Width: 10, Height: 10, ByteSize: 1, Data: []byte("x"),
+	})
+	require.NoError(t, err)
+
+	updated, err := svc.UpdateProfile(context.Background(), userID, applicationprofile.UpdateProfileInput{
+		Bio: "sin ubicación pero completo", OnboardingCompleted: true,
+	})
+	require.NoError(t, err)
+	require.True(t, updated.OnboardingCompleted)
+	require.False(t, updated.HasLocation)
+}
+
 func TestCreatePhotoAssignsFirstPhotoAsPrimary(t *testing.T) {
 	repo := newFakeProfileRepo()
 	store := newFakeStorage()

backend/internal/application/profile/service_test.go

@@ -18,10 +18,14 @@ type Profile struct {
 	Bio       string
 	Interests []string
 	City      string
-	// Location carries coordinates to persist on a write. Reads never
-	// resolve it back (HasLocation is used instead) so a lossy PostGIS
-	// NULL-geography round trip can't produce a scan error.
-	Location            *Coordinates
+	// Location and ClearLocation express the write intent for the stored
+	// coordinates, which has three states: Location set replaces them,
+	// ClearLocation drops them, and neither leaves them untouched. A profile
+	// update that simply omits coordinates must never erase them.
+	Location      *Coordinates
+	ClearLocation bool
+	// HasLocation is read-only: reads never resolve Location back, because a
+	// lossy PostGIS NULL-geography round trip can't be scanned safely.
 	HasLocation         bool
 	Questionnaire       map[string]any
 	OnboardingCompleted bool

backend/internal/domain/profile/entity.go

@@ -13,4 +13,9 @@ var (
 	ErrConsentRequired     = errors.New("explicit consent is required before saving this preference")
 	ErrInvalidAgeRange     = errors.New("invalid age range preference")
 	ErrInvalidDistance     = errors.New("invalid max distance preference")
+	// ErrIncompleteCoordinates guards against a half-applied location: a
+	// latitude without its longitude (or the reverse) is rejected instead of
+	// being silently dropped.
+	ErrIncompleteCoordinates = errors.New("latitude and longitude must be provided together")
+	ErrConflictingLocation   = errors.New("coordinates and clear location cannot be combined")
 )