Laravel Versionable

https://github.com/overtrue/laravel-versionable
Admin
Laravel Versionable provides a minimalist way to make Eloquent models support version history,...
Tokens:46,627
Snippets:578
Trust Score:9.8
License:MIT
Update:2 months ago
Show doc for...
Tokens:
Raw
### Installation and Setup Example

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/service-provider.md

Demonstrates the typical installation and setup process for the laravel-versionable package in a fresh Laravel application.

```bash
# In a fresh Laravel installation
composer require overtrue/laravel-versionable
php artisan vendor:publish --provider="Overtrue\LaravelVersionable\ServiceProvider"
php artisan migrate
```

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

### Install Laravel Versionable

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/README.md

Install the package via Composer, publish its assets, and run migrations to set up the versions table.

```bash
composer require overtrue/laravel-versionable
php artisan vendor:publish --provider="Overtrue\LaravelVersionable\ServiceProvider"
php artisan migrate
```

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

### Customized Versionable Configuration Example

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/service-provider.md

An example of how to customize the versionable configuration, such as increasing the number of versions to keep or enabling UUIDs.

```php
// config/versionable.php
return [
    'keep_versions' => 10,
    'uuid' => true,
];
```

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

### Install Laravel Versionable

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/README.md

Install the package using Composer. This command fetches and installs the latest version of the library.

```shell
composer require overtrue/laravel-versionable -vvv
```

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

### Install Laravel Versionable Package

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/service-provider.md

Install the package using Composer.

```bash
composer require overtrue/laravel-versionable
```

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

### Install and Test Laravel Versionable

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/AGENTS.md

Commands to install dependencies, run tests, and check code style for the overtrue/laravel-versionable package.

```bash
composer install
composer test
composer check-style
```

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

### Minimal Model Setup with Versionable Trait

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/README.md

Basic integration of the Versionable trait into an Eloquent model. This setup versions all attributes except timestamps.

```php
class Post extends Model
{
    use Versionable;
}
```

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

### Model Setup with Whitelist

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/README.md

Configures versioning to only include specified attributes by using the $versionable property. Recommended for selective versioning.

```php
class Post extends Model
{
    use Versionable;
    
    protected $versionable = ['title', 'content', 'slug'];
}
```

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

### Custom Version Model Example

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/configuration.md

Example of a custom version model extending the base Version class, with a custom table name and relationship.

```php
namespace App\Models;

use Overtrue\LaravelVersionable\Version;

class PostVersion extends Version
{
    protected $table = 'post_versions';
    
    public function post()
    {
        return $this->belongsTo(Post::class, 'versionable_id');
    }
}
```

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

### Model Setup with Custom Configuration

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/README.md

Allows for advanced customization of versioning behavior, including specifying the version model, user foreign key, and version strategy.

```php
class Post extends Model
{
    use Versionable;

    protected $versionable = ['title', 'content'];
    protected $versionStrategy = VersionStrategy::SNAPSHOT;
    public string $versionModel = CustomVersion::class;
    public string $userForeignKeyName = 'editor_id';
}
```

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

### Array Type Example

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/types.md

Shows methods that operate on arrays, such as setting versionable attributes, removing versions by ID, or specifying options for diffing and rendering.

```php
// Array of attribute names
public function setVersionable(array $attributes): static

// Array of version IDs
public function removeVersions(array $ids)

// Array of differ/render options
public function diff(?Version $toVersion = null, array $differOptions = [], array $renderOptions = []): Diff
```

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

### Get Version Strategy

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/versionable-trait.md

Retrieves the version storage strategy for the model. This can be either DIFF or SNAPSHOT.

```php
public function getVersionStrategy(): VersionStrategy
```

```php
$strategy = $post->getVersionStrategy();
if ($strategy === VersionStrategy::DIFF) {
    echo "Storing diffs";
}
```

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

### Nullable Return Type Example

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/types.md

Illustrates methods that may return null, indicated by the '?Type' signature, such as when a version doesn't exist or a previous version is unavailable.

```php
// Returns null if version doesn't exist at that time
public function versionAt($time = null, $tz = null): ?Version

// Returns null if no previous version exists
public function previousVersion(): ?static

// Returns null if versionable was deleted
public function revertWithoutSaving(): ?Model
```

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

### Union Return Type Example

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/types.md

Demonstrates methods that accept multiple types using union types, such as accepting either an integer or string for IDs, or an enum or string for strategy.

```php
// Accepts either int or string (for numeric or UUID IDs)
public function getVersion(int|string $id): ?Version

// Accepts either VersionStrategy enum or string
public function setVersionStrategy(VersionStrategy|string $strategy): static
```

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

### Accessing Oldest Versions of a Model

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/versionable-trait.md

Get a query builder for versions ordered from oldest to latest. Useful for fetching historical data, for example, the oldest 5 versions.

```php
$post = Post::find(1);
$oldVersions = $post->oldestVersions()->take(5)->get();
```

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

### Accessing Latest Versions of a Model

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/versionable-trait.md

Get a query builder for versions ordered from latest to oldest. Useful for fetching recent history, for example, the latest 5 versions.

```php
$post = Post::find(1);
$recentVersions = $post->latestVersions()->take(5)->get();
```

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

### Get All Versions for a Model

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/database-schema.md

Retrieves all historical versions for a specific model instance. This is useful for auditing or displaying a complete history.

```php
Post::find(1)->versions()->get();
```

