┌ Which authentication provider do you prefer? ────────────────┐
 │   ○ Laravel's built-in authentication                        │
 │ › ● WorkOS (Requires WorkOS account)                         │
 └──────────────────────────────────────────────────────────────┘

WORKOS_CLIENT_ID=xxxx
WORKOS_API_KEY=xxxx
WORKOS_REDIRECT_URL="http://localhost:8000/authenticate"

AADSTS50105: Your administrator has configured the application HOGE SAML App ('xxxxx') to block users unless they are specifically granted ('assigned') access to the application. The signed in user 'foo@bar.example.com' is blocked because they are not a direct member of a group with access, nor had access directly assigned by an administrator. Please contact your administrator to assign access to this application.

Single Sign-On failed for XXXXXX

Your foo.example.com connection received invalid user attributes and failed to authenticate a user.
 
Why this might happen
 
The user attributes are misconfigured in Entra ID (Azure AD).
A single user is misconfigured in Entra ID (Azure AD). (Check the received attributes below).
 
How to fix this
 
Verify that attribute mapping is correct in the Entra ID (Azure AD) dashboard.

% composer require bref/bref bref/laravel-bridge --update-with-dependencies

% npm install @bref.sh/constructs

const vpc = new ec2.Vpc(this, "BrefVpc", {
  maxAzs: 1,
  natGateways: 0,
  restrictDefaultSecurityGroup: true,
  subnetConfiguration: [
    {
      name: "BrefPrivate",
      subnetType: ec2.SubnetType.PRIVATE_ISOLATED,
    },
  ],
});

const fileSystem = new efs.FileSystem(this, "BrefEfs", {
  vpc: vpc,
  removalPolicy: cdk.RemovalPolicy.DESTROY,
  performanceMode: efs.PerformanceMode.GENERAL_PURPOSE,
  throughputMode: efs.ThroughputMode.BURSTING,
  oneZone: true,
});

const accessPoint = this.fileSystem.addAccessPoint("BrefAccessPoint", {
  path: "/bref"
  createAcl: {
    ownerUid: "1001",
    ownerGid: "1001",
    permissions: "750",
  },
  posixUser: {
    uid: "1001",
    gid: "1001",
  },
});

const backendFn = new PhpFpmFunction(this, "BrefApiFunction", {
  functionName: "ApiFunction",
  handler: "public/index.php",
  code: packagePhpCode("../laravel/", {
    exclude: ["tests/**", "var/**"],
  }),
  timeout: cdk.Duration.seconds(28),
  memorySize: 1024,
  vpc: vpc,
  filesystem: lambda.FileSystem.fromEfsAccessPoint(
    accessPoint,
    "/mnt/efs",
  ),
  environment: {
    APP_ENV: "production",
    LOG_CHANNEL: "stderr",
    DB_CONNECTION: "sqlite",
    DB_DATABASE: "/mnt/efs/database.sqlite",
  },
  phpVersion: "8.4",
});

const api = new apigwv2.HttpApi(this, "BrefHttpApi", {
  defaultIntegration: new integrations.HttpLambdaIntegration(
    "Integration",
    backendFn,
  ),
});

new cdk.CfnOutput(this, "ApiUrl", {
  value: api.url!,
});

new ConsoleFunction(this, "BrefConsoleFunction", {
  functionName: "ConsoleFunction",
  handler: "artisan",
  code: packagePhpCode("../laravel/", {
    exclude: ["tests/**", "var/**"],
  }),
  timeout: cdk.Duration.seconds(28),
  memorySize: 512,
  vpc: vpc,
  filesystem: lambda.FileSystem.fromEfsAccessPoint(
    accessPoint,
    "/mnt/efs",
  ),
  environment: {
    APP_ENV: "production",
    LOG_CHANNEL: "stderr",
    DB_CONNECTION: "sqlite",
    DB_DATABASE: "/mnt/efs/database.sqlite",
  },
  phpVersion: "8.4",
});

% cdk deploy

(略)

Outputs:
BrefStack.ApiUrl = https://example.execute-api.ap-northeast-1.amazonaws.com/

% aws lambda invoke \
     --function-name ConsoleFunction \
     --region ap-northeast-1 \
     --cli-binary-format raw-in-base64-out \
     --payload '"migrate --force"' \
     response.json

{
    "StatusCode": 200,
    "ExecutedVersion": "$LATEST"
}

->withMiddleware(function (Middleware $middleware) {
    $middleware->statefulApi();
})

/**
 * Indicate that Sanctum's frontend state middleware should be enabled.
 *
 * @return $this
 */
public function statefulApi()
{
    $this->statefulApi = true;

    return $this;
}

/**
 * Get the middleware groups.
 *
 * @return array
 */
