Team User Table

Schema::create('team_user', function (Blueprint $table) {
    $table->id();
    $table->foreignId('team_id')->constrained()->cascadeOnDelete();
    $table->foreignId('user_id')->constrained()->cascadeOnDelete();
    $table->timestamps();

    $table->unique(['team_id', 'user_id']);
});

$table->unique(['team_id', 'user_id']);

use App\Models\Team;
use App\Models\User;

$team = Team::find(1);
$user = User::find(2);

// Method 1: Using attach
$team->users()->attach($user->id);

// Method 2: Using sync (without detaching)
$team->users()->syncWithoutDetaching([$user->id]);

// With timestamps
$team->users()->attach($user->id, [
    'created_at' => now(),
    'updated_at' => now(),
]);

$team = Team::find(1);
$user = User::find(2);

// Detach single user
$team->users()->detach($user->id);

// Detach multiple users
$team->users()->detach([2, 3, 4]);

// Remove all members
$team->users()->detach();

$team = Team::find(1);
$user = User::find(2);

// Method 1: Using contains
if ($team->users->contains($user)) {
    // User is a member
}

// Method 2: Using where
$isMember = $team->users()->where('users.id', $user->id)->exists();

// Method 3: From user side
$belongsToTeam = $user->teams()->where('teams.id', $team->id)->exists();

$team = Team::find(1);

// Get all members
$members = $team->users;

// Get members with specific attributes
$members = $team->users()->get(['users.id', 'users.name', 'users.email']);

// Count members
$memberCount = $team->users()->count();

// Get recent members
$recentMembers = $team->users()
    ->orderByPivot('created_at', 'desc')
    ->limit(10)
    ->get();

$user = User::find(1);

// Get all teams user belongs to
$teams = $user->teams;

// Get teams with owner information
$teams = $user->teams()->with('owner')->get();

// Count teams
$teamCount = $user->teams()->count();

// Bad - N+1 query problem
$teams = Team::all();
foreach ($teams as $team) {
    echo $team->users->count(); // Additional query per team
}

// Good - Single query
$teams = Team::withCount('users')->get();
foreach ($teams as $team) {
    echo $team->users_count;
}

Schema::table('team_user', function (Blueprint $table) {
    $table->index('created_at'); // For sorting by join date
});

Schema::table('team_user', function (Blueprint $table) {
    $table->string('role')->default('member')->after('user_id');
    $table->boolean('is_active')->default(true)->after('role');
});

// In User model
public function teams(): BelongsToMany
{
    return $this->belongsToMany(Team::class)
        ->withPivot('role', 'is_active')
        ->withTimestamps();
}

// Attach with role
$team->users()->attach($user->id, [
    'role' => 'admin',
    'is_active' => true,
]);

// Access pivot data
foreach ($team->users as $user) {
    echo $user->pivot->role; // admin
    echo $user->pivot->created_at; // When joined
}

// Update pivot data
$team->users()->updateExistingPivot($user->id, [
    'role' => 'manager',
]);

$team->delete(); // All memberships removed

$user->delete(); // Removed from all teams

use App\Models\Team;
use App\Models\User;

test('user can be added to team', function () {
    $team = Team::factory()->create();
    $user = User::factory()->create();

    $team->users()->attach($user->id);

    expect($team->users->contains($user))->toBeTrue();
    expect($team->users()->count())->toBe(1);
});

test('user cannot be added to team twice', function () {
    $team = Team::factory()->create();
    $user = User::factory()->create();

    $team->users()->attach($user->id);

    // This will throw a database exception due to unique constraint
    expect(fn () => $team->users()->attach($user->id))
        ->toThrow(\Illuminate\Database\QueryException::class);
});

test('removing user from team works', function () {
    $team = Team::factory()->create();
    $user = User::factory()->create();

    $team->users()->attach($user->id);
    expect($team->users()->count())->toBe(1);

    $team->users()->detach($user->id);
    expect($team->users()->count())->toBe(0);
});