```sql
SELECT * FROM versions 
WHERE versionable_type = 'App\Models\Post' 
AND versionable_id = 1
AND deleted_at IS NULL
ORDER BY created_at DESC;
```

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

### Querying Versions with Nullable User ID

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/database-schema.md

Provides examples for querying versions based on the presence or absence of a 'user_id', and safely accessing the associated user.

```php
// Versions with user
$versions = $post->versions()->whereNotNull('user_id')->get();

// System versions (no user)
$systemVersions = $post->versions()->whereNull('user_id')->get();

// Get user safely
$user = $version->user; // Returns null if no user_id
```

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

### Optimized Version Query Example

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/database-schema.md

Demonstrates how the composite index on `versions(versionable_type, versionable_id)` optimizes queries to fetch all versions for a specific model instance, such as retrieving all versions of a `Post` with ID 1.

```php
Post::find(1)->versions()->get() // Uses index
```

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

### Get trashed versions

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/versionable-trait.md

Use `getTrashedVersions` to retrieve a collection of all versions that have been soft-deleted.

```php
public function getTrashedVersions(): Collection
```

```php
$trashed = $post->getTrashedVersions();
```

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

### DIFF Strategy JSON Content Example

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/database-schema.md

Illustrates the JSON structure for the `contents` column when using the DIFF strategy. Only the attributes that have changed since the last version are stored.

```json
{
  "title": "Updated Title",
  "slug": "updated-slug"
}
```

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

### Service Provider Class Definition

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/service-provider.md

Defines the ServiceProvider class, extending Illuminate\Support\ServiceProvider. It includes boot() and register() methods for package setup.

```php
class ServiceProvider extends \Illuminate\Support\ServiceProvider
{
    public function boot(): void
    public function register(): void
}
```

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

### Get Next Version - Laravel Versionable

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/version-model.md

Retrieve the single version that immediately follows the current one. Returns null if no next version exists.

```php
public function nextVersion(): ?static
```

```php
$v2 = $post->getVersion(2);
$v3 = $v2->nextVersion();
```

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

### Basic Diff Comparison

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/diff-class.md

Compares two specific versions of a Post model to get the differences.

```php
$post = Post::find(1);
$v1 = $post->getVersion(1);
$v2 = $post->getVersion(2);

// Compare v1 to v2
$diff = $v1->diff($v2);
```

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

### SNAPSHOT Strategy JSON Content Example

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/database-schema.md

Illustrates the JSON structure for the `contents` column when using the SNAPSHOT strategy. All versionable attributes of the model are stored in this JSON object.

```json
{
  "id": 1,
  "title": "Updated Title",
  "content": "Full content here",
  "slug": "updated-slug",
  "user_id": 5,
  "created_at": "2024-01-15 10:00:00",
  "updated_at": "2024-01-16 11:30:00"
}
```

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

### Model Setup with Blacklist

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/README.md

Excludes specific attributes from versioning by using the $dontVersionable property. Useful for preventing sensitive or auto-updating fields from being versioned.

```php
class Post extends Model
{
    use Versionable;
    
    protected $dontVersionable = ['created_at', 'updated_at'];
}
```

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

### Create and Update Models

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/README.md

Versions are automatically created when a versionable model is saved. This example shows creating a new post and then updating its title.

```php
$post = Post::create(['title' => 'version1', 'content' => 'version1 content']);
$post->update(['title' => 'version2']);
```

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

### Polymorphic Relationship Example

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/database-schema.md

Demonstrates how the `versionable_id` and `versionable_type` columns enable tracking versions for different model types within the same `versions` table. This allows querying versions for Posts, Pages, and Articles using their respective model instances.

```php
Post::find(1)->versions()     // Post#1 versions
Page::find(5)->versions()     // Page#5 versions
Article::find(2)->versions()  // Article#2 versions
```

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

### Compare Two Versions

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/common-patterns.md

Get two specific versions of a model and calculate the differences between them. The diff can be converted to an array for further processing.

```php
$v1 = $post->getVersion(1);
$v2 = $post->getVersion(2);

$diff = $v1->diff($v2);
$array = $diff->toArray();
// ['title' => ['old' => '...', 'new' => '...'], ...]
```

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

### Get Previous Version - Laravel Versionable

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/version-model.md

Retrieve the single version that immediately precedes the current one. Returns null if no previous version exists.

```php
public function previousVersion(): ?static
```

```php
$v2 = $post->getVersion(2);
$v1 = $v2->previousVersion();
```

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

### VersionStrategy Enum Usage

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/api-index.md

Demonstrates how to use the VersionStrategy enum for managing versionable attributes. Includes examples of assigning cases, accessing their string values, and creating enum instances from strings.

```PHP
use Overtrue\LaravelVersionable\VersionStrategy;

// Use as enum
$strategy = VersionStrategy::DIFF;

// Convert to string
$value = $strategy->value;

// Create from string
$strategy = VersionStrategy::from('DIFF');
$strategy = VersionStrategy::tryFrom('diff'); // Case-sensitive, returns null
```

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

### Get Versionable Attributes

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/versionable-trait.md

Retrieves the whitelist of attributes that are tracked for versioning. If the list is empty, all attributes except blacklisted ones are tracked.

```php
public function getVersionable(): array
```

```php
$attrs = $post->getVersionable(); // ['title', 'content']
```

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

### Get Number of Versions to Keep

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/versionable-trait.md

