Laravel Serializable Closure

https://github.com/laravel/serializable-closure
Admin
A PHP package that provides an easy and secure way to serialize closures in Laravel applications.
Tokens:30,769
Snippets:382
Trust Score:9.7
License:MIT
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install Laravel Serializable Closure

Source: https://github.com/laravel/serializable-closure/blob/2.x/README.md

Install the package using Composer. Requires PHP 7.4+.

```bash
composer require laravel/serializable-closure
```

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

### Custom Signer Implementation Example

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Contracts.md

Provides an example of a custom signer implementation adhering to the Signer interface. This involves defining custom signing and verification logic.

```php
use Laravel\SerializableClosure\Contracts\Signer;

class CustomSigner implements Signer
{
    public function __construct(private string $key) {}

    public function sign($serializable): array
    {
        // Custom signing logic
        return [
            'serializable' => $serializable,
            'signature' => custom_sign($serializable, $this->key),
        ];
    }

    public function verify(array $signature): bool
    {
        // Custom verification logic
        return custom_verify(
            $signature['serializable'],
            $signature['signature'],
            $this->key
        );
    }
}
```

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

### Serializable Closure Integration Example

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Support-Classes.md

Illustrates the workflow for serializing and unserializing closures using the Native serializer, ClosureScope, and ClosureStream. This example shows the complete process from scope creation to closure restoration.

```php
use Laravel\SerializableClosure\Serializers\Native;
use Laravel\SerializableClosure\Support\ClosureScope;
use Laravel\SerializableClosure\Support\ClosureStream;

// 1. Create a scope for tracking
$scope = new ClosureScope();

// 2. Serialize a closure
$closure = fn() => 'test';
$serializer = new Native($closure);
$data = $serializer->__serialize();

// 3. Register stream protocol for unserialization
ClosureStream::register();

// 4. Restore the closure
$restored = unserialize(serialize($data));
```

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

### Example Closure Stream Protocol

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Support-Classes.md

An example of the stream protocol format with actual closure code. When included, this PHP file creates the closure with its scope preserved.

```php
<?php
return fn($x) => $x * 2;
```

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

### Environment Variable Configuration Example

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/configuration.md

Shows a common pattern for configuring the secret key using environment variables, falling back to APP_KEY if APP_SECRET is not set.

```php
SerializableClosure::setSecretKey(env('APP_SECRET') ?? env('APP_KEY'));
```

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

### Structure Metadata Example

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/types.md

Example of the structure metadata array, which contains information about classes, traits, interfaces, and namespaces in a file. Used to represent file structure.

```php
[
    [
        'type' => 'namespace',
        'name' => 'App\\Handlers',
        'start' => 1,
        'end' => 100,
        'classes' => ['Handler' => '\\App\\Handlers\\Handler'],
    ],
    [
        'type' => 'class',
        'name' => 'ClosureFactory',
        'start' => 5,
        'end' => 95,
    ],
]
```

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

### Serializable Interface Usage Example

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Contracts.md

Demonstrates how to use the Serializable interface to process closures. You can invoke the closure directly or retrieve its instance.

```php
use Laravel\SerializableClosure\Contracts\Serializable;

function processClosure(Serializable $serializable) {
    // Can call the closure
    $result = $serializable();

    // Or retrieve it for other operations
    $closure = $serializable->getClosure();
}
```

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

### Get Closure Use Variables Example

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/types.md

Demonstrates how to retrieve the variables captured by a closure using ReflectionClosure. This is useful for inspecting closure state.

```php
$x = 10;
$y = 'test';

$closure = function() use ($x, $y) {
    return "$y: $x";
};

$reflector = new ReflectionClosure($closure);
$vars = $reflector->getUseVariables();

// $vars = ['x' => 10, 'y' => 'test']
```

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

### Schedule Tasks with Closures

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/README.md

Schedule a task to run daily using a closure. This example defines a daily scheduled task that generates a report.

```php
schedule()->call(
    new SerializableClosure(fn() => Report::generate())
)->daily();
```

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

### Example Signed Closure Data

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Signers-Hmac.md

An example of a complete signature array containing a serialized closure and its corresponding base64 encoded HMAC-SHA256 hash.

```php
[ 
    'serializable' => 'O:45:"Laravel\\SerializableClosure\\Serializers\\Native":5:{s:3:"use";a:0:{}s:8:"function";s:15:"fn() => \"test\"";s:5:"scope";N;s:4:"this";N;s:4:"self";s:40:"abc123def456...";}',
    'hash' => 'abcdef1234567890abcdef1234567890+/=='
]
```

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

### Implement and Install Custom Signer

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/configuration.md

Define a custom signer class implementing the Signer interface for custom signing and verification logic, such as RSA.

```php
use Laravel\SerializableClosure\Contracts\Signer;
use Laravel\SerializableClosure\Serializers\Signed;

class RsaSigner implements Signer {
    public function sign($serializable): array {
        // RSA signing logic
    }

    public function verify(array $signature): bool {
        // RSA verification logic
    }
}

// Install custom signer
Signed::$signer = new RsaSigner();
```

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

### Cache Callbacks with Closures

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/README.md

This example demonstrates caching a closure's result using the `cache()->remember()` method. The closure will be executed only if the cache entry does not exist.

```php
$cached = cache()->remember('callback:user:' . $user->id, 3600,
    new SerializableClosure(fn() => $user->computeExpensive())
);
```

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

### Serialized Closure Data Example

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/types.md

An example of the serialized closure data structure, showing captured variables, function code, scope, and other metadata. This format is used internally by the serialization process.

