Schema Context Bundle

https://github.com/macpaw/schema-context-bundle
Admin
Schema Context Bundle is a Symfony bundle that manages dynamic schema context across applications,...
Tokens:23,318
Snippets:206
Trust Score:9.8
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install via Composer

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/README.md

Install the bundle using Composer. Run this command in your project root.

```bash
composer require macpaw/schema-context-bundle
```

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

### Example configuration file (config/packages/schema_context.yaml)

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/configuration.md

Example configuration file for the schema-context bundle. Sets the environment name, header name, environment schema, and overridable environments. The `%env(...)%` placeholders are resolved by Symfony Flex.

```yaml
# config/packages/schema_context.yaml
schema_context:
    environment_name: '%env(APP_ENV)%' # Current environment name (example: 'develop')
    header_name: 'X-Tenant' # Key name in baggage header to extract schema name
    environment_schema: '%env(ENVIRONMENT_SCHEMA)%' # The schema for this environment (example: 'public')
    overridable_environments: ['develop', 'staging', 'test'] # Environments where schema can be overridden
```

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

### Environment variables example (.env)

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/configuration.md

Illustrative `.env` example showing the environment variables used by the configuration placeholders. The bundle itself does not read environment variables directly.

```env
APP_ENV=develop
ENVIRONMENT_SCHEMA=public
```

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

### Basic usage with automatic wiring

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-request-listener.md

Shows how to consume the resolver result in a controller when the listener is automatically wired. The example assumes a request with baggage header 'X-Schema=tenant_a,user-id=12345'.

```php
use Macpaw\SchemaContextBundle\Service\BaggageSchemaResolver;

public function index(BaggageSchemaResolver $schemaResolver): Response
{
    // request: baggage: X-Schema=tenant_a,user-id=12345
    $schema = $schemaResolver->getSchema();   // 'tenant_a'
    $baggage = $schemaResolver->getBaggage(); // ['X-Schema' => 'tenant_a', 'user-id' => '12345']
}
```

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

### Manual construction and invocation

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-request-listener.md

Manually constructs the listener and invokes onKernelRequest with a request event. The example shows expected resolver state when the baggage header is 'X-Schema=tenant1'.

```php
use Macpaw\SchemaContextBundle\EventListener\BaggageRequestListener;
use Macpaw\SchemaContextBundle\Service\BaggageCodec;
use Macpaw\SchemaContextBundle\Service\BaggageSchemaResolver;

$resolver = new BaggageSchemaResolver('default', 'dev', ['dev', 'test']);
$listener = new BaggageRequestListener($resolver, new BaggageCodec(), 'X-Schema');

$listener->onKernelRequest($requestEvent);
// $resolver->getSchema()  == 'tenant1'  (when HTTP_BAGGAGE == 'X-Schema=tenant1')
// $resolver->getBaggage() == ['X-Schema' => 'tenant1']
```

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

### Manual construction with mocked inner client

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-aware-http-client.md

PHP example that manually constructs a BaggageAwareHttpClient with a resolver and codec, then sends a request. The inner client receives the baggage header merged with the resolver's baggage.

```php
use Macpaw\SchemaContextBundle\HttpClient\BaggageAwareHttpClient;
use Macpaw\SchemaContextBundle\Service\BaggageCodec;
use Macpaw\SchemaContextBundle\Service\BaggageSchemaResolver;

$resolver = new BaggageSchemaResolver('default', 'dev', ['dev', 'test']);
$resolver->setBaggage(['X-Schema' => 'tenant_42', 'foo' => null]);

$client = new BaggageAwareHttpClient($innerHttpClient, $resolver, new BaggageCodec());

$client->request('GET', 'https://api.example.com/test', [
    'headers' => ['baggage' => 'test = 123'],
]);
// inner client receives headers: baggage => 'test=123,X-Schema=tenant_42,foo'
```

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

### BaggageProcessor usage example with resulting log record

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-processor.md

Shows the resolver holding a baggage map and the resulting log record after processing. The baggage is added under the 'baggage' key in 'extra', preserving existing extra keys. Records produced while the resolver has no baggage are returned unchanged.

```php
$resolver->setBaggage(['X-Schema' => 'tenant_a', 'user-id' => '12345']);
```

```php
[
    'message' => 'payment processed',
    // ...
    'extra' => [
        'baggage' => ['X-Schema' => 'tenant_a', 'user-id' => '12345'],
    ],
]
```

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

### Example baggage header request

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/README.md

Shows the W3C standard baggage header format with schema-related keys. The bundle extracts the schema value using the key from 'header_name' configuration.

```http
GET /api/endpoint HTTP/1.1
Host: example.com
baggage: X-Tenant=tenant_a,user-id=12345,trace-id=abc123
```

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

### Basic usage with injected client

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-aware-http-client.md

PHP example showing a pay method that uses the injected BaggageAwareHttpClient to send a POST request. The outgoing baggage header is automatically injected from the resolver.

```php
public function pay(HttpClientInterface $paymentClient): void
{
    $paymentClient->request('POST', 'https://payments.example.com/charge', [
        'headers' => ['content-type' => 'application/json'],
        'body' => '{"amount": 100}',
    ]);
    // outgoing baggage header is injected automatically from the resolver
}
```

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

### BaggageRequestListener

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-request-listener.md

Documentation for the BaggageRequestListener class, including its constructor, methods, and usage examples.

