refactor: clean up codebase, remove dead code and obsolete docs

Remove influencer-era documentation, unused components, boilerplate
assets, and ghost tiktok cron job. Add supplier invoice management,
document API routes, and PWA icons. Replace boilerplate README.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

app/api/transactions/[id]/categorize/route.ts

@@ -5,13 +5,14 @@ import { ensureInitialized } from '@/lib/init'
 import { buildMappingResultFromCategory } from '@/lib/bookkeeping/category-mapping'
 import { createTransactionJournalEntry } from '@/lib/bookkeeping/transaction-entries'
 import { saveUserMappingRule } from '@/lib/bookkeeping/mapping-engine'
-import type { Transaction, TransactionCategory, EntityType } from '@/types'
+import type { Transaction, TransactionCategory, EntityType, VatTreatment } from '@/types'
 
 ensureInitialized()
 
 interface CategorizeRequest {
   is_business: boolean
   category?: TransactionCategory
+  vat_treatment?: VatTreatment
 }
 
 /**
@@ -20,7 +21,8 @@ interface CategorizeRequest {
 async function ensureFiscalPeriod(
   supabase: Awaited<ReturnType<typeof createClient>>,
   userId: string,
-  date: string
+  date: string,
+  fiscalYearStartMonth: number = 1
 ): Promise<boolean> {
   // Check if a fiscal period already covers this date
   const { data: existing } = await supabase
@@ -36,18 +38,38 @@ async function ensureFiscalPeriod(
     return true
   }
 
-  // No fiscal period exists - create one for the year of the transaction
-  const transactionDate = new Date(date)
-  const year = transactionDate.getFullYear()
+  // Compute fiscal year period based on start month
+  const txDate = new Date(date)
+  const txMonth = txDate.getMonth() + 1
+  const txYear = txDate.getFullYear()
 
-  const periodStart = `${year}-01-01`
-  const periodEnd = `${year}-12-31`
+  let periodStartYear: number
+  if (fiscalYearStartMonth === 1) {
+    periodStartYear = txYear
+  } else if (txMonth >= fiscalYearStartMonth) {
+    periodStartYear = txYear
+  } else {
+    periodStartYear = txYear - 1
+  }
+
+  const startMonth = String(fiscalYearStartMonth).padStart(2, '0')
+  const periodStart = `${periodStartYear}-${startMonth}-01`
+
+  // Period ends the day before the next fiscal year starts
+  const endYear = fiscalYearStartMonth === 1 ? periodStartYear : periodStartYear + 1
+  const endMonth = fiscalYearStartMonth === 1 ? 12 : fiscalYearStartMonth - 1
+  const lastDay = new Date(endYear, endMonth, 0).getDate()
+  const periodEnd = `${endYear}-${String(endMonth).padStart(2, '0')}-${String(lastDay).padStart(2, '0')}`
+
+  const periodName = fiscalYearStartMonth === 1
+    ? `Räkenskapsår ${periodStartYear}`
+    : `Räkenskapsår ${periodStartYear}/${endYear}`
 
   const { error } = await supabase
     .from('fiscal_periods')
     .upsert({
       user_id: userId,
-      name: `Räkenskapsår ${year}`,
+      name: periodName,
       period_start: periodStart,
       period_end: periodEnd,
     }, {
@@ -122,14 +144,15 @@ export async function POST(
     })
   }
 
-  // Fetch company settings to get entity type
+  // Fetch company settings to get entity type and fiscal year start
   const { data: settings } = await supabase
     .from('company_settings')
-    .select('entity_type')
+    .select('entity_type, fiscal_year_start_month')
     .eq('user_id', user.id)
     .single()
 
   const entityType: EntityType = (settings?.entity_type as EntityType) || 'enskild_firma'
+  const fiscalYearStartMonth: number = settings?.fiscal_year_start_month ?? 1
 
   // Determine the category to use
   const finalCategory: TransactionCategory = is_business
@@ -141,11 +164,12 @@ export async function POST(
     finalCategory,
     transaction as Transaction,
     is_business,
-    entityType
+    entityType,
+    body.vat_treatment
   )
 
   // Ensure fiscal period exists for the transaction date
-  await ensureFiscalPeriod(supabase, user.id, transaction.date)
+  await ensureFiscalPeriod(supabase, user.id, transaction.date, fiscalYearStartMonth)
 
   // Try to create journal entry
   let journalEntryCreated = false

app/api/transactions/[id]/match-invoice/route.ts

@@ -1,7 +1,11 @@
 import { createClient } from '@/lib/supabase/server'
 import { NextResponse } from 'next/server'
 import { createJournalEntry, findFiscalPeriod } from '@/lib/bookkeeping/engine'
-import type { Transaction, Invoice, CreateJournalEntryInput } from '@/types'
+import {
+  getRevenueAccount,
+  getOutputVatAccount,
+} from '@/lib/bookkeeping/invoice-entries'
+import type { Transaction, Invoice, CreateJournalEntryInput, VatTreatment } from '@/types'
 
 interface MatchInvoiceRequest {
   invoice_id: string
@@ -132,7 +136,16 @@ export async function POST(
   const now = new Date().toISOString()
   const paidAmount = transaction.amount
 
-  // Create journal entry for payment receipt
+  // Fetch accounting method
+  const { data: settings } = await supabase
+    .from('company_settings')
+    .select('accounting_method')
+    .eq('user_id', user.id)
+    .single()
+
+  const accountingMethod = settings?.accounting_method || 'accrual'
+
+  // Create journal entry for payment receipt (method-aware)
   let journalEntryId: string | null = null
   let journalEntryError: string | null = null
 
@@ -140,26 +153,69 @@ export async function POST(
     const fiscalPeriodId = await ensureFiscalPeriod(supabase, user.id, transaction.date)
 
     if (fiscalPeriodId) {
-      const journalInput: CreateJournalEntryInput = {
-        fiscal_period_id: fiscalPeriodId,
-        entry_date: transaction.date,
-        description: `Betalning mottagen: Faktura ${invoice.invoice_number}`,
-        source_type: 'invoice_paid',
-        source_id: invoice.id,
-        lines: [
+      let journalInput: CreateJournalEntryInput
+
+      if (accountingMethod === 'cash') {
+        // Kontantmetoden: combined revenue entry at payment
+        // Debit 1930 Företagskonto, Credit 30xx Försäljning, Credit 26xx Utgående moms
+        const revenueAccount = getRevenueAccount(invoice.vat_treatment as VatTreatment)
+        const lines: CreateJournalEntryInput['lines'] = [
           {
-            account_number: '1930', // Företagskonto (Bank)
-            debit_amount: paidAmount,
+            account_number: '1930',
+            debit_amount: invoice.total,
             credit_amount: 0,
             line_description: `Inbetalning faktura ${invoice.invoice_number}`,
           },
           {
-            account_number: '1510', // Kundfordringar (Accounts Receivable)
+            account_number: revenueAccount,
             debit_amount: 0,
-            credit_amount: paidAmount,
-            line_description: `Faktura ${invoice.invoice_number} betald`,
+            credit_amount: invoice.subtotal,
+            line_description: `Försäljning faktura ${invoice.invoice_number}`,
           },
-        ],
+        ]
+
+        if (invoice.vat_amount > 0) {
+          const vatAccount = getOutputVatAccount(invoice.vat_treatment as VatTreatment)
+          lines.push({
+            account_number: vatAccount,
+            debit_amount: 0,
+            credit_amount: invoice.vat_amount,
+            line_description: `Utgående moms faktura ${invoice.invoice_number}`,
+          })
+        }
+
+        journalInput = {
+          fiscal_period_id: fiscalPeriodId,
+          entry_date: transaction.date,
+          description: `Betalning faktura ${invoice.invoice_number} (kontantmetoden)`,
+          source_type: 'invoice_cash_payment',
+          source_id: invoice.id,
+          lines,
+        }
+      } else {
+        // Faktureringsmetoden: clear receivable
+        // Debit 1930 Företagskonto, Credit 1510 Kundfordringar
+        journalInput = {
+          fiscal_period_id: fiscalPeriodId,
+          entry_date: transaction.date,
+          description: `Betalning mottagen: Faktura ${invoice.invoice_number}`,
+          source_type: 'invoice_paid',
+          source_id: invoice.id,
+          lines: [
+            {
+              account_number: '1930',
+              debit_amount: paidAmount,
+              credit_amount: 0,
+              line_description: `Inbetalning faktura ${invoice.invoice_number}`,
+            },
+            {
+              account_number: '1510',
+              debit_amount: 0,
+              credit_amount: paidAmount,
+              line_description: `Faktura ${invoice.invoice_number} betald`,
+            },
+          ],
+        }
       }
 
       const journalEntry = await createJournalEntry(user.id, journalInput)

app/api/transactions/[id]/match-supplier-invoice/route.ts

@@ -0,0 +1,211 @@
+import { createClient } from '@/lib/supabase/server'
+import { NextResponse } from 'next/server'
+import { findFiscalPeriod } from '@/lib/bookkeeping/engine'
+import {
+  createSupplierInvoicePaymentEntry,
+  createSupplierInvoiceCashEntry,
+} from '@/lib/bookkeeping/supplier-invoice-entries'
+import type { SupplierInvoice, SupplierInvoiceItem } from '@/types'
+
+interface MatchRequest {
+  supplier_invoice_id: string
+}
+
+/**
+ * Ensure a fiscal period exists for the given date
+ */
+async function ensureFiscalPeriod(
+  supabase: Awaited<ReturnType<typeof createClient>>,
+  userId: string,
+  date: string
+): Promise<string | null> {
+  const existingPeriodId = await findFiscalPeriod(userId, date)
+  if (existingPeriodId) return existingPeriodId
+
+  const transactionDate = new Date(date)
+  const year = transactionDate.getFullYear()
+
+  const { data, error } = await supabase
+    .from('fiscal_periods')
+    .upsert({
+      user_id: userId,
+      name: `Räkenskapsår ${year}`,
+      period_start: `${year}-01-01`,
+      period_end: `${year}-12-31`,
+    }, {
+      onConflict: 'user_id,period_start,period_end',
+    })
+    .select('id')
+    .single()
+
+  if (error) {
+    console.error('Failed to create fiscal period:', error)
+    return null
+  }
+
+  return data?.id || null
+}
+
+/**
+ * POST /api/transactions/[id]/match-supplier-invoice
+ *
+ * Match a negative transaction (expense) to a supplier invoice.
+ */
+export async function POST(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const supabase = await createClient()
+  const { id: transactionId } = await params
+
+  const { data: { user } } = await supabase.auth.getUser()
+
+  if (!user) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const body: MatchRequest = await request.json()
+  const { supplier_invoice_id } = body
+
+  if (!supplier_invoice_id) {
+    return NextResponse.json({ error: 'supplier_invoice_id is required' }, { status: 400 })
+  }
+
+  // Fetch the transaction
+  const { data: transaction, error: fetchTxError } = await supabase
+    .from('transactions')
+    .select('*')
+    .eq('id', transactionId)
+    .eq('user_id', user.id)
+    .single()
+
+  if (fetchTxError || !transaction) {
+    return NextResponse.json({ error: 'Transaction not found' }, { status: 404 })
+  }
+
+  // Verify transaction is an expense (amount < 0)
+  if (transaction.amount >= 0) {
+    return NextResponse.json(
+      { error: 'Bara utgiftstransaktioner kan matchas mot leverantörsfakturor' },
+      { status: 400 }
+    )
+  }
+
+  if (transaction.supplier_invoice_id) {
+    return NextResponse.json(
+      { error: 'Transaktionen är redan kopplad till en leverantörsfaktura' },
+      { status: 400 }
+    )
+  }
+
+  // Fetch the invoice with supplier and items
+  const { data: invoice, error: fetchInvError } = await supabase
+    .from('supplier_invoices')
+    .select('*, supplier:suppliers(*), items:supplier_invoice_items(*)')
+    .eq('id', supplier_invoice_id)
+    .eq('user_id', user.id)
+    .single()
+
+  if (fetchInvError || !invoice) {
+    return NextResponse.json({ error: 'Supplier invoice not found' }, { status: 404 })
+  }
+
+  if (invoice.status === 'paid' || invoice.status === 'credited') {
+    return NextResponse.json(
+      { error: 'Leverantörsfakturan är redan betald' },
+      { status: 400 }
+    )
+  }
+
+  const paymentAmount = Math.abs(transaction.amount)
+  const now = new Date().toISOString()
+
+  // Get accounting method
+  const { data: settings } = await supabase
+    .from('company_settings')
+    .select('accounting_method')
+    .eq('user_id', user.id)
+    .single()
+
+  const accountingMethod = settings?.accounting_method || 'accrual'
+
+  // Create journal entry
+  let journalEntryId: string | null = null
+
+  try {
+    if (accountingMethod === 'cash') {
+      const journalEntry = await createSupplierInvoiceCashEntry(
+        user.id,
+        invoice as SupplierInvoice,
+        (invoice.items || []) as SupplierInvoiceItem[],
+        transaction.date,
+        invoice.supplier?.supplier_type || 'swedish_business'
+      )
+      if (journalEntry) journalEntryId = journalEntry.id
+    } else {
+      const journalEntry = await createSupplierInvoicePaymentEntry(
+        user.id,
+        invoice as SupplierInvoice,
+        paymentAmount,
+        transaction.date
+      )
+      if (journalEntry) journalEntryId = journalEntry.id
+    }
+  } catch (err) {
+    console.error('Failed to create payment journal entry:', err)
+  }
+
+  // Update supplier invoice
+  const newRemaining = Math.max(0, Math.round((invoice.remaining_amount - paymentAmount) * 100) / 100)
+  const newPaidAmount = Math.round((invoice.paid_amount + paymentAmount) * 100) / 100
+  const isFullyPaid = newRemaining <= 0
+  const newStatus = isFullyPaid ? 'paid' : 'partially_paid'
+
+  const { error: updateInvError } = await supabase
+    .from('supplier_invoices')
+    .update({
+      status: newStatus,
+      remaining_amount: newRemaining,
+      paid_amount: newPaidAmount,
+      paid_at: isFullyPaid ? now : null,
+      payment_journal_entry_id: journalEntryId,
+      transaction_id: transactionId,
+    })
+    .eq('id', supplier_invoice_id)
+
+  if (updateInvError) {
+    return NextResponse.json({ error: 'Failed to update supplier invoice' }, { status: 500 })
+  }
+
+  // Record payment
+  await supabase.from('supplier_invoice_payments').insert({
+    supplier_invoice_id,
+    payment_date: transaction.date,
+    amount: paymentAmount,
+    currency: invoice.currency,
+    journal_entry_id: journalEntryId,
+    transaction_id: transactionId,
+  })
+
+  // Update transaction
+  const { error: updateTxError } = await supabase
+    .from('transactions')
+    .update({
+      supplier_invoice_id,
+      journal_entry_id: journalEntryId,
+      is_business: true,
+    })
+    .eq('id', transactionId)
+
+  if (updateTxError) {
+    return NextResponse.json({ error: 'Failed to link transaction' }, { status: 500 })
+  }
+
+  return NextResponse.json({
+    success: true,
+    invoice_status: newStatus,
+    paid_amount: newPaidAmount,
+    remaining_amount: newRemaining,
+    journal_entry_id: journalEntryId,
+  })
+}