Retrieves the configured number of versions to retain. This setting is used by the auto-cleanup logic. A value of 0 means all versions are kept.

```php
public function getKeepVersionsCount(): string
```

```php
$keep = $post->getKeepVersionsCount();
```

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

### Get Diff as Context Text Format

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/diff-class.md

Renders the differences between two versions in a context format, similar to the output of the `diff -c` command. This format highlights changes with surrounding unchanged lines.

```php
public function toContextText(array $differOptions = [], array $renderOptions = [], bool $stripTags = false): array
```

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

### Publish and Run Migrations

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/configuration.md

Commands to publish the package's migration files and then run them to create the necessary database tables for versioning.

```bash
php artisan vendor:publish --provider="Overtrue\LaravelVersionable\ServiceProvider" --tag=migrations
php artisan migrate
```

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

### Get Version Difference Statistics

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/common-patterns.md

Retrieve statistics about the differences between versions, including the number of inserted and deleted lines, and the percentage of changes. This can be used to detect major revisions.

```php
$diff = $post->getVersion(3)->diff();
$stats = $diff->getStatistics();

echo "Added: {$stats['inserted']} lines";
echo "Removed: {$stats['deleted']} lines";
echo "Changed: " . ($stats['changedRatio'] * 100) . "%";

// Large change detection
if ($stats['inserted'] + $stats['deleted'] > 100) {
    echo "Major revision";
}
```

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

### Prepare for 6.0: Avoid Deprecated Methods

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/migration-guide.md

Methods like `createVersion()` and `history()` are deprecated in 5.x and will be removed in 6.0. Use the recommended alternatives for future compatibility.

```php
// Don't use these in new code
$post->createVersion(); // Will be removed
$post->history();       // Will be removed

// Use these instead
// Just call save() — versioning is automatic
$post->update([...]);

// Use latestVersions()
$versions = $post->latestVersions();
```

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

### Get Diff as Unified Text Format

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/diff-class.md

Renders the differences between two versions in a unified text format, similar to the output of the `diff -u` command. This format is suitable for displaying changes in a standard text-based diff view.

```php
$diff = $post->getVersion(2)->diff();
$text = $diff->toText();
// Each attribute shows unified diff format like:
// @@ -1,3 +1,3 @@
//  unchanged line
// -removed line
// +added line
```

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

### Publish Configuration and Migrations

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/README.md

Publish the package's configuration file and database migrations using the Artisan command. This sets up the necessary files for the package.

```bash
php artisan vendor:publish --provider="Overtrue\LaravelVersionable\ServiceProvider"
```

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

### Get Attributes Not Versioned

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/versionable-trait.md

Retrieves the blacklist of attributes that should be excluded from versioning.

```php
public function getDontVersionable(): array
```

```php
$excluded = $post->getDontVersionable();
```

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

### Basic Versioning Operations in PHP

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/README.md

Demonstrates creating, updating, and accessing versions of a model. Includes retrieving all versions, the latest version, a specific version by ID, and comparing versions.

```php
// Automatic versioning
$post = Post::create(['title' => 'First', 'content' => 'Hello']);
$post->update(['title' => 'Updated']);

// Access versions
$post->versions;           // All versions
$post->latestVersion;      // Latest
$post->getVersion(1);      // By ID

// Compare versions
$diff = $post->getVersion(1)->diff($post->getVersion(2));
$html = $diff->toHtml();

// Revert
$post->revertToVersion(1);
```

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

### Republish Configuration

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/migration-guide.md

Use this command to republish the configuration file. Backup your current config first and manually merge any custom settings back.

```bash
# Backup current config
cp config/versionable.php config/versionable.php.bak

# Republish
php artisan vendor:publish --provider="Overtrue\LaravelVersionable\ServiceProvider" --tag=config --force

# Manually merge any custom settings back
```

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

### Environment-Specific Configuration for Versionable

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/migration-guide.md

Configure versionable settings using environment variables. Set the number of versions to keep and whether to use UUIDs.

```php
// config/versionable.php
return [
    'keep_versions' => (int) env('VERSIONABLE_KEEP_VERSIONS', 0),
    'uuid' => (bool) env('VERSIONABLE_USE_UUID', false),
    // ...
];
```

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

### Get Change Statistics

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/diff-class.md

Retrieves statistics about the changes between two versions, such as the number of inserted or deleted lines.

```php
$diff = $post->getVersion(2)->diff();

$stats = $diff->getStatistics();
if ($stats['inserted'] > 100) {
    echo "Large change: {$stats['inserted']} lines added";
}
```

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

### Basic Versioning Operations

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/README.md

Demonstrates creating, updating, retrieving, comparing, and reverting model versions. Ensure the `Versionable` trait is applied to your model.

```php
$post = Post::create(['title' => 'Hello', 'content' => 'World']);
$post->versions()->count(); // 1

$post->update(['title' => 'Updated']);
$post->versions()->count(); // 2

$v1 = $post->getVersion(1);
$v2 = $post->getVersion(2);

$diff = $v1->diff($v2);
echo $diff->toHtml();

$post->revertToVersion(1);
$post->title; // 'Hello'
```

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

### Get Versionable Model

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/version-model.md

Retrieve the original model instance that a version record tracks using the versionable() polymorphic relationship.

```php
public function versionable(): MorphTo
```

```php
$version = Version::find(1);
$post = $version->versionable; // Retrieves the Post model
```

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

### Run Database Migrations

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/README.md