```php
[
    'use' => ['count' => 42],
    'function' => 'fn($x) => $x * $count',
    'scope' => null,
    'this' => null,
    'self' => '0000000000000000000000003e1a6d5c',
]
```

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

### Get File Tokens

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/ReflectionClosure.md

Loads and caches all PHP tokens for the entire source file where the closure is defined. This provides a comprehensive view of the file's structure.

```php
protected function getFileTokens(): array
```

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

### Key Rotation Strategy

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/configuration.md

Illustrates a strategy for rotating secret keys, including maintaining a list of old keys and migrating data. This example shows setting an old key, serializing, then setting a new key and serializing again.

```php
// Old key
SerializableClosure::setSecretKey('old-secret');
$old = serialize(new SerializableClosure($closure));

// New key
SerializableClosure::setSecretKey('new-secret');
$new = serialize(new SerializableClosure($closure));

// Old data can no longer be unserialized with new key
// Implement migration strategy:
// 1. Maintain list of acceptable old keys
// 2. Try new key first, fall back to old keys
// 3. Gradually migrate data to new key
```

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

### ClosureScope Usage Example

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/types.md

Demonstrates how to use the ClosureScope object for tracking closure references during serialization to prevent infinite recursion. The scope stores object references and can be used to mark objects as processed.

```php
$scope = new ClosureScope();
$scope->serializations = 1;
$scope->toSerialize = 5;

// Store an object to mark it as processed
$scope[$object] = true;

// Check if an object was already processed
if (isset($scope[$object])) {
    // Skip re-processing
}
```

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

### Get File Structures

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/ReflectionClosure.md

Retrieves structural information, including classes, interfaces, and traits, along with their line ranges for the closure's source file. This provides metadata about the file's organization.

```php
protected function getStructures(): array
```

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

### Restore Non-Serializable Objects After Unserialization

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/configuration.md

This example demonstrates how to restore objects that are not directly serializable by using a custom unserialization logic within the resolver. Assumes `unserialize_custom` is a defined function.

```php
SerializableClosure::resolveUseVariablesUsing(function($variables) {
    foreach ($variables as &$value) {
        if (is_string($value) && str_starts_with($value, 'serialized:')) {
            $value = unserialize_custom($value);
        }
    }
    return $variables;
});
```

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

### SelfReference Usage Example

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Support-Classes.md

Demonstrates how a closure that references itself is handled during serialization by creating a SelfReference object. This is used internally to manage recursive closures.

```php
$closure = null;
$closure = function() use (&$closure) {
    // Recursive closure
    return $closure;
};

// During serialization, a SelfReference is created
// to represent the recursive reference
```

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

### Custom Encrypted Serializable Implementation

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Contracts.md

Provides an example of a custom Serializable implementation that wraps another Serializable object and adds encryption capabilities. This custom serializer must implement the Serializable contract.

```php
use Laravel\SerializableClosure\Contracts\Serializable;

class EncryptedSerializable implements Serializable
{
    public function __construct(
        private Serializable $wrapped,
        private string $key
    ) {}

    public function __invoke()
    {
        return call_user_func_array(
            $this->wrapped,
            func_get_args()
        );
    }

    public function getClosure(): \Closure
    {
        return $this->wrapped->getClosure();
    }
}
```

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

### Get Closure Source Tokens

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/ReflectionClosure.md

Retrieves the PHP tokens for the specific source location of a closure within its file. This is useful for detailed code analysis.

```php
protected function getTokens(): array
```

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

### Encrypt Sensitive Data in Use Variables

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/configuration.md

Example of transforming use variables to encrypt sensitive string data before serialization. Sensitive strings are prefixed with 'secret:' and then encrypted.

```php
use Laravel\SerializableClosure\SerializableClosure;

SerializableClosure::transformUseVariablesUsing(function($variables) {
    foreach ($variables as &$value) {
        if (is_string($value) && str_starts_with($value, 'secret:')) {
            $value = 'encrypted:' . encrypt(substr($value, 7));
        }
    }
    return $variables;
});

$secret = 'secret:sensitive-data';
$closure = fn() => $secret;
$serialized = serialize(new SerializableClosure($closure));
// Secret is encrypted in serialized data
```

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

### Token Array Structure Example

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/types.md

Illustrates the structure of a PHP token array as returned by token_get_all(), used internally by ReflectionClosure for code analysis. It can contain token ID, string, and line number, or single-character tokens.

```php
[
    [token_id, token_string, line_number],  // Token array
    // or
    'single_character_token',               // Single-char tokens
    // ...
]
```

```php
[
    [T_FUNCTION, 'function', 1],
    [T_WHITESPACE, ' ', 1],
    '(' ,
    [T_VARIABLE, '$x', 1],
    ')',
    '{',
    // ...
    '}'
]
```

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

### Trigger Missing Secret Key Exception

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/errors.md

This example shows the scenario that triggers the MissingSecretKeyException: attempting to serialize a closure with the default Signed serializer when no secret key is configured.

```php
use Laravel\SerializableClosure\Exceptions\MissingSecretKeyException;

// No secret key configured
SerializableClosure::setSecretKey(null);

// This creates a Signed serializer by default
$serializable = new SerializableClosure(fn() => 'data');

try {
    $serialized = serialize($serializable);
    // Throws MissingSecretKeyException during serialization
} catch (MissingSecretKeyException $e) {
    echo "Configure a secret key first";
}
```

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

### Instantiate and Use ClosureScope

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Support-Classes.md

Demonstrates how to instantiate `ClosureScope` and use it to track objects, preventing duplicate serialization and checking for already processed objects.