```APIDOC
## Class: Macpaw\SchemaContextBundle\EventListener\BaggageRequestListener

### Description
HTTP kernel event subscriber that extracts the W3C `baggage` request header on every kernel request and stores the decoded baggage map and schema into the shared `BaggageSchemaResolver`.

### Constructor

```php
public function __construct(
    private BaggageSchemaResolver $baggageSchemaResolver,
    private BaggageCodec $baggageCodec,
    private string $schemaRequestHeader,
)
```

#### Parameters
- **$baggageSchemaResolver** (Macpaw\SchemaContextBundle\Service\BaggageSchemaResolver) - Required - Resolver to populate; wired as `@Macpaw\SchemaContextBundle\Service\BaggageSchemaResolver`
- **$baggageCodec** (Macpaw\SchemaContextBundle\Service\BaggageCodec) - Required - Codec used to decode the header
- **$schemaRequestHeader** (string) - Required - Key inside the baggage header that carries the schema value; wired from the `%schema_context.header_name%` parameter (default `X-Schema`)

### Method: getSubscribedEvents

```php
public static function getSubscribedEvents(): array
```

#### Return type
`array` — the event subscription map `[KernelEvents::REQUEST => [['onKernelRequest', 100]]]`, i.e. the `onKernelRequest` handler is invoked for the `REQUEST` kernel event with priority `100`.

### Method: onKernelRequest

```php
public function onKernelRequest(RequestEvent $event): void
```

#### Parameters
- **$event** (Symfony\Component\HttpKernel\Event\RequestEvent) - Required - Request event; the request is accessed via `$event->getRequest()`.

#### Behavior
1. Reads the `baggage` header: `$request->headers->get('baggage')`.
2. If the header is present, decodes it with `BaggageCodec::decode` into the baggage map and picks the schema at key `$schemaRequestHeader` (`?? null`).
3. Stores both on the resolver via `setBaggage(...)` and `setSchema(...)`.
4. If the header is missing, both are set to `null` — `getSchema()` then falls back to the environment schema.

The listener itself never throws `EnvironmentSchemaMismatchException`; however, `setSchema` will throw it when a schema override is attempted in a non-overridable environment.

#### Return type
`void`.

### Usage examples

#### Basic use — automatic via bundle wiring

The listener is wired for you; you only consume the result:

```php
use Macpaw\SchemaContextBundle\Service\BaggageSchemaResolver;

public function index(BaggageSchemaResolver $schemaResolver): Response
{
    // request: baggage: X-Schema=tenant_a,user-id=12345
    $schema = $schemaResolver->getSchema();   // 'tenant_a'
    $baggage = $schemaResolver->getBaggage(); // ['X-Schema' => 'tenant_a', 'user-id' => '12345']
}
```

#### Manual construction and invocation

```php
use Macpaw\SchemaContextBundle\EventListener\BaggageRequestListener;
use Macpaw\SchemaContextBundle\Service\BaggageCodec;
use Macpaw\SchemaContextBundle\Service\BaggageSchemaResolver;

$resolver = new BaggageSchemaResolver('default', 'dev', ['dev', 'test']);
$listener = new BaggageRequestListener($resolver, new BaggageCodec(), 'X-Schema');

$listener->onKernelRequest($requestEvent);
// $resolver->getSchema()  == 'tenant1'  (when HTTP_BAGGAGE == 'X-Schema=tenant1')
// $resolver->getBaggage() == ['X-Schema' => 'tenant1']
```
```

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

### Catching the exception in application code

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/environment-schema-mismatch-exception.md

Example of catching the exception in application code. It creates a BaggageSchemaResolver with a fixed schema 'public' in the 'production' environment, then attempts to set 'tenant_a', which triggers the exception. The catch block retrieves the HTTP 500 code and the formatted message.

```php
use Macpaw\SchemaContextBundle\Service\BaggageSchemaResolver;
use Macpaw\SchemaContextBundle\Exception\EnvironmentSchemaMismatchException;

$resolver = new BaggageSchemaResolver('public', 'production', ['develop', 'staging', 'test']);

try {
    $resolver->setSchema('tenant_a');
} catch (EnvironmentSchemaMismatchException $e) {
    $code = $e->getCode();      // 500 (HTTP_INTERNAL_SERVER_ERROR)
    $message = $e->getMessage(); // Schema mismatch in "production" environment: expected "public", got "tenant_a". Allowed override environments: [develop, staging, test].
}
```

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

### Inject BaggageSchemaResolver and get schema/baggage

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/README.md

Use dependency injection to receive BaggageSchemaResolver and call getSchema() and getBaggage() to retrieve the current schema and baggage values. Place this inside a controller or service method.

```php
use Macpaw\SchemaContextBundle\Service\BaggageSchemaResolver;

public function index(BaggageSchemaResolver $schemaResolver)
{
    $schema = $schemaResolver->getSchema();
    $baggage = $schemaResolver->getBaggage();
    // Use schema in logic
}
```

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

### Bundle Configuration in schema_context.yaml

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/README.md

Configure the bundle in config/packages/schema_context.yaml. Set environment name, header name, environment schema, and overridable environments.

```yaml
schema_context:
    environment_name: '%env(APP_ENV)%' # Current environment name (example: 'develop')
    header_name: 'X-Tenant' # Key name in baggage header to extract schema name
    environment_schema: '%env(ENVIRONMENT_SCHEMA)%' # The schema for this environment (example: 'public')
    overridable_environments: ['develop', 'staging', 'test'] # Environments where schema can be overridden via baggage header or Symfony Messenger stamp
```

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