public function getMiddlewareGroups()
{
    $middleware = [
        'web' => array_values(array_filter([
            \Illuminate\Cookie\Middleware\EncryptCookies::class,
            \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
            \Illuminate\Session\Middleware\StartSession::class,
            \Illuminate\View\Middleware\ShareErrorsFromSession::class,
            \Illuminate\Foundation\Http\Middleware\ValidateCsrfToken::class,
            \Illuminate\Routing\Middleware\SubstituteBindings::class,
            $this->authenticatedSessions ? 'auth.session' : null,
        ])),
        'api' => array_values(array_filter([
            $this->statefulApi ? \Laravel\Sanctum\Http\Middleware\EnsureFrontendRequestsAreStateful::class : null,
            $this->apiLimiter ? 'throttle:'.$this->apiLimiter : null,
            \Illuminate\Routing\Middleware\SubstituteBindings::class,
        ])),
    ];
(省略)
}

/**
 * Handle the incoming requests.
 *
 * @param  \Illuminate\Http\Request  $request
 * @param  callable  $next
 * @return \Illuminate\Http\Response
 */
public function handle($request, $next)
{
    $this->configureSecureCookieSessions();

    return (new Pipeline(app()))->send($request)->through(
        static::fromFrontend($request) ? $this->frontendMiddleware() : []
    )->then(function ($request) use ($next) {
        return $next($request);
    });
}

(省略)

/**
 * Get the middleware that should be applied to requests from the "frontend".
 *
 * @return array
 */
protected function frontendMiddleware()
{
    $middleware = array_values(array_filter(array_unique([
        config('sanctum.middleware.encrypt_cookies', \Illuminate\Cookie\Middleware\EncryptCookies::class),
        \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
        \Illuminate\Session\Middleware\StartSession::class,
        config('sanctum.middleware.validate_csrf_token', config('sanctum.middleware.verify_csrf_token', \Illuminate\Foundation\Http\Middleware\VerifyCsrfToken::class)),
        config('sanctum.middleware.authenticate_session'),
    ])));

    array_unshift($middleware, function ($request, $next) {
        $request->attributes->set('sanctum', true);

        return $next($request);
    });

    return $middleware;
}

/**
 * Handle an incoming request.
 *
 * @param  \Illuminate\Http\Request  $request
 * @param  \Closure  $next
 * @return mixed
 *
 * @throws \Illuminate\Session\TokenMismatchException
 */
public function handle($request, Closure $next)
{
    if (
        $this->isReading($request) ||
        $this->runningUnitTests() ||
        $this->inExceptArray($request) ||
        $this->tokensMatch($request)
    ) {
        return tap($next($request), function ($response) use ($request) {
            if ($this->shouldAddXsrfTokenCookie()) {
                $this->addCookieToResponse($request, $response);
            }
        });
    }

    throw new TokenMismatchException('CSRF token mismatch.');
}

/**
 * Determine if the session and input CSRF tokens match.
 *
 * @param  \Illuminate\Http\Request  $request
 * @return bool
 */
protected function tokensMatch($request)
{
    $token = $this->getTokenFromRequest($request);

    return is_string($request->session()->token()) &&
            is_string($token) &&
            hash_equals($request->session()->token(), $token);
}

/**
 * Handle an incoming request.
 *
 * @param  \Illuminate\Http\Request  $request
 * @param  \Closure  $next
 * @return mixed
 *
 * @throws \Illuminate\Session\TokenMismatchException
 */
public function handle($request, Closure $next)
{
    if (
        $this->isReading($request) ||
        $this->runningUnitTests() ||
        $this->inExceptArray($request) ||
        $this->tokensMatch($request)
    ) {
        return tap($next($request), function ($response) use ($request) {
            if ($this->shouldAddXsrfTokenCookie()) {
                $this->addCookieToResponse($request, $response);
            }
        });
    }

    throw new TokenMismatchException('CSRF token mismatch.');
}

(省略)

/**
 * Add the CSRF token to the response cookies.
 *
 * @param  \Illuminate\Http\Request  $request
 * @param  \Symfony\Component\HttpFoundation\Response  $response
 * @return \Symfony\Component\HttpFoundation\Response
 */
protected function addCookieToResponse($request, $response)
{
    $config = config('session');

    if ($response instanceof Responsable) {
        $response = $response->toResponse($request);
    }

    $response->headers->setCookie($this->newCookie($request, $config));

    return $response;
}

(省略)

/**
 * Create a new "XSRF-TOKEN" cookie that contains the CSRF token.
 *
 * @param  \Illuminate\Http\Request  $request
 * @param  array  $config
 * @return \Symfony\Component\HttpFoundation\Cookie
 */