```php
use Laravel\SerializableClosure\Support\ClosureScope;

$scope = new ClosureScope();

// Objects are stored to prevent duplicate serialization
$object1 = new stdClass();
$scope[$object1] = true;

// Check if object was already processed
if (isset($scope[$object1])) {
    // Already serialized, skip
}
```

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

### Swapping Serializable Implementations

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Contracts.md

Demonstrates how to swap between different Serializable implementations, such as the default Signed implementation and a custom encrypted one, without altering client code.

```php
use Laravel\SerializableClosure\Signed;
use Laravel\SerializableClosure\Closure as SerializableClosure;

// Current implementation
$serializable = new Signed($closure);

// Could be swapped to a different implementation
// $serializable = new Custom\EncryptedSigned($closure);
```

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

### Instantiate and Invoke Signed Serializer

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Serializers-Signed.md

Demonstrates how to create a Signed serializer instance for a closure and then invoke the closure through the serializer.

```php
$closure = fn($x) => $x + 1;
$signed = new Signed($closure);
echo $signed(5); // 6
```

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

### Unsigned Closure with Global Key

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/SerializableClosure.md

Demonstrates the use of a global secret key for signing closures, while also showing how to create an unsigned closure that bypasses this global key.

```php
SerializableClosure::setSecretKey('global-key');

// This closure is signed
$signed = new SerializableClosure(fn() => 'signed');

// This closure bypasses the global key
$unsigned = SerializableClosure::unsigned(fn() => 'unsigned');

$signedSerialized = serialize($signed);
$unsignedSerialized = serialize($unsigned);
```

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

### Configure Secret Key for Production

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/configuration.md

Ensure a secret key is configured and used for signing closures in production environments. Throws a RuntimeException if the secret is missing.

```php
// Require signing in production
if (app()->isProduction()) {
    $secret = env('CLOSURE_SECRET');
    if (!$secret) {
        throw new RuntimeException(
            'CLOSURE_SECRET must be configured in production'
        );
    }
    SerializableClosure::setSecretKey($secret);
}
```

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

### Signed Serializer Get Closure

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Serializers-Signed.md

Retrieves the original or reconstructed closure from the Signed serializer instance.

```APIDOC
## `getClosure(): \Closure`

### Description
Returns the wrapped closure.

### Method
`getClosure`

### Parameters
#### Path Parameters
None

### Return
`\Closure` — the original or reconstructed closure
```

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

### Typical Configuration in Laravel Service Provider

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/configuration.md

Demonstrates how to configure the secret key in a Laravel application's service provider using an environment variable.

```php
// In a service provider boot() method
use Laravel\SerializableClosure\SerializableClosure;

class AppServiceProvider
{
    public function boot()
    {
        if (env('APP_SECRET')) {
            SerializableClosure::setSecretKey(env('APP_SECRET'));
        }
    }
}
```

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

### Get Property Value (PHP 8.4+)

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Serializers-Native.md

Retrieves a property's value, bypassing property hooks introduced in PHP 8.4.

```php
protected static function getPropertyValue(ReflectionProperty $property, object $object): mixed
```

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

### Basic Closure Serialization

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/README.md

Demonstrates how to serialize and unserialize a closure without using the signing feature. Ensure the SerializableClosure class is imported.

```php
use Laravel\SerializableClosure\SerializableClosure;

// Create a closure
$closure = fn($x) => $x * 2;

// Serialize without signing
$serialized = serialize(new SerializableClosure($closure));

// Unserialize
$restored = unserialize($serialized);
$result = $restored->getClosure()(5); // 10
```

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

### Handle Missing Secret Key Exception

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/errors.md

Demonstrates how to catch and handle the MissingSecretKeyException. It shows how to configure the secret key and provides a fallback for development environments.

```php
use Laravel\SerializableClosure\SerializableClosure;
use Laravel\SerializableClosure\Exceptions\MissingSecretKeyException;

try {
    SerializableClosure::setSecretKey(
        env('APP_SECRET') ?: null
    );

    $closure = fn() => 'sensitive data';
    $serialized = serialize(new SerializableClosure($closure));
} catch (MissingSecretKeyException $e) {
    if (app()->isProduction()) {
        // Fail hard in production
        throw $e;
    }

    // Allow unsigned in development
    $serialized = serialize(
        SerializableClosure::unsigned($closure)
    );
}
```

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

### Serialize and Unserialize Closures

Source: https://github.com/laravel/serializable-closure/blob/2.x/README.md

Demonstrates how to serialize a closure, set a secret key for security, and then unserialize it to retrieve the original closure. Ensure each closure is on its own line to avoid potential issues with identical signatures.

```php
use Laravel\SerializableClosure\SerializableClosure;

$closure = fn () => 'james';

// Recommended
SerializableClosure::setSecretKey('secret');

$serialized = serialize(new SerializableClosure($closure));
$closure = unserialize($serialized)->getClosure();

echo $closure(); // james;
```

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

### Get Imported Constants

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/ReflectionClosure.md

Retrieves a mapping of imported constant names to their values within the closure's namespace. This is useful for understanding constant usage.

```php
protected function getConstants(): array
```

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

### Register ClosureStream Wrapper and Include Closure

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Support-Classes.md

Shows how to register the custom `ClosureStream` wrapper and then use the `include` statement with a stream path to reconstruct a closure from its code representation.

```php
ClosureStream::register();

$closure = include ClosureStream::STREAM_PROTO . '://fn() => "test"';
```

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

### Get Error Details for InvalidSignatureException

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/errors.md

Retrieve detailed error information, including the full stack trace, file, and line number, when an InvalidSignatureException occurs.

```php
// Get full stack trace
try {
    unserialize($data);
} catch (InvalidSignatureException $e) {
    echo $e->getTraceAsString();
    echo "File: " . $e->getFile();
    echo "Line: " . $e->getLine();
}
```

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

