├── .gitignore
├── tests
    ├── config
    │   └── database.php
    ├── Unit
    │   ├── Models
    │   │   ├── Create
    │   │   │   └── CreateTest.php
    │   │   ├── Dummy.php
    │   │   └── Find
    │   │   │   └── FindTest.php
    │   └── Factories
    │   │   └── DummyFactory.php
    ├── database
    │   └── migrations
    │   │   └── create_dummy_table.php
    └── TestCase.php
├── composer.json
├── License.txt
├── phpunit.xml
├── README.md
└── src
    └── HasCompositeKey.php


/.gitignore:
--------------------------------------------------------------------------------
1 | /vendor
2 | .phpunit.result.cache
3 | /.idea
4 | /logs
5 | /tests/database/*.sqlite


--------------------------------------------------------------------------------
/tests/config/database.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | return [
4 |     'sqlite' => [
5 |         'driver' => 'sqlite',
6 |         'database' => 'tests/database/testing.sqlite',
7 |         'prefix' => '',
8 |     ],
9 | ];


--------------------------------------------------------------------------------
/tests/Unit/Models/Create/CreateTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Thiagoprz\CompositeKey\Tests\Unit\Models\Create;
 4 | 
 5 | use Thiagoprz\CompositeKey\Tests\TestCase;
 6 | use Thiagoprz\CompositeKey\Unit\Models\Dummy;
 7 | 
 8 | class CreateTest extends TestCase
 9 | {
10 |     /**
11 |      * @return void
12 |      */
13 |     protected function setUp(): void
14 |     {
15 |         parent::setUp();
16 |     }
17 | 
18 |     /**
19 |      * @return void
20 |      * @testdox Test create model success
21 |      */
22 |     public function test_create_success()
23 |     {
24 |         $model = Dummy::factory()->make();
25 |         $success = $model->save();
26 |         $this->assertTrue($success);
27 |     }
28 | }


--------------------------------------------------------------------------------
/tests/Unit/Factories/DummyFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Thiagoprz\CompositeKey\Tests\Unit\Factories;
 4 | 
 5 | use Illuminate\Database\Eloquent\Factories\Factory;
 6 | use Thiagoprz\CompositeKey\Unit\Models\Dummy;
 7 | 
 8 | class DummyFactory extends Factory
 9 | {
10 |     protected $model = Dummy::class;
11 | 
12 |     public function definition()
13 |     {
14 |         return [
15 |             'key_1' => $this->faker->numberBetween(1, 9999999),
16 |             'key_2' => $this->faker->numberBetween(1, 9999999),
17 |             'name' => $this->faker->name(),
18 |             'email' => $this->faker->email(),
19 |             'phone' => $this->faker->phoneNumber(),
20 |             'city' => $this->faker->city(),
21 |         ];
22 |     }
23 | 
24 | }


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "thiagoprz/eloquent-composite-key",
 3 |     "description": "Eloquent Composite Key Support Package",
 4 |     "type": "library",
 5 |     "autoload": {
 6 |         "classmap": [
 7 |             "src/"
 8 |         ],
 9 |         "psr-4": {
10 |             "Thiagoprz\\CompositeKey\\": "src"
11 |         }
12 |     },
13 |     "autoload-dev": {
14 |         "classmap": [
15 |             "tests/"
16 |         ],
17 |         "psr-4": {
18 |             "Thiagoprz\\CompositeKey\\Tests\\": "tests"
19 |         }
20 |     },
21 |     "require": {
22 |         "php": "^7.1 || ^8.0 || ^8.1"
23 |     },
24 |     "require-dev": {
25 |         "orchestra/testbench": "6",
26 |         "squizlabs/php_codesniffer": "4.0.x-dev"
27 |     },
28 |     "license": "MIT",
29 |     "authors": [
30 |         {
31 |             "name": "Thiago Przyczynski",
32 |             "email": "przyczynski@gmail.com"
33 |         }
34 |     ],
35 |     "minimum-stability": "dev"
36 | }
37 | 