protected function newCookie($request, $config)
{
    return new Cookie(
        'XSRF-TOKEN',
        $request->session()->token(),
        $this->availableAt(60 * $config['lifetime']),
        $config['path'],
        $config['domain'],
        $config['secure'],
        false,
        false,
        $config['same_site'] ?? null,
        $config['partitioned'] ?? false
    );
}

$ composer create-project laravel/laravel .
$ composer require nwidart/laravel-modules

"extra": {
    "laravel": {
        "dont-discover": []
    },
    "merge-plugin": {
        "include": [
            "Modules/*/composer.json"
        ]
    }
},

$ php artisan module:make Posts
$ php artisan module:make-middleware PostsMiddleware Posts

<?php

namespace Modules\Posts\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class PostsMiddleware
{
    /**
     * Handle an incoming request.
     */
    public function handle(Request $request, Closure $next)
    {
        echo 'Hello, world!! ';
        return $next($request);
    }
}

<?php

use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Exceptions;
use Illuminate\Foundation\Configuration\Middleware;

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        commands: __DIR__.'/../routes/console.php',
        health: '/up',
    )
    ->withMiddleware(function (Middleware $middleware) {
        // グローバルミドルウェアで登録
        $middleware->append(\Modules\Posts\Http\Middleware\PostsMiddleware::class);

        // ミドルウェアグループに登録
        $middleware->appendToGroup('group', [\Modules\Posts\Http\Middleware\PostsMiddleware::class]);

        // エイリアスとして登録
        $middleware->alias(['post' => \Modules\Posts\Http\Middleware\PostsMiddleware::class ]);
    })
    ->withExceptions(function (Exceptions $exceptions) {
        //
    })->create();

<?php

use Illuminate\Support\Facades\Route;

Route::get('/posts/global', function() {
    return '(global)';
});

Route::get( '/posts/alias', function() {
    return '(alias)';
})->middleware('post');

Route::middleware(['group'])->group(function() {
    Route::get( '/posts/group', function() {
        return '(group)';
    });
});

$ curl http://localhost:8000/posts/global
Hello, world!! (global)%

$ curl http://localhost:8000/posts/alias 
Hello, world!! Hello, world!! (alias)%

$ curl http://localhost:8000/posts/group
Hello, world!! Hello, world!! (group)%

<?php

use Illuminate\Support\Facades\Route;

Route::get('/global', function() {
    return '(global common)';
});

$ curl http://localhost:8000/global     
Hello, world!! (global common)%

/**
 * Register any application services.
 *
 * @return void
 */
public function register()
{
    $this->booted(function () {
        $this->setRootControllerNamespace();

        if ($this->routesAreCached()) {
            $this->loadCachedRoutes();
        } else {
            $this->loadRoutes();

            $this->app->booted(function () {
                $this->app['router']->getRoutes()->refreshNameLookups();
                $this->app['router']->getRoutes()->refreshActionLookups();
            });
        }
    });
}

/**
 * Load the application routes.
 *
 * @return void
 */
protected function loadRoutes()
{
    if (! is_null(self::$alwaysLoadRoutesUsing)) {
        $this->app->call(self::$alwaysLoadRoutesUsing);
    }

    if (! is_null($this->loadRoutesUsing)) {
        $this->app->call($this->loadRoutesUsing);
    } elseif (method_exists($this, 'map')) {
        $this->app->call([$this, 'map']);
    }
}

<?php

namespace Modules\Posts\Providers;

use Illuminate\Support\Facades\Route;
use Illuminate\Foundation\Support\Providers\RouteServiceProvider as ServiceProvider;
use Modules\Posts\Http\Middleware\PostsMiddleware;

class RouteServiceProvider extends ServiceProvider
{
    /**
     * Called before routes are registered.
     *
     * Register any model bindings or pattern based filters.
     */
    public function boot(): void
    {
        parent::boot();
    }

    /**
     * Define the routes for the application.
     */
    public function map(): void
    {
        Route::aliasMiddleware('post', PostsMiddleware::class);
        $this->mapApiRoutes();

        $this->mapWebRoutes();
    }

    /**
     * Define the "web" routes for the application.
     *
     * These routes all receive session state, CSRF protection, etc.
     */
    protected function mapWebRoutes(): void
    {
        Route::middleware(['web', 'post'])->group(module_path('Posts', '/routes/web.php'));
    }

    /**
     * Define the "api" routes for the application.
     *
     * These routes are typically stateless.
     */
    protected function mapApiRoutes(): void
    {
        Route::middleware('api')->prefix('api')->name('api.')->group(module_path('Posts', '/routes/api.php'));
    }
}

$ curl http://localhost:8000/posts/global
Hello, world!! (global)%

<?php

use Illuminate\Support\Facades\Route;

Route::get('/global', function() {
    return '(global common)';
})->middleware('post');