### Prevent Missing Secret Key Exception: Ensure Configuration

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/errors.md

Shows how to ensure the secret key is configured before attempting to use SerializableClosure. This can be done during application bootstrap or with a check before use.

```php
// In application bootstrap
SerializableClosure::setSecretKey(config('app.closure_secret'));
```

```php
// Or check before use
if (!env('APP_SECRET')) {
    throw new MissingSecretKeyException(
        'APP_SECRET must be configured'
    );
}
```

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

### Automatic Signing with Secret Key

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Serializers-Signed.md

Demonstrates how to set a secret key globally and use the Signed serializer for automatic signing and verification of closures. The closure is automatically reconstructed and usable upon successful signature verification during unserialization.

```php
use Laravel\SerializableClosure\SerializableClosure;

// Set secret key globally
SerializableClosure::setSecretKey('my-secret-key');

$closure = fn($x) => $x * 2;

// New instances automatically use Signed serializer
$serializable = new SerializableClosure($closure);
$serialized = serialize($serializable);

// Signature is verified during unserialization
$restored = unserialize($serialized);
$result = $restored->getClosure()(5); // 10
```

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

### Swapping to a Custom Signer

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Contracts.md

Illustrates how to replace the default signer with a custom implementation. This is done by directly assigning an instance of your custom signer to the static `Signed::$signer` property.

```php
use Laravel\SerializableClosure\Serializers\Signed;

$customSigner = new CustomSigner('secret');
Signed::$signer = $customSigner;

// Now all SerializableClosure instances use the custom signer
$serializable = new SerializableClosure($closure);
$signed = serialize($serializable);
```

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

### Resolve Use Variables After Unserialization

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Serializers-Native.md

Applies a custom resolver to closure use variables after unserialization via the Native serializer. This example unserializes each variable, assuming they were serialized.

```php
SerializableClosure::resolveUseVariablesUsing(function($variables) {
    // All closures will use this resolver
    // after unserialization via Native serializer
    return array_map('unserialize', $variables);
});

$data = [...]; // Serialized data
$serializer = new Native(fn() => null);
$serializer->__unserialize($data); // Variables are unserialized
```

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

### Transform Use Variables Before Serialization

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Serializers-Native.md

Applies a custom transformation to closure use variables before serialization using the Native serializer. This example filters variables, removing any that are null.

```php
SerializableClosure::transformUseVariablesUsing(function($variables) {
    // All closures will use this transformation
    // before serialization via Native serializer
    return array_filter($variables);
});

$closure = fn() => $someVar;
$serializer = new Native($closure);
$data = $serializer->__serialize(); // Variables are filtered
```

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

### Create Hmac Signer Instance

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Signers-Hmac.md

Instantiate the Hmac signer with a secret key. This key is crucial for generating and verifying signatures.

```php
use Laravel\SerializableClosure\Signers\Hmac;

$signer = new Hmac('my-secret-key');
```

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

### Get Imported Functions

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/ReflectionClosure.md

Retrieves a mapping of imported function aliases to their fully qualified names within the closure's namespace. This aids in resolving function calls.

```php
protected function getFunctions(): array
```

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

### Dependency Inversion with Signer Interface

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Contracts.md

Illustrates how the JobQueue class depends on the abstract Signer interface, allowing for different signing strategies to be injected and used for signature verification.

```php
use Laravel\SerializableClosure\Contracts\Signer;
use Laravel\SerializableClosure\Exceptions\InvalidSignatureException;

class JobQueue
{
    public function __construct(
        private Signer $signer
    ) {}

    public function dispatch($closureData)
    {
        if (!$this->signer->verify($closureData)) {
            throw new InvalidSignatureException();
        }
        // Process closure
    }
}
```

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

### Configure Secret Key for Development

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/configuration.md

Set the secret key for development environments. In development, the secret is optional and can be null.

```php
// config/services.php
return [
    'closure' => [
        'secret' => env('CLOSURE_SECRET', null), // Unsigned in dev
    ],
];

// In service provider
SerializableClosure::setSecretKey(
    config('services.closure.secret')
);
```

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

### Get Imported Classes

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/ReflectionClosure.md

Retrieves a mapping of imported class aliases to their fully qualified names within the closure's namespace. This helps resolve class references.

```php
protected function getClasses(): array
```

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

### Create a SerializableClosure Instance

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/SerializableClosure.md

Instantiate SerializableClosure by passing a PHP closure. The class automatically selects a serializer (Signed or Native) based on configuration.

```php
use Laravel\SerializableClosure\SerializableClosure;

$closure = function(int $x) {
    return $x * 2;
};

$serializable = new SerializableClosure($closure);
```

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

### Get Built-in PHP Types

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/ReflectionClosure.md

Retrieves a list of all PHP built-in type names used for validation. This includes scalar types and other common types like callable and iterable.

```php
protected static function getBuiltinTypes(): array
```

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

### Get Closure Use Variables

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/ReflectionClosure.md

Extracts variables captured by the closure in its 'use()' clause. Returns an associative array of variable names and their initialized values. This method is inherited from ReflectionFunction.

```PHP
$x = 10;
$y = 20;

$closure = function() use ($x, $y) {
    return $x + $y;
};

$reflector = new ReflectionClosure($closure);
$vars = $reflector->getUseVariables();
// ['x' => 10, 'y' => 20]
```

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

### Prevent Missing Secret Key Exception: Use Explicit Unsigned Mode

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/errors.md

Demonstrates how to bypass the signing requirement by explicitly creating an unsigned SerializableClosure instance.

