Tenancy for Laravel

https://tenancyforlaravel.com/docs/v3
Admin
Tenancy for Laravel is a package that provides multi-tenancy capabilities for Laravel applications,...
Tokens:27,141
Snippets:406
Trust Score:8.2
Update:1 month ago
Show doc for...
Tokens:
Raw
### Tenant App Testing Setup

Source: https://tenancyforlaravel.com/docs/v3/testing

To test tenant-specific functionality, create a tenant and initialize tenancy within the `setUp()` method of your test case. This setup is crucial for multi-database tenancy when not using `:memory:` SQLite databases or `RefreshDatabase`.

```php
class TestCase // extends ...
{
    protected $tenancy = false;

    public function setUp(): void
    {
        parent::setUp();

        if ($this->tenancy) {
            $this->initializeTenancy();
        }
    }

    public function initializeTenancy()
    {
        $tenant = Tenant::create();

        tenancy()->initialize($tenant);
    }

    // ...
}
```

```php
class FooTest extends TestCase
{
    protected $tenancy = true;

    /** @test    */
    public function some_test()
    {
        $this->assertTrue(...);
    }
}
```

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

### Set up CreateTenantConnection Listener

Source: https://tenancyforlaravel.com/docs/v3/manual-mode

Configure the TenancyServiceProvider to listen for TenancyInitialized events and create the tenant connection. This is part of the manual mode setup.

```php
// app/Providers/TenancyServiceProvider.php

Events\TenancyInitialized::class => [
    Listeners\CreateTenantConnection::class,
],

```

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

### Tenant Routes Example

Source: https://tenancyforlaravel.com/docs/v3/quickstart

Define tenant-specific routes that are protected by tenancy middleware. This example shows a basic route returning tenant ID.

```php
Route::middleware([
    'web',
    InitializeTenancyByDomain::class,
    PreventAccessFromCentralDomains::class,
])->group(function () {
    Route::get('/', function () {
        return 'This is your multi-tenant application. The id of the current tenant is ' . tenant('id');
    });
});
```

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

### Run Tenancy Installation Artisan Command

Source: https://tenancyforlaravel.com/docs/v3/installation

Execute the tenancy:install artisan command to generate necessary files like migrations, configuration, and routes.

```bash
php artisan tenancy:install
```

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

### Create a Tenant

Source: https://tenancyforlaravel.com/docs/v3/tenants

Tenants can be created like any other Eloquent model. This example shows creating a tenant with a 'plan' attribute.

```php
$tenant = Tenant::create([
    'plan' => 'free',
]);
```

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

### Listen for TenancyInitialized Event

Source: https://tenancyforlaravel.com/docs/v3/event-system

This example shows how to register a listener for the TenancyInitialized event using Laravel's Event facade. This is typically done within a service provider to hook into the tenancy bootstrapping process.

```php
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
```

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

### Configure Central Domains (Valet)

Source: https://tenancyforlaravel.com/docs/v3/quickstart

Specify the central domains for your application in the config/tenancy.php file. Example for Laravel Valet.

```php
'central_domains' => [
    'saas.test', // Add the ones that you use. I use this one with Laravel Valet.
],
```

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

### Initialize Tenancy Manually

Source: https://tenancyforlaravel.com/docs/v3/manual-initialization

Use this method when you need to initialize tenancy for a specific tenant, for example, when using `artisan tinker`. Resolve the `Tenancy` instance from the container using the `tenancy()` helper.

```php
$tenant = Tenant::find('some-id');

tenancy()->initialize($tenant);

```

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

### Define Custom Tenant Model

Source: https://tenancyforlaravel.com/docs/v3/tenants

Extend the base Tenant model to include HasDatabase and HasDomains concerns for domain/subdomain identification and tenant databases. This is a common setup for most applications.

```php
<?php

namespace App;

use Stancl\Tenancy\Database\Models\Tenant as BaseTenant;
use Stancl\Tenancy\Contracts\TenantWithDatabase;
use Stancl\Tenancy\Database\Concerns\HasDatabase;
use Stancl\Tenancy\Database\Concerns\HasDomains;

class Tenant extends BaseTenant implements TenantWithDatabase
{
    use HasDatabase, HasDomains;
}
```

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

### Run Migrations

Source: https://tenancyforlaravel.com/docs/v3/quickstart

Apply the generated migrations to set up the database schema for tenancy.

```bash
php artisan migrate
```

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

### Initialize Tenancy by Path Middleware

Source: https://tenancyforlaravel.com/docs/v3/tenant-identification

Use this middleware to identify tenants based on a URL path. Ensure your routes are prefixed with '/{tenant}'.

```php
use Stancl\Tenancy\Middleware\InitializeTenancyByPath;

Route::group([
    'prefix' => '/{tenant}',
    'middleware' => [InitializeTenancyByPath::class],
], function () {
    Route::get('/foo', 'FooController@index');
});

```

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