{
    "Posts": false
}

$ curl -I  http://localhost:8000/global
HTTP/1.1 500 Internal Server Error

$user = User::find(1);

// App\Models\User {
//    id: 5,
//    name: "kiichiro",
//    email: "kiichiro@example.com",
//    email_verified_at: "2024-05-28 06:44:34",
//    password: "$2y$12$jJuJzdMPZ/gSwVSp3DzNE.1SwACJGqPLsWLWP3HGUZRhP1Q/9zJs2",
//    remember_token: "KjmFVc1rUZ",
//    created_at: "2024-05-28 06:44:35",
//    updated_at: "2024-05-28 06:51:32",
// }

$user = User::select(['id', 'name'])->find(1);

// App\Models\User {
//     id: 1,
//     name: "kiichiro",
// }

$user->email; // null

public function boot(): void
{
    Model::preventAccessingMissingAttributes();
}

$user = User::select(['id', 'name'])->find(1);
$user->email;

// Illuminate\Database\Eloquent\MissingAttributeException  The attribute [email] either does not exist or was not retrieved for model [App\Models\User].

$user = User::select(['id', 'name'])->find(1);
$user->email = 'kiichiro@example.com';
$user->email;
// 'kiichiro@example.com'

$user = User::select(['id', 'name'])->find(1);
$user->fill(['email' => 'kiichiro@example.com']);
$user->email;
// 'kiichiro@example.com'

/**
 * Dynamically retrieve attributes on the model.
 *
 * @param  string  $key
 * @return mixed
 */
public function __get($key)
{
    return $this->getAttribute($key);
}

/**
 * Get an attribute from the model.
 *
 * @param  string  $key
 * @return mixed
 */
public function getAttribute($key)
{
    if (! $key) {
        return;
    }

    // If the attribute exists in the attribute array or has a "get" mutator we will
    // get the attribute's value. Otherwise, we will proceed as if the developers
    // are asking for a relationship's value. This covers both types of values.
    if ($this->hasAttribute($key)) {
        return $this->getAttributeValue($key);
    }

    // Here we will determine if the model base class itself contains this given key
    // since we don't want to treat any of those methods as relationships because
    // they are all intended as helper methods and none of these are relations.
    if (method_exists(self::class, $key)) {
        return $this->throwMissingAttributeExceptionIfApplicable($key);
    }

    return $this->isRelation($key) || $this->relationLoaded($key)
                ? $this->getRelationValue($key)
                : $this->throwMissingAttributeExceptionIfApplicable($key);
}

/**
 * Determine whether an attribute exists on the model.
 *
 * @param  string  $key
 * @return bool
 */
public function hasAttribute($key)
{
    if (! $key) {
        return false;
    }

    return array_key_exists($key, $this->attributes) ||
        array_key_exists($key, $this->casts) ||
        $this->hasGetMutator($key) ||
        $this->hasAttributeMutator($key) ||
        $this->isClassCastable($key);
}

public function up(): void
{
    Schema::create('posts', function (Blueprint $table) {
        $table->id();
        $table->json('post_meta');
        $table->string('post_meta_slug')->nullable()->virtualAs('JSON_UNQUOTE(post_meta->"$.slug")');
        $table->index('post_meta_slug');
    });
}

mysql> show create table posts;
+-------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Table | Create Table                                                                                                                                                                                                                                                                                                                                                                                                            |
+-------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| posts | CREATE TABLE `posts` (
  `id` bigint unsigned NOT NULL AUTO_INCREMENT,
  `post_meta` json NOT NULL,
  `post_meta_slug` varchar(255) COLLATE utf8mb4_unicode_ci GENERATED ALWAYS AS (json_unquote(json_extract(`post_meta`,_utf8mb4'$.slug'))) VIRTUAL,
  PRIMARY KEY (`id`),
  KEY `posts_post_meta_slug_index` (`post_meta_slug`)
) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci |
+-------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.00 sec)

INSERT INTO posts (post_meta) values
('{"slug":"6nwolmsp8y", "title": "AWS-CDKWordPress"}'),
('{"slug":"4yeiux7wqq", "title": "WPScanxmlrpc"}'),
('{"slug":"3yjela8tgv", "title": "WordPressHTTPHTTPS (version5.7)"}'),
('{"slug":"4771lv37ot", "title": "Laravel SailMySQLPostgres"}'),
('{"slug":"2xch5zq3e9", "title": "BeautifulSoupSelenium"}'),
('{"slug":"1xbq0pridw", "title": "ACF10Delicious Brains Inc."}'),
('{"slug":"10bwr53umq", "title": "Amazon LightsailAWS CDK"}'),
('{"slug":"43nyielz64", "title": "Amazon LightsailSSL"}'),
('{"slug":"40a2u2w7rv", "title": "AWS Solutions Architect Associate"}'),
('{"slug":"26ru99uao0", "title": "AWS CDKTypeScriptLambda + SAM Local"}')
;

