PHPackages                             kenzal/mysql-binary-uuids - 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. kenzal/mysql-binary-uuids

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

kenzal/mysql-binary-uuids
=========================

Store UUIDs and ULIDs as binary in MySQL for Laravel

v1.1.0(1mo ago)06↓50%MITPHPPHP ^8.2CI passing

Since Jun 12Pushed 1mo agoCompare

[ Source](https://github.com/kenzal/mysql-binary-uuids)[ Packagist](https://packagist.org/packages/kenzal/mysql-binary-uuids)[ RSS](/packages/kenzal-mysql-binary-uuids/feed)WikiDiscussions main Synced 1w ago

READMEChangelog (3)Dependencies (5)Versions (4)Used By (0)

Laravel MySQL Binary UUIDs
==========================

[](#laravel-mysql-binary-uuids)

Store UUIDs and ULIDs as efficient binary(16) columns in MySQL instead of char(36) or char(26), saving storage space and improving index performance.

[![Tests](https://github.com/kenzal/mysql-binary-uuids/actions/workflows/tests.yml/badge.svg)](https://github.com/kenzal/mysql-binary-uuids/actions/workflows/tests.yml)[![Code Style](https://github.com/kenzal/mysql-binary-uuids/actions/workflows/code-style.yml/badge.svg)](https://github.com/kenzal/mysql-binary-uuids/actions/workflows/code-style.yml)[![PHP Version](https://camo.githubusercontent.com/d7cf673ddeced88c2d069953eaee53a1af801683f85db9ce2eb33c3a4986f06f/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f7068702d382e32253230253743253230382e33253230253743253230382e34253230253743253230382e352d626c75652e737667)](https://php.net)[![Laravel Version](https://camo.githubusercontent.com/cc6fc30282c6ef51cb0e125edb0474fcc9a79473100fdfa5fcdaeeffb2efb748/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f6c61726176656c2d313225323025374325323031332d7265642e737667)](https://laravel.com)[![Packagist Version](https://camo.githubusercontent.com/48e3d852eacc9192ad7cc36aa50bc7d248c990f0bebc16688726d5beb6e3605d/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f762f6b656e7a616c2f6d7973716c2d62696e6172792d7575696473)](https://packagist.org/packages/kenzal/mysql-binary-uuids)[![License](https://camo.githubusercontent.com/8bb50fd2278f18fc326bf71f6e88ca8f884f72f179d3e555e20ed30157190d0d/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f6c6963656e73652d4d49542d677265656e2e737667)](LICENSE)

Table of Contents
-----------------

[](#table-of-contents)

- [Why Use Binary Storage?](#why-use-binary-storage)
- [Requirements](#requirements)
- [Installation](#installation)
- [Features](#features)
- [Usage](#usage)
- [Route Model Binding](#route-model-binding)
- [API Reference](#api-reference)
- [Testing](#testing)
- [Performance Considerations](#performance-considerations)
- [Compatibility](#compatibility)
- [Contributing](#contributing)
- [Credits](#credits)

Why Use Binary Storage?
-----------------------

[](#why-use-binary-storage)

Storing UUIDs and ULIDs as binary data provides significant benefits:

- **Storage Efficiency**: Binary(16) uses 16 bytes vs char(36)/char(26) which uses 36/26 bytes
- **Index Performance**: Smaller indexes mean faster lookups and reduced memory usage
- **Native Format**: UUIDs/ULIDs are stored in their native binary format
- **Compatibility**: Works seamlessly with Laravel's UUID/ULID objects

### Storage Comparison

[](#storage-comparison)

TypeString StorageBinary StorageSavingsUUID36 bytes (char)16 bytes (binary)**56% reduction**ULID26 bytes (char)16 bytes (binary)**38% reduction**Requirements
------------

[](#requirements)

- PHP 8.2+ (for Laravel 12) or PHP 8.3+ (for Laravel 13)
- Laravel 12.0 or 13.0
- MySQL 5.7 or higher (MySQL 8.0+ recommended)

### Compatibility Matrix

[](#compatibility-matrix)

LaravelPHP 8.2PHP 8.3PHP 8.4PHP 8.512.x✅✅✅✅13.x❌✅✅✅Installation
------------

[](#installation)

Install via Composer:

```
composer require kenzal/mysql-binary-uuids
```

The service provider will be automatically registered.

Caution

**Upgrading from String (char) UUIDs**

If you're migrating an existing project from `char(36)` or `varchar(36)` UUIDs to `binary(16)`:

1. Install this package
2. Update your models to use the traits or casts
3. [Create migrations to convert columns](#working-with-existing-data)
4. **Plan for a breaking schema change** — test thoroughly in staging first

**Key query change:** Binary(16) columns store UUIDs/ULIDs as raw bytes, not human-readable strings. When querying, you **must** pass `UuidInterface` or `Ulid` objects — raw strings will not be automatically converted to binary at the connection level:

```
use Ramsey\Uuid\Uuid;

// ✅ Query with objects
User::find($uuidObject);
User::find(Uuid::fromString($uuidString));
User::where('id', $uuidObject)->first();

// ❌ Returns null — raw strings won't match binary(16)
User::find($uuidString);
User::where('id', $uuidString)->first();
```

[Route-model binding](#route-model-binding) is handled automatically — string UUIDs/ULIDs from URLs are converted to objects before querying.

Features
--------

[](#features)

### ✨ Automatic Schema Support

[](#-automatic-schema-support)

UUIDs are automatically stored as `binary(16)` when using Laravel's schema builder:

```
Schema::create('users', function (Blueprint $table) {
    $table->uuid('id')->primary();  // Stored as binary(16)
    $table->uuid('organization_id');
    $table->timestamps();
});
```

### 🔄 Eloquent Casts

[](#-eloquent-casts)

Cast binary UUID/ULID columns to native Laravel objects:

```
use Kenzal\MysqlBinaryUuids\Casts\BinaryUuid;
use Kenzal\MysqlBinaryUuids\Casts\BinaryUlid;

class User extends Model
{
    protected function casts(): array
    {
        return [
            'id' => BinaryUuid::class,
            'session_id' => BinaryUlid::class,
        ];
    }
}
```

### 🎯 Model Traits

[](#-model-traits)

Drop-in replacements for Laravel's `HasUuids` and `HasUlids` traits:

```
use Kenzal\MysqlBinaryUuids\Concerns\HasBinaryUuids;

class User extends Model
{
    use HasBinaryUuids;

    // That's it! Automatic UUID v7 generation with binary storage
}
```

### 🛠️ Blueprint Macros

[](#️-blueprint-macros)

Additional Blueprint methods for ULID columns:

```
Schema::create('sessions', function (Blueprint $table) {
    $table->binaryUlid('id')->primary();
    $table->binaryUlid('user_id');
    $table->foreignBinaryUlid('parent_id')->nullable();
});
```

Usage
-----

[](#usage)

### Basic Usage with Casts

[](#basic-usage-with-casts)

```
use Illuminate\Database\Eloquent\Model;
use Kenzal\MysqlBinaryUuids\Casts\BinaryUuid;

class Post extends Model
{
    protected function casts(): array
    {
        return [
            'id' => BinaryUuid::class,
            'author_id' => BinaryUuid::class,
        ];
    }
}

// Create a post (provide an ID since no trait for auto-generation)
$post = Post::create([
    'id' => '019eb8b2-8b13-7232-a60c-f19b6f0827df',
    'title' => 'My Post',
    'author_id' => '550e8400-e29b-41d4-a716-446655440000',
]);

// Access as UUID objects
echo $post->id->toString(); // "019eb8b2-8b13-7232-a60c-f19b6f0827df"
echo $post->author_id->toString(); // "550e8400-e29b-41d4-a716-446655440000"

// Works with UUID objects too
use Ramsey\Uuid\Uuid;

$post->author_id = Uuid::uuid4();
$post->save();
```

### Using Model Traits

[](#using-model-traits)

The `HasBinaryUuids` and `HasBinaryUlids` traits provide automatic ID generation:

```
use Illuminate\Database\Eloquent\Model;
use Kenzal\MysqlBinaryUuids\Concerns\HasBinaryUuids;

class User extends Model
{
    use HasBinaryUuids;

    protected $fillable = ['name', 'email'];
}

// UUID v7 is automatically generated
$user = User::create([
    'name' => 'John Doe',
    'email' => 'john@example.com',
]);

echo $user->id->toString(); // Auto-generated UUID v7
```

#### Using ULIDs

[](#using-ulids)

```
use Kenzal\MysqlBinaryUuids\Concerns\HasBinaryUlids;

class Session extends Model
{
    use HasBinaryUlids;

    protected $fillable = ['user_id'];
}

$session = Session::create([
    'user_id' => $user->id,
]);

// ULID objects are chronologically sortable
echo $session->id; // "01ARZ3NDEKTSV4RRFFQ69G5FAV"
```

### Custom Unique ID Columns

[](#custom-unique-id-columns)

By default, traits apply to the `id` column. Customize via the `uuidColumns()` or `ulidColumns()` methods:

```
use Kenzal\MysqlBinaryUuids\Concerns\HasBinaryUuids;

class Document extends Model
{
    use HasBinaryUuids;

    public function uuidColumns(): array
    {
        return ['id', 'document_number', 'revision_id'];
    }
}

// All three columns get binary UUID casts and auto-generation
```

### Custom UUID/ULID Types

[](#custom-uuidulid-types)

You can specify custom UUID/ULID subclasses for specific columns using string keys. This is useful when you need to extend UUIDs with domain-specific behavior.

First, create your custom UUID class:

```
use Kenzal\MysqlBinaryUuids\ExtensibleUuid;

class DocumentUuid extends ExtensibleUuid
{
    // ...
}
```

Then reference it in your model:

```
use Kenzal\MysqlBinaryUuids\Concerns\HasBinaryUuids;

class Document extends Model
{
    use HasBinaryUuids;

    public function uuidColumns(): array
    {
        return [
            'id',  // Uses default BinaryUuid cast
            'document_uuid' => DocumentUuid::class,  // Custom UUID subclass
        ];
    }
}
```

The same pattern works with `ExtensibleUlid` and `ulidColumns()`.

#### Using Directly in `casts()`

[](#using-directly-in-casts)

Since `ExtensibleUuid` and `ExtensibleUlid` implement Laravel's `Castable` interface, you can also use them directly in the `casts()` array without traits:

```
use Kenzal\MysqlBinaryUuids\Casts\BinaryUuid;
use Kenzal\MysqlBinaryUuids\ExtensibleUuid;

class CustomUuid extends ExtensibleUuid {}

class Document extends Model
{
    protected function casts(): array
    {
        return [
            'id' => BinaryUuid::class,
            'document_uuid' => CustomUuid::class,
        ];
    }
}
```

### Using Both UUID and ULID Columns

[](#using-both-uuid-and-ulid-columns)

A model can have both UUID and ULID columns by using one trait for auto-generation and explicit casts for others:

```
use Kenzal\MysqlBinaryUuids\Concerns\HasBinaryUuids;
use Kenzal\MysqlBinaryUuids\Casts\BinaryUlid;

class MixedModel extends Model
{
    use HasBinaryUuids;  // For UUID primary key

    public function uuidColumns(): array
    {
        return ['id'];  // UUID auto-generated
    }

    protected function casts(): array
    {
        return [
            'session_id' => BinaryUlid::class,  // ULID manually specified
        ];
    }
}
```

### Migration Examples

[](#migration-examples)

#### Creating Tables with UUIDs

[](#creating-tables-with-uuids)

```
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up(): void
    {
        Schema::create('organizations', function (Blueprint $table) {
            $table->uuid('id')->primary();
            $table->string('name');
            $table->timestamps();
        });

        Schema::create('users', function (Blueprint $table) {
            $table->uuid('id')->primary();
            $table->uuid('organization_id');
            $table->string('name');
            $table->string('email')->unique();
            $table->timestamps();

            $table->foreign('organization_id')
                  ->references('id')
                  ->on('organizations')
                  ->onDelete('cascade');
        });
    }
};
```

#### Creating Tables with ULIDs

[](#creating-tables-with-ulids)

```
Schema::create('sessions', function (Blueprint $table) {
    $table->binaryUlid('id')->primary();
    $table->uuid('user_id');
    $table->string('ip_address');
    $table->text('user_agent');
    $table->timestamp('last_activity');

    $table->index('user_id');
    $table->index('last_activity');
});
```

#### Nullable UUID/ULID Columns

[](#nullable-uuidulid-columns)

```
Schema::create('posts', function (Blueprint $table) {
    $table->uuid('id')->primary();
    $table->uuid('parent_id')->nullable(); // Optional parent post
    $table->uuid('author_id');
    $table->string('title');
    $table->text('content');
    $table->timestamps();
});
```

### Working with Existing Data

[](#working-with-existing-data)

If you're migrating from string-based UUIDs, create a migration to convert:

```
use Illuminate\Database\Migrations\Migration;
use Illuminate\Support\Facades\DB;

return new class extends Migration
{
    public function up(): void
    {
        // First, create a temporary column
        DB::statement('ALTER TABLE users ADD COLUMN id_binary BINARY(16) AFTER id');

        // Convert existing UUIDs to binary
        DB::statement('UPDATE users SET id_binary = UNHEX(REPLACE(id, "-", ""))');

        // Drop old column and rename new one
        DB::statement('ALTER TABLE users DROP PRIMARY KEY, DROP COLUMN id');
        DB::statement('ALTER TABLE users CHANGE id_binary id BINARY(16)');
        DB::statement('ALTER TABLE users ADD PRIMARY KEY (id)');
    }

    public function down(): void
    {
        // Convert back to char(36) if needed
        DB::statement('ALTER TABLE users ADD COLUMN id_char CHAR(36) AFTER id');
        DB::statement('UPDATE users SET id_char = LOWER(CONCAT(
            HEX(SUBSTRING(id, 1, 4)), "-",
            HEX(SUBSTRING(id, 5, 2)), "-",
            HEX(SUBSTRING(id, 7, 2)), "-",
            HEX(SUBSTRING(id, 9, 2)), "-",
            HEX(SUBSTRING(id, 11, 6))
        ))');
        DB::statement('ALTER TABLE users DROP PRIMARY KEY, DROP COLUMN id');
        DB::statement('ALTER TABLE users CHANGE id_char id CHAR(36)');
        DB::statement('ALTER TABLE users ADD PRIMARY KEY (id)');
    }
};
```

Route Model Binding
-------------------

[](#route-model-binding)

Binary UUID/ULID columns work seamlessly with Laravel's implicit and explicit route-model binding. The traits handle the conversion automatically — string UUIDs/ULIDs from URLs are converted to `UuidInterface`/`Ulid` objects before querying, and the connection handles the binary conversion.

### Implicit Binding

[](#implicit-binding)

With traits, no additional configuration is needed:

```
use Illuminate\Database\Eloquent\Model;
use Kenzal\MysqlBinaryUuids\Concerns\HasBinaryUuids;

class User extends Model
{
    use HasBinaryUuids;
}

// GET /users/550e8400-e29b-41d4-a716-446655440000
Route::get('/users/{user}', function (User $user) {
    return $user; // Resolved correctly from binary(16) column
});
```

### Explicit Binding

[](#explicit-binding)

Works with casts too — register the binding in `AppServiceProvider`:

```
use App\Models\Post;
use Illuminate\Support\Facades\Route;
use Ramsey\Uuid\Uuid;

Route::bind('post', function (string $value) {
    return Post::where('id', Uuid::fromString($value))->firstOrFail();
});
```

Or use Laravel's `getRouteKeyName()` on the model.

### Custom Route Key Names

[](#custom-route-key-names)

Override `getRouteKeyName()` to bind on a different binary UUID/ULID column:

```
class Document extends Model
{
    use HasBinaryUuids;

    public function uuidColumns(): array
    {
        return ['id', 'document_uuid'];
    }

    public function getRouteKeyName(): string
    {
        return 'document_uuid';
    }
}

// GET /documents/550e8400-e29b-41d4-a716-446655440000
Route::get('/documents/{document}', function (Document $document) {
    return $document;
});
```

API Reference
-------------

[](#api-reference)

### Casts

[](#casts)

#### `BinaryUuid`

[](#binaryuuid)

Casts binary(16) columns to `Ramsey\Uuid\UuidInterface` objects.

```
protected function casts(): array
{
    return [
        'id' => BinaryUuid::class,
    ];
}
```

**Methods:**

- `get()`: Converts binary data to UUID object
- `set()`: Accepts UUID strings or objects, converts to binary

#### `BinaryUlid`

[](#binaryulid)

Casts binary(16) columns to `Symfony\Component\Uid\Ulid` objects.

```
protected function casts(): array
{
    return [
        'id' => BinaryUlid::class,
    ];
}
```

**Methods:**

- `get()`: Converts binary data to ULID object
- `set()`: Accepts ULID strings or objects, converts to binary

### Traits

[](#traits)

#### `HasBinaryUuids`

[](#hasbinaryuuids)

Provides automatic UUID v7 generation with binary storage.

**Features:**

- Generates UUID v7 for new models
- Applies `BinaryUuid` cast to `uuidColumns()` columns
- Sets `$keyType = 'uuid'` and `$incrementing = false` (via `HasUniqueStringIds`)
- Route-model binding — resolves string UUID URLs against binary(16) columns

**Methods:**

- `newUniqueId()`: Generates a new UUID v7
- `isValidUniqueId($value)`: Validates UUID format
- `uuidColumns()`: Returns array of columns that should have UUIDs (default: `['id']`)
    - Supports custom UUID subclasses: `['uuid_id' => DocumentUuid::class]`

#### `HasBinaryUlids`

[](#hasbinaryulids)

Provides automatic ULID generation with binary storage.

**Features:**

- Generates ULIDs for new models
- Applies `BinaryUlid` cast to `ulidColumns()` columns
- Sets `$keyType = 'uuid'` and `$incrementing = false` (via `HasUniqueStringIds`)
- Route-model binding — resolves string ULID URLs against binary(16) columns
- ULIDs are chronologically sortable

**Methods:**

- `newUniqueId()`: Generates a new ULID
- `isValidUniqueId($value)`: Validates ULID format
- `ulidColumns()`: Returns array of columns that should have ULIDs (default: `['id']`)
    - Supports custom ULID subclasses: `['ulid_id' => CustomUlid::class]`

### Blueprint Macros

[](#blueprint-macros)

#### `binaryUlid(string $column = 'ulid')`

[](#binaryulidstring-column--ulid)

Create a binary(16) ULID column.

```
$table->binaryUlid('id')->primary();
$table->binaryUlid('session_id')->nullable();
```

#### `foreignBinaryUlid(string $column)`

[](#foreignbinaryulidstring-column)

Create a foreign key column for referencing a binary ULID.

```
$table->foreignBinaryUlid('parent_id')
      ->references('id')
      ->on('parents');
```

Testing
-------

[](#testing)

The package includes a comprehensive test suite:

```
composer test
```

Run specific test suites:

```
composer test -- --filter=Unit
composer test -- --filter=Feature
composer test -- --filter=HasBinaryUuids
```

Performance Considerations
--------------------------

[](#performance-considerations)

### Query Performance

[](#query-performance)

Binary UUIDs maintain excellent query performance. When querying, pass `UuidInterface` or `Ulid` objects — the connection automatically converts them to binary:

```
use Ramsey\Uuid\Uuid;

// Pass objects, not raw strings
$user = User::where('id', Uuid::fromString($uuidString))->first();
$user = User::find($uuidObject);

// Raw strings won't match binary(16) columns
User::find($uuidString); // null — use the object instead
```

### Index Recommendations

[](#index-recommendations)

For optimal performance:

1. **Always index UUID/ULID foreign keys:**

    ```
    $table->uuid('organization_id');
    $table->index('organization_id');
    ```
2. **Use UUID v7 or ULIDs for time-ordered data:**

    - Both have time-based sorting
    - Reduces index fragmentation
    - Better for clustered indexes
3. **Consider composite indexes:**

    ```
    $table->index(['organization_id', 'created_at']);
    ```

Compatibility
-------------

[](#compatibility)

### UUID Versions

[](#uuid-versions)

This package works with all UUID versions:

- **UUID v4**: Random UUIDs
- **UUID v7**: Time-ordered UUIDs (recommended, used by default)

The `HasBinaryUuids` trait generates UUID v7 by default for better database performance.

### ULID Format

[](#ulid-format)

ULIDs are 128-bit identifiers:

- 48-bit timestamp (millisecond precision)
- 80-bit random component
- Lexicographically sortable
- Case-insensitive base32 encoding

Contributing
------------

[](#contributing)

Contributions are welcome! Please feel free to submit a Pull Request.

### Development Setup

[](#development-setup)

```
git clone https://github.com/kenzal/mysql-binary-uuids.git
cd mysql-binary-uuids
composer install
```

### Local Testing Configuration

[](#local-testing-configuration)

Copy `phpunit.xml.dist` to `phpunit.xml` and customize for your local environment:

```
cp phpunit.xml.dist phpunit.xml
```

Then edit `phpunit.xml` with your local MySQL credentials:

```

```

**Note**: `phpunit.xml` is gitignored so your local credentials won't be committed.

### Running Tests

[](#running-tests)

```
composer test
```

Or run specific test suites:

```
# Run only unit tests
composer test:unit

# Run only feature tests
composer test:feature
```

### Code Style

[](#code-style)

This package uses [Laravel Pint](https://laravel.com/docs/pint) for code formatting. Before submitting a PR:

```
# Check code style
composer format:test

# Fix code style issues
composer format
```

Make sure all tests pass and code style checks pass before submitting a PR.

License
-------

[](#license)

This package is open-sourced software licensed under the [MIT license](LICENSE).

Credits
-------

[](#credits)

- **Author**: J. Kenzal Hunter, Sr. ([PGP Info](https://ksavalon.net/pgp), [PGP Key](https://ksavalon.net/pgp/public.asc))
- **Laravel**: Taylor Otwell and the Laravel community
- **Ramsey UUID**: Ben Ramsey
- **Symfony UID**: Symfony community

Support
-------

[](#support)

- **Issues**: [GitHub Issues](https://github.com/kenzal/mysql-binary-uuids/issues)
- **Discussions**: [GitHub Discussions](https://github.com/kenzal/mysql-binary-uuids/discussions)

Changelog
---------

[](#changelog)

See [CHANGELOG.md](CHANGELOG.md) for version history.

---

**Made with ❤️ for the Laravel community**

###  Health Score

39

—

LowBetter than 84% of packages

Maintenance90

Actively maintained with recent releases

Popularity5

Limited adoption so far

Community6

Small or concentrated contributor base

Maturity48

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 100% 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 ~0 days

Total

3

Last Release

45d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/f421d21816ff4060beb5248cd10094f7a76a3b4476f629349225f0cc770fb685?d=identicon)[kenzal](/maintainers/kenzal)

---

Top Contributors

[![kenzal](https://avatars.githubusercontent.com/u/2412533?v=4)](https://github.com/kenzal "kenzal (6 commits)")

###  Code Quality

TestsPest

Code StyleLaravel Pint

### Embed Badge

![Health badge](/badges/kenzal-mysql-binary-uuids/health.svg)

```
[![Health](https://phpackages.com/badges/kenzal-mysql-binary-uuids/health.svg)](https://phpackages.com/packages/kenzal-mysql-binary-uuids)
```

###  Alternatives

[mongodb/laravel-mongodb

A MongoDB based Eloquent model and Query builder for Laravel

7.1k8.4M99](/packages/mongodb-laravel-mongodb)[kirschbaum-development/eloquent-power-joins

The Laravel magic applied to joins.

1.6k32.6M46](/packages/kirschbaum-development-eloquent-power-joins)[yajra/laravel-oci8

Oracle DB driver for Laravel via OCI8

8793.2M25](/packages/yajra-laravel-oci8)[bavix/laravel-wallet

It's easy to work with a virtual wallet.

1.3k1.3M19](/packages/bavix-laravel-wallet)[glushkovds/phpclickhouse-laravel

Adapter of the most popular library https://github.com/smi2/phpClickHouse to Laravel

2051.5M2](/packages/glushkovds-phpclickhouse-laravel)[laravel-liberu/laravel-gedcom

A package that converts gedcom files to Eloquent models

782.5k1](/packages/laravel-liberu-laravel-gedcom)

PHPackages © 2026

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