--------------------------------------------------------------------------------
/tests/database/migrations/create_dummy_table.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Illuminate\Database\Migrations\Migration;
 4 | use Illuminate\Database\Schema\Blueprint;
 5 | use Illuminate\Support\Facades\Schema;
 6 | 
 7 | class CreateDummyTable extends Migration
 8 | {
 9 |     /**
10 |      * Run the migrations.
11 |      *
12 |      * @return void
13 |      */
14 |     public function up()
15 |     {
16 |         Schema::create('dummy', function (Blueprint $table) {
17 |             $table->unsignedBigInteger('key_1');
18 |             $table->unsignedBigInteger('key_2');
19 |             $table->string('name');
20 |             $table->string('email');
21 |             $table->string('phone');
22 |             $table->string('city');
23 |             $table->timestamps();
24 |         });
25 |     }
26 | 
27 |     /**
28 |      * Reverse the migrations.
29 |      *
30 |      * @return void
31 |      */
32 |     public function down()
33 |     {
34 |         Schema::dropIfExists('dummy');
35 |     }
36 | }


--------------------------------------------------------------------------------
/License.txt:
--------------------------------------------------------------------------------
1 | Copyright 2022 Thiago Cezar Pereira Przyczynski
2 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
3 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
4 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/tests/TestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Thiagoprz\CompositeKey\Tests;
 4 | 
 5 | use Orchestra\Testbench\TestCase as BaseTest;
 6 | 
 7 | class TestCase extends BaseTest
 8 | {
 9 |     /**
10 |      * @return void
11 |      */
12 |     protected function setUp(): void
13 |     {
14 |         parent::setUp();
15 |     }
16 | 
17 |     /**
18 |      * @param $app
19 |      * @return void
20 |      */
21 |     public function getEnvironmentSetUp($app)
22 |     {
23 |         $database = require __DIR__ . '/config/database.php';
24 |         $app['config']->set('database.default', 'testbench');
25 |         $app['config']->set('database.connections.testbench', $database['sqlite']);
26 |         $app['config']->set('app.debug', true);
27 |         $app['config']->set('logging.default', 'daily');
28 |         $app['config']->set('logging.channels.daily.path', 'logs/testing.log');
29 |         unlink(__DIR__ . '/database/testing.sqlite');
30 |         touch(__DIR__ . '/database/testing.sqlite');
31 |         require_once __DIR__ . '/database/migrations/create_dummy_table.php';
32 |         (new \CreateDummyTable)->up();
33 |     }
34 | }


--------------------------------------------------------------------------------
/tests/Unit/Models/Dummy.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace Thiagoprz\CompositeKey\Unit\Models;
 4 | 
 5 | use Illuminate\Database\Eloquent\Factories\HasFactory;
 6 | use Illuminate\Database\Eloquent\Model;
 7 | use Thiagoprz\CompositeKey\HasCompositeKey;
 8 | use Thiagoprz\CompositeKey\Tests\Unit\Factories\DummyFactory;
 9 | 
10 | /**
11 |  * @property int $key_1
12 |  * @property int $key_2
13 |  * @property string $name
14 |  * @property string $email
15 |  * @property string $phone
16 |  * @property string $city
17 |  */
18 | class Dummy extends Model
19 | {
20 |     use HasCompositeKey, HasFactory;
21 | 
22 |     /**
23 |      * @var string[]
24 |      */
25 |     protected $primaryKey = ['key_1', 'key_2'];
26 | 
27 |     /**
28 |      * Table name
29 |      * @var string
30 |      */
31 |     protected $table = 'dummy';
32 | 
33 |     /**
34 |      * @var string[]
35 |      */
36 |     protected $fillable = ['key_1', 'key_2', 'name', 'email', 'phone', 'city'];
37 | 
38 |     /**
39 |      * @return DummyFactory
40 |      */
41 |     protected static function newFactory()
42 |     {
43 |         return DummyFactory::new();
44 |     }
45 | }


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit
 3 |         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4 |         bootstrap="vendor/autoload.php"
 5 |         backupGlobals="false"
 6 |         backupStaticAttributes="false"
 7 |         colors="true"
 8 |         verbose="true"
 9 |         testdox="true"