mysql> select * from posts;
+----+------------------------------------------------------------------------+----------------+
| id | post_meta                                                              | post_meta_slug |
+----+------------------------------------------------------------------------+----------------+
|  1 | {"slug": "6nwolmsp8y", "title": "AWS-CDKWordPress"}                    | 6nwolmsp8y     |
|  2 | {"slug": "4yeiux7wqq", "title": "WPScanxmlrpc"}                        | 4yeiux7wqq     |
|  3 | {"slug": "3yjela8tgv", "title": "WordPressHTTPHTTPS (version5.7)"}     | 3yjela8tgv     |
|  4 | {"slug": "4771lv37ot", "title": "Laravel SailMySQLPostgres"}           | 4771lv37ot     |
|  5 | {"slug": "2xch5zq3e9", "title": "BeautifulSoupSelenium"}               | 2xch5zq3e9     |
|  6 | {"slug": "1xbq0pridw", "title": "ACF10Delicious Brains Inc."}          | 1xbq0pridw     |
|  7 | {"slug": "10bwr53umq", "title": "Amazon LightsailAWS CDK"}             | 10bwr53umq     |
|  8 | {"slug": "43nyielz64", "title": "Amazon LightsailSSL"}                 | 43nyielz64     |
|  9 | {"slug": "40a2u2w7rv", "title": "AWS Solutions Architect Associate"}   | 40a2u2w7rv     |
| 10 | {"slug": "26ru99uao0", "title": "AWS CDKTypeScriptLambda + SAM Local"} | 26ru99uao0     |
+----+------------------------------------------------------------------------+----------------+
10 rows in set (0.00 sec)

mysql> SELECT * FROM posts WHERE `post_meta`->"$.slug" = "6nwolmsp8y";
+----+-----------------------------------------------------+----------------+
| id | post_meta                                           | post_meta_slug |
+----+-----------------------------------------------------+----------------+
|  1 | {"slug": "6nwolmsp8y", "title": "AWS-CDKWordPress"} | 6nwolmsp8y     |
+----+-----------------------------------------------------+----------------+
1 row in set (0.02 sec)

mysql> SELECT * FROM posts WHERE JSON_UNQUOTE(JSON_EXTRACT(`post_meta`, "$.slug"))  = "6nwolmsp8y";
+----+-----------------------------------------------------+----------------+
| id | post_meta                                           | post_meta_slug |
+----+-----------------------------------------------------+----------------+
|  1 | {"slug": "6nwolmsp8y", "title": "AWS-CDKWordPress"} | 6nwolmsp8y     |
+----+-----------------------------------------------------+----------------+
1 row in set (0.00 sec)

mysql> EXPLAIN SELECT * FROM posts WHERE `post_meta`->"$.slug" = "6nwolmsp8y";
+----+-------------+-------+------------+------+----------------------------+----------------------------+---------+-------+------+----------+-------+
| id | select_type | table | partitions | type | possible_keys              | key                        | key_len | ref   | rows | filtered | Extra |
+----+-------------+-------+------------+------+----------------------------+----------------------------+---------+-------+------+----------+-------+
|  1 | SIMPLE      | posts | NULL       | ref  | posts_post_meta_slug_index | posts_post_meta_slug_index | 1023    | const |    1 |   100.00 | NULL  |
+----+-------------+-------+------------+------+----------------------------+----------------------------+---------+-------+------+----------+-------+
1 row in set, 1 warning (0.00 sec)

mysql> EXPLAIN SELECT * FROM posts WHERE JSON_UNQUOTE(JSON_EXTRACT(`post_meta`, "$.slug"))  = "6nwolmsp8y";
+----+-------------+-------+------------+------+----------------------------+----------------------------+---------+-------+------+----------+-------+
| id | select_type | table | partitions | type | possible_keys              | key                        | key_len | ref   | rows | filtered | Extra |
+----+-------------+-------+------------+------+----------------------------+----------------------------+---------+-------+------+----------+-------+
|  1 | SIMPLE      | posts | NULL       | ref  | posts_post_meta_slug_index | posts_post_meta_slug_index | 1023    | const |    1 |   100.00 | NULL  |
+----+-------------+-------+------------+------+----------------------------+----------------------------+---------+-------+------+----------+-------+
1 row in set, 1 warning (0.00 sec)

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model { }