Execute the database migrations to create the necessary tables for versioning. This command applies the schema changes to your database.

```bash
php artisan migrate
```

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

### Generic Collection Type Hinting

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/types.md

Illustrates how generic collections, specifically for Version models, are represented in type hints and property documentation.

```php
// Represents a collection of Version models
Collection<Version>

// Represented in property documentation as:
/** @property Collection<Version> $versions */
```

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

### Get Diff in Different Formats

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/diff-class.md

Retrieves the differences in various formats including array, HTML, text, and side-by-side HTML.

```php
// Plain array
$array = $diff->toArray();
// [ 'title' => ['old' => '...', 'new' => '...'], ... ]

// HTML for display
$html = $diff->toHtml();

// Text representation
$text = $diff->toText();

// Side-by-side HTML
$sideBySide = $diff->toSideBySideHtml();
```

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

### Accessing Merged Configuration

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/service-provider.md

Illustrates how to access configuration values after they have been merged by the service provider.

```php
// In any class after service provider registers
$keepVersions = config('versionable.keep_versions'); // 0 or user value
$userModel = config('versionable.user_model');
```

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

### Get Version Model Class

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/versionable-trait.md

Retrieves the class name of the model used for storing version data. Defaults to the Version::class.

```php
public function getVersionModel(): string
```

```php
$modelClass = $post->getVersionModel();
```

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

### Configuration Methods

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/api-index.md

Methods for configuring versioning behavior.

```APIDOC
## getVersionable()

### Description
Get the whitelist of attributes that are tracked for versioning.

### Returns
array

### Parameters
None
```

```APIDOC
## setVersionable(attrs)

### Description
Set the whitelist of attributes to be tracked for versioning at runtime.

### Returns
static

### Parameters
- **attrs** (array) - Required - An array of attribute names to track.
```

```APIDOC
## getDontVersionable()

### Description
Get the blacklist of attributes that are excluded from versioning.

### Returns
array

### Parameters
None
```

```APIDOC
## setDontVersionable(attrs)

### Description
Set the blacklist of attributes to be excluded from versioning at runtime.

### Returns
static

### Parameters
- **attrs** (array) - Required - An array of attribute names to exclude.
```

```APIDOC
## getVersionStrategy()

### Description
Get the current version storage strategy (DIFF or SNAPSHOT).

### Returns
VersionStrategy

### Parameters
None
```

```APIDOC
## setVersionStrategy(s)

### Description
Set the version storage strategy at runtime.

### Returns
static

### Parameters
- **s** (VersionStrategy|string) - Required - The version strategy to set (e.g., 'DIFF', 'SNAPSHOT').
```

```APIDOC
## getVersionModel()

### Description
Get the class name of the version model used for storing versions.

### Returns
string

### Parameters
None
```

```APIDOC
## getVersionUserId()

### Description
Get the user ID associated with the current version creation.

### Returns
int|null

### Parameters
None
```

```APIDOC
## getKeepVersionsCount()

### Description
Get the configured number of versions to keep.

### Returns
string

### Parameters
None
```

```APIDOC
## shouldBeVersioning()

### Description
Check if the current attribute changes should trigger versioning.

### Returns
bool

### Parameters
None
```

```APIDOC
## getVersionableAttributes(s, r)

### Description
Get the attributes that are trackable based on the version strategy and relation.

### Returns
array

### Parameters
- **s** (VersionStrategy) - Required - The version strategy.
- **r** (array) - Required - The relation attributes.
```

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

### Test Basic Versionable Functionality

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/migration-guide.md

Use Tinker to create, update, check, and revert model versions.

```bash
php artisan tinker

# Create a post
$post = Post::create(['title' => 'First', 'content' => 'Hello']);

# Verify version created
$post->versions()->count();  // Should be 1

# Update it
$post->update(['title' => 'Updated']);

# Check versions
$post->versions()->count();  // Should be 2

# View version data
$post->getVersion(1)->contents;  // ['title' => 'First', 'content' => 'Hello']
$post->getVersion(2)->contents;  // ['title' => 'Updated']

# Revert
$post->revertToVersion(1);
$post->title;  // Back to 'First'

exit
```

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

### Version Strategy: SNAPSHOT

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/README.md

Uses the SNAPSHOT strategy to store the complete state for every version. This offers faster access but consumes more storage.

```php
protected $versionStrategy = VersionStrategy::SNAPSHOT;
```

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

### Get Latest Version of a Model

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/database-schema.md

Retrieves the most recent version of a specific model instance. Useful for displaying the current state or the latest changes.

```php
Post::find(1)->latestVersion;
```

```sql
SELECT * FROM versions 
WHERE versionable_type = 'App\Models\Post' 
AND versionable_id = 1
AND deleted_at IS NULL
ORDER BY created_at DESC LIMIT 1;
```

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

### Manage Soft Deleted Versions

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/version-model.md

Demonstrates common operations for soft-deleted versions: deleting, force deleting, querying only trashed versions, and restoring them.

```php
// Soft delete a version
$version->delete();
```

```php
// Force delete (permanent)
$version->forceDelete();
```

```php
// Query only soft-deleted versions
$trashed = $post->versions()->onlyTrashed()->get();
```

```php
// Restore
$version->restore();
```

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

### Merge Configuration Implementation

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/service-provider.md

Shows how the package configuration is merged with the application's configuration using mergeConfigFrom.