### Manual instantiation with error handling

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-schema-resolver.md

Shows how to manually instantiate BaggageSchemaResolver with constructor arguments and use setSchema() and setBaggage() methods, including handling EnvironmentSchemaMismatchException.

```APIDOC
## BaggageSchemaResolver::__construct() and setSchema() and setBaggage()

### Description
Manually instantiate the resolver with a default schema, environment, and allowed override environments. Use setSchema() to change the schema (throws EnvironmentSchemaMismatchException in non-allowed environments) and setBaggage() to set the baggage map. Both methods are chainable.

### Method
- __construct(string $defaultSchema, string $environment, array $allowedOverrideEnvironments)
- setSchema(string $schema): self
- setBaggage(array $baggage): self

### Parameters
#### Constructor Parameters
- **defaultSchema** (string) - Required - The default schema name.
- **environment** (string) - Required - The current environment (e.g., 'production').
- **allowedOverrideEnvironments** (array) - Required - List of environments where schema override is allowed.

#### setSchema Parameters
- **schema** (string) - Required - The new schema name to set.

#### setBaggage Parameters
- **baggage** (array) - Required - The baggage map to set.

### Request Example
```php
use Macpaw\SchemaContextBundle\Service\BaggageSchemaResolver;
use Macpaw\SchemaContextBundle\Exception\EnvironmentSchemaMismatchException;

$resolver = new BaggageSchemaResolver('public', 'production', ['develop', 'staging', 'test']);

try {
    $resolver->setSchema('tenant_a');
    // never reached in 'production': throws EnvironmentSchemaMismatchException
} catch (EnvironmentSchemaMismatchException $e) {
    $message = $e->getMessage();
    // Schema mismatch in "production" environment: expected "public", got "tenant_a". Allowed override environments: [develop, staging, test].
}

// Chainable API
$resolver->setSchema('tenant_a')->setBaggage(['X-Schema' => 'tenant_a', 'user-id' => '12345']);
```

### Response
#### Success Response
- **self** (BaggageSchemaResolver) - Returns the resolver instance for chaining.

#### Error Response
- **EnvironmentSchemaMismatchException** - Thrown when setSchema() is called in an environment not in allowedOverrideEnvironments and the schema differs from the default.
```

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

### withOptions

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-aware-http-client.md

Creates a new instance of BaggageAwareHttpClient with the provided options, preserving the same baggage resolver and codec.

```APIDOC
## Method: `withOptions`

### Description
Creates a new instance of the same class with the given options, preserving the baggage resolver and codec.

### Method
withOptions

### Endpoint
N/A - This is a PHP method, not an HTTP endpoint.

### Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `$options` | `array<string, mixed>` | yes | — | Options applied to a new client |

### Return Type
`static` — a new instance of the same class. Calls `$inner->withOptions($options)` and wraps the resulting client with `new self($wrapped, $this->baggageSchemaResolver, $this->baggageCodec)`, preserving the same resolver and codec.

### Usage Examples

#### Basic use — injected via service configuration

```yaml
services:
    baggage_aware_payment_http_client:
        class: Macpaw\SchemaContextBundle\HttpClient\BaggageAwareHttpClient
        decorates: payment_http_client
        arguments:
            - '@baggage_aware_payment_http_client.inner'
```

```php
public function pay(HttpClientInterface $paymentClient): void
{
    $paymentClient->request('POST', 'https://payments.example.com/charge', [
        'headers' => ['content-type' => 'application/json'],
        'body' => '{"amount": 100}',
    ]);
    // outgoing baggage header is injected automatically from the resolver
}
```

#### Manual construction with a mocked inner client

```php
use Macpaw\SchemaContextBundle\HttpClient\BaggageAwareHttpClient;
use Macpaw\SchemaContextBundle\Service\BaggageCodec;
use Macpaw\SchemaContextBundle\Service\BaggageSchemaResolver;

$resolver = new BaggageSchemaResolver('default', 'dev', ['dev', 'test']);
$resolver->setBaggage(['X-Schema' => 'tenant_42', 'foo' => null]);

$client = new BaggageAwareHttpClient($innerHttpClient, $resolver, new BaggageCodec());

$client->request('GET', 'https://api.example.com/test', [
    'headers' => ['baggage' => 'test = 123'],
]);
// inner client receives headers: baggage => 'test=123,X-Schema=tenant_42,foo'
```
```

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

### Constructing the exception directly

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/environment-schema-mismatch-exception.md

Shows how to construct the exception directly. The constructor is public, so it can be instantiated manually, though the bundle only creates it from setSchema.

```php
use Macpaw\SchemaContextBundle\Exception\EnvironmentSchemaMismatchException;

$e = new EnvironmentSchemaMismatchException('tenant_a', 'public', 'production', ['develop', 'staging', 'test']);
// getMessage() == 'Schema mismatch in "production" environment: expected "public", got "tenant_a". Allowed override environments: [develop, staging, test].'
```

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

### Constructor for BaggageSchemaResolver

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-schema-resolver.md

Constructor with three parameters: environmentSchema, environmentName, and schemaOverridableEnvironments. The constructor computes isSchemaOverridableEnvironment with a strict in_array lookup. No default values are provided; values come from container parameters.

```php
/**
 * @param string[] $schemaOverridableEnvironments
 */
public function __construct(
    private readonly string $environmentSchema,
    private readonly string $environmentName,
    private readonly array $schemaOverridableEnvironments,
)
```

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