> \App\Models\Post::where('post_meta->slug', '6nwolmsp8y')->explain();
= Illuminate\Support\Collection {#6207
    all: [
      {#7161
        +"id": 1,
        +"select_type": "SIMPLE",
        +"table": "posts",
        +"partitions": null,
        +"type": "ALL",
        +"possible_keys": null,
        +"key": null,
        +"key_len": null,
        +"ref": null,
        +"rows": 10,
        +"filtered": 100.0,
        +"Extra": "Using where",
      },
    ],
  }

> \App\Models\Post::where('post_meta->slug', '6nwolmsp8y')->toSql();
= "select * from `posts` where json_unquote(json_extract(`post_meta`, '$."slug"')) = ?"

SELECT * FROM `posts` WHERE JSON_UNQUOTE(JSON_EXTRACT(`post_meta`, '$."slug"')) = "6nwolmsp8y";

> \App\Models\Post::query()->whereRaw('JSON_UNQUOTE(JSON_EXTRACT(post_meta, "$.slug")) = ?', ['4yeiux7wqq'])->explain();
= Illuminate\Support\Collection {#7174
    all: [
      {#6210
        +"id": 1,
        +"select_type": "SIMPLE",
        +"table": "posts",
        +"partitions": null,
        +"type": "ref",
        +"possible_keys": "posts_post_meta_slug_index",
        +"key": "posts_post_meta_slug_index",
        +"key_len": "1023",
        +"ref": "const",
        +"rows": 1,
        +"filtered": 100.0,
        +"Extra": null,
      },
    ],
  }

> \App\Models\Post::query()->where('post_meta_slug', '4yeiux7wqq')->explain();
= Illuminate\Support\Collection {#7175
    all: [
      {#7165
        +"id": 1,
        +"select_type": "SIMPLE",
        +"table": "posts",
        +"partitions": null,
        +"type": "ref",
        +"possible_keys": "posts_post_meta_slug_index",
        +"key": "posts_post_meta_slug_index",
        +"key_len": "1023",
        +"ref": "const",
        +"rows": 1,
        +"filtered": 100.0,
        +"Extra": null,
      },
    ],
  }

public function up(): void
{
    Schema::create('posts', function (Blueprint $table) {
        $table->id();
        $table->json('post_meta');
    });
    DB::statement('ALTER TABLE posts ADD INDEX post_meta_slug_index((CAST(post_meta->>"$.slug" as CHAR(255)) COLLATE utf8mb4_bin))');
}

mysql> show create table posts;
+-------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Table | Create Table                                                                                                                                                                                                                                                                                                                                    |
+-------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| posts | CREATE TABLE `posts` (
  `id` bigint unsigned NOT NULL AUTO_INCREMENT,
  `post_meta` json NOT NULL,
  PRIMARY KEY (`id`),
  KEY `post_meta_slug_index` (((cast(json_unquote(json_extract(`post_meta`,_utf8mb4'$.slug')) as char(255) charset utf8mb4) collate utf8mb4_bin)))
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci |
+-------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.01 sec)

public function boot()
{
    Collection::macro('foo', function() {
        $this->map(function($value) {
            // 処理
        });
    });
}

// __callを宣言していないクラス
class Bar {}

$bar = new Bar();
$bar->bar(); // PHP Fatal error:  Uncaught Error: Call to undefined method Bar::bar()

// __callを宣言したクラス
class Foo {
    public function __call($method, $parameters) {
        echo 'Method: ' . $method;
    }
}

$foo = new Foo();
$foo->foo(); // Method: foo

/**
 * The registered string macros.
 *
 * @var array
 */
protected static $macros = [];

/**
 * Register a custom macro.
 *
 * @param  string  $name
 * @param  object|callable  $macro
 * @return void
 */
public static function macro($name, $macro)
{
    static::$macros[$name] = $macro;
}

public function boot()
{
    Collection::macro('foo', function() {
        $this->map(function($value) {
            // 処理
        });
    });
}

// インスタンス化して呼び出す
collect()->foo();

// staticメソッドとして呼び出す
Collection::foo();

/**
 * Dynamically handle calls to the class.
 *
 * @param  string  $method
 * @param  array  $parameters
 * @return mixed
 *
 * @throws \BadMethodCallException
 */
public static function __callStatic($method, $parameters)
{
    if (! static::hasMacro($method)) {
        throw new BadMethodCallException(sprintf(
            'Method %s::%s does not exist.', static::class, $method
        ));
    }

    $macro = static::$macros[$method];

    if ($macro instanceof Closure) {
        $macro = $macro->bindTo(null, static::class);
    }

    return $macro(...$parameters);
}

/**
 * Dynamically handle calls to the class.
 *
 * @param  string  $method
 * @param  array  $parameters
 * @return mixed
 *
 * @throws \BadMethodCallException
 */
