New Base func

app/api/banking/sync/route.ts

@@ -1,6 +1,11 @@
 import { createClient } from '@/lib/supabase/server'
 import { NextResponse } from 'next/server'
+import { eventBus } from '@/lib/events'
+import { ensureInitialized } from '@/lib/init'
 import { syncAccountTransactions } from '@/lib/banking/sync-transactions'
+import type { Transaction } from '@/types'
+
+ensureInitialized()
 
 interface StoredAccount {
   uid: string
@@ -63,18 +68,38 @@ export async function POST(request: Request) {
     }
 
     // Update connection with new account balances and sync timestamp
+    const syncedAt = new Date().toISOString()
     await supabase
       .from('bank_connections')
       .update({
         accounts,
-        last_synced_at: new Date().toISOString(),
+        last_synced_at: syncedAt,
       })
       .eq('id', connection.id)
 
+    // Emit event with newly synced transactions
+    if (totalImported > 0) {
+      const { data: syncedTransactions } = await supabase
+        .from('transactions')
+        .select('*')
+        .eq('user_id', user.id)
+        .eq('bank_connection_id', connection.id)
+        .gte('created_at', fromDate)
+        .order('created_at', { ascending: false })
+        .limit(totalImported)
+
+      if (syncedTransactions && syncedTransactions.length > 0) {
+        await eventBus.emit({
+          type: 'transaction.synced',
+          payload: { transactions: syncedTransactions as Transaction[], userId: user.id },
+        })
+      }
+    }
+
     return NextResponse.json({
       imported: totalImported,
       duplicates: totalDuplicates,
-      last_synced_at: new Date().toISOString(),
+      last_synced_at: syncedAt,
     })
   } catch (error) {
     console.error('Sync error:', error)

app/api/bookkeeping/fiscal-periods/[id]/close/route.ts

@@ -0,0 +1,26 @@
+import { createClient } from '@/lib/supabase/server'
+import { NextResponse } from 'next/server'
+import { closePeriod } from '@/lib/core/bookkeeping/period-service'
+
+export async function POST(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params
+  const supabase = await createClient()
+  const { data: { user } } = await supabase.auth.getUser()
+
+  if (!user) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  try {
+    const period = await closePeriod(user.id, id)
+    return NextResponse.json({ data: period })
+  } catch (err) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : 'Failed to close period' },
+      { status: 400 }
+    )
+  }
+}

app/api/bookkeeping/fiscal-periods/[id]/lock/route.ts

@@ -0,0 +1,26 @@
+import { createClient } from '@/lib/supabase/server'
+import { NextResponse } from 'next/server'
+import { lockPeriod } from '@/lib/core/bookkeeping/period-service'
+
+export async function POST(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params
+  const supabase = await createClient()
+  const { data: { user } } = await supabase.auth.getUser()
+
+  if (!user) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  try {
+    const period = await lockPeriod(user.id, id)
+    return NextResponse.json({ data: period })
+  } catch (err) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : 'Failed to lock period' },
+      { status: 400 }
+    )
+  }
+}

app/api/bookkeeping/fiscal-periods/[id]/year-end/route.ts

@@ -0,0 +1,63 @@
+import { createClient } from '@/lib/supabase/server'
+import { NextResponse } from 'next/server'
+import {
+  validateYearEndReadiness,
+  previewYearEndClosing,
+  executeYearEndClosing,
+} from '@/lib/core/bookkeeping/year-end-service'
+
+/**
+ * GET: Validate readiness and preview year-end closing
+ */
+export async function GET(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params
+  const supabase = await createClient()
+  const { data: { user } } = await supabase.auth.getUser()
+
+  if (!user) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  try {
+    const [validation, preview] = await Promise.all([
+      validateYearEndReadiness(user.id, id),
+      previewYearEndClosing(user.id, id),
+    ])
+
+    return NextResponse.json({ data: { validation, preview } })
+  } catch (err) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : 'Failed to preview year-end' },
+      { status: 400 }
+    )
+  }
+}
+
+/**
+ * POST: Execute year-end closing
+ */
+export async function POST(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params
+  const supabase = await createClient()
+  const { data: { user } } = await supabase.auth.getUser()
+
+  if (!user) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  try {
+    const result = await executeYearEndClosing(user.id, id)
+    return NextResponse.json({ data: result })
+  } catch (err) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : 'Failed to execute year-end closing' },
+      { status: 400 }
+    )
+  }
+}