### Publish and Run Impersonation Migrations

Source: https://tenancyforlaravel.com/docs/v3/features/user-impersonation

Publish the migration file for the impersonation tokens table and then run your migrations.

```bash
php artisan vendor:publish --tag=impersonation-migrations
php artisan migrate
```

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

### Initialize Tenancy and Create Tenant User

Source: https://tenancyforlaravel.com/docs/v3/synced-resources-between-tenants

Initializes a specific tenant and then creates a user within that tenant's database. The user must have the same 'global_id' as the central user for synchronization.

```php
tenancy()->initialize($tenant);

// Create the same user in tenant DB
$user = User::create([
    'global_id' => 'acme',
    'name' => 'John Doe',
    'email' => 'john@localhost',
    'password' => 'secret',
    'role' => 'commenter', // unsynced
]);

```

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

### Install Tenancy Package with Composer

Source: https://tenancyforlaravel.com/docs/v3/installation

Use composer to require the stancl/tenancy package for your Laravel project. Ensure you are running Laravel 9.0 or higher.

```bash
composer require stancl/tenancy
```

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

### Apply MaintenanceMode Trait to Tenant Model

Source: https://tenancyforlaravel.com/docs/v3/tenant-maintenance-mode

Use the `MaintenanceMode` trait on your Tenant model to enable maintenance mode functionality. No additional setup is required.

```php
use Stancl\Tenancy\Database\Concerns\MaintenanceMode;

class Tenant extends BaseTenant
{
    use MaintenanceMode;
}
```

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

### Configure Tenant File Field Previews

Source: https://tenancyforlaravel.com/docs/v3/integrations/nova

Use `tenant_asset` helper function with `thumbnail` and `preview` methods on file fields to ensure correct display of tenant-specific assets.

```php
Avatar::make('Avatar', 'photo')
    ->disk('public')
    ->thumbnail(fn ($value, $disk) => tenant_asset($value)),
    ->preview(fn ($value, $disk) => tenant_asset($value)),
```

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

### Enable Universal Routes Feature

Source: https://tenancyforlaravel.com/docs/v3/features/universal-routes

Uncomment this line in your `tenancy.php` config file to enable the Universal Routes feature.

```php
Stancl\Tenancy\Features\UniversalRoutes::class,
```

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

### Enable TenantConfig Feature

Source: https://tenancyforlaravel.com/docs/v3/features/tenant-config

Uncomment this line in your `tenancy.features` config file to enable the TenantConfig feature.

```php
// Stancl\Tenancy\Features\TenantConfig::class,
```

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

### Initialize Tenant Context

Source: https://tenancyforlaravel.com/docs/v3/event-system

This code initializes the current tenant context within the application. It's a core step in the package's workflow after a tenant is identified.

```php
$this->tenancy->initialize($tenant);
```

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

### Run Custom Commands for Tenants (CLI)

Source: https://tenancyforlaravel.com/docs/v3/console-commands

Executes your own Artisan commands for specified tenants. Use --tenants to select tenants and --option/--argument to pass parameters to your command.

```php
php artisan tenants:run email:send --tenants=8075a580-1cb8-11e9-8822-49c5d8f8ff23 --option="queue=1" --option="subject=New Feature" --argument="body=We have launched a new feature. ..."
```

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

### Migrate Tenant Databases

Source: https://tenancyforlaravel.com/docs/v3/console-commands

Use this command to migrate the databases of your tenants. Specify tenant IDs using the --tenants option. Migrations are expected in database/migrations/tenant by default.

```php
php artisan tenants:migrate --tenants=8075a580-1cb8-11e9-8822-49c5d8f8ff23
```

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

### Create Tenants and Domains in Tinker

Source: https://tenancyforlaravel.com/docs/v3/quickstart

Use Tinker to programmatically create new tenants and associate domains with them for testing purposes. Ensure tenant IDs are unique.

```php
$ php artisan tinker
>>> $tenant1 = App\Models\Tenant::create(['id' => 'foo']);
>>> $tenant1->domains()->create(['domain' => 'foo.localhost']);
>>> 
>>> $tenant2 = App\Models\Tenant::create(['id' => 'bar']);
>>> $tenant2->domains()->create(['domain' => 'bar.localhost']);

```

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

### Tenant Command with Multiple Tenant Option

Source: https://tenancyforlaravel.com/docs/v3/tenant-aware-commands

Use `TenantAwareCommand` and `HasATenantsOption` traits to create a command that accepts multiple tenant IDs. By default, it runs for all tenants if no option is provided.

```php
class FooCommand extends Command
{
    use TenantAwareCommand, HasATenantsOption;

    public function handle()
    {
        //
    }
}
```

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

### Create a Basic Job Pipeline