public function __call($method, $parameters)
{
    if (! static::hasMacro($method)) {
        throw new BadMethodCallException(sprintf(
            'Method %s::%s does not exist.', static::class, $method
        ));
    }

    $macro = static::$macros[$method];

    if ($macro instanceof Closure) {
        $macro = $macro->bindTo($this, static::class);
    }

    return $macro(...$parameters);
}

$foo = Foo::getModel();

// ①明示的にStringを渡す
$foo->fill([
    'datetime' => Carbon::now()->toDateTimeString(),
    'date'     => Carbon::now()->toDateString(),
])->save();

// ②Carbonオブジェクトのまま渡す
$foo->fill([
    'datetime' => Carbon::now(),
    'date'     => Carbon::now(),
])->save();

$this->attributes[$key] = $value;

    /**
     * Prepare the query bindings for execution.
     *
     * @param  array  $bindings
     * @return array
     */
    public function prepareBindings(array $bindings)
    {
        $grammar = $this->getQueryGrammar();

        foreach ($bindings as $key => $value) {
            // We need to transform all instances of DateTimeInterface into the actual
            // date string. Each query grammar maintains its own date string format
            // so we'll just ask the grammar for the format to get from the date.
            if ($value instanceof DateTimeInterface) {
                $bindings[$key] = $value->format($grammar->getDateFormat());
            } elseif (is_bool($value)) {
                $bindings[$key] = (int) $value;
            }
        }

        return $bindings;
    }

    /**
     * Get the format for database stored dates.
     *
     * @return string
     */
    public function getDateFormat()
    {
        return 'Y-m-d H:i:s';
    }

    /**
     * Update the creation and update timestamps.
     *
     * @return $this
     */
    public function updateTimestamps()
    {
        $time = $this->freshTimestamp();

        $updatedAtColumn = $this->getUpdatedAtColumn();

        if (! is_null($updatedAtColumn) && ! $this->isDirty($updatedAtColumn)) {
            $this->setUpdatedAt($time);
        }

        $createdAtColumn = $this->getCreatedAtColumn();

        if (! $this->exists && ! is_null($createdAtColumn) && ! $this->isDirty($createdAtColumn)) {
            $this->setCreatedAt($time);
        }

        return $this;
    }

    /**
     * Get a fresh timestamp for the model.
     *
     * @return \Illuminate\Support\Carbon
     */
    public function freshTimestamp()
    {
        return Date::now();
    }

$ composer require jgrossi/corcel

$ ./vendor/bin/sail up -d
$ ./vendor/bin/sail artisan sail:publish

'connection' => 'wordpress',

// 'connections' に以下を追加
'wordpress' => [
    'driver' => 'mysql',
    'host' => env('WP_DB_HOST', '127.0.0.1'),
    'port' => env('WP_DB_PORT', '3306'),
    'database' => env('WP_DB_DATABASE', 'wordpress'),
    'username' => env('WP_DB_USERNAME', 'wordpress'),
    'password' => env('WP_DB_PASSWORD', ''),
    'charset' => 'utf8',
    'collation' => 'utf8_unicode_ci',
    'prefix' => 'wp_',
    'strict' => false,
    'engine' => null,
],

WP_DB_CONNECTION=mysql
WP_DB_HOST=db
WP_DB_PORT=3306
WP_DB_DATABASE=wordpress
WP_DB_USERNAME=wordpress
WP_DB_PASSWORD=wordpress

version: '3'

services:
  db:
    image: mysql:5.7
    volumes:
      - db_data:/var/lib/mysql
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: somewordpress
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: wordpress
    networks:
      - external

  wordpress:
    depends_on:
      - db
    image: wordpress:latest
    ports:
      - "8000:80"
    restart: always
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: wordpress
    networks:
      - external
networks:
  external:
    driver: bridge
    name: {Laravelのディレクトリ名}_sail
volumes:
  db_data:

Route::get('posts/{post_id}', function (int $postId) {
    $post = Post::query()->find($postId);
    return view('posts.show', compact('post'));
});

<!DOCTYPE html>
<html lang="{{ str_replace('_', '-', app()->getLocale()) }}">
    <head>
        <title>{{ $post->post_title }}</title>
    <body>
        <div>
            {!! $post->post_content !!}
        </div>
    </body>
</html>

$ curl http://localhost/posts/1
<!DOCTYPE html>
<html lang="en">
    <head>
        <title>Hello world!</title>
    </head>
    <body>
        <div>
            <!-- wp:paragraph -->
<p>WordPress へようこそ。こちらは最初の投稿です。編集または削除し、コンテンツ作成を始めてください。</p>
<!-- /wp:paragraph -->
        </div>
    </body>
</html>

/**
 * Generate a time-ordered UUID (version 4).
 *
 * @return \Ramsey\Uuid\UuidInterface
 */