### Run PHPUnit tests

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/README.md

Runs the test suite using PHPUnit.

```bash
vendor/bin/phpunit
```

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

### Manual bundle registration in config/bundles.php

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/schema-context-bundle.md

Manual registration of the bundle in config/bundles.php for Symfony applications not using Flex.

```php
// config/bundles.php
return [
    Macpaw\SchemaContextBundle\SchemaContextBundle::class => ['all' => true],
];
```

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

### Import SchemaContextBundle class

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/schema-context-bundle.md

Import statement for the SchemaContextBundle class.

```php
use Macpaw\SchemaContextBundle\SchemaContextBundle;
```

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

### Catching the exception

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/environment-schema-mismatch-exception.md

Shows how to catch the exception and retrieve its message. The exception extends the base Exception, so it is caught with the usual catch/getMessage() pattern.

```php
catch (EnvironmentSchemaMismatchException $e) {
    $e->getMessage();
}
```

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

### EnvironmentSchemaMismatchException constructor

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/environment-schema-mismatch-exception.md

Constructor signature for the exception. It takes the attempted schema, the environment's fixed schema, the environment name, and the list of environments where overriding is allowed. The parent constructor is called with Response::HTTP_INTERNAL_SERVER_ERROR as the exception code, so getCode() returns HTTP 500.

```php
/**
 * @param string[] $schemaOverridableEnvironments
 */
public function __construct(
    string $actualSchema,
    string $environmentSchema,
    string $environmentName,
    array $schemaOverridableEnvironments,
)
```

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

### withOptions method signature

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-aware-http-client.md

Declares the withOptions method that accepts an array of options and returns a static instance. The method wraps the inner client's withOptions result in a new BaggageAwareHttpClient, preserving the resolver and codec.

```php
/**
 * @param array<string, mixed> $options
 */
public function withOptions(array $options): static
```

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

### BaggageSchemaMiddleware constructor

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-schema-middleware.md

Constructor injecting the senders locator, baggage schema resolver, and baggage codec.

```php
public function __construct(
    private SendersLocatorInterface $sendersLocator,
    private BaggageSchemaResolver $baggageSchemaResolver,
    private BaggageCodec $baggageCodec,
)
```

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

### Configuration getConfigTreeBuilder method

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/dependency-injection.md

Returns the `TreeBuilder` rooted at the `schema_context` key. The builder chain uses `scalarNode()` and `arrayNode()` with `scalarPrototype()`. Defaults and constraints: `header_name` default `'X-Schema'`, `environment_name` default `'public'`, `environment_schema` required and non-empty, `overridable_environments` default empty array.

```php
public function getConfigTreeBuilder(): TreeBuilder
```

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

### Exception message format

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/environment-schema-mismatch-exception.md

The message format produced by the exception. It includes the environment name, the expected schema, the actual schema, and the list of allowed override environments.

```text
Schema mismatch in "<environmentName>" environment: expected "<environmentSchema>", got "<actualSchema>". Allowed override environments: [<comma-joined schemaOverridableEnvironments>].
```

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

### getSubscribedEvents method signature

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-request-listener.md

Returns the event subscription map [KernelEvents::REQUEST => [['onKernelRequest', 100]]], registering the onKernelRequest handler for the REQUEST kernel event with priority 100.

```php
public static function getSubscribedEvents(): array
```

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

### Manually instantiate BaggageSchemaResolver with error handling

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-schema-resolver.md

Use this snippet to manually create a BaggageSchemaResolver with explicit environment and allowed override environments. It demonstrates catching EnvironmentSchemaMismatchException when setting a schema in a non-allowed environment, and shows the chainable setSchema and setBaggage methods.

```php
use Macpaw\SchemaContextBundle\Service\BaggageSchemaResolver;
use Macpaw\SchemaContextBundle\Exception\EnvironmentSchemaMismatchException;

$resolver = new BaggageSchemaResolver('public', 'production', ['develop', 'staging', 'test']);

try {
    $resolver->setSchema('tenant_a');
    // never reached in 'production': throws EnvironmentSchemaMismatchException
} catch (EnvironmentSchemaMismatchException $e) {
    $message = $e->getMessage();
    // Schema mismatch in "production" environment: expected "public", got "tenant_a". Allowed override environments: [develop, staging, test].
}

// Chainable API
$resolver->setSchema('tenant_a')->setBaggage(['X-Schema' => 'tenant_a', 'user-id' => '12345']);
```

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

### SchemaContextCompilerPass process method

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/dependency-injection.md

Defines the process method of the compiler pass. The method body is empty, so the pass performs no work.

```php
public function process(ContainerBuilder $container): void
```

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

### Configuration class declaration

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/dependency-injection.md

Declares the bundle's configuration class implementing `ConfigurationInterface`. Source: `src/DependencyInjection/Configuration.php`.

```php
class Configuration implements ConfigurationInterface
```

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

### Configure schema_context in YAML

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/dependency-injection.md

Provides configuration for the schema_context tree. Sets the environment name, header name, environment schema, and overridable environments.

```yaml
# config/packages/schema_context.yaml
schema_context:
    environment_name: '%env(APP_ENV)%'
    header_name: 'X-Tenant'
    environment_schema: '%env(ENVIRONMENT_SCHEMA)%'
    overridable_environments: ['develop', 'staging', 'test']
```

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

### Basic use — injected into a controller

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-schema-resolver.md