Source: https://tenancyforlaravel.com/docs/v3/event-system

Define a job pipeline by listing the jobs to be executed sequentially. This is the foundational step for creating automated tenant workflows.

```php
use Stancl\JobPipeline\JobPipeline;
use Stancl\Tenancy\Jobs\{CreateDatabase, MigrateDatabase, SeedDatabase};

JobPipeline::make([
    CreateDatabase::class,
    MigrateDatabase::class,
    SeedDatabase::class,
])
```

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

### Migrate Fresh Tenant Databases

Source: https://tenancyforlaravel.com/docs/v3/console-commands

Performs a fresh migration for tenant databases by running db:wipe and tenants:migrate. Specify target tenants using the --tenants option.

```php
php artisan tenants:migrate-fresh --tenants=8075a580-1cb8-11e9-8822-49c5d8f8ff23
```

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

### Create Framework Directories for Tenant

Source: https://tenancyforlaravel.com/docs/v3/realtime-facades

Use this job in your TenantCreated job pipeline to create tenant-specific framework directories when using storage_path() suffixing and real-time facades. It ensures that tenant data is isolated.

```php
<?php

namespace App\Jobs;

use Stancl\Tenancy\Contracts\Tenant;

class CreateFrameworkDirectoriesForTenant
{
    protected $tenant;

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

    public function handle()
    {
        $this->tenant->run(function ($tenant) {
            $storage_path = storage_path();

            mkdir("$storage_path/framework/cache", 0777, true);
        });
    }
}

```

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

### Run Custom Commands for Tenants (Artisan::call)

Source: https://tenancyforlaravel.com/docs/v3/console-commands

Programmatically runs custom Artisan commands for tenants using Artisan::call. Pass command name, tenants, options, and arguments as an array.

```php
Artisan::call('tenants:run', [
    'commandname' => 'email:send', // String
    '--tenants' => ['8075a580-1cb8-11e9-8822-49c5d8f8ff23'], // Array
    '--option' => ['queue=1', 'subject=New Feature'], // Array
    '--argument' => ['body=We have launched a new feature.'] // Array
])
```

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

### Custom Tenant Command Implementation

Source: https://tenancyforlaravel.com/docs/v3/tenant-aware-commands

Implement tenant awareness manually by accepting a `tenant_id` argument and using `tenancy()->find()` within the `handle()` method to run code for a specific tenant.

```php
tenancy()->find($this->argument('tenant_id'))->run(function () {
    // Your actual command code
});
```

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

### Publish and Configure laravel-login-link

Source: https://tenancyforlaravel.com/docs/v3/integrations/spatie

Publish the configuration file for laravel-login-link and add tenant identification middlewares. This ensures that login links are correctly generated and validated within the tenant context.

```bash
php artisan vendor:publish --tag="login-link-config"
```

```php
'middleware' => [
    'web',
    // Add whatever tenant identification middlewares you use in your tenant routes
    InitializeTenancyByDomain::class,
    PreventAccessFromCentralDomains::class,
],
```

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

### Publish Nova Migrations

Source: https://tenancyforlaravel.com/docs/v3/integrations/nova

Use this command to publish Nova's migration files. These will then need to be moved to the tenant migration directory.

```bash
php artisan vendor:publish --tag=nova-migrations
```

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

### Configure OnFail Callback

Source: https://tenancyforlaravel.com/docs/v3/configuration

Set a static property to define a callback function that executes when tenancy initialization fails. This is often placed in `app/Providers/TenancyServiceProvider`.

```php
\Stancl\Tenancy\Middleware\InitializeTenancyByDomain::$onFail = function () {
    return redirect('https://my-central-domain.com/');
};
```

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

### Apply Tenant Route Middleware

Source: https://tenancyforlaravel.com/docs/v3/integrations/orchid

Ensure that tenant routes in routes/tenant.php include the necessary middleware for tenancy and platform access. This includes InitializeTenancyByDomain and PreventAccessFromCentralDomains.

```php
Route::middleware([
    'web',
    'platform',
    InitializeTenancyByDomain::class,
    PreventAccessFromCentralDomains::class,
]);
```

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

### Enable Telescope Tags Feature

Source: https://tenancyforlaravel.com/docs/v3/features/telescope-tags

Uncomment this line in your `tenancy.features` configuration file to enable automatic tagging of Telescope requests by the active tenant.

```php
// Stancl\Tenancy\Features\TelescopeTags::class,
```

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

### Create Tenant Domain

Source: https://tenancyforlaravel.com/docs/v3/domains

Use the `domains` relationship to create a domain for a tenant. This is optional and depends on your identification strategy.

```php
$tenant->domains()->create([
    'domain' => 'acme',
]);

```

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

### Create Users within Each Tenant Database

Source: https://tenancyforlaravel.com/docs/v3/quickstart