public static function orderedUuid()
{
    if (static::$uuidFactory) {
        return call_user_func(static::$uuidFactory);
    }

    $factory = new UuidFactory;

    $factory->setRandomGenerator(new CombGenerator(
        $factory->getRandomGenerator(),
        $factory->getNumberConverter()
    ));

    $factory->setCodec(new TimestampFirstCombCodec(
        $factory->getUuidBuilder()
    ));

    return $factory->uuid4();
}

public function uuid4(): UuidInterface
{
    $bytes = $this->randomGenerator->generate(16);

    return $this->uuidFromBytesAndVersion($bytes, 4);
}

/**
 * Returns an RFC 4122 variant Uuid, created from the provided bytes and version
 *
 * @param string $bytes The byte string to convert to a UUID
 * @param int $version The RFC 4122 version to apply to the UUID
 *
 * @return UuidInterface An instance of UuidInterface, created from the
 *     byte string and version
 *
 * @psalm-pure
 */
private function uuidFromBytesAndVersion(string $bytes, int $version): UuidInterface
{
    /** @var array $unpackedTime */
    $unpackedTime = unpack('n*', substr($bytes, 6, 2));
    $timeHi = (int) $unpackedTime[1];
    $timeHiAndVersion = pack('n*', BinaryUtils::applyVersion($timeHi, $version));

    /** @var array $unpackedClockSeq */
    $unpackedClockSeq = unpack('n*', substr($bytes, 8, 2));
    $clockSeqHi = (int) $unpackedClockSeq[1];
    $clockSeqHiAndReserved = pack('n*', BinaryUtils::applyVariant($clockSeqHi));

    $bytes = substr_replace($bytes, $timeHiAndVersion, 6, 2);
    $bytes = substr_replace($bytes, $clockSeqHiAndReserved, 8, 2);

    if ($this->isDefaultFeatureSet) {
        return LazyUuidFromString::fromBytes($bytes);
    }

    return $this->uuid($bytes);
}

/**
 * CombGenerator generates COMBs (combined UUID/timestamp)
 *
 * The CombGenerator, when used with the StringCodec (and, by proxy, the
 * TimestampLastCombCodec) or the TimestampFirstCombCodec, combines the current
 * timestamp with a UUID (hence the name "COMB"). The timestamp either appears
 * as the first or last 48 bits of the COMB, depending on the codec used.
 *
 * By default, COMBs will have the timestamp set as the last 48 bits of the
 * identifier.
 * (略)
 */

/**
 * @throws InvalidArgumentException if $length is not a positive integer
 *     greater than or equal to CombGenerator::TIMESTAMP_BYTES
 *
 * @inheritDoc
 */
public function generate(int $length): string
{
    if ($length < self::TIMESTAMP_BYTES) {
        throw new InvalidArgumentException(
            'Length must be a positive integer greater than or equal to ' . self::TIMESTAMP_BYTES
        );
    }

    $hash = '';
    if (self::TIMESTAMP_BYTES > 0 && $length > self::TIMESTAMP_BYTES) {
        $hash = $this->randomGenerator->generate($length - self::TIMESTAMP_BYTES);
    }

    $lsbTime = str_pad(
        $this->converter->toHex($this->timestamp()),
        self::TIMESTAMP_BYTES * 2,
        '0',
        STR_PAD_LEFT
    );

    return (string) hex2bin(
        str_pad(
            bin2hex($hash),
            $length - self::TIMESTAMP_BYTES,
            '0'
        )
        . $lsbTime
    );
}

/**
 * @psalm-return non-empty-string
 */
public function toString(): string
{
    return $this->codec->encode($this);
}

/**
 * @psalm-return non-empty-string
 * @psalm-suppress MoreSpecificReturnType we know that the retrieved `string` is never empty
 * @psalm-suppress LessSpecificReturnStatement we know that the retrieved `string` is never empty
 */
public function encode(UuidInterface $uuid): string
{
    $bytes = $this->swapBytes($uuid->getFields()->getBytes());

    return sprintf(
        '%08s-%04s-%04s-%04s-%012s',
        bin2hex(substr($bytes, 0, 4)),
        bin2hex(substr($bytes, 4, 2)),
        bin2hex(substr($bytes, 6, 2)),
        bin2hex(substr($bytes, 8, 2)),
        bin2hex(substr($bytes, 10))
    );
}

/**
 * Swaps bytes according to the timestamp-first COMB rules
 */
private function swapBytes(string $bytes): string
{
    $first48Bits = substr($bytes, 0, 6);
    $last48Bits = substr($bytes, -6);

    $bytes = substr_replace($bytes, $last48Bits, 0, 6);
    $bytes = substr_replace($bytes, $first48Bits, -6);

    return $bytes;
}