app/api/customers/route.ts

@@ -1,6 +1,10 @@
 import { createClient } from '@/lib/supabase/server'
 import { NextResponse } from 'next/server'
-import type { CreateCustomerInput } from '@/types'
+import { eventBus } from '@/lib/events'
+import { ensureInitialized } from '@/lib/init'
+import type { CreateCustomerInput, Customer } from '@/types'
+
+ensureInitialized()
 
 export async function GET() {
   const supabase = await createClient()
@@ -60,5 +64,10 @@ export async function POST(request: Request) {
     return NextResponse.json({ error: error.message }, { status: 500 })
   }
 
+  await eventBus.emit({
+    type: 'customer.created',
+    payload: { customer: data as Customer, userId: user.id },
+  })
+
   return NextResponse.json({ data })
 }

app/api/extensions/ai-categorization/settings/route.ts

@@ -0,0 +1,60 @@
+import { createClient } from '@/lib/supabase/server'
+import { NextResponse } from 'next/server'
+import { getSettings, saveSettings } from '@/extensions/ai-categorization'
+
+/**
+ * GET /api/extensions/ai-categorization/settings
+ * Get the current user's ai-categorization extension settings
+ */
+export async function GET() {
+  const supabase = await createClient()
+
+  const {
+    data: { user },
+  } = await supabase.auth.getUser()
+
+  if (!user) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const settings = await getSettings(user.id)
+  return NextResponse.json({ data: settings })
+}
+
+/**
+ * PATCH /api/extensions/ai-categorization/settings
+ * Update the current user's ai-categorization extension settings
+ */
+export async function PATCH(request: Request) {
+  const supabase = await createClient()
+
+  const {
+    data: { user },
+  } = await supabase.auth.getUser()
+
+  if (!user) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const body = await request.json()
+
+  // Validate setting keys
+  const allowedKeys = [
+    'autoSuggestEnabled',
+    'confidenceThreshold',
+    'providerModel',
+  ]
+  const filtered: Record<string, unknown> = {}
+  for (const key of allowedKeys) {
+    if (key in body) {
+      filtered[key] = body[key]
+    }
+  }
+
+  if (Object.keys(filtered).length === 0) {
+    return NextResponse.json({ error: 'No valid settings provided' }, { status: 400 })
+  }
+
+  const settings = await saveSettings(user.id, filtered)
+  return NextResponse.json({ data: settings })
+}

app/api/extensions/ai-categorization/suggestions/route.ts

@@ -0,0 +1,92 @@
+import { createClient } from '@/lib/supabase/server'
+import { NextResponse } from 'next/server'
+import { categorizeTransactions } from '@/extensions/ai-categorization'
+import type { CategorizationSuggestion } from '@/extensions/ai-categorization/categorizer'
+
+/**
+ * GET /api/extensions/ai-categorization/suggestions?transaction_ids=id1,id2,...
+ * Fetch pre-computed AI suggestions for given transaction IDs
+ */
+export async function GET(request: Request) {
+  const supabase = await createClient()
+
+  const {
+    data: { user },
+  } = await supabase.auth.getUser()
+
+  if (!user) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const { searchParams } = new URL(request.url)
+  const idsParam = searchParams.get('transaction_ids')
+
+  if (!idsParam) {
+    return NextResponse.json({ error: 'transaction_ids is required' }, { status: 400 })
+  }
+
+  const transactionIds = idsParam.split(',').filter(Boolean).slice(0, 50)
+
+  // Read stored suggestions from extension_data
+  const keys = transactionIds.map((id) => `suggestion:${id}`)
+
+  const { data: records } = await supabase
+    .from('extension_data')
+    .select('key, value')
+    .eq('user_id', user.id)
+    .eq('extension_id', 'ai-categorization')
+    .in('key', keys)
+
+  const suggestions: Record<string, CategorizationSuggestion> = {}
+  if (records) {
+    for (const record of records) {
+      const txId = record.key.replace('suggestion:', '')
+      suggestions[txId] = record.value as unknown as CategorizationSuggestion
+    }
+  }
+
+  return NextResponse.json({ suggestions })
+}
+
+/**
+ * POST /api/extensions/ai-categorization/suggestions
+ * Trigger on-demand AI categorization for given transaction IDs
+ */
+export async function POST(request: Request) {
+  const supabase = await createClient()
+
+  const {
+    data: { user },
+  } = await supabase.auth.getUser()
+
+  if (!user) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const body = await request.json()
+  const { transaction_ids } = body
+
+  if (!Array.isArray(transaction_ids) || transaction_ids.length === 0) {
+    return NextResponse.json({ error: 'transaction_ids is required' }, { status: 400 })
+  }
+
+  const ids = transaction_ids.slice(0, 50)
+
+  try {
+    const suggestions = await categorizeTransactions(user.id, ids)
+
+    // Group by transaction ID
+    const grouped: Record<string, CategorizationSuggestion> = {}
+    for (const s of suggestions) {
+      grouped[s.transactionId] = s
+    }
+
+    return NextResponse.json({ suggestions: grouped })
+  } catch (error) {
+    console.error('[ai-categorization] On-demand categorization failed:', error)
+    return NextResponse.json(
+      { error: 'AI categorization failed' },
+      { status: 500 }
+    )
+  }
+}

