PHPackages                             wilkques/database - 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. wilkques/database

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

wilkques/database
=================

v1.0.2(4mo ago)022MITPHPPHP >=5.4CI passing

Since Oct 18Pushed 4mo ago1 watchersCompare

[ Source](https://github.com/wilkques/php-database)[ Packagist](https://packagist.org/packages/wilkques/database)[ RSS](/packages/wilkques-database/feed)WikiDiscussions master Synced 1w ago

READMEChangelog (8)Dependencies (4)Versions (9)Used By (0)

Database
========

[](#database)

[![Latest Stable Version](https://camo.githubusercontent.com/44dfe915a6ae67f15f60a3ec4229dd004df371e759e1021036fcf000312f6f52/68747470733a2f2f706f7365722e707567782e6f72672f77696c6b717565732f64617461626173652f762f737461626c65)](https://packagist.org/packages/wilkques/database)[![License](https://camo.githubusercontent.com/5e6569480a5a0c90ad914a898c29b9520b38a93e681e971a60d142795184030f/68747470733a2f2f706f7365722e707567782e6f72672f77696c6b717565732f64617461626173652f6c6963656e7365)](https://packagist.org/packages/wilkques/database)

Notice
------

[](#notice)

1. `MySQL` Only
2. Database operate

ENV
---

[](#env)

1. php >= 5.4
2. mysql >= 5.6
3. PDO extension

How to use
----------

[](#how-to-use)

1. Via PHP require
    [Download Database](https://github.com/wilkques/Database)
    [Download EzLoader and See how to use](https://github.com/wilkques/EzLoader)

    ```
    require_once "path/to/your/folder/wilkques/Ezloader/src/helpers.php";
    require_once "path/to/your/folder/wilkques/Database/src/helpers.php";

    loadPHP();
    ```
2. Via Composer `composer require wilkques/database`

    ```
    require "vendor/autoload.php";
    ```
3. start

    ```
    $connection = \Wilkques\Database\Database::connect('', '', '', '', '', '', '');

    // or

    $connection = \Wilkques\Database\Database::connect([
        'driver'    => '',   // mysql
        'host'      => '',        // default localhost
        'username'  => '',
        'password'  => '',
        'database'  => '',
        'port'      => '',        // default 3360
        'charset'   => '',   // default utf8mb4
    ]);
    ```

Methods
-------

[](#methods)

### table or from

[](#table-or-from)

1. `table` or `from` or `fromSub``table` same `from`

    ```
    $db->table('');

    // or

    $db->table('', '');

    // or

    $db->table(
        function ($query) {
            $query->table('');
            // do something
        },
        ''
    );

    // output: select ... from (select ... from ) AS ``

    // same

    $dbTable = (
        new \Wilkques\Database\Queries\Builder(
            $connection,
            new \Wilkques\Database\Queries\Grammar\Drivers\MySql,
            new \Wilkques\Database\Queries\Processors\Processor,
        )
    )->table('');

    $db->fromSub(
        $dbTable,
        ''
    );

    // output: select ... from (select ... from ) AS ``

    // same

    $db->fromSub(
        function ($query) {
            $query->table('');
            // do something
        },
        ''
    );

    // output: select ... from (select ... from ) AS ``

    // or

    $db->table([
        function ($query) {
            $query->table('');
        },
        function ($query) {
            $query->table('');
        },
    ]);

    // output: select ... from (select ... from ), (select ... from )

    // or

    $db->table([
        '' => function ($query) {
            $query->table('');
        },
        '' => function ($query) {
            $query->table('');
        },
    ]);

    // output: select ... from (select ... from ) AS ``, (select ... from ) AS ``
    ```

### select

[](#select)

1. `select` or `selectSub`

    ```
    $db->select(
        '',
        '',
        '',
        function ($query) {
            $query->table('');
            // do something
        }
    );

    // output: select , , , (select ...)

    // or

    $db->select([
        '' => '',
        '' => '',
    ]);

    // output: select  AS ``,  AS ``

    // or

    $db->select([
        '',
        '',
        '',
        function ($query) {
            $query->table('');
            // do something
        },
        '' => function ($query) {
            $query->table('');
            // do something
        },
    ]);

    // output: select , , , (select ...), (select ...) AS ``

    // or

    $db->select("``, ``, ``");

    // or

    $db->selectSub(
        function ($query) {
            $query->table('');
            // do something
        },
        ''
    );

    // output: select (select ...) AS ``
    ```
2. `selectSub`

    ```
    $db->selectSub(
        function ($query) {
            $query->table('');
            // do something
        }
    );

    // output: select (select ...)

    // or

    $db->selectSub(
        function ($query) {
            $query->table('');
            // do something
        },
        ''
    );

    // output: select (select ...) AS ``
    ```

### join

[](#join)

1. `join`

    ```
    $db->from('')->join(
        '',
        '.',
        '.'
    );

    // output: select ... join  ON . = .

    // or

    $db->from('')->join(
        '',
        function ($join) {
            $join->on('.', '.')
            ->orOn('.', '.');

            // do something
        }
    );

    // output: select ... join  ON . = . OR . = .
    ```
2. `joinWhere`

    ```
    $db->from('')->joinWhere(
        '',
        '.',
        '.'
    );

    // output: select ... join  WHERE . = .

    // or

    $db->from('')->joinWhere(
        '',
        function ($join) {
            $join->on('.', '.')
            ->orOn('.', '.');

            // do something
        }
    );

    // output: select ... join  WHERE . = . OR . = .
    ```
3. `joinSub`

    ```
    $db->from('')->joinSub(
        function ($query) {
            $query->table('');

            // do something
        },
        '',
        function (\Wilkques\Database\Queries\JoinClause $join) {
            $join->on('.', '.')
            ->orOn('.', '.');
        }
    );

    // output: select ... join (select ...) as `` ON . = . OR . = .

    // or

    $dbTable = (
        new \Wilkques\Database\Queries\Builder(
            $connection,
            new \Wilkques\Database\Queries\Grammar\Drivers\MySql,
            new \Wilkques\Database\Queries\Processors\Processor,
        )
    )->table('');

    $db->from('')->joinSub(
        $dbTable,
        '',
        function (\Wilkques\Database\Queries\JoinClause $join) {
            $join->on('.', '.')
            ->orOn('.', '.');
        }
    );

    // output: select ... join (select ...) as `` ON . = . OR . = .
    ```
4. `joinSubWhere`

    ```
    $db->from('')->joinSubWhere(
        function ($builder) {
            $builder->table('');

            // do something
        },
        '',
        function (\Wilkques\Database\Queries\JoinClause $join) {
            $join->on('.', '.')
            ->orOn('.', '.');
        }
    );

    // output: select ... join (select ...) as `` WHERE . = . OR . = .

    // or

    $dbTable = (
        new \Wilkques\Database\Queries\Builder(
            $connection,
            new \Wilkques\Database\Queries\Grammar\Drivers\MySql,
            new \Wilkques\Database\Queries\Processors\Processor,
        )
    )->table('');

    $db->from('')->joinSubWhere(
        $dbTable,
        '',
        function (\Wilkques\Database\Queries\JoinClause $join) {
            $join->on('.', '.')
            ->orOn('.', '.');
        }
    );

    // output: select ... join (select ...) as `` WHERE . = . OR . = .
    ```
5. `leftJoin`

    same `join`
6. `leftJoinSub`

    same `joinSub`
7. `leftJoinWhere`

    same `join`
8. `leftJoinSubWhere`

    same `joinSub`
9. `rightJoin`

    same `join`
10. `rightJoinSub`

    same `joinSub`
11. `rightJoinWhere`

    same `join`
12. `rightJoinSubWhere`

    same `joinSub`
13. `crossJoin`

    same `join`
14. `crossJoinSub`

    same `joinSub`
15. `crossJoinWhere`

    same `join`
16. `crossJoinSubWhere`

    same `joinSub`

### where

[](#where)

1. `where`

    ```
    $db->where([
        [''],
        [''],
        [''],
    ]);

    // output: select ... where ( IS NULL AND  IS NULL AND  IS NULL)

    // or

    $db->where('');

    // output: select ... where ( IS NULL)

    // or

    $db->where([
        ['', ''],
        ['', ''],
        ['', ''],
    ]);

    // or

    $db->where([
        ['', '', ''],
        ['', '', ''],
        ['', '', ''],
    ]);

    // or

    $db->where('', "", '');

    // or

    $db->where('', '')
        ->where('', '')
        ->where('', '');

    // or

    $db->where('', "", '')
        ->where('', "", '')
        ->where('', "", '');

    // or

    $db->where(function ($query) {
        $query->where('', '')->where('', '');
    });

    // output: select ... where ( =  AND  = )

    // or

    $dbTable = (
        new \Wilkques\Database\Queries\Builder(
            $connection,
            new \Wilkques\Database\Queries\Grammar\Drivers\MySql,
            new \Wilkques\Database\Queries\Processors\Processor,
        )
    )->table('');

    $db->where($dbTable);

    // same

    $db->whereExists($dbTable);

    // output: select ... where EXISTS (select ...)

    // or

    $db->where('', $dbTable);

    // output: select ... where '' = (select ...)

    // or

    $db->where('', "", $dbTable);

    // output: select ... where ''  (select ...)

    // or

    $db->where('', "", function ($query) {
        $query->table('')->where('', '')->where('', '');
    });

    // output: select ... where ''  (select ...)
    ```
2. `orWhere`

    same `where`
3. `whereNull`

    ```
    $db->whereNull('');
    ```
4. `orWhereNull`

    same `whereNull`
5. `whereNotNull`

    same `whereNull`
6. `orWhereNotNull`

    same `whereNotNull`
7. `whereIn`

    ```
    $db->whereIn('', ['', '']);

    // or

    $dbTable = (
        new \Wilkques\Database\Queries\Builder(
            $connection,
            new \Wilkques\Database\Queries\Grammar\Drivers\MySql,
            new \Wilkques\Database\Queries\Processors\Processor,
        )
    )->table('');

    $db->whereIn('', $dbTable);

    // or

    $db->whereIn('', function ($query) {
        $query->select('')->table('');
    });
    ```
8. `orWhereIn`

    same `whereIn`
9. `whereNotIn`

    same `whereIn`
10. `orWhereNotIn`

    same `whereIn`
11. `whereBetween`

    ```
    $db->whereBetween('', ['', '']);
    ```
12. `orWhereBetween`

    same `whereBetween`
13. `whereNotBetween`

    same `whereBetween`
14. `orWhereNotBetween`

    same `whereBetween`
15. `whereExists`

    ```
    $db->whereExists(
        function ($query) {
            $query->table('');
            // do something
    });

    // or

    $dbTable = (
        new \Wilkques\Database\Queries\Builder(
            $connection,
            new \Wilkques\Database\Queries\Grammar\Drivers\MySql,
            new \Wilkques\Database\Queries\Processors\Processor,
        )
    )->table('');

    $db->whereExists($dbTable);

    // same

    $db->where($dbTable);
    ```
16. `whereNotExists`

    same `whereExists`
17. `orWhereExists`

    same `whereExists`
18. `orWhereNotExists`

    same `whereExists`
19. `whereLike`

    ```
    $db->whereLike('', '');
    ```
20. `orWhereLike`

    ```
    $db->orWhereLike('', '');
    ```

### having

[](#having)

1. `having`

    ```
    $db->having(``, ``);

    // or

    $db->having(``, "", ``);

    // or

    $db->having(
        ``,
        function ($query) {
            $query->table('');
            // do something
        }
    );

    // or

    $db->having(
        ``,
        "",
        function ($query) {
            $query->table('');
            // do something
        }
    );

    // or

    $dbTable = (
        new \Wilkques\Database\Queries\Builder(
            $connection,
            new \Wilkques\Database\Queries\Grammar\Drivers\MySql,
            new \Wilkques\Database\Queries\Processors\Processor,
        )
    )->table('');

    $db->having(``, $dbTable);

    // or

    $db->having(``, "", $dbTable);
    ```
2. `orHaving`

    ```
    $db->orHaving(``, ``);

    // or

    $db->orHaving(``, "", ``);

    // or

    $db->orHaving(
        ``,
        function ($query) {
            $query->table('');
            // do something
        }
    );

    // or

    $db->orHaving(
        ``,
        "",
        function ($query) {
            $query->table('');
            // do something
        }
    );

    // or

    $dbTable = (
        new \Wilkques\Database\Queries\Builder(
            $connection,
            new \Wilkques\Database\Queries\Grammar\Drivers\MySql,
            new \Wilkques\Database\Queries\Processors\Processor,
        )
    )->table('');

    $db->orHaving(``, $dbTable);

    // or

    $db->orHaving(``, "", $dbTable);
    ```

### limit or offset

[](#limit-or-offset)

1. `limit`

    ```
    $db->limit(1); // set query LIMIT

    // or

    $db->limit(10, 1); // set query LIMIT
    ```
2. `offset`

    ```
    $db->offset(1); // set query OFFSET
    ```

### group by

[](#group-by)

1. `groupBy`

    ```
    $db->groupBy('', 'DESC'); // default ASC

    // or

    $db->groupBy([
        ['', 'DESC'],
        ['', 'ASC'],
    ]);

    // or

    $db->groupBy([
        [
            function ($query) {
                $query->table('');
                // do something
            },
            'DESC'
        ],
        ['', 'ASC'],
    ]);

    // or

    $dbTable = (
        new \Wilkques\Database\Queries\Builder(
            $connection,
            new \Wilkques\Database\Queries\Grammar\Drivers\MySql,
            new \Wilkques\Database\Queries\Processors\Processor,
        )
    )->table('');

    $db->groupBy($dbTable, 'DESC'); // default ASC

    // or

    $db->groupBy([
        [
            $dbTable,
            'DESC'
        ],
        ['', 'ASC'],
    ]);
    ```
2. `groupByDesc`

    ```
    $db->groupByDesc('');

    // or

    $db->groupByDesc('', '');

    // or

    $db->groupByDesc(
        function ($query) {
            $query->table('');
            // do something
        },
        ''
    );

    // or

    $db->groupByDesc(['', '']);

    // or

    $db->groupByDesc([
        function ($query) {
            $query->table('');
            // do something
        },
        ''
    ]);

    // or

    $dbTable = (
        new \Wilkques\Database\Queries\Builder(
            $connection,
            new \Wilkques\Database\Queries\Grammar\Drivers\MySql,
            new \Wilkques\Database\Queries\Processors\Processor,
        )
    )->table('');

    $db->groupByDesc($dbTable, ''); // default ASC

    // or

    $db->groupByDesc([
        $dbTable,
        ''
    ]);
    ```
3. `groupByAsc`

    ```
    $db->groupByAsc('');

    // or

    $db->groupByAsc('', '');

    // or

    $db->groupByAsc(
        function ($query) {
            $query->table('');
            // do something
        },
        ''
    );

    // or

    $db->groupByAsc(['', '']);

    // or

    $db->groupByAsc([
        function ($query) {
            $query->table('');
            // do something
        },
        ''
    ]);

    // or

    $dbTable = (
        new \Wilkques\Database\Queries\Builder(
            $connection,
            new \Wilkques\Database\Queries\Grammar\Drivers\MySql,
            new \Wilkques\Database\Queries\Processors\Processor,
        )
    )->table('');

    $db->groupByAsc($dbTable, ''); // default ASC

    // or

    $db->groupByAsc([
        $dbTable,
        ''
    ]);
    ```

### order by

[](#order-by)

1. `orderBy`

    ```
    $db->orderBy('', "DESC"); // default ASC

    // or

    $db->orderBy([
        ['', 'DESC'],
        ['', 'ASC'],
    ]);

    // or

    $db->orderBy([
        [
            function ($query) {
                $query->table('');
                // do something
            },
            'DESC'
        ],
        ['', 'ASC'],
    ]);
    ```
2. `orderByDesc`

    ```
    $db->orderByDesc('');

    // or

    $db->orderByDesc('', '');

    // or

    $db->orderByDesc(
        function ($query) {
            $query->table('');
            // do something
        },
        ''
    );

    // or

    $db->orderByDesc(['', '']);

    // or

    $db->orderByDesc([
        function ($query) {
            $query->table('');
            // do something
        },
        ''
    ]);
    ```
3. `orderByAsc`

    ```
    $db->orderByAsc('');

    // or

    $db->orderByAsc('', '');

    // or

    $db->orderByAsc(
        function ($query) {
            $query->table('');
            // do something
        },
        ''
    );

    // or

    $db->orderByAsc(['', '']);

    // or

    $db->orderByAsc([
        function ($query) {
            $query->table('');
            // do something
        },
        ''
    ]);
    ```

### union

[](#union)

1. `union`

    ```
    $db->union(function ($query) {
        $query->table('');
        // do something
    });

    // or

    $dbTable = (
        new \Wilkques\Database\Queries\Builder(
            $connection,
            new \Wilkques\Database\Queries\Grammar\Drivers\MySql,
            new \Wilkques\Database\Queries\Processors\Processor,
        )
    )->table('');

    $db->union($dbTable);
    ```
2. `unionAll`sam `union`

### Get Data

[](#get-data)

1. `get`

    ```
    $db->get(); // get all data
    ```
2. `first`

    ```
    $db->first(); // get first data
    ```
3. `find`

    ```
    $db->find(''); // get find data
    ```

### Update

[](#update)

1. `update`

    ```
    $db->where('', "=", '')
        ->update([
            '' => ''
        ]);

    // or

    $db->where('', "=", '')->first();

    $db->update([
        '' => ''
    ]);

    // or

    $db->where('', "=", '')->first();

    $db->update([
        '' => function ($query) {
            $query->table('')->select('');

            // do something
        }
    ]);
    ```
2. `increment`

    ```
    $db->increment('');

    // or

    $db->increment('', '', [
        '' => 'update value 1',
        '' => 'update value 2',
        ...
    ]);
    ```
3. `decrement`

    ```
    $db->decrement('');

    // or

    $db->decrement('', '', [
        '' => 'update value 1',
        '' => 'update value 2',
        ...
    ]);
    ```

### Insert

[](#insert)

1. `insert`

    ```
    $db->insert([
            '' => 'ColumnValue1>',
            '' => 'ColumnValue2>',
            ...
        ]);

    // or

    $db->insert([
        [
            '' => 'ColumnValue1>',
            '' => 'ColumnValue2>',
            ...
        ],
        [
            '' => 'ColumnValue3>',
            '' => 'ColumnValue4>',
            ...
        ]
    ]);
    ```
2. `insertSub`

    ```
    $db->insertSub([
        ''
        ''
        ...
    ], function ($query) {
        $query->from('')->select(
            '',
            '',
            ...
        )->where('', '')->where('', '');
    });

    // output: Insert  (, ) SELECT ,  FROM
    // WHERE  =  AND  =
    ```

### Delete

[](#delete)

1. `delete`

    ```
    $db->where('', "=", '')
        ->delete([
            '' => ''
        ]);

    // or

    $db->where('', "=", '')->first();

    $db->delete();
    ```
2. `softDelete`

    ```
    $db->where('', "=", '')
        ->softDelete('', ''); // default deleted_at, "Y-m-d H:i:s"

    // or

    $db->where('', "=", '')->first();

    $db->softDelete('', ''); // default deleted_at, "Y-m-d H:i:s"
    ```
3. `reStore` recovery (`delete` cannot recovery data)

    ```
    $db->where('', "=", '')
        ->reStore(''); // default deleted_at

    // or

    $db->where('', "=", '')->first();

    $db->reStore(''); // default deleted_at
    ```

### Raw

[](#raw)

1. `raw````
    // select

    $db->select($db->raw(""));

    // example

    $db->select($db->raw("COUNT(*)"));

    // update

    $db->update([
        $db->raw(""),
    ]);
    ```

### SQL Execute

[](#sql-execute)

1. `query` set SQL string

    ```
    $db->query("")->fetch();

    // for example

    $db->query("SELECT * FROM ``")->fetch();
    ```
2. `prepare` execute SQL string

    ```
    $db->prepare("")->execute(['', '' ...])->fetch();
    ```
3. `bindParams` execute SQL string

    ```
    $stat = $db->prepare("");

    $stat->bindParams(['', '' ...])->execute();

    $stat->fetch();
    ```
4. `execute` execute SQL string

### SQL Execute result

[](#sql-execute-result)

1. `fetchNumeric` get result key to numeric
2. `fetchAssociative` get result key value
3. `fetchFirstColumn` get result first column
4. `fetchAllNumeric` get all result key to numeric
5. `fetchAllAssociative` get all result key value
6. `fetchAllFirstColumn` get all result first column
7. `rowCount` get result
8. `free` PDO method `closeCursor` [PHP PDOStatement::closeCursor](https://www.php.net/manual/en/pdostatement.closecursor.php)
9. `fetch` [PDOStatement::fetch](https://www.php.net/manual/en/pdostatement.fetch.php)
10. `fetchAll` [PDOStatement::fetchAll](https://www.php.net/manual/en/pdostatement.fetchall.php)

### Query Log

[](#query-log)

1. `enableQueryLog` enable query logs

    ```
    $db->enableQueryLog();
    ```
2. `getQueryLog` get all query string and bind data

    ```
    $db->getQueryLog();
    ```
3. `getParseQueryLog` or `parseQueryLog` get paser query logs

    ```
    $db->getParseQueryLog();
    ```
4. `getLastParseQuery` or `lastParseQuery` get paser query

    ```
    $db->getLastParseQuery();
    ```

### Lock

[](#lock)

1. `lockForUpdate`

    ```
    $db->lockForUpdate();
    ```
2. `sharedLock`

    ```
    $db->sharedLock();
    ```

### Page

[](#page)

1. `currentPage`

    ```
    $db->currentPage(1); // now page
    ```
2. `prePage`

    ```
    $db->prePage(15); // pre page
    ```
3. `getForPage`

    ```
    $db->getForPage(); // get page data

    // or

    $db->getForPage('', ''); // get page data
    ```

### Transaction

[](#transaction)

1. `beginTransaction`

    ```
    $db->beginTransaction();
    ```
2. `commit`

    ```
    $db->commit();
    ```
3. `rollback`

    ```
    $db->rollback();
    ```

### Connect

[](#connect)

1. `host`

    ```
    $db->host('');
    ```
2. `username`

    ```
    $db->username('');
    ```
3. `password`

    ```
    $db->password('');
    ```
4. `database`

    ```
    $db->database('');
    ```
5. `newConnection`

    ```
    $db->newConnection();

    // or

    $db->newConnection("");
    ```
6. `reConnection`

    ```
    $db->reConnection();

    // or

    $db->reConnection("");
    ```
7. `selectDatabase`

    ```
    $db->selectDatabase('');
    ```

###  Health Score

37

—

LowBetter than 83% of packages

Maintenance76

Regular maintenance activity

Popularity6

Limited adoption so far

Community7

Small or concentrated contributor base

Maturity50

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 ~220 days

Recently: every ~384 days

Total

8

Last Release

133d ago

Major Versions

v0.3.5 → v1.0.02025-05-28

### Community

Maintainers

![](https://www.gravatar.com/avatar/906e907ec7e3dbe49f32aebd0f36488176d3736a65d38675753ba9a6a21017b6?d=identicon)[wilkques](/maintainers/wilkques)

---

Top Contributors

[![wilkques](https://avatars.githubusercontent.com/u/51186879?v=4)](https://github.com/wilkques "wilkques (256 commits)")

###  Code Quality

TestsPHPUnit

### Embed Badge

![Health badge](/badges/wilkques-database/health.svg)

```
[![Health](https://phpackages.com/badges/wilkques-database/health.svg)](https://phpackages.com/packages/wilkques-database)
```

###  Alternatives

[doctrine/orm

Object-Relational-Mapper for PHP

10.2k285.3M6.2k](/packages/doctrine-orm)[jdorn/sql-formatter

a PHP SQL highlighting library

3.9k115.1M102](/packages/jdorn-sql-formatter)[illuminate/database

The Illuminate Database package.

2.8k52.4M9.4k](/packages/illuminate-database)[ramsey/uuid-doctrine

Use ramsey/uuid as a Doctrine field type.

90440.3M211](/packages/ramsey-uuid-doctrine)[reliese/laravel

Reliese Components for Laravel Framework code generation.

1.7k3.4M16](/packages/reliese-laravel)[wildside/userstamps

Laravel Userstamps provides an Eloquent trait which automatically maintains `created\_by` and `updated\_by` columns on your model, populated by the currently authenticated user in your application.

7511.7M13](/packages/wildside-userstamps)

PHPackages © 2026

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