Description

This PR implements LinkedIn account support for user profiles in the backend, addressing issue #163. Users can now add their LinkedIn account to their profile with global, case-insensitive uniqueness enforcement (first-come-first-serve), following the same pattern as the existing GitHub login feature.

Problem Statement

Currently, users can only add their GitHub handle to their profiles. There's no way to:

• Add LinkedIn account information to profiles
• Validate LinkedIn account format
• Ensure LinkedIn account uniqueness across profiles
• Retrieve profiles with LinkedIn account data

This limits users' ability to showcase their professional identity on the platform.

Solution

Implemented comprehensive LinkedIn account support across all backend layers:

1. Database Layer (backend/migrations/004_add_linkedin_account.sql)

Migration:

ALTER TABLE profiles ADD COLUMN IF NOT EXISTS linkedin_account TEXT;
CREATE UNIQUE INDEX IF NOT EXISTS unique_linkedin_account_lower ON profiles (LOWER(linkedin_account));

Features:

• Adds linkedin_account column to profiles table
• Creates unique case-insensitive index for global uniqueness
• Follows same pattern as github_login implementation

2. Domain Layer

Profile Entity (backend/src/domain/entities/profile.rs):

• Added linkedin_account: Option<String> field
• Initialized to None in Profile::new()
• Serializable for API responses

Repository Trait (backend/src/domain/repositories/profile_repository.rs):

async fn find_by_linkedin_account(
    &self,
    linkedin_account: &str,
) -> Result<Option<Profile>, Box<dyn std::error::Error + Send + Sync>>;

3. Infrastructure Layer (backend/src/infrastructure/repositories/postgres_profile_repository.rs)

Implementation:

• Added linkedin_account to all SELECT queries
• Included linkedin_account in INSERT and UPDATE operations
• Implemented find_by_linkedin_account with case-insensitive lookup

Example Query:

SELECT address, name, description, avatar_url, github_login, linkedin_account, created_at, updated_at
FROM profiles
WHERE LOWER(linkedin_account) = LOWER($1)

4. Application Layer

DTOs (backend/src/application/dtos/profile_dtos.rs):

• Added linkedin_account to UpdateProfileRequest
• Added linkedin_account to ProfileResponse

Update Profile Command (backend/src/application/commands/update_profile.rs):

Validation Logic:

if let Some(ref account) = request.linkedin_account {
    let trimmed = account.trim();

    if trimmed.is_empty() {
        profile.linkedin_account = None;
    } else {
        // Validate format (3-100 chars, alphanumeric + hyphens)
        let valid_format = regex::Regex::new(r"^[a-zA-Z0-9-]{3,100}$").unwrap();
        if !valid_format.is_match(trimmed) {
            return Err("Invalid LinkedIn account format".to_string());
        }
        
        // Check uniqueness
        if let Some(conflicting_profile) = profile_repository
            .find_by_linkedin_account(trimmed)
            .await?
        {
            if conflicting_profile.address != wallet_address {
                return Err("LinkedIn account already taken".to_string());
            }
        }
        
        profile.linkedin_account = Some(trimmed.to_string());
    }
}

Query Functions:

• Updated get_profile.rs to include linkedin_account
• Updated get_all_profiles.rs to include linkedin_account

Features Implemented

✅ Format Validation

• Length: 3-100 characters
• Allowed Characters: Alphanumeric (a-z, A-Z, 0-9) and hyphens (-)
• Regex Pattern: ^[a-zA-Z0-9-]{3,100}$

Valid Examples:

• john-doe
• jane-smith-123
• developer-2024

Invalid Examples:

• ab (too short)
• john_doe (underscores not allowed)
• john.doe (dots not allowed)

✅ Case-Insensitive Uniqueness

• john-doe and JOHN-DOE are considered the same
• Database index enforces uniqueness: LOWER(linkedin_account)
• First-come-first-serve: first user to claim owns it

✅ Conflict Prevention

• Users cannot take LinkedIn accounts already claimed by others
• Returns 409 Conflict with error: "LinkedIn account already taken"
• Self-update allowed: users can update their own LinkedIn account

✅ Empty Value Handling

• Sending empty string ("") sets linkedin_account to NULL
• Omitting field leaves existing value unchanged

✅ API Integration

• LinkedIn account included in all profile responses
• Works with existing authentication and authorization

API Usage

Update Profile with LinkedIn Account

Request:

PUT /api/profiles
Authorization: Bearer <token>
Content-Type: application/json

{
  "name": "John Doe",
  "linkedin_account": "john-doe-123"
}

Success Response (200 OK):

{
  "address": "0x1234567890abcdef",
  "name": "John Doe",
  "description": null,
  "avatar_url": null,
  "github_login": null,
  "linkedin_account": "john-doe-123",
  "created_at": "2024-01-01T00:00:00Z",
  "updated_at": "2024-01-02T00:00:00Z"
}

Error Response (409 Conflict):

{
  "error": "LinkedIn account already taken"
}

Error Response (400 Bad Request):

{
  "error": "Invalid LinkedIn account format"
}

Get Profile

Request:

GET /api/profiles/0x1234567890abcdef

Response:

{
  "address": "0x1234567890abcdef",
  "name": "John Doe",
  "linkedin_account": "john-doe-123",
  ...
}

Testing

Manual Testing Checklist

• ✅ Add LinkedIn account to profile
• ✅ Verify uniqueness constraint (different wallet, same LinkedIn)
• ✅ Test case-insensitivity (john-doe vs JOHN-DOE)
• ✅ Validate format (too short, invalid characters)
• ✅ Test empty value (sets to NULL)
• ✅ Self-update (user updates own LinkedIn account)
• ✅ Get profile returns LinkedIn account
• ✅ Get all profiles returns LinkedIn accounts

Database Verification

-- Check unique index exists
SELECT indexname, indexdef 
FROM pg_indexes 
WHERE tablename = 'profiles' 
AND indexname = 'unique_linkedin_account_lower';

-- Verify data
SELECT address, name, github_login, linkedin_account 
FROM profiles 
WHERE linkedin_account IS NOT NULL;

Consistency with GitHub Login

This implementation follows the exact same pattern as the GitHub login feature:

Files Changed

New Files

• backend/migrations/004_add_linkedin_account.sql - Database migration
• LINKEDIN_BACKEND_IMPLEMENTATION.md - Comprehensive documentation

Modified Files

• backend/src/domain/entities/profile.rs - Added linkedin_account field
• backend/src/domain/repositories/profile_repository.rs - Added find_by_linkedin_account method
• backend/src/infrastructure/repositories/postgres_profile_repository.rs - Implemented LinkedIn support
• backend/src/application/dtos/profile_dtos.rs - Added linkedin_account to DTOs
• backend/src/application/commands/update_profile.rs - Added validation logic
• backend/src/application/queries/get_profile.rs - Include linkedin_account in response
• backend/src/application/queries/get_all_profiles.rs - Include linkedin_account in response

Benefits

✅ Complete Backend Support: LinkedIn account fully integrated across all layers
✅ Robust Validation: Format checking and uniqueness enforcement
✅ Consistent Pattern: Follows existing GitHub login implementation
✅ Case-Insensitive: Prevents duplicate accounts with different casing
✅ Error Handling: Clear error messages for validation failures
✅ Backward Compatible: Existing profiles work without changes
✅ Well Documented: Comprehensive documentation with examples
✅ Database Integrity: Unique index ensures data consistency

Migration Instructions

Running the Migration

cd backend
sqlx migrate run

Verification

# Check migration applied
sqlx migrate info

# Verify in database
psql -d theguild -c "\\d profiles"

Future Enhancements

Potential improvements for future PRs:

1. LinkedIn Profile Verification - OAuth integration to verify ownership
2. LinkedIn Profile Data - Fetch and display LinkedIn information
3. Search by LinkedIn - API endpoint to search profiles by LinkedIn
4. LinkedIn Profile Links - Generate clickable profile URLs
5. Batch Operations - Import LinkedIn accounts from CSV

Related Issues

Fixes #163

Notes

• All changes are backward compatible
• Existing profiles will have linkedin_account set to NULL
• No breaking changes to existing API endpoints
• Frontend integration required separately (issue Add linkedin account to user profiles #162)
• Follows Rust best practices and project conventions
• Uses existing authentication and authorization middleware

Documentation

See LINKEDIN_BACKEND_IMPLEMENTATION.md for comprehensive documentation including:

• Detailed implementation guide
• API usage examples
• Validation rules
• Testing procedures
• Database schema
• Migration instructions

Ready for Review: This PR is complete, well-tested, and ready for review. It provides full backend support for LinkedIn accounts following the established patterns in the codebase.