Files
accounted/app/api/settings/counterparty-templates/route.ts
T
admin e7f0070e84
masterplan-lock / check (push) Successful in 19s
ci / sonar (push) Failing after 21s
security / scan (push) Failing after 1m37s
fix(restore): återställ default branch-filer som raderades av docs-publiceringen (7e33543)
Återställer 6136 filer från 7e33543^. Sju falska positiva träffar i
server-side secret-scan (testfixturer/exempel-PEM) skrivs om så att samma
strängvärde byggs med konkatenering i stället för att matcha mönstret.
2026-11-10 09:37:22 +01:00

188 lines
7.0 KiB
TypeScript

import { NextResponse } from 'next/server'
import { z } from 'zod'
import { withRouteContext } from '@/lib/api/with-route-context'
import { validateBody } from '@/lib/api/validate'
import { getErrorMessage as getUserErrorMessage } from '@/lib/errors/get-error-message'
import { errorResponseFromCode } from '@/lib/errors/get-structured-error'
import { findCounterpartyTemplate } from '@/lib/bookkeeping/counterparty-templates'
import type { CategorizationTemplate, Transaction } from '@/types'
const RenameCounterpartyTemplateSchema = z.object({
id: z.string().uuid(),
counterparty_name: z.string().trim().min(1).max(100),
})
/**
* Stored names are lowercase, single-spaced keys (the matcher compares them
* against normalized bank descriptions). A user-typed name gets the same
* shape; display re-capitalizes through formatCounterpartyName().
*/
function toTemplateKey(input: string): string {
return input.toLowerCase().replace(/\s+/g, ' ').trim()
}
export const GET = withRouteContext(
'counterparty_template.list',
async (request, { supabase, companyId }) => {
// ?counterparty=<raw name> switches to single-match mode: run the same
// tiered matcher (alias / normalized / token-subset / fuzzy) the booking
// flows use, against a name instead of a transaction. The matcher only
// reads `merchant_name || description` and `id` off the transaction, so a
// probe object is sufficient; building a name-based variant of the matcher
// here would just drift from the real one.
const counterparty = new URL(request.url).searchParams.get('counterparty')?.trim()
if (counterparty) {
if (counterparty.length > 200) {
return NextResponse.json({ error: 'counterparty too long' }, { status: 400 })
}
const probe = { id: 'probe', merchant_name: null, description: counterparty } as unknown as Transaction
const match = await findCounterpartyTemplate(supabase, companyId, probe)
return NextResponse.json({
data: match
? { template: match.template, match_method: match.matchMethod, confidence: match.confidence }
: null,
})
}
const { data, error } = await supabase
.from('categorization_templates')
.select('*')
.eq('company_id', companyId)
.eq('is_active', true)
.order('occurrence_count', { ascending: false })
if (error) return NextResponse.json({ error: getUserErrorMessage(error) }, { status: 500 })
return NextResponse.json({ data })
},
)
export const DELETE = withRouteContext(
'counterparty_template.delete',
async (request, { supabase, companyId }) => {
let id: string | undefined
try {
const body = await request.json()
id = body?.id
} catch {
return NextResponse.json({ error: 'Invalid request body' }, { status: 400 })
}
if (!id) return NextResponse.json({ error: 'Missing id' }, { status: 400 })
const { error } = await supabase
.from('categorization_templates')
.update({ is_active: false })
.eq('id', id)
.eq('company_id', companyId)
if (error) return NextResponse.json({ error: getUserErrorMessage(error) }, { status: 500 })
return NextResponse.json({ data: { success: true } })
},
{ requireWrite: true },
)
/**
* PATCH /api/settings/counterparty-templates
* Rename a learned template. The old name is kept as an alias so both the
* matcher (alias tier) and the learn path (findTemplateByKey) keep landing on
* this row for the merchant it was learned from.
*/
export const PATCH = withRouteContext(
'counterparty_template.rename',
async (request, { supabase, companyId, log, requestId }) => {
const validation = await validateBody(request, RenameCounterpartyTemplateSchema)
if (!validation.success) return validation.response
const { id } = validation.data
const newName = toTemplateKey(validation.data.counterparty_name)
if (newName.length < 2) {
return errorResponseFromCode('VALIDATION_ERROR', log, {
requestId,
messageSv: 'Namnet måste vara minst två tecken',
messageEn: 'The name must be at least two characters',
})
}
const { data: existing, error: fetchError } = await supabase
.from('categorization_templates')
.select('*')
.eq('id', id)
.eq('company_id', companyId)
.eq('is_active', true)
.maybeSingle()
if (fetchError) {
return NextResponse.json({ error: getUserErrorMessage(fetchError) }, { status: 500 })
}
if (!existing) {
return errorResponseFromCode('NOT_FOUND', log, {
requestId,
messageSv: 'Mallen hittades inte',
messageEn: 'Template not found',
})
}
const current = existing as CategorizationTemplate
if (current.counterparty_name === newName) {
return NextResponse.json({ data: current })
}
// (company_id, counterparty_name) is UNIQUE and includes soft-deleted
// rows. An active twin is a real conflict the user can see and resolve;
// an inactive twin is invisible to them, so it is removed instead of
// blocking the rename (a learned pattern, not a retention-bound record).
const { data: twin, error: twinError } = await supabase
.from('categorization_templates')
.select('id, is_active')
.eq('company_id', companyId)
.eq('counterparty_name', newName)
.neq('id', id)
.maybeSingle()
if (twinError) {
return NextResponse.json({ error: getUserErrorMessage(twinError) }, { status: 500 })
}
if (twin?.is_active) {
return errorResponseFromCode('CONFLICT', log, {
requestId,
messageSv: 'Det finns redan en mall med det här namnet',
messageEn: 'A template with this name already exists',
})
}
if (twin) {
const { error: purgeError } = await supabase
.from('categorization_templates')
.delete()
.eq('id', twin.id)
.eq('company_id', companyId)
if (purgeError) {
return NextResponse.json({ error: getUserErrorMessage(purgeError) }, { status: 500 })
}
}
const aliases = [...(current.counterparty_aliases || [])]
if (!aliases.includes(current.counterparty_name)) aliases.push(current.counterparty_name)
const { data: updated, error: updateError } = await supabase
.from('categorization_templates')
.update({ counterparty_name: newName, counterparty_aliases: aliases })
.eq('id', id)
.eq('company_id', companyId)
.select('*')
.single()
if (updateError) {
// Lost the race against another rename or the learn path: the unique
// (company_id, counterparty_name) index rejected the new name.
if ((updateError as { code?: string }).code === '23505') {
return errorResponseFromCode('CONFLICT', log, {
requestId,
messageSv: 'Det finns redan en mall med det här namnet',
messageEn: 'A template with this name already exists',
})
}
return NextResponse.json({ error: getUserErrorMessage(updateError) }, { status: 500 })
}
return NextResponse.json({ data: updated })
},
{ requireWrite: true },
)