Laravel Mercure Broadcaster

https://github.com/mvanduijker/laravel-mercure-broadcaster
Admin
A Laravel broadcaster for Mercure, enabling Server-Sent Events (SSE) for real-time communication in...
Tokens:15,110
Snippets:114
Trust Score:8.5
License:MIT
Update:1 week ago
Show doc for...
Tokens:
Raw
### Configure broadcasting.php for Mercure

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/README.md

Example configuration for config/broadcasting.php to use the Mercure broadcaster. Sets the default driver to 'mercure' and defines the connection with URL and secret from environment variables.

```php
<?php

return [

    'default' => env('BROADCAST_DRIVER', 'mercure'),

    'connections' => [

        // ...

        'mercure' => [
            'driver' => 'mercure',
            'url' => env('MERCURE_URL', 'http://localhost:3000/.well-known/mercure'),
            'secret' => env('MERCURE_SECRET', 'aVerySecretKey'),
        ],

    ],

];
```

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

### Install package via Composer

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/README.md

Install the Laravel Mercure Broadcaster package using Composer. Requires Mercure to be installed and running first.

```bash
composer require mvanduijker/laravel-mercure-broadcaster
```

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

### Error handling and migration example

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/channel.md

Converts the deprecation notice to an exception, catches it, and migrates to the native PrivateChannel class.

```php
set_error_handler(static function (int $severity, string $message, string $file, int $line): never {
    throw new \ErrorException($message, 0, $severity, $file, $line);
});

try {
    $channel = new \Duijker\LaravelMercureBroadcaster\Broadcasting\Channel('http://example/event', true);
} catch (\ErrorException $e) {
    // "Class ... Channel is deprecated, use Illuminate\Broadcasting\Channel or ..."
    // migrate to the native equivalent:
    $channel = new \Illuminate\Broadcasting\PrivateChannel('http://example/event');
} finally {
    restore_error_handler();
}
```

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

### Run tests with composer

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/README.md

Execute the test suite using Composer.

```bash
composer test
```

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

### __toString() usage example

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/channel.md

Casting a Channel instance to string returns the channel name.

```php
echo (string) new \Duijker\LaravelMercureBroadcaster\Broadcasting\Channel('http://example/event');
// 'http://example/event'
```

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

### Basic ShouldBroadcast event example

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/mercure-broadcaster.md

Example of a Laravel event class implementing ShouldBroadcast with a broadcastOn method returning a Channel. Used with the mercure driver.

```php
<?php

namespace App\Events;

use Illuminate\Broadcasting\Channel;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;

class NewsItemCreated implements ShouldBroadcast
{
    public function __construct(public array $newsItem) {}

    public function broadcastOn()
    {
        return new Channel('http://example/news-items');
    }
}
```

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

### Direct instantiation of MercureBroadcaster

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/mercure-broadcaster.md

Example of constructing the broadcaster directly outside the container, using a Hub with a StaticTokenProvider for the publisher JWT.

```php
use Duijker\LaravelMercureBroadcaster\Broadcasting\Broadcasters\MercureBroadcaster;
use Symfony\Component\Mercure\Hub;
use Symfony\Component\Mercure\Jwt\StaticTokenProvider;

$broadcaster = new MercureBroadcaster(
    new Hub(
        'http://localhost:3000/.well-known/mercure',
        new StaticTokenProvider($publisherJwt) // publisher JWT with mercure.publish claim
    )
);
```

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

### Basic usage in event broadcasting

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/channel.md

Example event class using the deprecated Channel for broadcasting. This pattern is used in the package's own tests.

```php
use Duijker\LaravelMercureBroadcaster\Broadcasting\Channel;
use Illuminate\Contracts\Broadcasting\ShouldBroadcastNow;

class ExampleEvent implements ShouldBroadcastNow
{
    public $property;

    public function __construct($property)
    {
        $this->property = $property;
    }

    public function broadcastOn()
    {
        return new Channel('http://example/event', true);
    }
}
```

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

### Subscribe to private channel with EventSource and credentials

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/README.md

Use EventSource with withCredentials to include the authorization cookie for private channels. The topic must match the private channel name.