Iterate through all tenants and execute a closure for each, ensuring that any user creation or modification occurs within the respective tenant's database. This is useful for populating tenant-specific data.

```php
App\Models\Tenant::all()->runForEach(function () {
    App\Models\User::factory()->create();
});

```

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

### Filesystem Tenancy Configuration Override

Source: https://tenancyforlaravel.com/docs/v3/tenancy-bootstrappers

Configure root overrides for local storage disks to make them tenant-aware. The %storage_path% placeholder is replaced with the output of the storage_path() helper.

```php
// Tenancy config (tenancy.filesystem.root_override)
// %storage_path% gets replaced by storage_path()'s output
// E.g. Storage::disk('local')->path('') will return "/$path_to_your_application/storage/tenant42/app"
// (Given a suffix_base of 'tenant' and a tenant with a key of `42`. Same as in the example above in the Storage path helper section)
'root_override' => [
    'local' => '%storage_path%/app/',
    'public' => '%storage_path%/app/public/',
]
```

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

### List All Tenants

Source: https://tenancyforlaravel.com/docs/v3/console-commands

Displays a list of all tenants registered in the system, including their IDs and hostnames.

```php
php artisan tenants:list
Listing all tenants.
[Tenant] id: dbe0b330-1a6e-11e9-b4c3-354da4b4f339 @ localhost
[Tenant] id: 49670df0-1a87-11e9-b7ba-cf5353777957 @ dev.localhost
```

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

### Register Tenant Routes

Source: https://tenancyforlaravel.com/docs/v3/routes

Define tenant routes in `routes/tenant.php`. These routes are automatically applied with 'web' middleware, tenant initialization, and access prevention middleware.

```php
Route::middleware([
    'web',
    InitializeTenancyByDomain::class,
    PreventAccessFromCentralDomains::class,
])->group(function () {
    Route::get('/', function () {
        return 'This is your multi-tenant application. The id of the current tenant is ' . tenant('id');
    });
});

```

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

### Configure Livewire File Upload Middleware

Source: https://tenancyforlaravel.com/docs/v3/integrations/livewire

Ensure file uploads work correctly by setting the appropriate middleware for `FilePreviewController` and temporary file uploads.

```php
// specify the right identification middleware
FilePreviewController::$middleware = ['web', 'universal', InitializeTenancyByDomain::class];
```

```php
// config/livewire.php

'livewire.temporary_file_upload.middleware' => ['throttle:60,1', 'universal', InitializeTenancyByDomain::class],
```

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

### Configure Nova Authentication Routes for Tenancy

Source: https://tenancyforlaravel.com/docs/v3/integrations/nova

Replace default authentication route methods with custom ones that include tenancy middleware for proper tenant routing.

```php
->withAuthenticationRoutes([
    // You can make this simpler by creating a tenancy route group
    InitializeTenancyByDomain::class,
    PreventAccessFromCentralDomains::class,
    'nova',
])
->withPasswordResetRoutes([
    // You can make this simpler by creating a tenancy route group
    InitializeTenancyByDomain::class,
    PreventAccessFromCentralDomains::class,
    'nova',
])
```

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

### Configuring TenantAssetsController Middleware

Source: https://tenancyforlaravel.com/docs/v3/tenancy-bootstrappers

Assign the appropriate identification middleware to TenantAssetsController to ensure correct tenant resolution for asset requests. Import necessary classes.

```php
public function boot()
{
    // Update the middleware used by the asset controller
    TenantAssetsController::$tenancyMiddleware = InitializeTenancyByDomainOrSubdomain::class;
}
```

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

### Map Tenant Storage to Config Key

Source: https://tenancyforlaravel.com/docs/v3/features/tenant-config

Configure the `$storageToConfigMap` static property to map keys from tenant storage (e.g., Tenant model properties) to application config keys. This allows tenant-specific values to override global config settings.

```php
\Stancl\Tenancy\Features\TenantConfig::$storageToConfigMap = [
    'paypal_api_key' => 'services.paypal.api_key',
];
```

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

### Map Tenant Storage to Multiple Config Keys

Source: https://tenancyforlaravel.com/docs/v3/features/tenant-config

To copy a tenant storage value to multiple configuration keys, specify the config keys as an array in the `$storageToConfigMap`. This is useful for settings that affect multiple parts of your application.

```php
\Stancl\Tenancy\Features\TenantConfig::$storageToConfigMap = [
    'locale' => [
        'app.locale',
        'locales.default',
    ],
];
```

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

### Run Code in Tenant Context

Source: https://tenancyforlaravel.com/docs/v3/tenants

Execute a callable function within a specific tenant's context using the run() method. This is useful for performing tenant-specific operations.

```php
$tenant->run(function () {
    User::create(...);
});
```

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

### Configure Tenancy Middleware for Orchid