Shows how to inject BaggageSchemaResolver into a controller and use its getSchema() and getBaggage() methods.

```APIDOC
## BaggageSchemaResolver::getSchema() and getBaggage()

### Description
Retrieves the current schema name and baggage map. The schema is a string like 'public' or 'tenant_a', and the baggage is an array of string keys to nullable string values or null.

### Method
- getSchema(): string
- getBaggage(): array<string,string|null>|null

### Parameters
None.

### Request Example
```php
use Macpaw\SchemaContextBundle\Service\BaggageSchemaResolver;

public function index(BaggageSchemaResolver $schemaResolver): Response
{
    $schema = $schemaResolver->getSchema();   // e.g. 'public' or 'tenant_a'
    $baggage = $schemaResolver->getBaggage(); // array<string,string|null>|null

    return $this->render('index', [
        'schema' => $schema,
        'baggage' => $baggage,
    ]);
}
```

### Response
#### Success Response
- **schema** (string) - The current schema name.
- **baggage** (array<string,string|null>|null) - The baggage map or null if not set.
```

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

### BaggageProcessor constructor with BaggageSchemaResolver

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-processor.md

Constructor that injects the shared BaggageSchemaResolver whose current baggage map is copied into each log record. The resolver is required and has no default.

```php
public function __construct(
    private readonly BaggageSchemaResolver $baggageSchemaResolver,
)
```

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

### BaggageAwareHttpClient constructor

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-aware-http-client.md

Constructor signature for BaggageAwareHttpClient. Requires the decorated HTTP client, the baggage schema resolver, and the baggage codec.

```php
public function __construct(
    private HttpClientInterface $inner,
    private BaggageSchemaResolver $baggageSchemaResolver,
    private BaggageCodec $baggageCodec,
)
```

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

### BaggageRequestListener constructor

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-request-listener.md

Constructor that injects the BaggageSchemaResolver, BaggageCodec, and the schema request header key. The schemaRequestHeader is wired from the %schema_context.header_name% parameter (default X-Schema).

```php
public function __construct(
    private BaggageSchemaResolver $baggageSchemaResolver,
    private BaggageCodec $baggageCodec,
    private string $schemaRequestHeader,
)
```

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

### Basic encoding and decoding with BaggageCodec

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-codec.md

Shows basic encoding and decoding with BaggageCodec. Encoding a map with a null value produces a bare key, and decoding trims whitespace around keys and values. The round-trip is the identity function apart from trimming and ordering normalization.

```php
use Macpaw\SchemaContextBundle\Service\BaggageCodec;

$codec = new BaggageCodec();

$encoded = $codec->encode(['X-Schema' => 'tenant_a', 'user-id' => null, 'trace-id' => 'abc123']);
// 'X-Schema=tenant_a,user-id,trace-id=abc123'

$decoded = $codec->decode('X-Schema=tenant_a,user-id,trace-id=abc123');
// ['X-Schema' => 'tenant_a', 'user-id' => null, 'trace-id' => 'abc123']

$normalized = $codec->decode(' X-Schema = tenant_a , test ');
// ['X-Schema' => 'tenant_a', 'test' => null]
```

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

### SchemaContextBundle build method signature

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/schema-context-bundle.md

Method signature for the build method that registers the compiler pass. It takes a ContainerBuilder and returns void.

```php
public function build(ContainerBuilder $container)
```

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

### HTTP client options and log records annotation

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/types.md

PHPDoc annotation for a generic options/record map with string keys and mixed values. Used by BaggageAwareHttpClient::request, withOptions, and BaggageProcessor::__invoke.

```php
/**
 * @param array<string, mixed> $options
 */
```

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

### onKernelRequest method signature

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-request-listener.md

Handles the kernel request event. Reads the baggage header, decodes it with BaggageCodec::decode, and stores the baggage map and schema on the resolver. If the header is missing, both are set to null.

```php
public function onKernelRequest(RequestEvent $event): void
```

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

### Service configuration for BaggageAwareHttpClient

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-aware-http-client.md

YAML service definition that decorates the payment_http_client service with BaggageAwareHttpClient, injecting the inner client via the '@baggage_aware_payment_http_client.inner' argument.

```yaml
services:
    baggage_aware_payment_http_client:
        class: Macpaw\SchemaContextBundle\HttpClient\BaggageAwareHttpClient
        decorates: payment_http_client
        arguments:
            - '@baggage_aware_payment_http_client.inner'
```

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

### Enable BaggageProcessor as Monolog processor

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-processor.md

YAML service configuration to enable the BaggageProcessor as a Monolog processor. This is required because the processor is not registered by config/services.yaml by default.

```yaml
services:
    Macpaw\SchemaContextBundle\Monolog\BaggageProcessor:
        tags:
            - { name: monolog.processor }
```

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

### Constructing a BaggageSchemaStamp

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-schema-stamp.md

Creates a new BaggageSchemaStamp with a schema name and encoded baggage string, then attaches it to an envelope using the with() method.

```php
use Macpaw\SchemaContextBundle\Messenger\Stamp\BaggageSchemaStamp;

$stamp = new BaggageSchemaStamp('tenant_a', 'X-Schema=tenant_a,user-id=12345');
$envelope = $envelope->with($stamp);
```

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

### SchemaContextBundle class declaration

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/schema-context-bundle.md

Declares the bundle class extending the HttpKernel Bundle base class. This is the entry point for the Schema Context feature set.

```php
class SchemaContextBundle extends Bundle
```

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