```javascript
var es = new EventSource('http://localhost:3000/.well-known/mercure?topic=' + encodeURIComponent('http://example/user/1/direct-messages'), { withCredentials: true });
es.addEventListener('message', (messageEvent) => {
    var eventData = JSON.parse(messageEvent.data);
    console.log(eventData);
});
```

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

### Define a public broadcast event with ShouldBroadcast

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/README.md

Create an event class that implements ShouldBroadcast and defines a public channel. The event's public properties are serialized and broadcast to the channel.

```php
<?php

namespace App\Events;

use Illuminate\Broadcasting\Channel;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;

class NewsItemCreated implements ShouldBroadcast
{
    /**
     * @var NewsItem
     */
    public $newsItem;

    public function __construct(NewsItem $newsItem)
    {
        $this->newsItem = $newsItem;
    }

    public function broadcastOn()
    {
        return new Channel('http://example/news-items');
    }
}
```

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

### Subscribe to public channel with EventSource

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/README.md

Use the EventSource API to listen for messages on a public Mercure topic. The topic URL must be URL-encoded.

```javascript
var es = new EventSource('http://localhost:3000/.well-known/mercure?topic=' + encodeURIComponent('http://example/news-items'));
es.addEventListener('message', (messageEvent) => {
    var eventData = JSON.parse(messageEvent.data);
    console.log(eventData);
});
```

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

### Define a private broadcast event with PrivateChannel

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/README.md

Create an event that broadcasts on a private channel. The channel name includes the user ID and must match the subscription topic.

```php
<?php

namespace App\Events;

use Illuminate\Broadcasting\PrivateChannel;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;

class DirectMessageCreated implements ShouldBroadcast
{
    /**
     * @var DirectMessage
     */
    public $directMessage;

    public function __construct(DirectMessage $directMessage)
    {
        $this->directMessage = $directMessage;
    }

    public function broadcastOn()
    {
        return new PrivateChannel(
            "http://example/user/{$this->directMessage->user_id}/direct-messages", 
        );
    }
}
```

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

### Mercure broadcast connection configuration

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/laravel-mercure-broadcaster-service-provider.md

Example configuration for the 'mercure' broadcast connection. The 'driver' must be exactly 'mercure' and a 'url' key is required. The 'secret' is used for JWT generation.

```php
// config/broadcasting.php
'connections' => [
    'mercure' => [
        'driver' => 'mercure',
        'url' => env('MERCURE_URL', 'http://localhost:3000/.well-known/mercure'),
        'secret' => env('MERCURE_SECRET', 'aVerySecretKey'),
    ],
],
```

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

### Private channel broadcast with error handling

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/mercure-broadcaster.md

Shows broadcasting to both public and private channels. Catches exceptions from publish() and logs them. Note that each channel gets its own Update.

```php
use Illuminate\Broadcasting\Channel;
use Illuminate\Broadcasting\PrivateChannel;

$broadcaster = $app->make(\Illuminate\Contracts\Broadcasting\Broadcaster::class);

try {
    $broadcaster->broadcast(
        [
            new Channel('http://example/news-items'),
            new PrivateChannel('http://example/user/1/direct-messages'),
        ],
        'message.created',
        ['text' => 'Hello']
    );
} catch (\Throwable $e) {
    // publish() exceptions from the configured HubInterface propagate unmodified
    \Illuminate\Support\Facades\Log::error('Mercure publish failed', ['error' => $e]);
}
```

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

### Override publisher JWT singleton

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/laravel-mercure-broadcaster-service-provider.md

Shows how to override the publisher JWT binding in your own service provider's register() method. This example restricts the publish scope to a specific topic and adds a custom audience claim. The override must return a string JWT; boot() resolves it through the container automatically. Ensure the Mercure subscriber cookie middleware stays in sync.

```php
// In your own service provider's register() method:
$this->app->singleton('mvanduijker.mercure_broadcaster.publisher_jwt', function () {
    $config = \Lcobucci\JWT\Configuration::forSymmetricSigner(
        new \Lcobucci\JWT\Signer\Hmac\Sha256(),
        \Lcobucci\JWT\Signer\Key\InMemory::plainText(config('broadcasting.connections.mercure.secret'))
    );

    return $config->builder()
        ->withClaim('mercure', ['publish' => ['http://example/news-items']]) // restricted scope
        ->withClaim('aud', 'https://example.com')                             // custom claim
        ->getToken($config->signer(), $config->signingKey())
        ->toString();
});
```

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