```php
$this->mergeConfigFrom(
    __DIR__.'/../config/versionable.php',
    'versionable'
);
```

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

### Limit Storage - Global Configuration

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/getting-started.md

Configure the global setting for how many versions to keep by default. This is set in the `config/versionable.php` file.

```php
// config/versionable.php
return [
    'keep_versions' => 10, // Automatically keeps only 10 latest
];
```

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

### Accessing VersionStrategy Enum Cases

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/types.md

Demonstrates how to access the specific cases of the VersionStrategy enum, DIFF and SNAPSHOT.

```php
VersionStrategy::DIFF
```

```php
VersionStrategy::SNAPSHOT
```

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

### Get Versions by User

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/database-schema.md

Retrieves all historical versions of a model that were created or modified by a specific user. Useful for tracking changes made by individual users.

```php
Post::find(1)->versions()->where('user_id', 5)->get();
```

```sql
SELECT * FROM versions 
WHERE versionable_type = 'App\Models\Post' 
AND versionable_id = 1
AND user_id = 5
AND deleted_at IS NULL;
```

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

### React to Version Creation

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/common-patterns.md

Listen for the 'updated' model event to trigger actions after a new version is created. Ensure the model should be versioned before dispatching an event.

```php
class Post extends Model
{
    use Versionable;

    protected static function booted()
    {
        static::updated(function ($post) {
            // After update (and version created), send notification
            if ($post->shouldBeVersioning()) {
                event(new PostVersioned($post));
            }
        });
    }
}
```

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

### Get Model Version at Specific Time

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/database-schema.md

Retrieves the version of a model as it existed at a particular timestamp. This is valuable for historical analysis or restoring to a past state.

```php
Post::find(1)->versionAt('2024-01-15 12:00:00');
```

```sql
SELECT * FROM versions 
WHERE versionable_type = 'App\Models\Post' 
AND versionable_id = 1
AND created_at <= '2024-01-15 12:00:00'
AND deleted_at IS NULL
ORDER BY created_at DESC LIMIT 1;
```

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

### nextVersion()

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/version-model.md

Returns the single version immediately after this one.

```APIDOC
## nextVersion()

### Description
Returns the single version immediately after this one.

### Returns
`Version|null`

### Example
```php
$v2 = $post->getVersion(2);
$v3 = $v2->nextVersion();
```
```

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

### Basic Usage of Versionable Models

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/DOCUMENTATION-INDEX.md

Create, update, and interact with versioned models. Access version history, compare versions, and revert to previous states.

```php
$post = Post::create(['title' => 'Hello']);    // v1 created
$post->update(['title' => 'World']);           // v2 created

$post->versions;                    // All versions
$post->getVersion(1)->diff();       // What changed
$post->revertToVersion(1);          // Back to v1
```

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

### Migrate createVersion() to automatic versioning

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/migration-guide.md

In version 5.x, `createVersion()` is removed and versioning is automatic on save. Use `update()` instead.

```php
// Old (4.x)
$post->createVersion(['title' => 'New Title']);

// New (5.x) - Versions are created automatically
$post->update(['title' => 'New Title']);
```

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

### Default Versionable Configuration

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/service-provider.md

The default configuration file for the versionable package. Customize settings like version retention and user foreign key here.

```php
<?php

use App\Models\User;
use Overtrue\LaravelVersionable\Version;

return [
    'keep_versions' => 0,
    'user_foreign_key' => 'user_id',
    'version_model' => Version::class,
    'user_model' => User::class,
    'uuid' => false,
];
```

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

### Get Version User ID

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/versionable-trait.md

Retrieves the user ID associated with created versions. It defaults to the model's 'user_id' attribute or the currently authenticated user.

```php
public function getVersionUserId(): int|null
```

```php
$userId = $post->getVersionUserId();
```

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

### Configuration Options for Versionable

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/README.md

Defines settings for versioning, such as how many versions to keep, foreign key names, and model classes. Set 'keep_versions' to 0 to retain all historical versions.

```php
return [
    'keep_versions' => 0,                                    // 0 = keep all
    'user_foreign_key' => 'user_id',                        // FK column name
    'version_model' => \Overtrue\LaravelVersionable\Version::class,
    'user_model' => \App\Models\User::class,
    'uuid' => false,                                        // Use UUID IDs?
];
```

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

### Getting Version Change Statistics

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/README.md

Retrieves and displays the number of lines added and removed between two versions of a model. This uses the `diff` method and its `getStatistics` helper.

```php
$stats = $post->getVersion(2)->diff()->getStatistics();
echo "Added {$stats['inserted']}, removed {$stats['deleted']} lines";
```

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

### Project File Structure

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/DOCUMENTATION-INDEX.md

This tree displays the organization of the project's documentation files, indicating the purpose of each file.

```tree
/output/
├── README.md                      ← START HERE
├── DOCUMENTATION-INDEX.md         ← You are here
├── getting-started.md             ← Installation & basics
├── api-index.md                   ← Quick method lookup
├── versionable-trait.md           ← Full Versionable API
├── version-model.md               ← Full Version API
├── diff-class.md                  ← Full Diff API
├── types.md                       ← Types & enums
├── configuration.md               ← Config options
├── service-provider.md            ← ServiceProvider
├── database-schema.md             ← Database structure
├── common-patterns.md             ← Best practices
└── migration-guide.md             ← Version upgrades
```

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

### Default Configuration

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/getting-started.md