### BaggageSchemaStamp constructor

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/types.md

Constructor of BaggageSchemaStamp, the bundle's only data class. It implements StampInterface and holds two public promoted properties: schema (nullable string) and baggage (nullable encoded baggage header string).

```php
public function __construct(public ?string $schema, public ?string $baggage)
```

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

### EnvironmentSchemaMismatchException message format

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/errors.md

The exact message produced by EnvironmentSchemaMismatchException when the schema mismatch condition is met. It includes the environment name, expected and actual schemas, and the list of allowed override environments.

```text
Schema mismatch in "<environmentName>" environment: expected "<environmentSchema>", got "<actualSchema>". Allowed override environments: [<comma-joined list>].
```

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

### Catch EnvironmentSchemaMismatchException in PHP

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/errors.md

Shows how to catch EnvironmentSchemaMismatchException in consumer code. The exception is thrown synchronously from setSchema and carries code 500 (Response::HTTP_INTERNAL_SERVER_ERROR).

```php
use Macpaw\SchemaContextBundle\Service\BaggageSchemaResolver;
use Macpaw\SchemaContextBundle\Exception\EnvironmentSchemaMismatchException;

$resolver = new BaggageSchemaResolver('public', 'production', ['develop', 'staging', 'test']);

try {
    $resolver->setSchema('tenant_a');
} catch (EnvironmentSchemaMismatchException $e) {
    $code = $e->getCode();       // 500 — Response::HTTP_INTERNAL_SERVER_ERROR
    $cause = $e->getMessage();   // human-readable explanation
}
```

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

### End-to-end producer and worker flow

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-schema-middleware.md

Shows the end-to-end flow: the producer sets schema and baggage on the resolver and dispatches a message, which attaches a BaggageSchemaStamp. On the worker side, the middleware restores the schema and baggage on the resolver for the handler and resets it afterward.

```php
// Producer process: dispatching a message
$resolver->setSchema('tenant_a')->setBaggage(['X-Schema' => 'tenant_a']);
$bus->dispatch($message);
// -> envelope is sent with BaggageSchemaStamp(schema: 'tenant_a', baggage: 'X-Schema=tenant_a')

// Worker process: consuming the message
// -> middleware restores schema/baggage on the resolver for the handler,
//    then calls $resolver->reset() once the handler finished
public function handle(Message $message): void
{
    $resolver->getSchema();   // 'tenant_a' (restored from the stamp)
    $resolver->getBaggage();  // ['X-Schema' => 'tenant_a'] (decoded from the stamp)
}
```

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

### Declare BaggageAwareHttpClient as a service decorator

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-aware-http-client.md

Declares a service that decorates an existing HTTP client with BaggageAwareHttpClient. The decorates key names the client to wrap, and the inner service is passed as the first argument.

```yaml
services:
    baggage_aware_payment_http_client:
        class: Macpaw\SchemaContextBundle\HttpClient\BaggageAwareHttpClient
        decorates: payment_http_client # http client to decorate
        arguments:
            - '@baggage_aware_payment_http_client.inner'
```

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

### setSchema method signature

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-schema-resolver.md

Stores a schema name. null, empty, or whitespace-only strings are normalized to null. Returns $this (chainable). Throws EnvironmentSchemaMismatchException when overriding in a non-overridable environment.

```php
public function setSchema(?string $schema): self
```

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

### handle(Envelope $envelope, StackInterface $stack): Envelope

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-schema-middleware.md

Processes an envelope through the middleware, restoring or attaching baggage schema context depending on whether the message is being consumed or dispatched.

```APIDOC
## handle(Envelope $envelope, StackInterface $stack): Envelope

### Description
Processes an envelope through the middleware, restoring or attaching baggage schema context depending on whether the message is being consumed or dispatched.

### Method
handle

### Parameters
- **$envelope** (Symfony\Component\Messenger\Envelope) - Required - The envelope being processed
- **$stack** (Symfony\Component\Messenger\Middleware\StackInterface) - Required - Middleware stack; the next middleware is invoked as `$stack->next()->handle($envelope, $stack)`

### Worker branch (message consumption)
Triggered when the envelope satisfies both:
- `$envelope->last(ReceivedStamp::class)` is truthy (`isWorker`), **and**
- no sender for the envelope is an instance of `Symfony\Component\Messenger\Transport\Sync\SyncTransport` (`isSyncTransport`).

Behavior:
1. Reads the last `BaggageSchemaStamp` from the envelope.
2. If present: restores context on the resolver — `setSchema($stamp->schema)` and `setBaggage($stamp->baggage === null ? null : $this->baggageCodec->decode($stamp->baggage))`.
3. Delegates to the next middleware.
4. Calls `$this->baggageSchemaResolver->reset()` after the stack returns.
5. Returns the downstream result unchanged.

A missing or non-`BaggageSchemaStamp` stamp results in no context restoration (the resolver keeps its current state during the downstream handling, which is still reset afterwards).

### Producer branch (message dispatch)
Triggered in all other cases (no `ReceivedStamp`, or a sync transport). Behavior:
1. Reads `BaggageSchemaResolver::getSchema()` and, when baggage is not `null`, encodes it with `BaggageCodec::encode`.
2. Attaches `new BaggageSchemaStamp($schema, $baggage)` to the envelope (`$envelope->with(...)`).
3. Delegates to the next middleware and returns its result.

A `null` baggage in the resolver is propagated as a `null` stamp baggage; with a non-`null` resolver baggage the stamp carries the encoded string.

### Return type
`Envelope` — the envelope returned by the next middleware in the stack (stamped, in the producer branch).

### Throws
`Macpaw\SchemaContextBundle\Exception\EnvironmentSchemaMismatchException` can surface from `BaggageSchemaResolver::setSchema` during the worker branch when a stamp's schema differs from the environment schema in a non-overridable environment. See [errors.md](../errors.md).
```

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