app/api/extensions/receipt-ocr/settings/route.ts

@@ -0,0 +1,61 @@
+import { createClient } from '@/lib/supabase/server'
+import { NextResponse } from 'next/server'
+import { getSettings, saveSettings } from '@/extensions/receipt-ocr'
+
+/**
+ * GET /api/extensions/receipt-ocr/settings
+ * Get the current user's receipt-ocr extension settings
+ */
+export async function GET() {
+  const supabase = await createClient()
+
+  const {
+    data: { user },
+  } = await supabase.auth.getUser()
+
+  if (!user) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const settings = await getSettings(user.id)
+  return NextResponse.json({ data: settings })
+}
+
+/**
+ * PATCH /api/extensions/receipt-ocr/settings
+ * Update the current user's receipt-ocr extension settings
+ */
+export async function PATCH(request: Request) {
+  const supabase = await createClient()
+
+  const {
+    data: { user },
+  } = await supabase.auth.getUser()
+
+  if (!user) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const body = await request.json()
+
+  // Validate setting keys
+  const allowedKeys = [
+    'autoOcrEnabled',
+    'autoMatchEnabled',
+    'autoMatchThreshold',
+    'ocrConfidenceThreshold',
+  ]
+  const filtered: Record<string, unknown> = {}
+  for (const key of allowedKeys) {
+    if (key in body) {
+      filtered[key] = body[key]
+    }
+  }
+
+  if (Object.keys(filtered).length === 0) {
+    return NextResponse.json({ error: 'No valid settings provided' }, { status: 400 })
+  }
+
+  const settings = await saveSettings(user.id, filtered)
+  return NextResponse.json({ data: settings })
+}

app/api/invoices/[id]/send/route.ts

@@ -1,5 +1,7 @@
 import { createClient } from '@/lib/supabase/server'
 import { NextResponse } from 'next/server'
+import { eventBus } from '@/lib/events'
+import { ensureInitialized } from '@/lib/init'
 import { renderToBuffer } from '@react-pdf/renderer'
 import { InvoicePDF } from '@/lib/invoice/pdf-template'
 import { sendEmail, isResendConfigured } from '@/lib/email/resend'
@@ -10,6 +12,8 @@ import {
 } from '@/lib/email/invoice-templates'
 import type { Invoice, InvoiceItem, Customer, CompanySettings } from '@/types'
 