10 |         convertErrorsToExceptions="true"
11 |         convertNoticesToExceptions="true"
12 |         convertWarningsToExceptions="true"
13 |         processIsolation="false"
14 |         stopOnFailure="false"
15 |         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/9.3/phpunit.xsd"
16 | >
17 |     <coverage>
18 |         <include>
19 |             <directory suffix=".php">src/</directory>
20 |         </include>
21 |     </coverage>
22 |     <testsuites>
23 |         <testsuite name="Unit">
24 |             <directory suffix="Test.php">tests</directory>
25 |         </testsuite>
26 |     </testsuites>
27 |     <php>
28 |         <env name="DB_CONNECTION" value="testing"/>
29 |         <env name="DB_DATABASE" value="sqlite"/>
30 |         <env name="APP_KEY" value="base64:2fl+Ktvkfl+Fuz4Qp/A75G2RTiWVA/ZoKZvp6fiiM10="/>
31 |     </php>
32 | </phpunit>


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Eloquent Composite Key
 2 | Package to enable composite key support on Eloquent Models.
 3 | 
 4 | ## Installation
 5 | Install it with composer:
 6 | 
 7 | `composer require thiagoprz/eloquent-composite-key`
 8 | 
 9 | ## Usage
10 | Define the primaryKey as an array and use the HasCompositeKey trait on your model class.
11 | ```
12 | <?php
13 | ...
14 | use Thiagoprz\CompositeKey\HasCompositeKey;
15 | 
16 | class User extends Model 
17 | {
18 |     use HasCompositeKey;
19 |     ...
20 |     protected $primaryKey = ['firstKey', 'secondKey'];
21 |     ...
22 | }
23 | ```
24 | Using primary keys to find records:
25 | ```
26 | <?php
27 | ...
28 | // Returns model instance or null
29 | $user = User::find([
30 |     'key_1' => $key1,
31 |     'key_2' => $key2,
32 | ]);
33 | ...
34 | // Throws ModelNotFoundException
35 | $user = User::findOrFail([
36 |     'key_1' => $key1,
37 |     'key_2' => $key2,
38 | ]);
39 | ...
40 | ```
41 | 
42 | The main idea of this package is to allow Laravel projects use composite keys on models despite Eloquent not supporting them officially (see https://laravel.com/docs/8.x/eloquent#composite-primary-keys).  
43 | 
44 | 
45 | ## License
46 | [MIT](https://github.com/thiagoprz/eloquent-composite-key/blob/master/License.txt)


--------------------------------------------------------------------------------
/tests/Unit/Models/Find/FindTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Thiagoprz\CompositeKey\Tests\Unit\Models\Find;
 4 | 
 5 | use Illuminate\Database\Eloquent\ModelNotFoundException;
 6 | use Thiagoprz\CompositeKey\Tests\TestCase;
 7 | use Thiagoprz\CompositeKey\Unit\Models\Dummy;
 8 | 
 9 | class FindTest extends TestCase
10 | {
11 | 
12 |     /**
13 |      * @var Dummy[]
14 |      */
15 |     private $dummies;
16 | 
17 |     protected function setUp(): void
18 |     {
19 |         parent::setUp();
20 |         $this->dummies = Dummy::factory()->count(2)->create();
21 |     }
22 | 
23 |     /**
24 |      * @return void
25 |      */
26 |     public function test_find_model_success()
27 |     {
28 |         $model = Dummy::find([
29 |             $this->dummies[0]->key_1,
30 |             $this->dummies[0]->key_2,
31 |         ]);
32 |         $this->assertEquals($this->dummies[0]->getAttributes(), $model->getAttributes());
33 |     }
34 | 
35 |     /**
36 |      * @return void
37 |      */
38 |     public function test_find_wrong_arguments_failure()
39 |     {
40 |         $this->expectException(\TypeError::class);
41 |         Dummy::find($this->dummies[0]->key_1);
42 |     }
43 | 
44 |     /**
45 |      * @return void
46 |      */
47 |     public function test_find_or_fail_success()
48 |     {
49 |         $model = Dummy::findOrFail([
50 |             $this->dummies[0]->key_1,
51 |             $this->dummies[0]->key_2,
52 |         ]);
53 |         $this->assertEquals($this->dummies[0]->getAttributes(), $model->getAttributes());
54 |     }
55 | 
56 |     /**
57 |      * @return void
58 |      */
59 |     public function test_find_or_fail_model_not_found_exception_failure()
60 |     {
61 |         $this->expectException(ModelNotFoundException::class);
62 |         Dummy::findOrFail([
63 |             1234,
64 |             21341,
65 |         ]);
66 |     }
67 | }


--------------------------------------------------------------------------------
/src/HasCompositeKey.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Thiagoprz\CompositeKey;
  4 | 
  5 | use Illuminate\Database\Eloquent\ModelNotFoundException;
  6 | 
  7 | /**
  8 |  * Trait HasCompositeKey
  9 |  * @package Thiagoprz\CompositeKey
 10 |  */
 11 | trait HasCompositeKey
 12 | {
 13 | 
 14 |     public function getIncrementing()
 15 |     {
 16 |         return false;
 17 |     }
 18 | 
 19 |     public function getCasts()
 20 |     {
 21 |         if ($this->getIncrementing()) {
 22 |             return array_merge([$this->getKeyName() => $this->getKeyType()], $this->casts);
 23 |         }
 24 |         return $this->casts;
 25 |     }
 26 | 
 27 |     public function getKeyName()
 28 |     {
 29 |         return $this->primaryKey;
 30 |     }
 31 | 
 32 |     public function getKey()
 33 |     {
 34 |         $fields = $this->getKeyName();
 35 |         $keys = [];
 36 |         array_map(function ($key) use (&$keys) {
 37 |             $keys[] = $this->getAttribute($key);
 38 |         }, $fields);
 39 |         return $keys;
 40 |     }
 41 | 
 42 |     protected function getKeysForSaveQuery($query)
 43 |     {
 44 |         foreach ($this->primaryKey as $key) {
 45 |             $query->where($key, '=', $this->getAttribute($key));
 46 |         }
 47 |         return $query;
 48 |     }
 49 | 
 50 |     protected function setKeysForSaveQuery($query)
 51 |     {
 52 |         $keys = $this->getKeyName();
 53 |         return !is_array($keys) ? parent::setKeysForSaveQuery($query) : $query->where(function ($q) use ($keys) {
 54 |             foreach ($keys as $key) {
 55 |                 $q->where($key, '=', $this->getAttribute($key));
 56 |             }
 57 |         });
 58 |     }
 59 | 
 60 |     public function getQueueableId()
 61 |     {
 62 |         return implode(':', array_map(fn($key) => $this->getAttribute($key), $this->getKeyName()));
 63 |     }
 64 | 
 65 | 
 66 |     public static function find(string|array $ids)
 67 |     {
 68 |         if (is_string($ids)) {
 69 |             $ids = explode(':', $ids);
 70 |         }
 71 | 
 72 |         $model = new static();
 73 |         $keyNames = $model->getKeyName();
 74 | 
 75 |         if (!is_array($ids) || count($ids) !== count($keyNames)) {
 76 |             return null;
 77 |         }
 78 | 
 79 |         return static::where(function ($query) use ($keyNames, $ids) {
 80 |             foreach ($keyNames as $index => $key) {
 81 |                 $query->where($key, '=', $ids[$index]);
 82 |             }
 83 |         })->first();
 84 |     }
 85 | 
 86 | 
 87 |     /**
 88 |      * Find model by primary key or throws ModelNotFoundException
 89 |      *
 90 |      * @param array $ids
 91 |      * @return mixed
 92 |      */
 93 |     public static function findOrFail(array $ids)
 94 |     {
 95 |         $modelClass = get_called_class();
 96 |         $model = new $modelClass();
 97 |         $record = $model->find($ids);
 98 |         if (!$record) {
 99 |             throw new ModelNotFoundException;
100 |         }
101 |         return $record;
102 |     }
103 | 
104 |     public function newQueryForRestoration($ids)
105 |     {
106 |         if (is_string($ids) && str_contains($ids, ':')) {
107 |             $ids = explode(':', $ids);
108 |         }
109 | 
110 |         if (is_array($ids)) {
111 |             $keyNames = $this->getKeyName();
112 | 
113 |             if (count($ids) !== count($keyNames)) {
114 |                 return parent::newQueryForRestoration($ids);
115 |             }
116 | 
117 |             $query = $this->newQueryWithoutScopes();
118 |             foreach ($keyNames as $index => $key) {
119 |                 $query->where($key, '=', $ids[$index]);
120 |             }
121 | 
122 |             return $query;
123 |         }
124 | 
125 |         return parent::newQueryForRestoration($ids);
126 |     }
127 | }
128 | 


--------------------------------------------------------------------------------