Edit config/versionable.php to customize package settings like version retention, foreign keys, and model configurations. Set 'keep_versions' to 0 to retain all versions.

```php
return [
    // Keep only 10 latest versions (older ones auto-deleted)
    // 0 = keep all versions
    'keep_versions' => 0,

    // Foreign key in versions table
    'user_foreign_key' => 'user_id',

    // Model for versions
    'version_model' => \Overtrue\LaravelVersionable\Version::class,

    // User model
    'user_model' => \App\Models\User::class,

    // Use UUID for version IDs (instead of auto-increment)
    'uuid' => false,
];
```

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

### Create a Custom Version Model

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/version-model.md

Extend the base `Version` class to create a custom version model. Define the table name and override methods like `getOriginalModel` to add specific behavior.

```php
namespace App\Models;

use Overtrue\LaravelVersionable\Version;

class PostVersion extends Version
{
    protected $table = 'post_versions';
    
    public function getOriginalModel()
    {
        return $this->versionable;
    }
}
```

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

### Get User Who Created Version

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/version-model.md

Access the user who created a specific version through the user() relationship. This relationship automatically includes soft-deleted users if the user model supports it.

```php
public function user(): ?BelongsTo
```

```php
$version = $post->versions()->first();
echo $version->user->name;
```

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

### Dynamic Configuration with Environment Variables

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/configuration.md

Configure version keeping and UUID usage dynamically using Laravel's env() helper. Default values are provided if the environment variables are not set.

```php
'keep_versions' => (int) env('VERSIONABLE_KEEP_VERSIONS', 0),
'uuid' => (bool) env('VERSIONABLE_USE_UUID', false),
```

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

### Get System Versions (No User)

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/database-schema.md

Retrieves historical versions of a model that were not associated with a specific user (system-generated changes). Useful for distinguishing automated updates from user actions.

```php
Post::find(1)->versions()->whereNull('user_id')->get();
```

```sql
SELECT * FROM versions 
WHERE versionable_type = 'App\Models\Post' 
AND versionable_id = 1
AND user_id IS NULL
AND deleted_at IS NULL;
```

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

### toContextText

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/diff-class.md

Renders the differences between two versions in a context format, similar to the output of `diff -c`.

```APIDOC
## toContextText

### Description
Renders diff in context format (similar to `diff -c`).

### Method
public

### Parameters
#### Other Parameters
- **differOptions** (array) - Optional - Override differ options
- **renderOptions** (array) - Optional - Override renderer options
- **stripTags** (bool) - Optional - Remove HTML tags

### Response
#### Success Response
- **array** - Keyed by attribute name, each contains context diff format
```

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

### Get Previous Versions - Laravel Versionable

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/version-model.md

Retrieve a query builder for all versions preceding the current one, ordered by latest first. This method accounts for both timestamp and ID ordering.

```php
public function previousVersions(): MorphMany
```

```php
$version = $post->getVersion(5);
$previous = $version->previousVersions()->first(); // Get version 4
$allBefore = $version->previousVersions()->get(); // All versions before this
```

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

### Get Diff as Associative Array

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/diff-class.md

Returns the differences between two versions as an associative array. This is useful for programmatic access to attribute changes. Optionally remove HTML tags from the output.

```php
$diff = $post->getVersion(2)->diff($post->getVersion(1));
$result = $diff->toArray();
// Output:
// [
//     'title' => ['old' => 'Old Title', 'new' => 'New Title'],
//     'content' => ['old' => 'Old content', 'new' => 'New content']
// ]
```

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

### Static Control Methods

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/api-index.md

Global methods for controlling versioning behavior.

```APIDOC
## getVersioning()

### Description
Check if versioning is enabled globally.

### Returns
bool

### Parameters
None
```

```APIDOC
## enableVersioning()

### Description
Enable versioning globally.

### Returns
void

### Parameters
None
```

```APIDOC
## disableVersioning()

### Description
Disable versioning globally.

### Returns
void

### Parameters
None
```

```APIDOC
## withoutVersion(cb)

### Description
Temporarily disable versioning for a given callback.

### Returns
void

### Parameters
- **cb** (callable) - Required - The callback function to execute without versioning.
```

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

### Custom Schema Creation

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/database-schema.md

An example of how to customize the 'versions' table schema using Laravel's Schema Builder. This allows for custom IDs, foreign key names, and additional columns.

```php
Schema::create('versions', function (Blueprint $table) {
    // Use string IDs for both tables
    $table->string('id')->primary();
    
    // Use custom user FK name
    $table->unsignedBigInteger('author_id')->nullable();
    
    // Use smaller versionable_id
    $table->unsignedInteger('versionable_id');
    
    // Add custom columns
    $table->string('ip_address')->nullable();
    $table->string('user_agent')->nullable();
    
    // Standard columns
    $table->uuidMorphs('versionable');
    $table->json('contents')->nullable();
    $table->timestamps();
    $table->softDeletes();
});
```

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

### Prepare for 6.0: Default Strategy Change

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/migration-guide.md

The default `versionStrategy` will change from `DIFF` to `SNAPSHOT` in version 6.0. Explicitly set the strategy if you wish to retain the `DIFF` behavior.

```php
// If you want to keep DIFF strategy, explicitly set it
class Post extends Model
{
    use Versionable;

    protected $versionStrategy = VersionStrategy::DIFF;
}

// If you're okay with SNAPSHOT, do nothing
// or explicitly set it for clarity
protected $versionStrategy = VersionStrategy::SNAPSHOT;
```

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