### Inject BaggageSchemaResolver into a controller

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-schema-resolver.md

Use this snippet to inject the BaggageSchemaResolver service into a controller action. It retrieves the current schema (e.g., 'public' or 'tenant_a') and baggage array, then passes them to the view.

```php
use Macpaw\SchemaContextBundle\Service\BaggageSchemaResolver;

public function index(BaggageSchemaResolver $schemaResolver): Response
{
    $schema = $schemaResolver->getSchema();   // e.g. 'public' or 'tenant_a'
    $baggage = $schemaResolver->getBaggage(); // array<string,string|null>|null

    return $this->render('index', [
        'schema' => $schema,
        'baggage' => $baggage,
    ]);
}
```

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

### BaggageCodec class declaration

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-codec.md

The BaggageCodec class is stateless and has no declared constructor, so it has an implicit public no-argument constructor.

```php
class BaggageCodec
```

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

### EnvironmentSchemaMismatchException class declaration

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/environment-schema-mismatch-exception.md

The class declaration for the bundle's only custom exception. It extends the PHP built-in Exception class, so it can be caught with the usual catch/getMessage() pattern.

```php
class EnvironmentSchemaMismatchException extends Exception
```

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

### Enable BaggageSchemaMiddleware in messenger.yaml

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/README.md

Adds the BaggageSchemaMiddleware to the default message bus middleware stack. This automatically adds a BaggageSchemaStamp to dispatched messages and restores schema/baggage context on message handling.

```yaml
framework:
    messenger:
        buses:
            messenger.bus.default:
                middleware:
                    - Macpaw\SchemaContextBundle\Messenger\Middleware\BaggageSchemaMiddleware
```

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

### request

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-aware-http-client.md

Sends an HTTP request, merging the resolver's current baggage map with caller-supplied headers. The baggage header is overwritten with the merged result.

```APIDOC
## `request`

### Description
Sends an HTTP request, merging the resolver's current baggage map with caller-supplied headers. The baggage header is overwritten with the merged result.

### Method
`request`

### Signature
```php
public function request(string $method, string $url, array $options = []): ResponseInterface
```

### Parameters

#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **$method** (string) - Required - HTTP method, e.g. `GET`, `POST`
- **$url** (string) - Required - Request URL
- **$options** (array<string, mixed>) - Optional - Request options; only the `headers` key is inspected. If `options['headers']` is not an array it is treated as empty

### Behavior
1. Reads `options['headers']['baggage']` (if present) and decodes it with `BaggageCodec::decode`.
2. Merges the resolver's current baggage map (`BaggageSchemaResolver::getBaggage() ?? []`) **after** the caller-supplied entries. In the case of duplicated keys the resolver value wins (spread order).
3. Encodes the merged map back into `options['headers']['baggage']` and delegates to `$inner->request($method, $url, $options)`.

Note: the baggage header is overwritten unconditionally — a caller-supplied header is merged with, never replaced by, the resolver context.

### Return type
`Symfony\Contracts\HttpClient\ResponseInterface` — the response from the inner client.

### Response
#### Success Response (200)
- **body** (ResponseInterface) - The response from the inner client.

#### Response Example
```json
{
  "example": "response body"
}
```
```

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

### setBaggage method signature

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-schema-resolver.md

Stores a baggage map. An empty array is normalized to null. Returns $this (chainable). Does not trim keys/values; callers should pass already-normalized data.

```php
/**
 * @param array<string,string|null> $baggage
 */
public function setBaggage(?array $baggage): self
```

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

### isSyncTransport helper signature

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-schema-middleware.md

Declares the private helper that iterates over the senders for the envelope and returns true as soon as one is an instance of SyncTransport, indicating a synchronous transport.

```php
private function isSyncTransport(Envelope $envelope): bool
```

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

### setSchema

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-schema-resolver.md

Stores a schema name. null, empty, or whitespace-only strings are normalized to null. Returns $this for chaining.

```APIDOC
## setSchema

### Description
Stores a schema name. `null`, empty, or whitespace-only strings are normalized to `null`. Returns `$this` for chaining.

### Method
`setSchema`

### Signature
```php
public function setSchema(?string $schema): self
```

### Parameters
- `$schema` (`?string`) - Required - Schema name to store. `null`, empty, or whitespace-only strings are normalized to `null`.

### Return Value
- `self` - Returns `$this` (chainable).

### Throws
- `Macpaw\SchemaContextBundle\Exception\EnvironmentSchemaMismatchException` - When the current environment is **not** in `$schemaOverridableEnvironments` **and** the provided schema is non-`null` **and** differs from `$environmentSchema`; i.e. an attempt to override the schema in a non-overridable environment.
```

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

### SchemaContextCompilerPass class declaration

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/dependency-injection.md

Declares the compiler pass class that implements CompilerPassInterface. The class is registered by the bundle and its process method is currently empty.

```php
final class SchemaContextCompilerPass implements CompilerPassInterface
```

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

### BaggageCodec::encode method signature

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-codec.md

