PHPackages                             nerdymind/laravel-acquaintances - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Database & ORM](/categories/database)
4. /
5. nerdymind/laravel-acquaintances

ActiveLibrary[Database & ORM](/categories/database)

nerdymind/laravel-acquaintances
===============================

This light package, with no dependencies, gives Eloquent models the ability to manage friendships (with groups). And interactions such as: Likes, favorites, votes, subscribe, follow, ..etc. And it includes advanced rating system.

v3.3.3(5y ago)012MITPHPPHP >=7.1

Since Jan 23Pushed 5y agoCompare

[ Source](https://github.com/NerdyMind-Marketing/laravel-acquaintances)[ Packagist](https://packagist.org/packages/nerdymind/laravel-acquaintances)[ RSS](/packages/nerdymind-laravel-acquaintances/feed)WikiDiscussions master Synced 2d ago

READMEChangelog (2)Dependencies (7)Versions (17)Used By (0)

Laravel 7 Acquaintances
=======================

[](#laravel-7-acquaintances)

[![Latest Version](https://camo.githubusercontent.com/eafa4a3dc8f62f637c0e54ec11df8f7004f3efeb529fb74e01fe6b8680bc2d8e/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f72656c656173652f6e657264796d696e642f6c61726176656c2d6163717561696e74616e6365732e7376673f7374796c653d666c61742d737175617265)](https://github.com/NerdyMind-Marketing/laravel-acquaintances/releases)[![Total Downloads](https://camo.githubusercontent.com/fb5e956e6ae73660282f7ef52e232ad12ee88cf798af37aa6255af03ea9eb4e5/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f64742f6e657264796d696e642f6c61726176656c2d6163717561696e74616e6365732e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/nerdymind/laravel-acquaintances)[![License](https://camo.githubusercontent.com/11c6a681e3ba95ac4c45b5a8db4d659dda3ea58635604f2bac2abf320f22cf83/68747470733a2f2f706f7365722e707567782e6f72672f6d756c746963617265742f6c61726176656c2d6163717561696e74616e6365732f6c6963656e73652e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/multicaret/laravel-acquaintances)

[![](https://camo.githubusercontent.com/d595c647d0dc28bbd9dd9c21e91acf44b03edc9e2411c71ebdd73d97d3099ef0/68747470733a2f2f63646e2e6d756c746963617265742e636f6d2f7061636b616765732f6173736574732f696d672f6c61726176656c2d6163717561696e74616e6365732e7376673f757064617465643d31)](https://camo.githubusercontent.com/d595c647d0dc28bbd9dd9c21e91acf44b03edc9e2411c71ebdd73d97d3099ef0/68747470733a2f2f63646e2e6d756c746963617265742e636f6d2f7061636b616765732f6173736574732f696d672f6c61726176656c2d6163717561696e74616e6365732e7376673f757064617465643d31)

[Laravel News Article](https://laravel-news.com/manage-friendships-likes-and-more-with-the-acquaintances-laravel-package)

TL;DR
-----

[](#tldr)

Gives eloquent models:

- Friendships & Groups ability
- Interactions ability such as:
    - Likes
    - Favorites
    - Votes (up/down)
    - Subscribe
    - Follow
    - Ratings

Take this example:

```
$user1 = User::find(1);
$user2 = User::find(2);

$user1->befriend($user2);
$user2->acceptFriendRequest($user1);

// The messy breakup :(
$user2->unfriend($user1);
```

1. [Introduction](#introduction)
2. [Installation](#installation)
3. [Friendships:](#friendships)
    - [Friend Requests](#friend-requests)
    - [Check Friend Requests](#check-friend-requests)
    - [Retrieve Friend Requests](#retrieve-friend-requests)
    - [Retrieve Friends](#retrieve-friends)
    - [Friend Groups](#friend-groups)
4. [Interactions](#interactions)
    - [Traits Usage](#traits-usage)
    - [Follow](#follow)
    - [Rate](#rate)
    - [Like](#like)
    - [Favorite](#favorite)
    - [Subscribe](#subscribe)
    - [Vote](#vote)
    - [Parameters](#parameters)
    - [Query relations](#query-relations)
    - [Working with model](#working-with-model)
5. [Events](#events)
6. [Contributing](#contributing)

Introduction
------------

[](#introduction)

This light package gives Eloquent models the ability to manage their acquaintances and other cool useful stuff. You can easily design your social-like System (Facebook, Twitter, Foursquare...etc).

##### Acquaintances includes:

[](#acquaintances-includes)

- Send Friend Requests
- Accept Friend Requests
- Deny Friend Requests
- Block a User
- Group Friends
- Rate a User or a Model, supporting multiple aspects
- Follow a User or a Model
- Like a User or a Model
- Subscribe a User or a Model
- Favorite a User or a Model
- Vote (Upvote & Downvote a User or a Model)

---

Installation
------------

[](#installation)

First, install the package through Composer.

```
$ composer require nerdymind/laravel-acquaintances
```

Laravel 5.8 => version 2.x (branch master)

Laravel 5.7 and below => version 1.x (branch v1)

#### Laravel 5.4 and down

[](#laravel-54-and-down)

Then include the service provider inside `config/app.php`.

```
'providers' => [
    ...
    Multicaret\Acquaintances\AcquaintancesServiceProvider::class,
    ...
];
```

Publish config and migrations:

```
$ php artisan vendor:publish --provider="Multicaret\Acquaintances\AcquaintancesServiceProvider"
```

Configure the published config in:

```
config\acquaintances.php

```

Finally, migrate the database to create the table:

```
$ php artisan migrate
```

---

Setup a Model
-------------

[](#setup-a-model)

Example:

```
use Multicaret\Acquaintances\Traits\CanBeFollowed;
use Multicaret\Acquaintances\Traits\CanFollow;
use Multicaret\Acquaintances\Traits\CanLike;
use Multicaret\Acquaintances\Traits\Friendable;
//...

class User extends Model
{
    use Friendable;
    use CanLike;
    use CanFollow, CanBeFollowed;
    use CanRate, CanBeRated;
    //...
}
```

All available APIs are listed below for Friendships & Interactions.

---

Friendships:
------------

[](#friendships)

### Friend Requests:

[](#friend-requests)

Add `Friendable` Trait to User model.

```
use Multicaret\Acquaintances\Traits\Friendable;

class User extends Model
{
    use Friendable;
}
```

#### Send a Friend Request

[](#send-a-friend-request)

```
$user->befriend($recipient);
```

#### Accept a Friend Request

[](#accept-a-friend-request)

```
$user->acceptFriendRequest($sender);
```

#### Deny a Friend Request

[](#deny-a-friend-request)

```
$user->denyFriendRequest($sender);
```

#### Remove Friend

[](#remove-friend)

```
$user->unfriend($friend);
```

#### Block a Model

[](#block-a-model)

```
$user->blockFriend($friend);
```

#### Unblock a Model

[](#unblock-a-model)

```
$user->unblockFriend($friend);
```

#### Check if Model is Friend with another Model

[](#check-if-model-is-friend-with-another-model)

```
$user->isFriendWith($friend);
```

### Check Friend Requests:

[](#check-friend-requests)

#### Check if Model has a pending friend request from another Model

[](#check-if-model-has-a-pending-friend-request-from-another-model)

```
$user->hasFriendRequestFrom($sender);
```

#### Check if Model has already sent a friend request to another Model

[](#check-if-model-has-already-sent-a-friend-request-to-another-model)

```
$user->hasSentFriendRequestTo($recipient);
```

#### Check if Model has blocked another Model

[](#check-if-model-has-blocked-another-model)

```
$user->hasBlocked($friend);
```

#### Check if Model is blocked by another Model

[](#check-if-model-is-blocked-by-another-model)

```
$user->isBlockedBy($friend);
```

---

### Retrieve Friend Requests:

[](#retrieve-friend-requests)

#### Get a single friendship

[](#get-a-single-friendship)

```
$user->getFriendship($friend);
```

#### Get a list of all Friendships

[](#get-a-list-of-all-friendships)

```
$user->getAllFriendships();
```

#### Get a list of pending Friendships

[](#get-a-list-of-pending-friendships)

```
$user->getPendingFriendships();
```

#### Get a list of accepted Friendships

[](#get-a-list-of-accepted-friendships)

```
$user->getAcceptedFriendships();
```

#### Get a list of denied Friendships

[](#get-a-list-of-denied-friendships)

```
$user->getDeniedFriendships();
```

#### Get a list of blocked Friendships

[](#get-a-list-of-blocked-friendships)

```
$user->getBlockedFriendships();
```

#### Get a list of pending Friend Requests

[](#get-a-list-of-pending-friend-requests)

```
$user->getFriendRequests();
```

#### Get the number of Friends

[](#get-the-number-of-friends)

```
$user->getFriendsCount();
```

#### Get the number of Pending Requests

[](#get-the-number-of-pending-requests)

```
$user->getPendingsCount();
```

#### Get the number of mutual Friends with another user

[](#get-the-number-of-mutual-friends-with-another-user)

```
$user->getMutualFriendsCount($otherUser);
```

Retrieve Friends:
-----------------

[](#retrieve-friends)

To get a collection of friend models (ex. User) use the following methods:

#### `getFriends()`

[](#getfriends)

```
$user->getFriends();
// or panigated
$user->getFriends($perPage = 20, $group_name);
// or paginated with certain fields
$user->getFriends($perPage = 20, $group_name, $fields = ['id','name']);
```

Parameters:

- `$perPage`: integer (default: `0`), Get values paginated
- `$group_name`: string (default: `''`), Get collection of Friends in specific group paginated
- `$fields`: array (default: `['*']`), Specify the desired fields to query.

#### `getFriendsOfFriends()`

[](#getfriendsoffriends)

```
$user->getFriendsOfFriends();
// or
$user->getFriendsOfFriends($perPage = 20);
// or
$user->getFriendsOfFriends($perPage = 20, $fields = ['id','name']);
```

Parameters:

- `$perPage`: integer (default: `0`), Get values paginated
- `$fields`: array (default: `['*']`), Specify the desired fields to query.

#### `getMutualFriends()`

[](#getmutualfriends)

Get mutual Friends with another user

```
$user->getMutualFriends($otherUser);
// or
$user->getMutualFriends($otherUser, $perPage = 20);
// or
$user->getMutualFriends($otherUser, $perPage = 20, $fields = ['id','name']);
```

Parameters:

- `$other`: Model (required), The Other user model to check mutual friends with
- `$perPage`: integer (default: `0`), Get values paginated
- `$fields`: array (default: `['*']`), Specify the desired fields to query.

Friend Groups:
--------------

[](#friend-groups)

The friend groups are defined in the `config/acquaintances.php` file. The package comes with a few default groups. To modify them, or add your own, you need to specify a `slug` and a `key`.

```
// config/acquaintances.php
...
'groups' => [
    'acquaintances' => 0,
    'close_friends' => 1,
    'family' => 2
]
```

Since you've configured friend groups, you can group/ungroup friends using the following methods.

#### Group a Friend

[](#group-a-friend)

```
$user->groupFriend($friend, $group_name);
```

#### Remove a Friend from family group

[](#remove-a-friend-from-family-group)

```
$user->ungroupFriend($friend, 'family');
```

#### Remove a Friend from all groups

[](#remove-a-friend-from-all-groups)

```
$user->ungroupFriend($friend);
```

#### Get the number of Friends in specific group

[](#get-the-number-of-friends-in-specific-group)

```
$user->getFriendsCount($group_name);
```

#### To filter `friendships` by group you can pass a group slug.

[](#to-filter-friendships-by-group-you-can-pass-a-group-slug)

```
$user->getAllFriendships($group_name);
$user->getAcceptedFriendships($group_name);
$user->getPendingFriendships($group_name);
...
```

Interactions
------------

[](#interactions)

### Traits Usage:

[](#traits-usage)

Add `CanXXX` Traits to User model.

```
use Multicaret\Acquaintances\Traits\CanFollow;
use Multicaret\Acquaintances\Traits\CanLike;
use Multicaret\Acquaintances\Traits\CanFavorite;
use Multicaret\Acquaintances\Traits\CanSubscribe;
use Multicaret\Acquaintances\Traits\CanVote;

class User extends Model
{
    use CanFollow, CanLike, CanFavorite, CanSubscribe, CanVote;
}
```

Add `CanBeXXX` Trait to target model, such as 'Post' or 'Book' ...:

```
use Multicaret\Acquaintances\Traits\CanBeLiked;
use Multicaret\Acquaintances\Traits\CanBeFavorited;
use Multicaret\Acquaintances\Traits\CanBeVoted;
use Multicaret\Acquaintances\Traits\CanBeRated;

class Post extends Model
{
    use CanBeLiked, CanBeFavorited, CanBeVoted, CanBeRated;
}
```

All available APIs are listed below.

### Follow

[](#follow)

#### `\Multicaret\Acquaintances\Traits\CanFollow`

[](#multicaretacquaintancestraitscanfollow)

```
$user->follow($targets)
$user->unfollow($targets)
$user->toggleFollow($targets)
$user->followings()->get() // App\User:class
$user->followings(App\Post::class)->get()
$user->isFollowing($target)
```

#### `\Multicaret\Acquaintances\Traits\CanBeFollowed`

[](#multicaretacquaintancestraitscanbefollowed)

```
$object->followers()->get()
$object->isFollowedBy($user)
$object->followersCount() // or as attribute $object->followers_count
$object->followersCountReadable() // return readable number with precision, i.e: 5.2K
```

### Rate

[](#rate)

#### `\Multicaret\Acquaintances\Traits\CanRate`

[](#multicaretacquaintancestraitscanrate)

```
$user->rate($targets)
$user->unrate($targets)
$user->toggleRate($targets)
$user->ratings()->get() // App\User:class
$user->rateings(App\Post::class)->get()
$user->hasRated($target)
```

#### `\Multicaret\Acquaintances\Traits\CanBeRated`

[](#multicaretacquaintancestraitscanberated)

```
$object->raters()->get()
$object->isRatedBy($user)

$object->averageRating() // or as attribute $object->average_rating
$object->averageRatingAllTypes() // or as attribute $object->average_rating_all_types

$object->sumRating() // or as attribute $object->sum_rating
$object->sumRatingAllTypes() // or as attribute $object->sum_rating_all_types_all_types

$object->sumRatingReadable() // return readable number with precision, i.e: 5.2K
$object->sumRatingAllTypesReadable() // return readable number with precision, i.e: 5.2K

$object->ratingPercent($max = 5) // calculating the percentage based on the passed coefficient
$object->ratingPercentAllTypes($max = 5) // calculating the percentage based on the passed coefficient

// User Related:

$object->userAverageRatingAllTypes() // or as attribute $object->user_average_rating_all_types

$object->userSumRatingAllTypes() // or as attribute $object->user_sum_rating_all_types

$object->userSumRatingReadable() // return readable number with precision, i.e: 5.2K
$object->userSumRatingAllTypesReadable() // return readable number with precision, i.e: 5.2K
```

### Like

[](#like)

#### `\Multicaret\Acquaintances\Traits\CanLike`

[](#multicaretacquaintancestraitscanlike)

```
$user->like($targets)
$user->unlike($targets)
$user->toggleLike($targets)
$user->hasLiked($target)
$user->likes()->get() // default object: App\User:class
$user->likes(App\Post::class)->get()
```

#### `\Multicaret\Acquaintances\Traits\CanBeLiked`

[](#multicaretacquaintancestraitscanbeliked)

```
$object->likers()->get() //
$object->fans()->get() // or $object->fans. it's an alias of likers()
$object->isLikedBy($user)
$object->likersCount() // or as attribute $object->likers_count
$object->likersCountReadable() // return readable number with precision, i.e: 5.2K
```

### Favorite

[](#favorite)

#### `\Multicaret\Acquaintances\Traits\CanFavorite`

[](#multicaretacquaintancestraitscanfavorite)

```
$user->favorite($targets)
$user->unfavorite($targets)
$user->toggleFavorite($targets)
$user->hasFavorited($target)
$user->favorites()->get() // App\User:class
$user->favorites(App\Post::class)->get()
```

#### `\Multicaret\Acquaintances\Traits\CanBeFavorited`

[](#multicaretacquaintancestraitscanbefavorited)

```
$object->favoriters()->get() // or $object->favoriters
$object->isFavoritedBy($user)
$object->favoritersCount() // or as attribute $object->favoriters_count
$object->favoritersCountReadable() // return readable number with precision, i.e: 5.2K
```

### Subscribe

[](#subscribe)

#### `\Multicaret\Acquaintances\Traits\CanSubscribe`

[](#multicaretacquaintancestraitscansubscribe)

```
$user->subscribe($targets)
$user->unsubscribe($targets)
$user->toggleSubscribe($targets)
$user->hasSubscribed($target)
$user->subscriptions()->get() // default object: App\User:class
$user->subscriptions(App\Post::class)->get()
```

#### `Multicaret\Acquaintances\Traits\CanBeSubscribed`

[](#multicaretacquaintancestraitscanbesubscribed)

```
$object->subscribers() // or $object->subscribers
$object->isSubscribedBy($user)
$object->subscribersCount() // or as attribute $object->subscribers_count
$object->subscribersCountReadable() // return readable number with precision, i.e: 5.2K
```

### Vote

[](#vote)

#### `\Multicaret\Acquaintances\Traits\CanVote`

[](#multicaretacquaintancestraitscanvote)

```
$user->vote($target) // Vote with 'upvote' for default
$user->upvote($target)
$user->downvote($target)
$user->cancelVote($target)
$user->hasUpvoted($target)
$user->hasDownvoted($target)
$user->votes(App\Post::class)->get()
$user->upvotes(App\Post::class)->get()
$user->downvotes(App\Post::class)->get()
```

#### `\Multicaret\Acquaintances\Traits\CanBeVoted`

[](#multicaretacquaintancestraitscanbevoted)

```
$object->voters()->get()
$object->isVotedBy($user)
$object->votersCount() // or as attribute $object->voters_count
$object->votersCountReadable() // return readable number with precision, i.e: 5.2K

$object->upvoters()->get()
$object->isUpvotedBy($user)
$object->upvotersCount() // or as attribute $object->upvoters_count
$object->upvotersCountReadable() // return readable number with precision, i.e: 5.2K

$object->downvoters()->get()
$object->isDownvotedBy($user)
$object->downvotersCount() // or as attribute $object->downvoters_count
$object->downvotersCountReadable() // return readable number with precision, i.e: 5.2K
```

### Parameters

[](#parameters)

All of the above mentioned methods of creating relationships, such as 'follow', 'like', 'unfollow', 'unlike', their syntax is as follows:

```
follow(array|int|\Illuminate\Database\Eloquent\Model $targets, $class = __CLASS__)
```

So you can call them like this:

```
// id / int|array
$user->follow(1); // targets: 1, $class = App\User
$user->follow(1, App\Post::class); // targets: 1, $class = App\Post
$user->follow([1, 2, 3]); // targets: [1, 2, 3], $class = App\User

// Model
$post = App\Post::find(7);
$user->follow($post); // targets: $post->id, $class = App\Post

// Model array
$posts = App\Post::popular()->get();
$user->follow($posts); // targets: [1, 2, ...], $class = App\Post
```

### Query relations

[](#query-relations)

```
$followers = $user->followers
$followers = $user->followers()->where('id', '>', 10)->get()
$followers = $user->followers()->orderByDesc('id')->get()
```

You may use the others in the same way.

### Working with model

[](#working-with-model)

```
use Multicaret\Acquaintances\Models\InteractionRelation;

// Get most popular object
// 1- All types
$relations = InteractionRelation::popular()->get();

// 2- subject_type = App\Post
$relations = InteractionRelation::popular(App\Post::class)->get();

// 3- subject_type = App\User
$relations = InteractionRelation::popular('user')->get();

// 4- subject_type = App\Post
$relations = InteractionRelation::popular('post')->get();

// 5- Pagination
$relations = InteractionRelation::popular(App\Post::class)->paginate(15);
```

Events
------

[](#events)

This is the list of the events fired by default for each action:

Event nameFiredacq.friendships.sentWhen a friend request is sentacq.friendships.acceptedWhen a friend request is acceptedacq.friendships.deniedWhen a friend request is deniedacq.friendships.blockedWhen a friend is blockedacq.friendships.unblockedWhen a friend is unblockedacq.friendships.cancelledWhen a friendship is cancelledacq.ratings.rateWhen a an item or items get Ratedacq.ratings.unrateWhen a an item or items get unRatedacq.vote.upWhen a an item or items get upvotedacq.vote.downWhen a an item or items get downvotedacq.vote.cancelWhen a an item or items get vote cancellationacq.likes.likeWhen a an item or items get likedacq.likes.unlikeWhen a an item or items get unlikedacq.followships.followWhen a an item or items get followedacq.followships.unfollowWhen a an item or items get unfollowedacq.favorites.favoriteWhen a an item or items get favoredacq.favorites.unfavoriteWhen a an item or items get unfavoredacq.subscriptions.subscribeWhen a an item or items get subscribedacq.subscriptions.unsubscribeWhen a an item or items get unsubscribed### Contributing

[](#contributing)

See the [CONTRIBUTING](CONTRIBUTING.md) guide.

### Change Log

[](#change-log)

See the [log](CHANGELOG.md) file.

###  Health Score

28

—

LowBetter than 54% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity5

Limited adoption so far

Community9

Small or concentrated contributor base

Maturity66

Established project with proven stability

 Bus Factor1

Top contributor holds 93.3% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~59 days

Recently: every ~13 days

Total

16

Last Release

2141d ago

Major Versions

v1.2.0 → v2.0.02019-05-20

v2.0.0 → v3.0.02020-04-04

PHP version history (2 changes)v1.0.0PHP >=5.5.9

v2.0.0PHP >=7.1

### Community

Maintainers

![](https://avatars.githubusercontent.com/u/3821383?v=4)[NerdyMind Marketing](/maintainers/nerdymind)[@NerdyMind](https://github.com/NerdyMind)

---

Top Contributors

[![mkwsra](https://avatars.githubusercontent.com/u/1743919?v=4)](https://github.com/mkwsra "mkwsra (42 commits)")[![GreenImp](https://avatars.githubusercontent.com/u/1846676?v=4)](https://github.com/GreenImp "GreenImp (2 commits)")[![ctf0](https://avatars.githubusercontent.com/u/7388088?v=4)](https://github.com/ctf0 "ctf0 (1 commits)")

---

Tags

laraveleloquentfriendsRatesocial medialikeRatingfriendshipsFollowersfriend-systeminteractionsfollowshipswish-list

###  Code Quality

TestsPHPUnit

### Embed Badge

![Health badge](/badges/nerdymind-laravel-acquaintances/health.svg)

```
[![Health](https://phpackages.com/badges/nerdymind-laravel-acquaintances/health.svg)](https://phpackages.com/packages/nerdymind-laravel-acquaintances)
```

###  Alternatives

[multicaret/laravel-acquaintances

This light package, with no dependencies, gives Eloquent models the ability to manage friendships (with groups), verifications, and interactions such as: Likes, favorites, votes, subscribe, follow, ..etc. And it includes advanced rating system.

851266.9k2](/packages/multicaret-laravel-acquaintances)[cybercog/laravel-love

Make Laravel Eloquent models reactable with any type of emotions in a minutes!

1.2k302.7k1](/packages/cybercog-laravel-love)[hootlex/laravel-friendships

This package gives Eloquent models the ability to manage their friendships.

705114.6k](/packages/hootlex-laravel-friendships)[qirolab/laravel-reactions

Implement reactions (like, dislike, love, emotion etc) on Laravel Eloquent models.

19564.6k](/packages/qirolab-laravel-reactions)[merodiro/friendships

This package gives users the ability to manage their friendships.

459.7k](/packages/merodiro-friendships)[demency/laravel-friendships

This package gives Eloquent models the ability to manage their friendships.

201.0k](/packages/demency-laravel-friendships)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)