App\Tenant\Manager

Complexity

Total Complexity

23

Size/Duplication

Total Lines	170
Duplicated Lines	0 %

Importance

Changes	2
Bugs	2	Features	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	makeStoragePartition()	0	3	1
A	rootStorage()	0	5	1
A	__construct()	0	8	1
A	createDatabase()	0	9	1
A	fromModel()	0	6	1
A	connect()	0	15	2
A	databaseExists()	0	13	3
A	disconnect()	0	13	1
A	hasStoragePartition()	0	3	1
A	connectionName()	0	3	1
A	tenantId()	0	3	1
A	deleteStoragePartition()	0	3	1
A	partitionName()	0	3	1
A	storage()	0	9	2
A	storagePath()	0	3	1
A	tenant()	0	5	1
A	database()	0	3	1
A	dropDatabase()	0	5	1
A	migrateDatabase()	0	9	1

<?php

declare(strict_types=1);

namespace App\Tenant;

use App\Models\Tenant;
use App\Models\User;
use Illuminate\Config\Repository;
use Illuminate\Contracts\Filesystem\Filesystem;
use Illuminate\Database\ConnectionInterface;
use Illuminate\Database\DatabaseManager;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Artisan;
use Illuminate\Support\Facades\Storage;

class Manager
{
    protected User $user;
    protected string|null $partition = null;
    protected string $connectionName = 'tenantdb';
    protected string $defaultDatabase = 'tenant';
    protected string $defaultConnection = 'mysql';

    public function __construct(
        protected string|int $tenant_id,
        string|int $user_id,
        string|int|null $database_name,
        protected Repository $config,
        protected DatabaseManager $database,
    ) {
        $this->partition = $database_name ?? "tenant{$tenant_id}";
    }

    public static function fromModel(Model $model, User $user): self
    {
        return app(static::class, [

The expression return app(static::class, array('tenant_id' => $model->getKey(), 'user_id' => $user->getKey(), 'database_name' => tenancy()->find($model->getKey())->tenancy_db_name ?? null)) could return the type Illuminate\Contracts\Foundation\Application|Illuminate\Foundation\Application which is incompatible with the type-hinted return App\Tenant\Manager. Consider adding an additional type-check to rule them out.

            'tenant_id' => $model->getKey(),
            'user_id' => $user->getKey(),
            'database_name' => tenancy()->find($model->getKey())->tenancy_db_name ?? null,

Accessing tenancy_db_name on the interface Stancl\Tenancy\Contracts\Tenant suggest that you code against a concrete implementation. How about adding an instanceof check?

        ]);
    }

    public static function tenant(string $company_id, string $user_id): self
    {
        return app(static::class, [

The expression return app(static::class, array('tenant_id' => $company_id, 'user_id' => $user_id)) could return the type Illuminate\Contracts\Foundation\Application|Illuminate\Foundation\Application which is incompatible with the type-hinted return App\Tenant\Manager. Consider adding an additional type-check to rule them out.

            'tenant_id' => $company_id,
            'user_id' => $user_id,
        ]);
    }

    public function connect(bool $default = false): self
    {
        // $this->config->set('database.connections.tenant.database', $this->partition);
        // $this->database->reconnect($this->connectionName);
        if ($default) {
            $this->config->set('database.default', $this->connectionName);
            $this->database->reconnect($this->defaultConnection);
        } else {
            $tenants = Tenant::find($this->tenant_id);
            $this->config->set('database.connections.tenantdb.database', $tenants->tenancy_db_name);
            $this->database->reconnect($this->connectionName);
            tenancy()->initialize($tenants);
        }

        return $this;
    }

    public function disconnect(): self
    {
        $this->config->set('database.default', $this->defaultConnection);
        // $this->config->set('database.connections.tenant.database', $this->defaultDatabase);

        $this->database->reconnect($this->connectionName);
        $this->database->reconnect($this->defaultConnection);

        $defaultDatabase = $this->config->get('database.connections.'.$this->defaultConnection.'.database');

        $this->database->statement("USE {$defaultDatabase};");

        return $this;
    }

    public function database(): ConnectionInterface
    {
        return $this->database->connection($this->connectionName);
    }

    public function databaseExists(): bool
    {
        try {
            if ($this->config->get('database.default') === 'sqlite') {
                // $this->connect(true);
                $this->config->set('database.default', 'tenant');
            }

            return $this->database->select(<<<SQL
        SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = '{$this->partition}';
        SQL) !== [];
        } catch (\PDOException) {
            return false;
        }
    }

    public function createDatabase(): self
    {
        $charset = $this->config->get('database.connections.mysql.charset', 'utf8');
        $collate = $this->config->get('database.connections.mysql.collation', 'utf8_unicode_ci');
        $this->database->statement("CREATE DATABASE {$this->partition} CHARACTER SET {$charset} COLLATE {$collate};");

        // $this->database->statement("USE {$this->partition};");

        return $this;
    }

    public function dropDatabase(): self
    {
        $this->database->statement("DROP DATABASE {$this->partition};");

        return $this;
    }

    public function migrateDatabase(): self
    {
        Artisan::call('migrate:fresh', [
            '--realpath' => database_path('migrations/tenant'),
            '--database' => $this->connectionName,
            '--force' => true,
        ]);

        return $this;
    }

    public function hasStoragePartition(): bool
    {
        return $this->rootStorage()->exists($this->partition);
    }

    public function makeStoragePartition(): bool
    {
        return $this->rootStorage()->makeDirectory($this->partition);
    }

    public function deleteStoragePartition(): bool
    {
        return $this->rootStorage()->deleteDirectory($this->partition);
    }

    public function storage(): Filesystem
    {
        if (! $this->hasStoragePartition()) {
            $this->makeStoragePartition();
        }

        return Storage::build([
            'driver' => 'local',
            'root' => storage_path("tenants/{$this->partition}"),
        ]);
    }

    public function rootStorage(): Filesystem
    {
        return Storage::build([
            'driver' => 'local',
            'root' => storage_path('tenants'),
        ]);
    }

    public function storagePath(string $path): string
    {
        return storage_path("tenants/{$this->partition}/{$path}");
    }

    public function connectionName(): string
    {
        return $this->connectionName;
    }

    public function partitionName(): string
    {
        return $this->partition;

The expression return $this->partition could return the type null which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

    }

    public function tenantId(): string|int
    {
        return $this->tenant_id;
    }
}