Encodes a baggage map into a W3C baggage header string. Keys with null values become bare keys, keys with string values become key=value pairs, and both keys and values are trimmed. Parts are joined with commas; an empty map encodes to an empty string.

```php
/**
 * @param array<string,string|null> $baggage
 */
public function encode(array $baggage): string
```

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

### Disable decoration in test environment

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-aware-http-client.md

Disables decoration of the baggage-aware HTTP client in test environments by re-declaring the service with its class and no decoration. Use when replacing or mocking HTTP clients, e.g., with macpaw/extended-mock-http-client.

```yaml
when@test:
    services:
        baggage_aware_payment_http_client:
            class: Macpaw\SchemaContextBundle\HttpClient\BaggageAwareHttpClient

```

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

### Extracting schema key from incoming baggage header

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-codec.md

Extracts the schema key from an incoming baggage header by decoding the header value and reading the 'X-Schema' key. Uses a null coalescing fallback for missing headers or keys.

```php
use Macpaw\SchemaContextBundle\Service\BaggageCodec;

$codec = new BaggageCodec();
$baggage = $codec->decode($request->headers->get('baggage') ?? '');

$schema = $baggage['X-Schema'] ?? null; // value under the configured header name
```

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

### BaggageProcessor __invoke method signature

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-processor.md

Signature of the __invoke method that processes a log record. It reads BaggageSchemaResolver::getBaggage() and, if the result is an array with at least one element, initializes $record['extra'] to [] if missing or not an array, then assigns the baggage map to $record['extra']['baggage']. Existing extra keys are preserved; empty or null baggage leaves the record untouched.

```php
/**
 * @param array<string, mixed> $record
 *
 * @return array<string, mixed>
 */
public function __invoke(array $record): array
```

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

### BaggageProcessor class declaration

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-processor.md

Declares the BaggageProcessor class, a plain Monolog log processor that injects the current baggage map into the 'extra' field of every log record. It does not implement a bundle-specific interface and is not registered by config/services.yaml.

```php
class BaggageProcessor
```

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

### BaggageSchemaMiddleware class declaration

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-schema-middleware.md

Declares the middleware class that implements Symfony's MiddlewareInterface.

```php
class BaggageSchemaMiddleware implements MiddlewareInterface
```

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

### getBaggage method signature

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-schema-resolver.md

Returns the currently stored baggage map, or null when no baggage has been set (or after reset()). The return type is ?array<string,string|null>.

```php
/**
 * @return array<string,string|null>|null
 */
public function getBaggage(): ?array
```

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

### BaggageRequestListener class declaration

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-request-listener.md

Declares the listener class that implements EventSubscriberInterface. The class is registered automatically by the bundle via the kernel.event_subscriber tag.

```php
class BaggageRequestListener implements EventSubscriberInterface
```

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

### BaggageCodec Methods

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-codec.md

Code snippets for the BaggageCodec class methods: encode and decode.

```APIDOC
## `encode`

### Description
Encodes a baggage map into a W3C baggage header string. Keys with null values are encoded as bare keys, while string values are encoded as `key=value` pairs. Both keys and values are trimmed, and parts are joined with commas.

### Method
`encode`

### Signature
```php
public function encode(array $baggage): string
```

### Parameters
- **$baggage** (array<string,string|null>) - Required - Baggage map. Keys with a `null` value are encoded as bare keys; keys with a string value are encoded as `key=value`; both keys and values are `trim()`med; parts are joined with `,`.

### Return Type
`string` - The encoded baggage header value (e.g. `foo,bar=baz`). An empty map encodes to the empty string.

### Example
```php
$codec = new BaggageCodec();
$encoded = $codec->encode(['X-Schema' => 'tenant_a', 'user-id' => null, 'trace-id' => 'abc123']);
// 'X-Schema=tenant_a,user-id,trace-id=abc123'
```
```

```APIDOC
## `decode`

### Description
Decodes a raw W3C baggage header string into an associative baggage map. Each comma-separated part is decoded as `key=value` (split on the first `=`, both sides trimmed) or as a bare key mapped to `null`. Whitespace-only parts and the empty string are skipped.

### Method
`decode`

### Signature
```php
public function decode(string $baggage): array
```

### Parameters
- **$baggage** (string) - Required - Raw baggage header value, e.g. `X-Schema=tenant_a,user-id=12345,trace-id=abc123`.

### Return Type
`array<string,string|null>` - Each comma-separated part decoded as `key=value` or as a bare key mapped to `null`.

### Example
```php
$codec = new BaggageCodec();
$decoded = $codec->decode('X-Schema=tenant_a,user-id,trace-id=abc123');
// ['X-Schema' => 'tenant_a', 'user-id' => null, 'trace-id' => 'abc123']
```
```

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

### Class declaration for BaggageSchemaResolver

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/api-reference/baggage-schema-resolver.md

Declares the BaggageSchemaResolver class. This is the primary service consumers inject to read the current schema.

```php
class BaggageSchemaResolver
```

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

### Schema-overridable environments list annotation

Source: https://github.com/macpaw/schema-context-bundle/blob/develop/_autodocs/types.md

PHPDoc annotation for the schema-overridable environments list, used as the third constructor argument of BaggageSchemaResolver and EnvironmentSchemaMismatchException. In configuration it corresponds to the schema_context.overridable_environments array node (default []).

```php
/**
 * @param string[] $schemaOverridableEnvironments
 */
```
Tokens:
Raw