### Configure Number of Versions to Keep

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/configuration.md

Set the number of latest versions to keep automatically. A value of 0 or less means all versions are kept.

```php
'keep_versions' => 0,
```

```php
'keep_versions' => 10, // Keep only 10 latest versions
```

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

### SNAPSHOT Version Strategy

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/getting-started.md

Employ the SNAPSHOT strategy to store all versionable attributes in every version. This approach is simpler to understand but consumes more storage space.

```php
class Post extends Model
{
    use Versionable;

    protected $versionStrategy = VersionStrategy::SNAPSHOT;
}
```

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

### Archiving Old Versions with a Console Command

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/migration-guide.md

Implement a console command to archive and delete old versions of models to optimize performance. Schedule this command to run periodically.

```php
// app/Console/Commands/ArchiveVersions.php
class ArchiveVersions extends Command
{
    public function handle()
    {
        // Archive versions older than 6 months
        Version::where('created_at', '<', now()->subMonths(6))
            ->each(fn($v) => $v->forceDelete());
    }
}

// Schedule in app/Console/Kernel.php
protected function schedule(Schedule $schedule)
{
    $schedule->command('archive:versions')->monthly();
}
```

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

### Get Diff as JSON Text Format

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/diff-class.md

Renders the differences between two versions in a JSON text format. This is ideal for applications that need to process diff data programmatically, such as in APIs or JavaScript frontends.

```php
public function toJsonText(array $differOptions = [], array $renderOptions = [], bool $stripTags = false): array
```

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

### Converting Between VersionStrategy Enum and String

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/types.md

Shows how to convert between the VersionStrategy enum and its string representation, including safe conversion methods.

```php
// From enum to string
$value = VersionStrategy::DIFF->value; // 'DIFF'

// From string to enum
$strategy = VersionStrategy::from('DIFF'); // VersionStrategy::DIFF

// Safe string conversion
$strategy = VersionStrategy::tryFrom('diff'); // null (case-sensitive)

// Within model configuration
protected $versionStrategy = VersionStrategy::DIFF;
// Or using string
protected $versionStrategy = 'diff';
```

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

### Comparing Versions

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/api-index.md

Compare two versions of a post to see the differences and retrieve statistics.

```php
$diff = $post->getVersion(2)->diff($post->getVersion(1));
$diff->toHtml();
$diff->getStatistics();
```

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

### Get Key Type - Laravel Versionable

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/version-model.md

Retrieve the data type of the primary key. Returns 'string' if UUID is configured, otherwise returns the parent model's key type (typically 'int').

```php
public function getKeyType(): string
```

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

### Configuring Versionable Properties

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/api-index.md

Customize versioning behavior by defining protected properties in your model.

```php
protected $versionable = ['title'];
protected $versionStrategy = VersionStrategy::SNAPSHOT;
public string $versionModel = CustomVersion::class;
```

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

### Apply Latest N Versions Update

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/common-patterns.md

When 'keep_versions' is set to a number greater than 0, the system automatically soft-deletes older versions after an update. For example, updating a post when configured to keep 50 versions will soft-delete version 1 if it's older than the 50 latest.

```php
// Applied automatically after each update
$post->update(['title' => 'Change 51']);
// Version 1 is soft-deleted, versions 2-51 remain
```

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

### Configure Model for Versioning

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/migration-guide.md

Use the Versionable trait and configure versionable attributes, strategy, and retention count.

```php
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Overtrue\LaravelVersionable\Versionable;
use Overtrue\LaravelVersionable\VersionStrategy;

class Post extends Model
{
    use Versionable;

    // Track only these attributes
    protected $versionable = ['title', 'content', 'slug'];

    // Store complete snapshots (recommended for clarity)
    protected $versionStrategy = VersionStrategy::SNAPSHOT;

    // Keep only 20 latest versions
    protected function getKeepVersionsCount(): int
    {
        return 20;
    }
}
```

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

### Version Model Navigation Methods

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/api-index.md

Methods for navigating through the version history of a model.

```APIDOC
## previousVersions()

### Description
Query all previous versions of the model.

### Returns
- MorphMany - A query builder for previous versions.
```

```APIDOC
## previousVersion()

### Description
Get the immediately preceding version of the model.

### Returns
- Version|null - The previous version object or null if none exists.
```

```APIDOC
## nextVersion()

### Description
Get the immediately succeeding version of the model.

### Returns
- Version|null - The next version object or null if none exists.
```

```APIDOC
## isLatest()

### Description
Check if this version is the latest version of the model.

### Returns
- bool - True if this is the latest version, false otherwise.
```

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

### Display Version History UI

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/common-patterns.md

Component to render version history, fetching all versions and calculating differences between consecutive versions for display.

```php
class VersionHistoryComponent extends Component
{
    public function render()
    {
        return view('version-history', [
            'versions' => $this->post->latestVersions,
            'diffs' => $this->getVersionDiffs(),
        ]);
    }

    private function getVersionDiffs()
    {
        $versions = $this->post->latestVersions->get();
        
        return $versions->mapWithKeys(function ($version) {
            $previous = $version->previousVersion();
            
            return [
                $version->id => $previous 
                    ? $previous->diff($version)->toArray() 
                    : [],
            ];
        });
    }
}
```

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

### Setting Environment Variables for Versionable

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/migration-guide.md