### Create middleware to set Mercure authorization cookie

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/README.md

Generate a JWT with subscribe claims and set it as a cookie for private channels. The cookie is named 'mercureAuthorization' and must be excluded from Laravel's encryption.

```php
<?php 

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Illuminate\Support\Facades\Cookie;
use Lcobucci\JWT\Configuration;
use Lcobucci\JWT\Signer\Hmac\Sha256;
use Lcobucci\JWT\Signer\Key\InMemory;

class MercureBroadcasterAuthorizationCookie
{
    public function handle(Request $request, Closure $next)
    {
        /** @var Response $response */
        $response = $next($request);

        if (!method_exists($response, 'withCookie')) {
            return $response;
        }

        return $response->withCookie($this->createCookie($request->user(), $request->secure()));
    }

    private function createCookie($user, bool $secure)
    {
        // Add topic(s) this user has access to
        // This can also be URI Templates (to match several topics), or * (to match all topics)
        $subscriptions = [
            "http://example/user/{$user->id}/direct-messages",
        ];

        $jwtConfiguration = Configuration::forSymmetricSigner(
            new Sha256(),
            InMemory::plainText(config('broadcasting.connections.mercure.secret'))
        );

        $token = $jwtConfiguration->builder()
            ->withClaim('mercure', ['subscribe' => $subscriptions])
            ->getToken($jwtConfiguration->signer(), $jwtConfiguration->signingKey())
            ->toString();

        return Cookie::make(
            'mercureAuthorization',
            $token,
            15,
            '/.well-known/mercure', // or which path you have mercure running
            parse_url(config('app.url'), PHP_URL_HOST),
            $secure,
            true
        );
    }
}
```

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

### boot() method signature

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/laravel-mercure-broadcaster-service-provider.md

Declares the boot() method with no parameters and void return type. It is a framework lifecycle hook that registers the mercure broadcast driver.

```php
public function boot()
```

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

### Constructor

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/mercure-broadcaster.md

Creates a new MercureBroadcaster instance with the given Mercure hub. The hub is stored in a protected typed property for later use.

```APIDOC
## Constructor

### Description
Creates a new MercureBroadcaster instance with the given Mercure hub. The hub is stored in a protected typed property for later use.

### Method
Constructor

### Signature
```php
public function __construct(HubInterface $hub)
```

### Parameters
- `$hub` (Symfony\Component\Mercure\HubInterface) - Required - The Mercure hub the broadcaster publishes updates to.

### Usage Example
```php
use Duijker\LaravelMercureBroadcaster\Broadcasting\Broadcasters\MercureBroadcaster;
use Symfony\Component\Mercure\Hub;
use Symfony\Component\Mercure\Jwt\StaticTokenProvider;

$broadcaster = new MercureBroadcaster(
    new Hub(
        'http://localhost:3000/.well-known/mercure',
        new StaticTokenProvider($publisherJwt) // publisher JWT with mercure.publish claim
    )
);
```
```

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

### Import Channel class

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/channel.md

Import the deprecated Channel class from the package namespace.

```php
use Duijker\LaravelMercureBroadcaster\Broadcasting\Channel;
```

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

### Service provider class skeleton

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/laravel-mercure-broadcaster-service-provider.md

Shows the class definition with boot() and register() methods, which are lifecycle hooks that bind the publisher JWT service and extend the broadcast manager with the mercure driver.

```php
class LaravelMercureBroadcasterServiceProvider extends ServiceProvider
{
    public function boot() { ... }

    public function register() { ... }
}
```

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

### Register mercure broadcast driver in boot()

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/laravel-mercure-broadcaster-service-provider.md

This code extends the BroadcastManager with the 'mercure' driver. It builds a Hub using the connection's 'url' config and a StaticTokenProvider wrapping the publisher JWT service, then constructs a MercureBroadcaster with that hub.