```php
// Bypass signing requirement
$unsigned = SerializableClosure::unsigned($closure);
$serialized = serialize($unsigned);
```

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

### Hmac Signer Constructor

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Signers-Hmac.md

Initializes a new Hmac Signer instance with a secret key.

```APIDOC
## Hmac Signer Constructor

### Description
Creates a new HMAC signer with the given secret key.

### Signature
```php
public function __construct(string $secret)
```

### Parameters
#### Path Parameters
- **secret** (string) - Required - The secret key for HMAC signing
```

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

### Get Closure Source Code

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/ReflectionClosure.md

Extracts the full source code of the closure, including modifiers like 'static', 'fn', parameter lists, return types, 'use()' clauses, and attributes.

```PHP
$closure = fn($x): int => $x * 2;
$reflector = new ReflectionClosure($closure);

echo $reflector->getCode();
// Output: fn($x): int => $x * 2
```

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

### Complete Closure Serialization Workflow

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/README.md

Demonstrates the full lifecycle of serializing a closure with captured variables, queuing it, and then unserializing it with automatic signature verification. Ensure your application secret key is configured via `env('APP_SECRET')` before serialization.

```php
use Laravel\SerializableClosure\SerializableClosure;
use Laravel\SerializableClosure\Exceptions\InvalidSignatureException;

// 1. Configure in bootstrap
SerializableClosure::setSecretKey(env('APP_SECRET'));

// 2. Define closure with captured variables
$userId = 123;
$closure = fn() => User::find($userId);

// 3. Serialize
$job = new Job(
    new SerializableClosure($closure)
);
queue()->push($job);

// 4. Later, unserialize (with automatic signature verification)
try {
    $restored = unserialize($jobData);
    $user = $restored->getClosure()(); // Gets User with ID 123
} catch (InvalidSignatureException $e) {
    Log::error('Invalid closure signature');
}
```

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

### Project File Organization

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/INDEX.md

This outlines the directory structure for the Serializable Closure project, indicating the purpose of each markdown file and the API reference organization.

```tree
output/
├── README.md                          # Overview and quick start
├── INDEX.md                           # This file
├── configuration.md                   # Configuration options
├── types.md                           # Type definitions
├── errors.md                          # Exception documentation
└── api-reference/
    ├── SerializableClosure.md         # Main class
    ├── UnsignedSerializableClosure.md # Unsigned variant
    ├── Serializers-Native.md          # Core serializer
    ├── Serializers-Signed.md          # Signing wrapper
    ├── Signers-Hmac.md                # HMAC signer
    ├── ReflectionClosure.md           # Reflection utility
    ├── Support-Classes.md             # Internal utilities
    └── Contracts.md                   # Interfaces
```

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

### Serialize and Unserialize Unsigned Closure

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/UnsignedSerializableClosure.md

Demonstrates how to serialize an UnsignedSerializableClosure instance and then unserialize it. The unserialization process does not perform signature verification.

```php
$unsigned = new UnsignedSerializableClosure(fn($x) => $x * 2);
$serialized = serialize($unsigned);
$restored = unserialize($serialized);
echo $restored->getClosure()(5); // 10
```

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

### Create ReflectionClosure Instance

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/ReflectionClosure.md

Instantiate ReflectionClosure with a closure. An optional pre-computed code string can be provided for internal use.

```PHP
use Laravel\SerializableClosure\Support\ReflectionClosure;

$closure = fn($x) => $x * 2;
$reflector = new ReflectionClosure($closure);
```

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

### Directly Configure Static Properties

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/configuration.md

Advanced configuration of internal static properties for serializers. Allows setting custom signers, transformers, and resolvers.

```php
use Laravel\SerializableClosure\Serializers\Native;
use Laravel\SerializableClosure\Serializers\Signed;
use Laravel\SerializableClosure\Signers\Hmac;

// Set custom signer
Signed::$signer = new CustomSigner('secret');

// Set transformer (equivalent to setSecretKey())
Native::$transformUseVariables = function($vars) { /* ... */ };

// Set resolver
Native::$resolveUseVariables = function($vars) { /* ... */ };
```

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

### Usage Notes

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Serializers-Native.md

Illustrates how to customize the serialization and unserialization process for closures using the Native serializer, including transforming and resolving use variables, and handling nested objects within closures.

```APIDOC
## Usage Notes

### Transformation of Use Variables

```php
SerializableClosure::transformUseVariablesUsing(function($variables) {
    // All closures will use this transformation
    // before serialization via Native serializer
    return array_filter($variables);
});

$closure = fn() => $someVar;
$serializer = new Native($closure);
$data = $serializer->__serialize(); // Variables are filtered
```

### Resolution After Unserialization

```php
SerializableClosure::resolveUseVariablesUsing(function($variables) {
    // All closures will use this resolver
    // after unserialization via Native serializer
    return array_map('unserialize', $variables);
});

$data = [...]; // Serialized data
$serializer = new Native(fn() => null);
$serializer->__unserialize($data); // Variables are unserialized
```

### Closure with Nested Objects

```php
class Handler {
    public Closure $callback;
}

$handler = new Handler();
$handler->callback = fn($x) => $x * 2;

$closure = fn() => $handler;
$serializer = new Native($closure);

// The $handler and its $callback are both serialized
$data = $serializer->__serialize();
```
```

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

### UnsignedSerializableClosure::__serialize()

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/UnsignedSerializableClosure.md

Prepares the closure for serialization using PHP's native serialization mechanism. It returns an array containing the internal `Native` serializer instance.