Define environment variables to control version keeping and UUID usage for different deployment environments.

```bash
# .env.production
VERSIONABLE_KEEP_VERSIONS=50

# .env.local
VERSIONABLE_KEEP_VERSIONS=0
VERSIONABLE_USE_UUID=true
```

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

### Whitelist Versioning Configuration

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/getting-started.md

Configure versioning to track only specified attributes by defining the `$versionable` property. Other attributes will be ignored.

```php
class Post extends Model
{
    use Versionable;

    protected $versionable = ['title', 'content', 'slug'];
    // Only these are tracked; others ignored
}
```

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

### Blacklist Versioning Configuration

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/getting-started.md

Configure versioning to track all attributes except those specified in the `$dontVersionable` property. This approach tracks everything by default.

```php
class Post extends Model
{
    use Versionable;

    protected $dontVersionable = ['created_at', 'updated_at', 'views'];
    // Everything except these is tracked
}
```

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

### Version Model Static Methods

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/api-index.md

Provides methods for creating and managing versions of models.

```APIDOC
## createForModel(m, r, t)

### Description
Create a version for a given model.

### Parameters
#### Path Parameters
- **m** (Model) - The model to create a version for.
- **r** (array) - The data to be stored in the version.
- **t** (string|DateTime|null) - The timestamp for the version.

### Returns
- Version - The newly created version object.
```

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

### previousVersion()

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/version-model.md

Returns the single version immediately before this one.

```APIDOC
## previousVersion()

### Description
Returns the single version immediately before this one.

### Returns
`Version|null`

### Example
```php
$v2 = $post->getVersion(2);
$v1 = $v2->previousVersion();
```
```

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

### Publish Config Only

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/service-provider.md

Publishes only the configuration file for the laravel-versionable package.

```bash
php artisan vendor:publish --provider="Overtrue\LaravelVersionable\ServiceProvider" --tag=config
```

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

### Configure User Model Class

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/configuration.md

Set the fully-qualified class name of the user model to associate with versions.

```php
'user_model' => \App\Models\User::class,
```

```php
'user_model' => \App\Models\Admin::class,
```

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

### Archive Old Versions

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/database-schema.md

Demonstrates how to periodically archive old versions of a model to manage storage growth. This method keeps a specified number of the latest versions.

```php
// Archive old versions periodically
Post::find(1)->removeOldVersions(50); // Keep only 50 latest
```

```php
// Or in config
'keep_versions' => 50,
```

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

### Compare to Previous Version

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/diff-class.md

Compares a specific version of a post to its immediately preceding version.

```php
$version = $post->getVersion(5);

// Diff automatically uses previousVersion() if toVersion not provided
$diff = $version->diff(); // Compares v5 to v4

$htmlDiff = $diff->toHtml();
```

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

### getVersionStrategy()

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/versionable-trait.md

Returns the version storage strategy for this model.

```APIDOC
## getVersionStrategy()

### Description
Returns the version storage strategy for this model.

### Returns
`VersionStrategy` — Either DIFF or SNAPSHOT

### Example
```php
$strategy = $post->getVersionStrategy();
if ($strategy === VersionStrategy::DIFF) {
    echo "Storing diffs";
}
```
```

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

### previousVersions()

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/version-model.md

Returns a query builder for all versions that came before this version, ordered by latest first. Accounts for both timestamp and ID ordering.

```APIDOC
## previousVersions()

### Description
Returns a query builder for all versions that came before this version, ordered by latest first. Accounts for both timestamp and ID ordering.

### Returns
Query builder for previous versions

### Example
```php
$version = $post->getVersion(5);
$previous = $version->previousVersions()->first(); // Get version 4
$allBefore = $version->previousVersions()->get(); // All versions before this
```
```

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

### Migrate history() to latestVersions()

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/migration-guide.md

The `history()` method has been replaced by `latestVersions()` in version 5.x. Use `latestVersions()` to retrieve version history.

```php
// Old (4.x)
$versions = $post->history();

// New (5.x)
$versions = $post->latestVersions();
```

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

### Diff Class Constructor

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/api-index.md

Initializes a new Diff instance with new and old versions, and optional differ and render options.

```APIDOC
## Constructor Diff

### Description
Initializes a new Diff instance with new and old versions, and optional differ and render options.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **newVersion** (Version) - Required - The newer version object for comparison.
- **oldVersion** (Version) - Required - The older version object for comparison.
- **differOptions** (array) - Optional - Options for the differ.
- **renderOptions** (array) - Optional - Options for the renderer.
```

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

### scopeOrderOldestFirst($query)

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/version-model.md

Orders versions by oldest first. If timestamp ordering is enabled (default), orders by `created_at` then `id`. Otherwise orders by `id` only.

```APIDOC
## scopeOrderOldestFirst($query)

### Description
Orders versions by oldest first. If timestamp ordering is enabled (default), orders by `created_at` then `id`. Otherwise orders by `id` only.

### Returns
Query builder ordered oldest first

### Example
```php
$oldVersions = Post::find(1)->versions()
    ->orderOldestFirst()
    ->take(5)
    ->get();
```
```

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

### Enable Versioning Globally

Source: https://github.com/overtrue/laravel-versionable/blob/5.x/_autodocs/versionable-trait.md

Re-enables version creation for the model class after it was disabled.

```php
public static function enableVersioning(): void
```

```php
Post::enableVersioning();
```
Tokens:
Raw