```php
$this->app
    ->make(BroadcastManager::class)
    ->extend('mercure', function ($app, array $config) {
        return new MercureBroadcaster(
            new Hub(
                $config['url'],
                new StaticTokenProvider($app->make('mvanduijker.mercure_broadcaster.publisher_jwt'))
            )
        );
    });
```

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

### Channel constructor signature

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/channel.md

Constructor accepts a string $name and optional bool $private (default false). Always raises E_USER_DEPRECATED notice.

```php
public function __construct(string $name, bool $private = false)
```

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

### __toString() method signature

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/channel.md

Method signature for __toString(), returns the channel name as string.

```php
public function __toString()
```

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

### MercureBroadcaster class skeleton

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/mercure-broadcaster.md

Shows the class definition and its methods. The constructor injects a HubInterface. The auth and validAuthenticationResponse methods are no-ops because Mercure handles its own JWT-based authorization. The broadcast method publishes updates to the Mercure hub.

```php
class MercureBroadcaster implements Broadcaster
{
    protected HubInterface $hub;

    public function __construct(HubInterface $hub) { ... }

    public function auth($request) { ... }

    public function validAuthenticationResponse($request, $result) { ... }

    public function broadcast(array $channels, $event, array $payload = []) { ... }
}
```

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

### Bind publisher JWT singleton

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/laravel-mercure-broadcaster-service-provider.md

Binds the publisher JWT as a container singleton under the key 'mvanduijker.mercure_broadcaster.publisher_jwt'. The JWT uses HS256 signing with the secret from config('broadcasting.connections.mercure.secret') and includes the claim 'mercure.publish' = ['*'] to grant publishing on all topics. The secret is read with no default argument; if absent, null is passed to InMemory::plainText().

```php
$this->app->singleton('mvanduijker.mercure_broadcaster.publisher_jwt', function () {
    $jwtConfiguration = Configuration::forSymmetricSigner(
        new Sha256(),
        InMemory::plainText(config('broadcasting.connections.mercure.secret'))
    );

    return $jwtConfiguration->builder()
        ->withClaim('mercure', ['publish' => ['*']])
        ->getToken($jwtConfiguration->signer(), $jwtConfiguration->signingKey())
        ->toString();
});
```

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

### Channel::__toString

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/channel.md

Returns the channel name as a string. This is used as the Mercure topic when broadcasting.

```APIDOC
## Channel::__toString

### Description
Returns the channel name as a string. This is used as the Mercure topic when broadcasting.

### Method
__toString

### Signature
```php
public function __toString()
```

### Parameters
None.

### Return Value
- `string` - The channel name (`$this->name`).

### Usage Example
```php
echo (string) new \Duijker\LaravelMercureBroadcaster\Broadcasting\Channel('http://example/event');
// 'http://example/event'
```
```

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

### Import MercureBroadcaster class

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/mercure-broadcaster.md

Use this import to reference the MercureBroadcaster class in your PHP code.

```php
use Duijker\LaravelMercureBroadcaster\Broadcasting\Broadcasters\MercureBroadcaster;
```

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

### Import LaravelMercureBroadcasterServiceProvider class

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/laravel-mercure-broadcaster-service-provider.md

Use this import to reference the service provider class in your Laravel application.

```php
use Duijker\LaravelMercureBroadcaster\LaravelMercureBroadcasterServiceProvider;
```

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

### Dispatching the event

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/mercure-broadcaster.md

Dispatches the NewsItemCreated event with a payload. This triggers the broadcast() method via Laravel's broadcaster pipeline.

```php
event(new NewsItemCreated(['title' => 'Hello world']));
```

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

### Channel::__construct

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/channel.md

Creates a new Channel instance with a name and optional privacy flag. Deprecated since version 3.8.0, use Illuminate\Broadcasting\Channel or PrivateChannel instead.

```APIDOC
## Channel::__construct

### Description
Creates a new Channel instance with a name and optional privacy flag. Deprecated since version 3.8.0, use Illuminate\Broadcasting\Channel or PrivateChannel instead.

### Method
Constructor

### Signature
```php
public function __construct(string $name, bool $private = false)
```

### Parameters
- `$name` (string) - Required - Channel/topic name; assigned to `$this->name`.
- `$private` (bool) - Optional (default: `false`) - Privacy flag; assigned to `$this->private`.

### Throws / Diagnostics
- **`E_USER_DEPRECATED` notice** — always raised on construction, with message: `Class Duijker\LaravelMercureBroadcaster\Broadcasting\Channel is deprecated, use Illuminate\Broadcasting\Channel or for private channels use Illuminate\Broadcasting\PrivateChannel`

### Usage Example
```php
use Duijker\LaravelMercureBroadcaster\Broadcasting\Channel;
use Illuminate\Contracts\Broadcasting\ShouldBroadcastNow;