+ensureInitialized()
+
 export async function POST(
   request: Request,
   { params }: { params: Promise<{ id: string }> }
@@ -154,6 +158,11 @@ export async function POST(
       // Don't fail the request - the email was sent successfully
     }
 
+    await eventBus.emit({
+      type: 'invoice.sent',
+      payload: { invoice: invoice as Invoice, userId: user.id },
+    })
+
     return NextResponse.json({
       success: true,
       message: `Fakturan har skickats till ${customer.email}`,

app/api/invoices/route.ts

@@ -1,6 +1,8 @@
 import { createClient } from '@/lib/supabase/server'
 import { NextResponse } from 'next/server'
-import type { CreateInvoiceInput, Invoice } from '@/types'
+import { eventBus } from '@/lib/events'
+import { ensureInitialized } from '@/lib/init'
+import type { CreateInvoiceInput, Invoice, CreditNote } from '@/types'
 import { getVatRules, calculateVat, calculateTotal } from '@/lib/invoice/vat-rules'
 import { fetchExchangeRate, convertToSEK } from '@/lib/currency/riksbanken'
 import {
@@ -8,6 +10,8 @@ import {
   createCreditNoteJournalEntry,
 } from '@/lib/bookkeeping/invoice-entries'
 
+ensureInitialized()
+
 interface CreateCreditNoteInput {
   credited_invoice_id: string
   reason?: string
@@ -189,6 +193,11 @@ export async function POST(request: Request) {
       console.error('Failed to create invoice journal entry:', err)
       // Don't fail the invoice creation
     }
+
+    await eventBus.emit({
+      type: 'invoice.created',
+      payload: { invoice: completeInvoice as Invoice, userId: user.id },
+    })
   }
 
   return NextResponse.json({ data: completeInvoice })
@@ -316,6 +325,11 @@ async function createCreditNote(
     } catch (err) {
       console.error('Failed to create credit note journal entry:', err)
     }
+
+    await eventBus.emit({
+      type: 'credit_note.created',
+      payload: { creditNote: completeCreditNote as CreditNote, userId },
+    })
   }
 
   return NextResponse.json({ data: completeCreditNote })

app/api/receipts/[id]/confirm/route.ts

@@ -1,6 +1,10 @@
 import { createClient } from '@/lib/supabase/server'
 import { NextResponse } from 'next/server'
-import type { ConfirmReceiptInput } from '@/types'
+import { eventBus } from '@/lib/events/bus'
+import { ensureInitialized } from '@/lib/init'
+import type { ConfirmReceiptInput, Receipt, ReceiptLineItem } from '@/types'
+
+ensureInitialized()
 
 /**
  * POST /api/receipts/[id]/confirm
@@ -104,5 +108,28 @@ export async function POST(
     return NextResponse.json({ error: 'Failed to update receipt' }, { status: 500 })
   }
 
+  // Calculate business/private totals from line items
+  const lineItems = ((updatedReceipt as unknown as Receipt).line_items || []) as ReceiptLineItem[]
+  let businessTotal = 0
+  let privateTotal = 0
+  for (const item of lineItems) {
+    if (item.is_business === true) {
+      businessTotal += item.line_total
+    } else if (item.is_business === false) {
+      privateTotal += item.line_total
+    }
+  }
+
+  // Emit receipt.confirmed event
+  await eventBus.emit({
+    type: 'receipt.confirmed',
+    payload: {
+      receipt: updatedReceipt as unknown as Receipt,
+      businessTotal: Math.round(businessTotal * 100) / 100,
+      privateTotal: Math.round(privateTotal * 100) / 100,
+      userId: user.id,
+    },
+  })
+
   return NextResponse.json({ data: updatedReceipt })
 }

app/api/receipts/[id]/match/route.ts

@@ -1,8 +1,12 @@
 import { createClient } from '@/lib/supabase/server'
 import { NextResponse } from 'next/server'
 import { findTransactionMatches } from '@/lib/receipts/receipt-matcher'
+import { eventBus } from '@/lib/events/bus'
+import { ensureInitialized } from '@/lib/init'
 import type { Receipt, Transaction } from '@/types'
 
+ensureInitialized()
+
 /**
  * POST /api/receipts/[id]/match
  * Find potential transaction matches for a receipt
@@ -100,7 +104,7 @@ export async function PATCH(
   // Verify receipt ownership
   const { data: receipt, error: receiptError } = await supabase
     .from('receipts')
-    .select('id')
+    .select('*, line_items:receipt_line_items(*)')
     .eq('id', id)
     .eq('user_id', user.id)
     .single()
@@ -112,7 +116,7 @@ export async function PATCH(
   // Verify transaction ownership
   const { data: transaction, error: txError } = await supabase
     .from('transactions')
-    .select('id')
+    .select('*')
     .eq('id', transaction_id)
     .eq('user_id', user.id)
     .single()
@@ -145,6 +149,18 @@ export async function PATCH(
     console.error('Transaction update error:', updateTxError)
   }
 
+  // Emit receipt.matched event
+  await eventBus.emit({
+    type: 'receipt.matched',
+    payload: {
+      receipt: receipt as unknown as Receipt,
+      transaction: transaction as Transaction,
+      confidence: match_confidence || 0,
+      autoMatched: false,
+      userId: user.id,
+    },
+  })
+
   return NextResponse.json({
     data: {
       receipt_id: id,

app/api/receipts/upload/route.ts

@@ -2,6 +2,10 @@ import { createClient } from '@/lib/supabase/server'
 import { NextResponse } from 'next/server'
 import { analyzeReceipt } from '@/lib/receipts/receipt-analyzer'
 import { processLineItems } from '@/lib/receipts/receipt-categorizer'
+import { eventBus } from '@/lib/events/bus'
+import { ensureInitialized } from '@/lib/init'
+
+ensureInitialized()
 
 /**
  * POST /api/receipts/upload
@@ -157,6 +161,17 @@ export async function POST(request: Request) {
         })
       }
 
+      // Emit receipt.extracted event
+      await eventBus.emit({
+        type: 'receipt.extracted',
+        payload: {
+          receipt: completeReceipt,
+          documentId: null,
+          confidence: extraction.confidence,
+          userId: user.id,
+        },
+      })
+
       return NextResponse.json({ data: completeReceipt })
     } catch (analysisError) {
       console.error('Receipt analysis error:', analysisError)

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

@@ -1,10 +1,14 @@
 import { createClient } from '@/lib/supabase/server'
 import { NextResponse } from 'next/server'
+import { eventBus } from '@/lib/events'
+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'
 
+ensureInitialized()
+
 interface CategorizeRequest {
   is_business: boolean
   category?: TransactionCategory
@@ -199,6 +203,16 @@ export async function POST(
     )
   }
 
+  await eventBus.emit({
+    type: 'transaction.categorized',
+    payload: {
+      transaction: transaction as Transaction,
+      account: mappingResult.debit_account,
+      taxCode: mappingResult.vat_lines[0]?.account_number || '',
+      userId: user.id,
+    },
+  })
+
   return NextResponse.json({
     success: true,
     journal_entry_created: journalEntryCreated,

app/api/transactions/suggest-categories/route.ts

@@ -1,6 +1,6 @@
 import { createClient } from '@/lib/supabase/server'
 import { NextResponse } from 'next/server'
-import { getSuggestedCategories, type SuggestedCategory } from '@/lib/transactions/category-suggestions'
+import { getSuggestedCategories, mergeAiSuggestions, type SuggestedCategory } from '@/lib/transactions/category-suggestions'
 import type { Transaction, TransactionCategory } from '@/types'
 
 /**
@@ -61,15 +61,40 @@ export async function POST(request: Request) {
     }
   }
 
+  // Fetch pre-computed AI suggestions for these transactions
+  const aiKeys = ids.map((id: string) => `suggestion:${id}`)
+  const { data: aiRecords } = await supabase
+    .from('extension_data')
+    .select('key, value')
+    .eq('user_id', user.id)
+    .eq('extension_id', 'ai-categorization')
+    .in('key', aiKeys)
+
+  const aiSuggestionsMap: Record<string, { category: string; basAccount: string; confidence: number; reasoning: string }> = {}
+  if (aiRecords) {
+    for (const record of aiRecords) {
+      const txId = record.key.replace('suggestion:', '')
+      aiSuggestionsMap[txId] = record.value as { category: string; basAccount: string; confidence: number; reasoning: string }
+    }
+  }
+
   // Generate suggestions for each transaction
   const suggestions: Record<string, SuggestedCategory[]> = {}
 
   for (const tx of transactions) {
-    suggestions[tx.id] = getSuggestedCategories(
+    let result = getSuggestedCategories(
       tx as Transaction,
       mappingRules || [],
       categoryHistory
     )
+
+    // Merge AI suggestions if available
+    const aiSuggestion = aiSuggestionsMap[tx.id]
+    if (aiSuggestion) {
+      result = mergeAiSuggestions(result, [aiSuggestion])
+    }
+
+    suggestions[tx.id] = result
   }
 
   return NextResponse.json({ suggestions })