```APIDOC
## Method __serialize()

### Description
Prepares the closure for serialization by PHP's native serialization process. It returns an array containing the internal `Native` serializer instance.

### Method
`__serialize(): array`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
None

### Request Example
```php
$serialized_data = $unsigned->__serialize();
// $serialized_data will be an array like ['serializable' => NativeSerializerInstance]
```

### Response
#### Success Response
`array` — an array with the key `serializable` containing the `Native` serializer instance

### Response Example
```json
{
  "serializable": "[Native Serializer Instance]"
}
```

### Throws
None
```

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

### Handle MissingSecretKeyException Environment-Specific

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/errors.md

Catch MissingSecretKeyException and implement environment-specific logic. In production, re-throw the exception; in development, allow unsigned closures.

```php
try {
    $serialized = serialize(new SerializableClosure($closure));
} catch (MissingSecretKeyException $e) {
    if (app()->environment('production')) {
        throw $e; // Strict in production
    }
    // Permissive in development
    return serialize(SerializableClosure::unsigned($closure));
}
```

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

### SerializableClosure::__serialize()

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/SerializableClosure.md

Prepares the closure for serialization using PHP's native serialization mechanism. It returns an array containing the internal Serializable implementation.

```APIDOC
## __serialize()

### Description
Prepares the closure for serialization via PHP's native serialization. Returns an array with the internal `Serializable` implementation.

### Method
None (Instance Method)

### Endpoint
None (Instance Method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
None

### Request Example
```php
// This method is called internally by PHP's serialize() function.
$serialized_data = serialize($serializable);
```

### Response
#### Success Response
- **array** - Array with key `serializable` containing the `Signed` or `Native` serializer instance

### Response Example
```json
{
  "serializable": { ... serializer instance ... }
}
```

### Throws
None
```

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

### Configure Secret Key for Testing

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/configuration.md

Set a consistent secret key for testing purposes. This ensures predictable signature verification during test runs.

```php
// In test setup
use Laravel\SerializableClosure\SerializableClosure;

beforeEach(function() {
    // Use consistent secret for tests
    SerializableClosure::setSecretKey('test-secret');
});
```

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

### Create Closure from Stream Path

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Support-Classes.md

Illustrates using the `include` statement with a stream path to create a closure directly from a string containing the closure's code. This method preserves magic constants and scope information.

```php
$code = 'fn($x) => $x * 2';
$path = 'laravel-serializable-closure://' . $code;
$closure = include $path; // Closure is created from the code
```

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

### Handling Missing Secret Key Exception

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Signers-Hmac.md

Illustrates how to catch a MissingSecretKeyException, which is thrown when attempting to sign a closure without configuring a secret key. A secret key must be set before signing operations.

```php
use Laravel\SerializableClosure\Exceptions\MissingSecretKeyException;

// If no secret key is set, signing throws
try {
    $signed = new Signed($closure); // Assuming Signed is a class that uses SerializableClosure
    serialize($signed); // Throws MissingSecretKeyException
} catch (MissingSecretKeyException $e) {
    echo 'Configure a secret key first';
}
```

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

### verify()

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Signers-Hmac.md

Verifies if the provided signature is valid for the serialized data.

```APIDOC
## verify()

### Description
Verifies that the signature is valid for the serialized data.

### Signature
```php
public function verify(array $signature): bool
```

### Parameters
#### Path Parameters
- **signature** (array) - Required - Signature array with `serializable` and `hash` keys

### Return
`bool` - true if signature is valid, false otherwise

### Example
```php
$signer = new Hmac('secret');
$signed = $signer->sign($serialized);

// Signature is valid
$isValid = $signer->verify($signed); // true

// Tampered signature fails verification
$tampered = $signed;
$tampered['hash'] = 'invalid-hash';
$isValid = $signer->verify($tampered); // false
```
```

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

### Register Event Listeners with Closures

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/README.md

Register an event listener using a closure. This snippet shows how to attach a callback function to an event.

```php
event()->listen('order.created',
    new SerializableClosure(fn($event) => $this->handleOrder($event))
);
```

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

### Create UnsignedSerializableClosure Instance

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/UnsignedSerializableClosure.md

Instantiate UnsignedSerializableClosure by passing the closure you want to serialize without signing. This constructor always uses the Native serializer.

```php
use Laravel\SerializableClosure\UnsignedSerializableClosure;

$closure = function(string $message) {
    return "Message: {$message}";
};

$unsigned = new UnsignedSerializableClosure($closure);
```

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

### Native Serializer Constructor

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Serializers-Native.md

Creates a new native serializer instance for a given closure. This is the primary way to instantiate the serializer.

```php
public function __construct(Closure $closure)
```

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

### Serialize Closure with Signed Serializer

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Serializers-Signed.md

Shows how to serialize a closure using the Signed serializer, which includes generating an HMAC-SHA256 signature for integrity.

```php
$closure = fn() => 'data';
$signed = new Signed($closure);
$data = $signed->__serialize();
```

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

### Verify Resolver Implementation for Variable Restoration

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/configuration.md

Troubleshoot issues with variables not being available after unserialization by verifying the resolver implementation. This snippet shows how to log restored variables for debugging.

```php
SerializableClosure::resolveUseVariablesUsing(function($vars) {
    // Debug: log what's being restored
    error_log('Variables: ' . json_encode(array_keys($vars)));
    return $vars;
});
```

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

### Closure Scope and Binding

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/README.md

Demonstrates how closures can be bound to objects or class scopes, preserving references to '$this', 'static', 'self', and 'parent'. The library detects and preserves these bindings.

```php
class Handler {
    public function method() {
        return fn() => $this->property;
    }
}

$handler = new Handler();
$closure = $handler->method();
// Closure is bound to $handler and requires its scope
```

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