class ExampleEvent implements ShouldBroadcastNow
{
    public $property;

    public function __construct($property)
    {
        $this->property = $property;
    }

    public function broadcastOn()
    {
        return new Channel('http://example/event', true);
    }
}
```

### Error Handling / Migration Example
```php
set_error_handler(static function (int $severity, string $message, string $file, int $line): never {
    throw new \ErrorException($message, 0, $severity, $file, $line);
});

try {
    $channel = new \Duijker\LaravelMercureBroadcaster\Broadcasting\Channel('http://example/event', true);
} catch (\ErrorException $e) {
    // "Class ... Channel is deprecated, use Illuminate\Broadcasting\Channel or ..."
    // migrate to the native equivalent:
    $channel = new \Illuminate\Broadcasting\PrivateChannel('http://example/event');
} finally {
    restore_error_handler();
}
```
```

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

### register() method signature

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/laravel-mercure-broadcaster-service-provider.md

Declares the register() method with no parameters and void return type. This method is part of the LaravelMercureBroadcasterServiceProvider and is called during service provider registration.

```php
public function register()
```

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

### Auto-discovery configuration in composer.json

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/laravel-mercure-broadcaster-service-provider.md

This JSON snippet shows the extra.laravel.providers entry that enables auto-discovery of the service provider, so manual registration is not required.

```json
"extra": {
    "laravel": {
        "providers": [
            "Duijker\\LaravelMercureBroadcaster\\LaravelMercureBroadcasterServiceProvider"
        ]
    }
}
```

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

### auth() method signature

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/mercure-broadcaster.md

The auth method required by the Broadcaster interface. It is a no-op that always returns null because Mercure handles its own JWT-based authorization.

```php
public function auth($request)
```

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

### Constructor signature

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/mercure-broadcaster.md

Constructor for MercureBroadcaster that accepts a Symfony Mercure HubInterface. The hub is stored in a protected typed property.

```php
public function __construct(HubInterface $hub)
```

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

### broadcast() method signature

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/mercure-broadcaster.md

Signature of the broadcast() method. Accepts an array of channel objects, an event name, and an optional payload array. Returns void.

```php
public function broadcast(array $channels, $event, array $payload = [])
```

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

### Native channel path in broadcast()

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/mercure-broadcaster.md

Publishes an Update for channels that are instances of Illuminate\Broadcasting\Channel (including PrivateChannel). Uses string representation as topic and checks instanceof PrivateChannel for privacy.

```php
$this->hub->publish(new Update($channel->__toString(), $payload, $channel instanceof PrivateChannel));
```

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

### Reading url config without fallback

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/errors.md

This snippet shows how the connection config's url key is read in LaravelMercureBroadcasterServiceProvider::boot(). There is no fallback, so a mercure connection missing broadcasting.connections.mercure.url produces a null/undefined URL when the driver is resolved.

```php
new Hub($config['url'], new StaticTokenProvider(...))
```

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

### Legacy channel path in broadcast()

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/mercure-broadcaster.md

Publishes an Update for channels that are not instances of Illuminate\Broadcasting\Channel. Reads topic from public 'name' property and privacy from public 'private' property. Commented as deprecated.

```php
$this->hub->publish(new Update($channel->name, $payload, $channel->private));
```

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

### auth()

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/mercure-broadcaster.md

A no-op method required by the Broadcaster interface. It does not perform any authentication because Mercure handles its own JWT-based authorization.

```APIDOC
## auth()

### Description
A no-op method required by the Broadcaster interface. It does not perform any authentication because Mercure handles its own JWT-based authorization.

### Method
auth

### Signature
```php
public function auth($request)
```

### Parameters
- `$request` (\Illuminate\Http\Request) - Required - The incoming socket-auth request (unused).

### Return
`mixed` - Always evaluates to `null` (no return statement).
```

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