Source: https://tenancyforlaravel.com/docs/v3/integrations/orchid

Add the InitializeTenancyByDomain middleware to the 'public' and 'private' middleware groups in config/platform.php. This ensures tenancy is initialized for Orchid routes.

```php
'middleware' => [
    'public'  => ['web', 'universal', InitializeTenancyByDomain::class], // Don't forget to import the middleware
    'private' => ['web', 'platform', 'universal', InitializeTenancyByDomain::class],
],
```

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

### Create Tenant Impersonation Route

Source: https://tenancyforlaravel.com/docs/v3/features/user-impersonation

Define a tenant route to handle impersonation requests. This route will use the UserImpersonation::makeResponse() method to verify the token and log in the user.

```php
use Stancl\Tenancy\Features\UserImpersonation;

// We're in your tenant routes!

Route::get('/impersonate/{token}', function ($token) {
    return UserImpersonation::makeResponse($token);
});

// Of course use a controller in a production app and not a Closure route.
// Closure routes cannot be cached.

```

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

### Custom Tenancy Bootstrapper Implementation

Source: https://tenancyforlaravel.com/docs/v3/tenancy-bootstrappers

Implement the TenancyBootstrapper interface to create custom logic for initializing and reverting tenancy. Register your bootstrapper in the config.

```php
namespace App;

use Stancl\Tenancy\Contracts\TenancyBootstrapper;
use Stancl\Tenancy\Contracts\Tenant;

class MyBootstrapper implements TenancyBootstrapper
{
    public function bootstrap(Tenant $tenant)
    {
        // ...
    }

    public function revert()
    {
        // ...
    }
}
```

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

### Execute Tenant Migrations

Source: https://tenancyforlaravel.com/docs/v3/migrations

Use this Artisan command to execute migrations located in the `database/migrations/tenant` directory. Ensure your tenant migrations have unique class names.

```bash
php artisan tenants:migrate
```

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

### Configure Tenant Model in Tenancy Config

Source: https://tenancyforlaravel.com/docs/v3/tenants

Specify your custom Tenant model in the tenancy.php configuration file to ensure the package uses your defined model.

```php
'tenant_model' => \App\Tenant::class,
```

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

### Configure Nova Middleware for Tenancy

Source: https://tenancyforlaravel.com/docs/v3/integrations/nova

Add tenancy-related middleware to Nova's middleware configuration to ensure proper tenant context is applied within Nova.

```php
'middleware' => [
    // You can make this simpler by creating a tenancy route group
    InitializeTenancyByDomain::class,
    PreventAccessFromCentralDomains::class,
    'web',
    Authenticate::class,
    DispatchServingNovaEvent::class,
    BootTools::class,
    Authorize::class,
]
```

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

### Define a Universal Route

Source: https://tenancyforlaravel.com/docs/v3/features/universal-routes

Create a route with the `universal` middleware and `InitializeTenancyByDomain` middleware. This route will function in both central and tenant applications.

```php
Route::get('/foo', function () {
    // ...
})->middleware(['universal', InitializeTenancyByDomain::class]);
```

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

### Create Custom Tenant Model

Source: https://tenancyforlaravel.com/docs/v3/quickstart

Define a custom Tenant model that extends the base Tenant model and uses HasDatabase and HasDomains concerns.

```php
<?php

namespace App\Models;

use Stancl\Tenancy\Database\Models\Tenant as BaseTenant;
use Stancl\Tenancy\Contracts\TenantWithDatabase;
use Stancl\Tenancy\Database\Concerns\HasDatabase;
use Stancl\Tenancy\Database\Concerns\HasDomains;

class Tenant extends BaseTenant implements TenantWithDatabase
{
    use HasDatabase, HasDomains;
}
```

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

### Configure Media Library URL Generator

Source: https://tenancyforlaravel.com/docs/v3/integrations/spatie

Update the media-library configuration to use the custom TenantAwareUrlGenerator. This applies the tenant-aware URL generation logic to all media items.

```php
'url_generator' => TenantAwareUrlGenerator::class,
```

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

### Configure laravel-permission Event Listeners

Source: https://tenancyforlaravel.com/docs/v3/integrations/spatie

Add listeners for TenancyBootstrapped and TenancyEnded events to manage the spatie/laravel-permission cache key per tenant. This prevents cache collisions between tenants.

```php
Events\TenancyBootstrapped::class => [
    function (Events\TenancyBootstrapped $event) {
        $permissionRegistrar = app("Spatie\Permission\PermissionRegistrar::class);
        $permissionRegistrar->cacheKey = 'spatie.permission.cache.tenant.' . $event->tenancy->tenant->getTenantKey();
    }
],

Events\TenancyEnded::class => [
    function (Events\TenancyEnded $event) {
        $permissionRegistrar = app("Spatie\Permission\PermissionRegistrar::class);
        $permissionRegistrar->cacheKey = 'spatie.permission.cache';
    }
],
```

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

