refactor bank account/account relationship

app/Filament/Company/Pages/Accounting/Transactions.php

 
     protected function getBankAccountOptions(?int $excludedAccountId = null, ?int $currentBankAccountId = null): array
     {
-        return BankAccount::join('accounts', 'accounts.bank_account_id', '=', 'bank_accounts.id')
-            ->where('accounts.archived', false)
-            ->select(['bank_accounts.id', 'accounts.name', 'accounts.subtype_id'])
-            ->with(['account.subtype' => static function ($query) {
+        return BankAccount::query()
+            ->whereHas('account', function (Builder $query) {
+                $query->where('archived', false);
+            })
+            ->with(['account' => function ($query) {
+                $query->where('archived', false);
+            }, 'account.subtype' => function ($query) {
                 $query->select(['id', 'name']);
             }])
-            ->when($excludedAccountId, function (Builder $query) use ($excludedAccountId) {
-                $query->whereNot('accounts.id', $excludedAccountId);
-            })
-            ->when($currentBankAccountId, function (Builder $query) use ($currentBankAccountId) {
-                // Ensure the current bank account is included even if archived
-                $query->orWhere('bank_accounts.id', $currentBankAccountId);
-            })
+            ->when($excludedAccountId, fn (Builder $query) => $query->where('account_id', '!=', $excludedAccountId))
+            ->when($currentBankAccountId, fn (Builder $query) => $query->orWhere('id', $currentBankAccountId))
             ->get()
             ->groupBy('account.subtype.name')
             ->map(fn (Collection $bankAccounts, string $subtype) => $bankAccounts->pluck('account.name', 'id'))

app/Models/Accounting/Account.php

 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Database\Eloquent\Relations\HasOne;
 use Illuminate\Support\Carbon;
 
 #[ObservedBy(AccountObserver::class)]
         'description',
         'archived',
         'default',
-        'bank_account_id',
         'created_by',
         'updated_by',
     ];
         return $this->belongsTo(Currency::class, 'currency_code', 'code');
     }
 
-    public function bankAccount(): BelongsTo
+    public function bankAccount(): HasOne
     {
-        return $this->belongsTo(BankAccount::class, 'bank_account_id');
+        return $this->hasOne(BankAccount::class, 'account_id');
     }
 
     public function getLastTransactionDate(): ?string

app/Models/Banking/BankAccount.php

 
     protected $fillable = [
         'company_id',
+        'account_id',
         'institution_id',
         'type',
         'number',
         return $this->hasOne(ConnectedBankAccount::class, 'bank_account_id');
     }
 
-    public function account(): HasOne
+    public function account(): BelongsTo
     {
-        return $this->hasOne(Account::class, 'bank_account_id');
+        return $this->belongsTo(Account::class, 'account_id');
     }
 
     public function institution(): BelongsTo

app/Services/AccountService.php

             ->whereExists(function (\Illuminate\Database\Query\Builder $subQuery) {
                 $subQuery->select(DB::raw(1))
                     ->from('journal_entries as je')
-                    ->join('accounts as bank_accounts', 'bank_accounts.id', '=', 'je.account_id')
-                    ->whereNotNull('bank_accounts.bank_account_id')
+                    ->join('bank_accounts', 'bank_accounts.account_id', '=', 'je.account_id') // Join bank_accounts on account_id
+                    ->whereNotNull('bank_accounts.id') // Ensure there is a linked BankAccount
                     ->whereColumn('je.transaction_id', 'journal_entries.transaction_id');
             })
             ->groupBy('accounts.id')

app/Services/ChartOfAccountsService.php

     {
         if (isset($subtypeConfig['accounts']) && is_array($subtypeConfig['accounts'])) {
             $baseCode = $subtypeConfig['base_code'];
-
             $defaultCurrencyCode = CurrencyAccessor::getDefaultCurrency();
 
             if (empty($defaultCurrencyCode)) {
             }
 
             foreach ($subtypeConfig['accounts'] as $accountName => $accountDetails) {
-                $bankAccount = null;
-
-                if ($subtypeConfig['multi_currency'] && isset($subtypeConfig['bank_account_type'])) {
-                    $bankAccount = $this->createBankAccountForMultiCurrency($company, $subtypeConfig['bank_account_type']);
-                }
-
-                $company->accounts()->createQuietly([
-                    'bank_account_id' => $bankAccount?->id,
+                // Create the Account without directly setting bank_account_id
+                $account = $company->accounts()->createQuietly([
                     'subtype_id' => $subtype->id,
                     'category' => $subtype->type->getCategory()->value,
                     'type' => $subtype->type->value,
                     'created_by' => $company->owner->id,
                     'updated_by' => $company->owner->id,
                 ]);
+
+                // Check if we need to create a BankAccount for this Account
+                if ($subtypeConfig['multi_currency'] && isset($subtypeConfig['bank_account_type'])) {
+                    $bankAccount = $this->createBankAccountForMultiCurrency($company, $subtypeConfig['bank_account_type']);
+
+                    // Associate the BankAccount with the Account
+                    $bankAccount->account()->associate($account);
+                    $bankAccount->saveQuietly();
+                }
             }
         }
     }

database/factories/Accounting/AccountFactory.php

 
     public function withBankAccount(string $name): static
     {
-        return $this->state(function (array $attributes) use ($name) {
-            $bankAccount = BankAccount::factory()->create();
+        return $this->afterCreating(function (Account $account) use ($name) {
             $accountSubtype = AccountSubtype::where('name', 'Cash and Cash Equivalents')->first();
 
-            return [
-                'bank_account_id' => $bankAccount->id,
+            // Create and associate a BankAccount with the Account
+            $bankAccount = BankAccount::factory()->create([
+                'account_id' => $account->id, // Associate with Account
+            ]);
+
+            // Update the Account with the subtype and name
+            $account->update([
                 'subtype_id' => $accountSubtype->id,
                 'name' => $name,
-            ];
+            ]);
         });
     }
 
     public function withForeignBankAccount(string $name, string $currencyCode, float $rate): static
     {
-        return $this->state(function (array $attributes) use ($currencyCode, $rate, $name) {
-            $currency = Currency::factory()->forCurrency($currencyCode, $rate)->create();
-            $bankAccount = BankAccount::factory()->create();
+        return $this->afterCreating(function (Account $account) use ($currencyCode, $rate, $name) {
             $accountSubtype = AccountSubtype::where('name', 'Cash and Cash Equivalents')->first();
 
-            return [
-                'bank_account_id' => $bankAccount->id,
+            // Create the Currency and BankAccount
+            $currency = Currency::factory()->forCurrency($currencyCode, $rate)->create();
+            $bankAccount = BankAccount::factory()->create([
+                'account_id' => $account->id, // Associate with Account
+            ]);
+
+            // Update the Account with the subtype, name, and currency code
+            $account->update([
                 'subtype_id' => $accountSubtype->id,
                 'name' => $name,
                 'currency_code' => $currency->code,
-            ];
+            ]);
         });
     }
 }

database/migrations/2023_09_03_100000_create_accounting_tables.php

             $table->timestamps();
         });
 
-        Schema::create('bank_accounts', function (Blueprint $table) {
-            $table->id();
-            $table->foreignId('company_id')->constrained()->cascadeOnDelete();
-            $table->foreignId('institution_id')->nullable()->constrained('institutions')->nullOnDelete();
-            $table->string('type')->default(BankAccountType::DEFAULT);
-            $table->string('number', 20)->nullable();
-            $table->boolean('enabled')->default(true);
-            $table->foreignId('created_by')->nullable()->constrained('users')->nullOnDelete();
-            $table->foreignId('updated_by')->nullable()->constrained('users')->nullOnDelete();
-            $table->timestamps();
-        });
-
         Schema::create('accounts', function (Blueprint $table) {
             $table->id();
             $table->foreignId('company_id')->constrained()->cascadeOnDelete();
             $table->text('description')->nullable();
             $table->boolean('archived')->default(false);
             $table->boolean('default')->default(false);
-            $table->foreignId('bank_account_id')->nullable()->constrained('bank_accounts')->cascadeOnDelete();
             $table->foreignId('created_by')->nullable()->constrained('users')->nullOnDelete();
             $table->foreignId('updated_by')->nullable()->constrained('users')->nullOnDelete();
             $table->timestamps();
             $table->unique(['company_id', 'code']);
         });
 
+        Schema::create('bank_accounts', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('company_id')->constrained()->cascadeOnDelete();
+            $table->foreignId('account_id')->nullable()->constrained('accounts')->nullOnDelete();
+            $table->foreignId('institution_id')->nullable()->constrained('institutions')->nullOnDelete();
+            $table->string('type')->default(BankAccountType::DEFAULT);
+            $table->string('number', 20)->nullable();
+            $table->boolean('enabled')->default(true);
+            $table->foreignId('created_by')->nullable()->constrained('users')->nullOnDelete();
+            $table->foreignId('updated_by')->nullable()->constrained('users')->nullOnDelete();
+            $table->timestamps();
+        });
+
         Schema::create('connected_bank_accounts', function (Blueprint $table) {
             $table->id();
             $table->foreignId('company_id')->constrained()->cascadeOnDelete();

database/migrations/2024_11_13_225714_create_adjustmentables_table.php

     {
         Schema::create('adjustmentables', function (Blueprint $table) {
             $table->id();
-            $table->foreignId('adjustment_id')->constrained()->cascadeOnDelete();
-            $table->string('adjustment_type');
-            $table->morphs('adjustmentable');
+            $table->unsignedBigInteger('adjustment_id');   // No foreign key constraint due to polymorphism
+            $table->string('adjustment_type');             // Type of adjustment (e.g., "App\Models\Tax" or "App\Models\Discount")
+            $table->morphs('adjustmentable');              // Creates adjustmentable_id and adjustmentable_type
             $table->timestamps();
+
+            // Optional indexes for efficient querying
+            $table->index(['adjustment_id', 'adjustment_type']);
+            $table->index(['adjustmentable_id', 'adjustmentable_type']);
         });
     }
 

tests/Feature/Accounting/TransactionTest.php

         ->withForeignBankAccount('CAD Bank Account', 'CAD', 1.36)
         ->create();
 
+    $foreignBankAccount->refresh();
+
     ConfigureCurrencies::syncCurrencies();
 
     // Create a transfer of 1500 CAD from the foreign bank account to USD bank account
         ->withForeignBankAccount('BHD Bank Account', 'BHD', 0.38)
         ->create();
 
+    $foreignBankAccount->refresh();
+
     ConfigureCurrencies::syncCurrencies();
 
     // Create a deposit of 1500 BHD to the foreign bank account
         ->withForeignBankAccount('Foreign Bank Account', 'GBP', 0.76) // GBP account
         ->create();
 
+    $foreignBankAccount->refresh();
+
     ConfigureCurrencies::syncCurrencies();
 
     /** @var Transaction $transaction */