### Unserialize Closure with Signed Serializer

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Serializers-Signed.md

Illustrates the process of unserializing a closure using the Signed serializer, including setting a secret key and verifying the signature during unserialization.

```php
SerializableClosure::setSecretKey('secret');

$closure = fn() => 'data';
$signed = new Signed($closure);
$data = $signed->__serialize();

// Later, during unserialization:
$restored = new Signed(fn() => null);
$restored->__unserialize($data); // Verifies signature
```

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

### Transmitting Closures Over Network

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Serializers-Signed.md

Shows how to securely transmit closures over a network using the Signed serializer. This involves setting the secret key, serializing the closure, and then unserializing and executing it on the receiving end, with signature verification ensuring integrity.

```php
use Laravel\SerializableClosure\SerializableClosure;

class JobQueue {
    public function dispatch(Closure $callback) {
        SerializableClosure::setSecretKey(env('APP_SECRET'));
        $serialized = serialize(new SerializableClosure($callback));
        return $this->store($serialized);
    }

    public function execute($serializedClosure) {
        SerializableClosure::setSecretKey(env('APP_SECRET'));
        $restored = unserialize($serializedClosure);
        return $restored->getClosure()();
    }
}
```

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

### Dispatch Closure to Queue

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/README.md

Use this snippet to dispatch a closure to a job queue. Ensure the secret key is set before serializing the closure.

```php
use Laravel\SerializableClosure\SerializableClosure;

// Dispatch closure to queue
SerializableClosure::setSecretKey(env('APP_SECRET'));

$job = new ProcessClosure(
    new SerializableClosure(fn() => $this->process())
);

queue()->push($job);
```

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

### Selective Signing with SerializableClosure and UnsignedSerializableClosure

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/UnsignedSerializableClosure.md

Provides a function to selectively sign closures based on a flag. Use signing for critical operations and bypass it for non-critical ones.

```php
use Laravel\SerializableClosure\SerializableClosure;
use Laravel\SerializableClosure\UnsignedSerializableClosure;

function serializeClosure($closure, $requireSignature = false) {
    if ($requireSignature) {
        return serialize(new SerializableClosure($closure));
    } else {
        return serialize(new UnsignedSerializableClosure($closure));
    }
}

// Critical operations use signing
$critical = serializeClosure(fn() => process_payment(), true);

// Non-critical operations don't need signing
$nonCritical = serializeClosure(fn() => log_event(), false);
```

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

### Set Secret Key or Use Unsigned Explicitly

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/configuration.md

Resolve MissingSecretKeyException by either setting a secret key or explicitly using the unsigned option when serializing closures. This prevents errors when signing is attempted without a key.

```php
// Option 1: Set key
SerializableClosure::setSecretKey('secret');

// Option 2: Use unsigned explicitly
$unsigned = SerializableClosure::unsigned($closure);
```

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

### Native Serializer

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/INDEX.md

Implements the default PHP serialization mechanism for SerializableClosure objects.

```APIDOC
## Class Serializers\Native

### Description
Handles the serialization and unserialization of closures using PHP's native serialization capabilities.

### Methods
- `serialize(Serializable $serializable)`: Serializes a Serializable object.
- `unserialize(string $data)`: Unserializes data into a Serializable object.

### Parameters
#### serialize Parameters
- **$serializable** (Serializable) - The object to serialize.

#### unserialize Parameters
- **$data** (string) - The serialized data string.

### Return Types
- `serialize()`: Returns the serialized string.
- `unserialize()`: Returns the unserialized Serializable object.
```

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

### UnsignedSerializableClosure Constructor

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/UnsignedSerializableClosure.md

Creates a new unsigned serializable closure instance. It always wraps the closure with a `Native` serializer, bypassing any globally configured secret key.

```APIDOC
## Constructor UnsignedSerializableClosure

### Description
Creates a new unsigned serializable closure instance, wrapping it with a `Native` serializer regardless of global secret key configuration.

### Method
`__construct(Closure $closure)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **closure** (`\Closure`) - Required - The closure to be serialized without signing.

### Request Example
```php
use Laravel\SerializableClosure\UnsignedSerializableClosure;

$closure = function(string $message) {
    return "Message: {$message}";
};

$unsigned = new UnsignedSerializableClosure($closure);
```

### Response
None

### Response Example
None

### Throws
None
```

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

### SerializableClosure Constructor

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/SerializableClosure.md

Creates a new SerializableClosure instance. It automatically wraps the provided closure with a serializer, either Signed or Native, based on the configuration of a secret key.

```APIDOC
## Constructor SerializableClosure

### Description
Creates a new serializable closure instance. Automatically wraps the closure with either a `Signed` or `Native` serializer based on whether a secret key has been configured.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Method
None (Constructor)

### Endpoint
None (Constructor)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **closure** (`\Closure`) - Required - The closure to be serialized

### Request Example
```php
use Laravel\SerializableClosure\SerializableClosure;

$closure = function(int $x) {
    return $x * 2;
};

$serializable = new SerializableClosure($closure);
```

### Response
None (Constructor)

### Throws
None
```

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

### Signed Serializer Constructor

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Serializers-Signed.md

Creates a new Signed serializer instance for a given closure. This serializer wraps the Native serializer with HMAC signing for integrity verification.

```APIDOC
## `__construct(Closure $closure)`

### Description
Creates a new signed serializer instance for the given closure.

### Method
`__construct`

### Parameters
#### Path Parameters
- **closure** (`\Closure`) - Required - The closure to serialize with signing
```

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

### Direct HMAC Signer Usage

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Signers-Hmac.md

Instantiate the Hmac signer directly to sign and verify serialized closure data. Ensure the secret key is kept secure.

```php
use Laravel\SerializableClosure\Signers\Hmac;