### Create Migration for Tenancy Package Upgrade

Source: https://tenancyforlaravel.com/docs/v3/upgrading

A migration file to upgrade the tenancy package. It modifies the 'domains' table by adding an auto-incrementing ID, unique constraint on 'domain', and timestamps, and changes the 'data' column in the 'tenants' table to a JSON type with timestamps.

```php
<?php

use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class UpgradeTenancyPackage extends Migration
{
    /**
     * Run the migrations.
     *
     * @return  void
     */
    public function up()
    {
        Schema::table('domains', function (Blueprint $table) {
            $table->dropPrimary();
        });

        Schema::table('domains', function (Blueprint $table) {
            $table->increments('id')->first();
            $table->unique('domain');
            $table->timestamps();
        });

        Schema::table('tenants', function (Blueprint $table) {
            $table->json('data')->nullable()->change();
            $table->timestamps();
        });

        DB::table('domains')->update([
            'created_at' => now(),
            'updated_at' => now()
        ]);
    }

    /**
     * Reverse the migrations.
     *
     * @return  void
     */
    public function down()
    {
        Schema::table('domains', function (Blueprint $table) {
            $table->dropColumn('id');
            $table->dropUnique(['domain']);
            $table->dropTimestamps();
            $table->primary('domain');
        });

        Schema::table('tenants', function (Blueprint $table) {
            $table->json('data')->nullable(false)->change();
            $table->dropTimestamps();
        });
    }
}



```

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

### Make Command Tenant-Aware with TenantAwareCommand Trait

Source: https://tenancyforlaravel.com/docs/v3/tenant-aware-commands

Utilize the `TenantAwareCommand` trait to make your custom Artisan command tenant-aware. This requires implementing a `getTenants()` method.

```php
class MyCommand extends Command
{
    use TenantAwareCommand;
}
```

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

### Enable Tenant Resolver Caching

Source: https://tenancyforlaravel.com/docs/v3/cached-lookup

Enable caching for the DomainTenantResolver to avoid database queries on each request. Configure the cache TTL and optionally specify a cache store.

```php
use Stancl\Tenancy\Resolvers;

// enable cache
DomainTenantResolver::$shouldCache = true;

// seconds, 3600 is the default value
DomainTenantResolver::$cacheTTL = 3600;

// specify some cache store
// null resolves to the default cache store
DomainTenantResolver::$cacheStore = 'redis';
```

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

### Automate MySQL Privilege Granting with Docker Compose

Source: https://tenancyforlaravel.com/docs/v3/integrations/sail

To automate privilege granting on container restart, create an SQL file with the necessary GRANT statements and add it to the MySQL volumes in your `docker-compose.yml`. Replace `PATH_TO_THE_SQL_FILE` and `SQL_FILE_NAME.sql` with your actual file path and desired name.

```yaml
mysql:
    # ...
    volumes:
        # ...
        - 'PATH_TO_THE_SQL_FILE:/docker-entrypoint-initdb.d/SQL_FILE_NAME.sql'
```

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

### Add Tenancy Service Provider to bootstrap/providers.php

Source: https://tenancyforlaravel.com/docs/v3/installation

Manually add the TenancyServiceProvider to your application's bootstrap/providers.php file to enable tenancy features.

```php
return [
    App\Providers\AppServiceProvider::class,
    App\Providers\TenancyServiceProvider::class, // <-- here
];
```

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

### Configure Tenant Migration Paths

Source: https://tenancyforlaravel.com/docs/v3/migrations

Modify the `migration_parameters.paths` in `config/tenancy.php` to specify custom directories for tenant migrations. This is useful for modular projects.

```php
'migration_parameters' => [
    'paths' => [
        database_path('migrations/tenant'),
    ],
],
```

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

### Configure Livewire Middleware Group (Livewire 2.x)

Source: https://tenancyforlaravel.com/docs/v3/integrations/livewire

Modify the `config/livewire.php` file to include tenancy middleware in the Livewire update route.

```php
'middleware_group' => ['web'],
```

```php
'middleware_group' => [
    'web',
    'universal',
    InitializeTenancyByDomain::class, // or whatever tenancy middleware you use
],
```

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

### Tenant Routes: Display All Users

Source: https://tenancyforlaravel.com/docs/v3/quickstart

Modify the tenant routes file to display all users within the current tenant's database. This is useful for verifying multi-tenancy.

```php
Route::get('/', function () {
    dd(\.App\Models\User::all());
    return 'This is your multi-tenant application. The id of the current tenant is ' . tenant('id');
});
```

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

### Create Custom Tenant-Aware URL Generator for laravel-medialibrary

Source: https://tenancyforlaravel.com/docs/v3/integrations/spatie