### Deprecation notice message

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/channel.md

The exact E_USER_DEPRECATED notice message raised on construction.

```text
Class Duijker\LaravelMercureBroadcaster\Broadcasting\Channel is deprecated, use Illuminate\Broadcasting\Channel or for private channels use Illuminate\Broadcasting\PrivateChannel
```

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

### Hub publish() call without try/catch

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/errors.md

This snippet shows the direct call to HubInterface::publish() in MercureBroadcaster::broadcast(). There is no try/catch around it, so any exception thrown by the hub implementation (e.g., transport failures) propagates verbatim to the caller. Catch \Throwable around the broadcast call to degrade gracefully.

```php
$this->hub->publish(new Update(...));
```

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

### Resolve MercureBroadcaster instance

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/laravel-mercure-broadcaster-service-provider.md

Resolves the broadcaster contract from the container, which returns a MercureBroadcaster instance when the 'mercure' driver is configured.

```php
$broadcaster = app(\Illuminate\Contracts\Broadcasting\Broadcaster::class);
// -> Duijker\LaravelMercureBroadcaster\Broadcasting\Broadcasters\MercureBroadcaster
```

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

### Channel class properties

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/channel.md

Public properties of the Channel class: $name (string) and $private (bool, default false).

```php
public $name;
public $private;
```

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

### Wiring summary of Mercure broadcaster components

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/configuration.md

Shows the flow from the secret configuration through the service provider to the MercureBroadcaster instance. The secret is used to sign a publisher JWT, which is wrapped in a StaticTokenProvider and passed to the Hub.

```text
config('broadcasting.connections.mercure.secret')
  └─ register(): singleton mvanduijker.mercure_broadcaster.publisher_jwt (HS256, publish *)
       └─ boot(): BroadcastManager::extend('mercure', fn)  ── $config['url'] ──► Hub
              └─ new StaticTokenProvider(publisher_jwt)
                     └─ new MercureBroadcaster(Hub)
```

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

### broadcast(array $channels, $event, array $payload = [])

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/mercure-broadcaster.md

Publishes an event to one or more Mercure channels. Serializes the event name and payload into a JSON string and publishes a separate Mercure Update for each channel.

```APIDOC
## broadcast(array $channels, $event, array $payload = [])

### Description
Publishes an event to one or more Mercure channels. Serializes the event name and payload into a JSON string and publishes a separate Mercure Update for each channel.

### Method
broadcast

### Signature
```php
public function broadcast(array $channels, $event, array $payload = [])
```

### Parameters
- **$channels** (array of channel objects) - Required - Channels to publish the event on. Each channel must be either an `Illuminate\Broadcasting\Channel` (or `PrivateChannel` subclass) or a legacy channel object with public `name` and `private` properties.
- **$event** (string) - Required - Event name, stored under the `event` key of the published payload.
- **$payload** (array) - Optional (default: `[]`) - Event data, stored under the `data` key of the published payload.

### Return Value
`void` (no return statement)

### Behavior
Serializes the payload once and publishes one `Symfony\Component\Mercure\Update` per channel:

```php
$payload = json_encode([
    'event' => $event,
    'data' => $payload,
]);
```

The resulting JSON string becomes the Mercure update's `data`, so subscribers (e.g. a browser `EventSource`) receive `{"event": "<event>", "data": { ... }}` and typically `JSON.parse` the full message.

### Accepted Channel Shapes
Two code paths are used depending on the channel type:

1. **Not** an instance of `Illuminate\Broadcasting\Channel` (legacy path):
   ```php
   $this->hub->publish(new Update($channel->name, $payload, $channel->private));
   ```
   The topic is read from the public `name` property, privacy from the public `private` property. This path is flagged for deprecation.

2. Instance of `Illuminate\Broadcasting\Channel` (native path, also covers `PrivateChannel`):
   ```php
   $this->hub->publish(new Update($channel->__toString(), $payload, $channel instanceof PrivateChannel));
   ```
   The topic is the channel's string representation; the `private` boolean is `true` iff the channel is an instance of `Illuminate\Broadcasting\PrivateChannel`.

### Throws
There is no `try/catch` anywhere in the method:
- **`json_encode` failure** — if the payload cannot be encoded, `json_encode` returns `false` and that `false` value is passed to `Update` as data. The failure is not checked or reported by this package.
- **Exceptions from `$hub->publish()`** — any exception thrown by the injected `HubInterface` implementation (e.g. transport errors while talking to the Mercure hub) propagates unmodified to the caller.

### Usage Examples

#### Basic Usage (Laravel Event)
Dispatch a `ShouldBroadcast` event with the `mercure` driver configured:

```php
<?php