$signer = new Hmac('app-secret-key');

$data = 'some serialized closure data';
$signed = $signer->sign($data);

// Store or transmit $signed

if ($signer->verify($signed)) {
    $original = $signed['serializable'];
    // Use $original
} else {
    throw new Exception('Invalid signature');
}
```

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

### Constructor: ReflectionClosure::__construct

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/ReflectionClosure.md

Creates a new ReflectionClosure instance to analyze a given closure. Optionally accepts pre-computed code for performance.

```APIDOC
## Constructor: ReflectionClosure::__construct

### Description
Creates a new reflection closure instance.

### Method
`__construct(Closure $closure, ?string $code = null)`

### Parameters
#### Path Parameters
- **closure** (`\Closure`) - Required - The closure to reflect
- **code** (`string`|`null`) - Optional - Pre-computed code (for internal use)

### Example
```php
use Laravel\SerializableClosure\Support\ReflectionClosure;

$closure = fn($x) => $x * 2;
$reflector = new ReflectionClosure($closure);
```
```

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

### Test Hmac Signature Validation

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/errors.md

Demonstrates how to use the Hmac signer to sign and verify serialized data. Includes tests for valid signatures and detection of tampering.

```php
use Laravel\SerializableClosure\Signers\Hmac;

$signer = new Hmac('secret');
$serialized = serialize(['test' => 'data']);
$signed = $signer->sign($serialized);

// Verify it works
if ($signer->verify($signed)) {
    echo "Signature valid";
}

// Verify tampering is detected
$tampered = $signed;
$tampered['hash'] = 'invalid';
if (!$signer->verify($tampered)) {
    echo "Tampering detected";
}
```

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

### sign()

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Signers-Hmac.md

Signs the serialized closure data using HMAC-SHA256 and returns the signature.

```APIDOC
## sign()

### Description
Signs the serialized closure data and returns the signature.

### Signature
```php
public function sign(string $serialized): array
```

### Parameters
#### Path Parameters
- **serialized** (string) - Required - The serialized closure data from `serialize()`

### Return
`array` - signature array with keys:
- `serializable`: The original serialized data (unchanged)
- `hash`: Base64-encoded HMAC-SHA256 hash

### Example
```php
$signer = new Hmac('secret');
$serialized = serialize([
    'use' => [],
    'function' => 'fn() => "test",
    'scope' => null,
    'this' => null,
    'self' => 'abc123'
]);

$signed = $signer->sign($serialized);
// $signed = [
//     'serializable' => $serialized,
//     'hash' => 'base64EncodedHash...'
// ]
```
```

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

### Handle Mismatched Signing Configuration

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/errors.md

Shows how to catch InvalidSignatureException when a signed closure is unserialized without a secret key configured. This prevents verification.

```PHP
// Serialized with a secret key
$serialized = serialize(new SerializableClosure($closure));

// Try to unserialize without setting a key
SerializableClosure::setSecretKey(null);

try {
    unserialize($serialized); // Throws InvalidSignatureException
} catch (InvalidSignatureException $e) {
    // The closure was signed but we have no key to verify
}
```

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

### Lazy Load Dependencies After Unserialization

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/configuration.md

Implement lazy loading for expensive services by resolving them only when the closure is unserialized. This improves performance by deferring the instantiation of heavy objects.

```php
SerializableClosure::resolveUseVariablesUsing(function($variables) {
    foreach ($variables as &$value) {
        if ($value === '__lazy__') {
            $value = app()->make('ExpensiveService');
        }
    }
    return $variables;
});
```

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

### __invoke()

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Serializers-Native.md

Invokes the wrapped closure with the provided arguments. Any exceptions thrown by the closure will be propagated.

```APIDOC
## __invoke()

### Description
Invokes the wrapped closure with given arguments.

### Parameters
Variadic arguments passed to the closure.

### Return
Mixed — the return value of the closure.

### Throws
Any exception thrown by the closure.

### Example
```php
$closure = fn($x) => $x * 2;
$native = new Native($closure);
echo $native(5); // 10
```
```

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

### Debug Closure Signing and Verification

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/README.md

Provides helper code to check if a closure has been signed and to verify the implementation of a signer. This is useful for debugging signature-related issues.

```php
// Check if closure is signed
$data = serialize(new SerializableClosure($closure));
if (str_contains($data, 'Signed')) {
    echo "Closure is signed\n";
}

// Verify signer implementation
$signer = new Hmac('secret');
$signed = $signer->sign('data');
echo "Valid: " . ($signer->verify($signed) ? 'yes' : 'no') . "\n";
```

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

### Throw Custom Missing Secret Key Exception

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/errors.md

Illustrates how to manually throw a MissingSecretKeyException with a custom error message.

```php
throw new MissingSecretKeyException(
    'Secret key required for closure signing in production'
);
```

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

### Using SerializableClosure with HMAC

Source: https://github.com/laravel/serializable-closure/blob/2.x/_autodocs/api-reference/Signers-Hmac.md

Utilize the SerializableClosure class, which internally uses the Hmac signer. Set a secret key for the application to enable signing and verification during serialization and deserialization.

```php
use Laravel\SerializableClosure\SerializableClosure;

// This creates an Hmac signer internally
SerializableClosure::setSecretKey('production-secret');

$closure = fn($x) => $x * 2;
$serializable = new SerializableClosure($closure);

// Serialization internally uses the Hmac signer
$serialized = serialize($serializable);

// Unserialization verifies the signature
$restored = unserialize($serialized); // Throws if signature invalid
```
Tokens:
Raw