Extend the default URL generator to create tenant-aware media URLs. This ensures that media assets are correctly referenced within each tenant's context.

```php
use Spatie\MediaLibrary\Support\UrlGenerator\DefaultUrlGenerator;

class TenantAwareUrlGenerator extends DefaultUrlGenerator
{
    public function getUrl(): string
    {
        $url = asset($this->getPathRelativeToRoot());

        $url = $this->versionUrl($url);

        return $url;
    }
}
```

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

### Tenant Command with Single Tenant Argument

Source: https://tenancyforlaravel.com/docs/v3/tenant-aware-commands

Combine `TenantAwareCommand` and `HasATenantArgument` traits for a command that requires a single tenant ID as an argument.

```php
class BarCommand extends Command
{
    use TenantAwareCommand, HasATenantArgument;

    public function handle()
    {
        //
    }
}
```

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

### Custom Tenant and User Models for Tenancy

Source: https://tenancyforlaravel.com/docs/v3/synced-resources-between-tenants

Defines custom Tenant, CentralUser, and User models with database relationships and synchronization logic. Ensure the CentralUser model uses the central connection.

```php
use Stancl\Tenancy\Database\Models\Tenant as BaseTenant;
use Stancl\Tenancy\Database\Models\TenantPivot;

class Tenant extends BaseTenant implements TenantWithDatabase
{
    use HasDatabase, HasDomains;

    public function users()
    {
        return $this->belongsToMany(CentralUser::class, 'tenant_users', 'tenant_id', 'global_user_id', 'id', 'global_id')
            ->using(TenantPivot::class);
    }
}

class CentralUser extends Model implements SyncMaster
{
    // Note that we force the central connection on this model
    use ResourceSyncing, CentralConnection;

    protected $guarded = [];
    public $timestamps = false;
    public $table = 'users';

    public function tenants(): BelongsToMany
    {
        return $this->belongsToMany(Tenant::class, 'tenant_users', 'global_user_id', 'tenant_id', 'global_id')
            ->using(TenantPivot::class);
    }

    public function getTenantModelName(): string
    {
        return User::class;
    }

    public function getGlobalIdentifierKey()
    {
        return $this->getAttribute($this->getGlobalIdentifierKeyName());
    }

    public function getGlobalIdentifierKeyName(): string
    {
        return 'global_id';
    }

    public function getCentralModelName(): string
    {
        return static::class;
    }

    public function getSyncedAttributeNames(): array
    {
        return [
            'name',
            'password',
            'email',
        ];
    }
}

class User extends Model implements Syncable
{
    use ResourceSyncing;

    protected $guarded = [];
    public $timestamps = false;

    public function getGlobalIdentifierKey()
    {
        return $this->getAttribute($this->getGlobalIdentifierKeyName());
    }

    public function getGlobalIdentifierKeyName(): string
    {
        return 'global_id';
    }

    public function getCentralModelName(): string
    {
        return CentralUser::class;
    }

    public function getSyncedAttributeNames(): array
    {
        return [
            'name',
            'password',
            'email',
        ];
    }
}

```

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

### Seed Tenant Databases

Source: https://tenancyforlaravel.com/docs/v3/console-commands

Seeds the databases of tenants. This command is tenant-aware and can be configured to use custom tenant seeders.

```php
php artisan tenants:seed
```

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

### Redirect for Path Identification

Source: https://tenancyforlaravel.com/docs/v3/features/user-impersonation

Construct the impersonation URL using the tenant's ID for path identification. Ensure the correct route prefix is used.

```php
// Make sure you use the correct prefix for your routes.
return redirect("{$tenant->id}/impersonate/{$token->token}");

```

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

### Implement SpatiePermissionsBootstrapper

Source: https://tenancyforlaravel.com/docs/v3/integrations/spatie

An alternative to event listeners for managing the spatie/laravel-permission cache key. This bootstrapper class handles setting and reverting the cache key during tenancy events.

```php
class SpatiePermissionsBootstrapper implements TenancyBootstrapper
{
    public function __construct(
        protected PermissionRegistrar $registrar,
    ) {}

    public function bootstrap(Tenant $tenant): void
    {
        $this->registrar->cacheKey = 'spatie.permission.cache.tenant.' . $tenant->getTenantKey();
    }

    public function revert(): void
    {
        $this->registrar->cacheKey = 'spatie.permission.cache';
    }
}

```

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

### Add Universal Middleware Group

Source: https://tenancyforlaravel.com/docs/v3/features/universal-routes

Add this middleware group to your `bootstrap/app.php` file. This group acts as a flag for universal routes and does not require any middleware within it.

```php
->withMiddleware(function (Middleware $middleware) {
    $middleware->group('universal', []);
})
```

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

### Configure Tenant Model in Tenancy Config

