# StoreException

## Overview

`StoreException` is a base exception class in the Midnite81\Guardian package. This exception serves as the parent class for all storage-related exceptions in the Guardian rate limiting system.

## Class Details

* **Namespace**: `Midnite81\Guardian\Exceptions\Store`
* **Extends**: `Exception`

## Purpose

The primary purpose of this exception is to provide a common base for all storage-related exceptions in the Guardian system. It allows for consistent handling of storage issues regardless of the specific storage implementation being used (e.g., DatabaseStore, RedisStore, FileStore).

## Hierarchy

`StoreException` is the parent class for more specific storage exceptions:

```
Exception
└── StoreException
    ├── DatabaseStoreException
    ├── RedisStoreException
    └── FileStoreException
```

This hierarchy allows for both general and specific exception handling depending on the needs of your application.

## Usage

While you typically won't throw `StoreException` directly, you might catch it to handle any storage-related exception in a general way:

```php
use Midnite81\Guardian\Exceptions\Store\StoreException;

try {
    // Your Guardian code using any storage method
    $guardian->send(function() {
        // Your rate-limited code here
    });
} catch (StoreException $e) {
    // Handle any storage-related exception
    error_log("Guardian storage error: " . $e->getMessage());
    // Implement fallback behavior
}
```

## Best Practices

1. Use `StoreException` for catch-all handling of storage issues when you don't need to distinguish between specific storage types.
2. Implement more specific exception handling (e.g., `DatabaseStoreException`) when you need to react differently based on the storage type.
3. Always log the full exception details for debugging purposes.
4. Consider implementing a fallback mechanism or graceful degradation when any storage exception occurs.

## Error Messages

The error messages for this exception will vary depending on the specific subclass that is thrown. However, all will relate to storage operations within the Guardian system.

## Integration with Guardian

`StoreException` is fundamental to Guardian's error handling system for storage operations. It provides a consistent way to catch and handle any storage-related issues, regardless of the specific storage implementation being used.

## Extending StoreException

If you're implementing a custom storage solution for Guardian, you should create a custom exception that extends `StoreException`. For example:

```php
use Midnite81\Guardian\Exceptions\Store\StoreException;

class CustomStoreException extends StoreException
{
    // Add any custom functionality here
}
```

## Security Considerations

When handling `StoreException` or its subclasses, be careful not to expose sensitive information about your storage system in user-facing error messages. Always log the full exception details securely, but provide only general error messages to end-users.

## Troubleshooting

If you're frequently encountering `StoreException` or its subclasses:

1. Review your storage configuration (database settings, Redis connection, file permissions, etc.).
2. Ensure your chosen storage system is properly set up and accessible.
3. Check for common issues like disk space, connection limits, or permission problems.
4. Consider implementing a monitoring system to alert you of persistent storage issues.

## Performance Implications

While `StoreException` itself doesn't directly impact performance, frequent storage exceptions can significantly affect your application's performance and reliability. Monitor the frequency of these exceptions and address underlying issues promptly.

By properly handling `StoreException` and its subclasses, you can ensure that your application gracefully manages storage-related issues in the Guardian rate limiting system, maintaining reliability across different storage implementations. This base exception class provides a flexible foundation for robust error handling in Guardian's storage operations.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://guardian.midnite.uk/exceptions/store-exception.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.