namespace App\Events;

use Illuminate\Broadcasting\Channel;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;

class NewsItemCreated implements ShouldBroadcast
{
    public function __construct(public array $newsItem) {}

    public function broadcastOn()
    {
        return new Channel('http://example/news-items');
    }
}
```

```php
event(new NewsItemCreated(['title' => 'Hello world']));
```

#### Direct Call with Private Channel and Error Handling
One `Update` per channel, so a payload is published once per channel even when several channels reference the same topic:

```php
use Illuminate\Broadcasting\Channel;
use Illuminate\Broadcasting\PrivateChannel;

$broadcaster = $app->make(\Illuminate\Contracts\Broadcasting\Broadcaster::class);

try {
    $broadcaster->broadcast(
        [
            new Channel('http://example/news-items'),
            new PrivateChannel('http://example/user/1/direct-messages'),
        ],
        'message.created',
        ['text' => 'Hello']
    );
} catch (\Throwable $e) {
    // publish() exceptions from the configured HubInterface propagate unmodified
    \Illuminate\Support\Facades\Log::error('Mercure publish failed', ['error' => $e]);
}
```

### Notes
- Because each channel produces a separate `Update`, the same payload body is sent once per channel (not deduplicated).
- Private channels do **not** require cookies or socket auth on the publish side; privacy is enforced by Mercure when subscribers connect (subscriber JWT cookie, generated by the consuming application — see the README's `MercureBroadcasterAuthorizationCookie` middleware example).

### Source
`src/Broadcasting/Broadcasters/MercureBroadcaster.php:53`
```

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

### Convert deprecation notice to exception with set_error_handler

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/errors.md

Use this PHP snippet to programmatically observe the E_USER_DEPRECATED notice raised when instantiating the legacy Channel class. It converts the notice into an ErrorException, allowing you to catch it in a try/catch block. The handler returns false for other severities to keep default handling, and restore_error_handler() is called in the finally block.

```php
set_error_handler(static function (int $severity, string $message, string $file, int $line): never {
    if ($severity === E_USER_DEPRECATED) {
        throw new \ErrorException($message, 0, $severity, $file, $line);
    }
    return false; // keep default handling for other severities
});

try {
    new \Duijker\LaravelMercureBroadcaster\Broadcasting\Channel('http://example/event');
} catch (\ErrorException $e) {
    // migrate instead of using the deprecated class
} finally {
    restore_error_handler();
}
```

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

### Payload serialization in broadcast()

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/api-reference/mercure-broadcaster.md

Serializes the event and payload into a JSON string that becomes the Mercure update's data. Subscribers receive the JSON with event and data keys.

```php
$payload = json_encode([
    'event' => $event,
    'data' => $payload,
]);
```

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

### Reading secret config without default

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/errors.md

This snippet shows how the secret config is read in LaravelMercureBroadcasterServiceProvider::register(). The config() call has no default argument, so if broadcasting.connections.mercure.secret is not set, null is passed to InMemory::plainText(). Ensure the config key exists with the same value as the hub's MERCURE_PUBLISHER_JWT_KEY.

```php
InMemory::plainText(config('broadcasting.connections.mercure.secret'))
```

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

### json_encode failure in broadcast()

Source: https://github.com/mvanduijker/laravel-mercure-broadcaster/blob/master/_autodocs/errors.md

This snippet shows the unguarded json_encode call in MercureBroadcaster::broadcast(). If the payload array cannot be encoded (e.g., contains non-UTF-8 strings), json_encode returns false, which is then passed as the data of every Symfony Update. No error is raised by the package.

```php
$payload = json_encode([...]);
```
Tokens:
Raw