Source: https://tenancyforlaravel.com/docs/v3/quickstart

Update the 'tenant_model' configuration option in config/tenancy.php to use your custom Tenant model.

```php
'tenant_model' => \App\Models\Tenant::class,
```

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

### Register Passport Routes for Universal Use (Passport 10.x)

Source: https://tenancyforlaravel.com/docs/v3/integrations/passport

Configure Passport routes to be accessible by both tenant and central applications by adding the 'universal' middleware and tenancy initialization middleware.

```php
// Passport 10.x
Passport::routes(null, ['middleware' => [
    'universal',
    InitializeTenancyByDomain::class
]]);
```

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

### Redirect to Route on Specific Domain using tenant_route()

Source: https://tenancyforlaravel.com/docs/v3/features/cross-domain-redirect

An alternative method using the `tenant_route()` helper to redirect users to a specified route on a given domain. This is useful for cross-domain redirects.

```php
return redirect(tenant_route($domain, 'home'));
```

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

### Accessing Global Assets with Storage Disk

Source: https://tenancyforlaravel.com/docs/v3/tenancy-bootstrappers

Use this method to access global assets like logos when they are stored on a separate disk. This bypasses tenant-specific storage.

```php
Storage::disk('branding')->url('header-logo.png');
```

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

### Publish and Move Migrations for laravel-permission

Source: https://tenancyforlaravel.com/docs/v3/integrations/spatie

Publish the migrations for laravel-permission and move them to the tenant's migration directory. This ensures tenant-specific permission tables are created.

```bash
php artisan vendor:publish --provider="Spatie\Permission\PermissionServiceProvider" --tag="migrations"
mv database/migrations/*_create_permission_tables.php database/migrations/tenant
```

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

### Registering Custom Bootstrapper in Config

Source: https://tenancyforlaravel.com/docs/v3/tenancy-bootstrappers

Add your custom bootstrapper class to the 'bootstrappers' array in your tenancy configuration file to enable its functionality.

```php
'bootstrappers' => [
    Stancl\Tenancy\Bootstrappers\DatabaseTenancyBootstrapper::class,
    Stancl\Tenancy\Bootstrappers\CacheTenancyBootstrapper::class,
    Stancl\Tenancy\Bootstrappers\FilesystemTenancyBootstrapper::class,
    Stancl\Tenancy\Bootstrappers\QueueTenancyBootstrapper::class,

    App\MyBootstrapper::class,
],
```

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

### Configure Database Queue for Central Connection

Source: https://tenancyforlaravel.com/docs/v3/queues

To ensure the database queue driver uses the central connection, add the 'connection' => 'central' line to your queue.connections.database configuration.

```php
'connection' => 'central',
```

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

### Enable Queueing for Resource Updates

Source: https://tenancyforlaravel.com/docs/v3/synced-resources-between-tenants

To queue the listener that copies changes to other databases in production, set the `shouldQueue` static property of the `UpdateSyncedResource` listener to `true`.

```php
\Stancl\Tenancy\Listeners\UpdateSyncedResource::$shouldQueue = true;

```

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

### Specify Tenant Database Name

Source: https://tenancyforlaravel.com/docs/v3/customizing-databases

Set the `tenancy_db_name` key when creating a tenant to specify its database name. If not provided, it's constructed using config values and the tenant ID.

```php
Tenant::create([
    'tenancy_db_name' => 'acme',
]);
```

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

### Convert Pipeline to Event Listener

Source: https://tenancyforlaravel.com/docs/v3/event-system

Convert a job pipeline into an event listener and bind it to a specific event. This allows the pipeline to be triggered automatically when the event is fired.

```php
use Stancl\Tenancy\Events\TenantCreated;
use Stancl\JobPipeline\JobPipeline;
use Stancl\Tenancy\Jobs\{CreateDatabase, MigrateDatabase, SeedDatabase};
use Illuminate\Support\Facades\Event;

Event::listen(TenantCreated::class, JobPipeline::make([
    CreateDatabase::class,
    MigrateDatabase::class,
    SeedDatabase::class,
])->send(function (TenantCreated $event) {
    return $event->tenant;
})->shouldBeQueued(true)->toListener());
```

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

### Enable User Impersonation Feature

Source: https://tenancyforlaravel.com/docs/v3/features/user-impersonation

Add the UserImpersonation class to your config/tenancy.php file to enable this feature.

```php
Stancl\Tenancy\Features\UserImpersonation::class,
```

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

### Put Tenant into Maintenance Mode

Source: https://tenancyforlaravel.com/docs/v3/tenant-maintenance-mode

Call the `putDownForMaintenance()` method on a tenant object to enable maintenance mode for that specific tenant. Ensure the `MaintenanceMode` trait is applied to your Tenant model.

```php
$tenant->putDownForMaintenance();
```
Tokens:
Raw