Fix/skv connection flow (#1015)

* feat(salary): one-click AGI submission with filing state machine and success feedback The AGI panel required users to know that "Ladda ner AGI-fil" was the generate step, then click submit, signing link, and kvittens manually. A nollkorning filing stalled on "AGI-XML saknas" pointing at a UI path that does not exist. - New primary button "Lamna in till Skatteverket" chains the existing endpoints client-side: generate XML if missing, POST underlag, poll kontrollresultat, create signing link, open Mina Sidor in a tab opened synchronously at click (popup-blocker safe). Inline stepper shows each step; the four old buttons become collapsed advanced/recovery actions, auto-expanded in stale-draft and rejected states. XML download stays visible and free for manual filing. - deriveAgiFilingState() + useAgiSubmission() lift the per-period submission record to the run page: the progress rail and salary hero now render the real state machine (generated, underlag inskickat, vantar pa BankID-signatur, inlamnad med kvittensnummer) instead of telling users to "lamna in" an already-submitted declaration. - Success card with kvittensnummer and signature metadata once signed, plus a toast when a poll flips the state while the page is open. - AGI kvittens cron every 15 min instead of every 2 h so filings signed on another device get stamped and emailed promptly. - Advanced submit also auto-generates, and the stale "Lon -> AGI -> Generera" error text now points at the real buttons. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(enable-banking): instant OAuth callback feedback and dead-attempt cleanup The bank redirect landed on a blank page for the several seconds the callback spent exchanging the PSD2 session and mirroring accounts, and every failed connect attempt left a status='error' row that rendered forever as an "Atgard kravs" card next to a successful retry, showing duplicate connections to the same bank. - Stream a branded "Slutfor bankanslutningen" progress page from the callback: the shell flushes before the session exchange starts and a script/meta redirect follows when the work completes, with a 30s slow-work escape hatch. Fast outcomes (denial, bad params, unknown state) keep their plain redirects. - Delete never-activated connection rows (no session_id, no accounts_data) on denial or exchange failure, and sweep leftovers for the same bank on the next connect. Established connections keep their "Atgard krävs" card via the accounts_data guard; FKs are ON DELETE SET NULL so deletion has no dependents. - Show "Banken ar ansluten: hamtar dina konton" while the settings panel loads after the callback instead of an anonymous spinner. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(invoices): reject re-send of issued invoices and gate bookkeeping on the sent flip A direct POST to /api/invoices/[id]/send against an already-issued invoice re-emailed the customer and posted a second revenue verifikat (createInvoiceJournalEntry has no dedup), overwriting journal_entry_id and orphaning the first entry. Only the UI hid the button; the v1 route and the MCP commit executor already rejected non-drafts. - Non-draft invoices now return 409 INVOICE_ALREADY_SENT. - The draft to sent status flip is an optimistic lock (status guard plus row-count check); journal entry, accrual schedules, PDF archival and the invoice.sent event only run for the request that won the flip. - On a flip failure the journal entry is deferred: the row stays draft and a retry re-runs the pipeline, ending with exactly one verifikat. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(invoices): payment links, failure visibility and sandbox guard for recurring auto-send - sendInvoiceFromSchedule now auto-creates an online payment link via applyPaymentLinkToInvoice before rendering and passes the payment link QR to the PDF: parity with the dashboard and v1 send routes, which recurring invoices silently lacked. - The recurring cron persists last_run_warning both when a claimed run throws (hourly retries stay visible on the schedule) and when a stale schedule is rolled forward, so a deterministic failure can no longer skip a month silently. - Auto-send is blocked for sandbox companies at the email chokepoint (freeze-and-retain: the invoice is still generated as a draft), covering both the cron and the run-now route with one guard. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat(salary): close the Fortnox payroll API gaps (phases 1-4) Payroll now runs end-to-end through the open API, including onboarding a client from another payroll system, with every write staged for approval. - v1: per-employee payslips (list/detail/PDF), payslip line writes, run roster attach/remove, absence ranges (per-day storage), jamkning fields, cutover opening balances (single + atomic bulk PUT), vacation balance + vacation-year-close. PUT added to the wrapper's idempotency/ test-key set (test keys could otherwise write through PUT). - MCP: 10 new tools (get_employee/get_payslip/list_absence/ get_vacation_balance reads + staged update_payslip_line, register_absence, create_employee, update_employee, set_employee_opening_balances, close_vacation_year), executors, risk tiers, op-type CHECK expansions. create_employee encrypts personnummer at staging: pending_operations never holds plaintext. - Scope-map audit retrofit: 11 formerly unmapped tools now scoped; BREAKING for keys that relied on the 4 default-allow writes. - Cutover: employee_opening_balances (derived lock trigger, self-unlocks on run correction), engine YTD/karens/liability integration, Ingaende saldon section in the employee editor. - Arbetsschema-lite: employees.hours_per_week/workdays_per_week drive the hourly/daily divisors; legacy 173/21 preserved exactly at defaults so existing pay math is byte-identical. - Vacation ledger + semesterberedning/arsavslut: recomputed per-year day balances (synced on book/correct, non-fatal), year-close with the min-20 floor, 5-year sparade-dagar expiry to forced payout, and a 2920/2940 drift adjustment via the bookkeeping engine; Semester dashboard card with preview-then-confirm dialog. - Fix: Zod 4 defaults leak through .partial(), which made every sparse employee PATCH fail validation and reset defaulted columns. Migrations 20260713100000/101000/110000/121000/122000 (applied to staging with version rows; prod via merge). vacation_ledger renamed from 20260713120000 to avoid colliding with vat_declaration_totals_rpc. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * perf: cut dashboard page-load latency (region, round trips, caching, VAT RPC) The dominant cost was infrastructure: Vercel functions ran in iad1 (Washington D.C.) while Supabase (DB + auth) lives in eu-north-1 (Stockholm), so every request paid 4-5 transatlantic round trips of auth + company resolution before doing any real work (measured 530-1900ms for single-query GETs in prod logs). Pin functions to arn1 and cut the redundant work on top: - vercel.json: functions to arn1, same city as the database - getActiveCompanyId: preference + first-membership queries run in parallel; the fallback result doubles as validation in the common single-company case (one round trip instead of two sequential) - withRouteContext: Server-Timing header and authMs/companyMs/handlerMs in the op-completed log, so latency is attributable per phase - dashboard layout: nav badge counts off the critical path; DashboardNav loads them client-side via the new use-worklist-badges SWR hook with debounced realtime revalidation - swr (new dependency, approved): global provider; useCompanySettings shares one cache entry across consumers and renders from cache on back-navigation instead of re-showing skeletons - /pending: realtime refetch debounced; bulk operations previously fired 4 requests per row-change event - VAT declaration: new get_vat_declaration_totals RPC returns per-account totals, settlement-shape detection (#984) and source_type counts in ONE round trip instead of paging every entry+line through PostgREST. Account lists stay TS-side parameters so ACCOUNT_RUTA remains the single source of truth. Shape-exclusion coverage moved to tests/pg/vat-declaration-totals-rpc.pg.test.ts; DDL already applied to staging. - bundle: CommandPalette lazy-mounts on first Ctrl/Cmd+K, AgentChat dynamic-imports the markdown parser, @vercel/speed-insights (new dependency, approved) added for real-user timings The /salary fetch-waterfall fix from the same effort already landed inside 2084a756. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(invoices): settle öre-rounded payments from the mark-paid flow An invoice with öresavrundning shows a rounded "Att betala" on the PDF; the customer pays that amount (up to 50 öre off the stored öre total) and the invoice-page mark-paid flow rejected it with MATCH_AMOUNT_EXCEEDS_REMAINING: a dead end, while the bank-transaction match flow already absorbed the residual to 3740. - PaymentBookingDialog now proposes the rounded bank leg plus the 3740 residual line (credit when rounded up, debit when rounded down), resolved via getDisplayTotal from the per-invoice override and company_settings.ore_rounding. - settleInvoicePayment and the v1 mark-paid route absorb the sub-krona residual, gated by planInvoicePaymentForLines: absorption applies ONLY when the caller lines carry the exact residual on 3740; otherwise the strict plan applies (sub-krona partials stay partial, no-3740 overshoots keep the 400), so the GL can never diverge from the AR sub-ledger. - planInvoicePayment absorb-band boundary tightened to >= 1 kr: an exactly-1-kr overshoot used to slip past both the guard and the absorb branch and silently over-record paid_amount (pre-existing on the bank-match path). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(security): resolve all 7 PR compliance findings - ASVS V3.3: per-request CSP nonce on the enable-banking finalize page (mirrors the mcp-oauth consent page); inline scripts are nonce-bound - ASVS V16: decouple callback finalize work from the response stream (eager promise + next/server after()) so a client disconnect cannot drop session persistence or the consent_granted audit emit - ISO 27001 A.8.15: failed audit-event emits log through the structured logger with a stable message for log-based alerting - ASVS V2.3: recurring-invoice cron and run-now routes resolve isSandboxCompany themselves and pass an explicit suppressAutoSend flag (defence in depth around the email chokepoint, freeze-and-retain kept) - ISO 27001 A.8.11: stagePendingOperation rejects plaintext personnummer-bearing keys in params/preview_data (key-based guard; EF org numbers make value-matching unsafe) - ASVS V4.5: employee PATCH body is truly sparse; cleared number fields are omitted instead of resetting DB values to hardcoded fallbacks - ASVS V8.2.1: route-level tests pin the v1 cross-company deny (404 by convention, not 403) on the payslip PDF endpoint Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat: implement vacation-year basis change validation and error handling - Added tests to block vacation-year basis changes when open balances exist. - Implemented error handling for open-balances guard query failures in the settings route. - Enhanced absence route to reject reversed date ranges with a validation error. - Updated absence handling to use atomic upserts instead of delete+insert for better performance and reliability. - Refactored salary calculation logic to correctly handle age-based avgifter rates according to Skatteverket's rules. - Improved error messaging for vacation year closure adjustments. - Adjusted employee opening balances handling to preserve audit information during upserts. * feat(settings): add validation to block vacation-year basis change with open balances feat(absence): reject reversed date ranges in absence queries fix(absence): update absence handling to use atomic upserts instead of delete+insert fix(employee): improve validation for jamkning dates in employee updates fix(opening-balances): ensure created_by field is preserved during upserts test(absence): enhance tests for absence range and date validations test(calculation): add tests for age-based avgifter rates and edge cases test(semesterberedning): validate vacation year closure adjustments and error handling test(employee-opening-balances): update tests to reflect changes in salary_run_employees schema * fix(migrations): implement NOT VALID constraints for pending_operations and add validation migration --------- Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
2026-07-13 22:54:33 +02:00
parent e7e3c35f9e
commit b6332e9ff4
154 changed files with 18364 additions and 1867 deletions
@@ -0,0 +1,202 @@
+/**
+ * pg-real tests for 20260713101000_employee_opening_balances.sql
+ * (payroll gap-closure 2.1: cutover state for mid-year migrations).
+ *
+ * Verifies:
+ *   - table exists with RLS enabled + all four company-scoped policies
+ *   - RLS isolation: a member of another company sees nothing
+ *   - UNIQUE (company_id, employee_id)
+ *   - CHECK constraints (ytd_tax <= ytd_gross, karens 0-10)
+ *   - the DERIVED lock trigger: writes rejected once the employee has a
+ *     BOOKED salary run, and allowed again when that run is corrected
+ *     (self-unlocking is the point of deriving instead of flagging).
+ */
+import { describe, it, expect } from 'vitest'
+import { randomUUID } from 'node:crypto'
+import { getPool, withUserContext } from './setup'
+import { insertAuthUser, insertCompany, insertCompanyMember } from './fixtures'
+
+async function seedEmployee(): Promise<{
+  userId: string
+  companyId: string
+  employeeId: string
+}> {
+  const userId = await insertAuthUser()
+  const companyId = await insertCompany({ createdBy: userId })
+  await insertCompanyMember({ companyId, userId, role: 'owner' })
+
+  const employeeId = randomUUID()
+  await getPool().query(
+    `INSERT INTO public.employees
+       (id, company_id, user_id, first_name, last_name, personnummer, personnummer_last4, employment_start)
+     VALUES ($1, $2, $3, 'Test', 'Testsson', 'enc-payload', '0000', '2026-01-01')`,
+    [employeeId, companyId, userId],
+  )
+  return { userId, companyId, employeeId }
+}
+
+async function insertOpeningBalances(params: {
+  companyId: string
+  employeeId: string
+  ytdGross?: number
+  ytdTax?: number
+  karens?: number
+}): Promise<string> {
+  const id = randomUUID()
+  await getPool().query(
+    `INSERT INTO public.employee_opening_balances
+       (id, company_id, employee_id, cutover_date, ytd_gross, ytd_tax, ytd_net,
+        vacation_paid_days_remaining, vacation_saved_days_by_year,
+        opening_semester_liability, opening_semester_liability_avgifter,
+        karens_periods_adjustment)
+     VALUES ($1, $2, $3, '2026-07-01', $4, $5, 0, 12.5, '{"2025": 5}', 42000, 13196.4, $6)`,
+    [id, params.companyId, params.employeeId, params.ytdGross ?? 210000, params.ytdTax ?? 48000, params.karens ?? 1],
+  )
+  return id
+}
+
+async function seedBookedRun(companyId: string, userId: string, employeeId: string): Promise<string> {
+  const runId = randomUUID()
+  await getPool().query(
+    `INSERT INTO public.salary_runs (id, company_id, user_id, period_year, period_month, payment_date, status)
+     VALUES ($1, $2, $3, 2026, 7, '2026-07-25', 'booked')`,
+    [runId, companyId, userId],
+  )
+  await getPool().query(
+    `INSERT INTO public.salary_run_employees (id, salary_run_id, employee_id, company_id, salary_type, monthly_salary, employment_degree)
+     VALUES ($1, $2, $3, $4, 'monthly', 35000, 100)`,
+    [randomUUID(), runId, employeeId, companyId],
+  )
+  return runId
+}
+
+describe('employee_opening_balances schema', () => {
+  it('table exists with RLS enabled and all four policies', async () => {
+    const rls = await getPool().query<{ relrowsecurity: boolean }>(
+      `SELECT relrowsecurity FROM pg_class WHERE relname = 'employee_opening_balances'`,
+    )
+    expect(rls.rows).toHaveLength(1)
+    expect(rls.rows[0].relrowsecurity).toBe(true)
+
+    const policies = await getPool().query<{ cmd: string }>(
+      `SELECT cmd FROM pg_policies
+        WHERE schemaname = 'public' AND tablename = 'employee_opening_balances'`,
+    )
+    expect(policies.rows.map((r) => r.cmd).sort()).toEqual(['DELETE', 'INSERT', 'SELECT', 'UPDATE'])
+  })
+
+  it('enforces one row per (company_id, employee_id)', async () => {
+    const seed = await seedEmployee()
+    await insertOpeningBalances(seed)
+    await expect(insertOpeningBalances(seed)).rejects.toThrow()
+  })
+
+  it('rejects ytd_tax exceeding ytd_gross', async () => {
+    const seed = await seedEmployee()
+    await expect(
+      insertOpeningBalances({ ...seed, ytdGross: 1000, ytdTax: 2000 }),
+    ).rejects.toThrow()
+  })
+
+  it('rejects karens_periods_adjustment outside 0-10', async () => {
+    const seed = await seedEmployee()
+    await expect(insertOpeningBalances({ ...seed, karens: 11 })).rejects.toThrow()
+  })
+})
+
+describe('employee_opening_balances RLS isolation', () => {
+  it('members of another company cannot read the row', async () => {
+    const a = await seedEmployee()
+    await insertOpeningBalances(a)
+
+    const outsider = await insertAuthUser()
+    const outsiderCompany = await insertCompany({ createdBy: outsider })
+    await insertCompanyMember({ companyId: outsiderCompany, userId: outsider, role: 'owner' })
+
+    const visibleToOwner = await withUserContext(a.userId, async (client) => {
+      const res = await client.query(
+        `SELECT id FROM public.employee_opening_balances WHERE company_id = $1`,
+        [a.companyId],
+      )
+      return res.rows.length
+    })
+    expect(visibleToOwner).toBe(1)
+
+    const visibleToOutsider = await withUserContext(outsider, async (client) => {
+      const res = await client.query(
+        `SELECT id FROM public.employee_opening_balances WHERE company_id = $1`,
+        [a.companyId],
+      )
+      return res.rows.length
+    })
+    expect(visibleToOutsider).toBe(0)
+  })
+})
+
+describe('enforce_opening_balances_lock trigger', () => {
+  it('blocks INSERT once the employee has a booked run', async () => {
+    const seed = await seedEmployee()
+    await seedBookedRun(seed.companyId, seed.userId, seed.employeeId)
+    await expect(insertOpeningBalances(seed)).rejects.toThrow(/låsta/)
+  })
+
+  it('blocks UPDATE once the employee has a booked run', async () => {
+    const seed = await seedEmployee()
+    const rowId = await insertOpeningBalances(seed)
+    await seedBookedRun(seed.companyId, seed.userId, seed.employeeId)
+
+    await expect(
+      getPool().query(
+        `UPDATE public.employee_opening_balances SET ytd_gross = 999999 WHERE id = $1`,
+        [rowId],
+      ),
+    ).rejects.toThrow(/låsta/)
+  })
+
+  it('self-unlocks when the only booked run is corrected', async () => {
+    const seed = await seedEmployee()
+    const rowId = await insertOpeningBalances(seed)
+    const runId = await seedBookedRun(seed.companyId, seed.userId, seed.employeeId)
+
+    // Locked while booked.
+    await expect(
+      getPool().query(
+        `UPDATE public.employee_opening_balances SET ytd_gross = 250000 WHERE id = $1`,
+        [rowId],
+      ),
+    ).rejects.toThrow(/låsta/)
+
+    // The correction flow flips the run to 'corrected': exactly the moment
+    // re-editing opening balances becomes legitimate again.
+    await getPool().query(`UPDATE public.salary_runs SET status = 'corrected' WHERE id = $1`, [runId])
+
+    await getPool().query(
+      `UPDATE public.employee_opening_balances SET ytd_gross = 250000 WHERE id = $1`,
+      [rowId],
+    )
+    const after = await getPool().query<{ ytd_gross: string }>(
+      `SELECT ytd_gross FROM public.employee_opening_balances WHERE id = $1`,
+      [rowId],
+    )
+    expect(Number(after.rows[0].ytd_gross)).toBe(250000)
+  })
+
+  it('does not lock on draft or review runs', async () => {
+    const seed = await seedEmployee()
+    const runId = randomUUID()
+    await getPool().query(
+      `INSERT INTO public.salary_runs (id, company_id, user_id, period_year, period_month, payment_date, status)
+       VALUES ($1, $2, $3, 2026, 7, '2026-07-25', 'review')`,
+      [runId, seed.companyId, seed.userId],
+    )
+    await getPool().query(
+      `INSERT INTO public.salary_run_employees (id, salary_run_id, employee_id, company_id, salary_type, monthly_salary, employment_degree)
+       VALUES ($1, $2, $3, $4, 'monthly', 35000, 100)`,
+      [randomUUID(), runId, seed.employeeId, seed.companyId],
+    )
+
+    // Review runs are still editable payroll state: cutover values may
+    // legitimately change before the first booking.
+    await insertOpeningBalances(seed)
+  })
+})
@@ -0,0 +1,180 @@
+/**
+ * pg-real tests for 20260713122000_vacation_ledger.sql
+ * (payroll gap-closure 3.1: vacation balance ledger + year closures).
+ *
+ * Verifies:
+ *   - both tables exist with RLS enabled
+ *   - employee_vacation_balances has all four policies; vacation_year_closures
+ *     deliberately has NO DELETE policy (closures are audit artifacts)
+ *   - UNIQUE (company_id, employee_id, vacation_year_start) on the ledger
+ *   - UNIQUE (company_id, vacation_year_start) on closures (replay -> 409)
+ *   - RLS isolation across companies
+ *   - company_settings.salary_vacation_year_basis CHECK
+ */
+import { describe, it, expect } from 'vitest'
+import { randomUUID } from 'node:crypto'
+import { getPool, withUserContext } from './setup'
+import { insertAuthUser, insertCompany, insertCompanyMember } from './fixtures'
+
+async function seedEmployee(): Promise<{
+  userId: string
+  companyId: string
+  employeeId: string
+}> {
+  const userId = await insertAuthUser()
+  const companyId = await insertCompany({ createdBy: userId })
+  await insertCompanyMember({ companyId, userId, role: 'owner' })
+
+  const employeeId = randomUUID()
+  await getPool().query(
+    `INSERT INTO public.employees
+       (id, company_id, user_id, first_name, last_name, personnummer, personnummer_last4, employment_start)
+     VALUES ($1, $2, $3, 'Test', 'Testsson', 'enc-payload', '0000', '2026-01-01')`,
+    [employeeId, companyId, userId],
+  )
+  return { userId, companyId, employeeId }
+}
+
+async function insertBalance(params: {
+  companyId: string
+  employeeId: string
+  yearStart?: string
+}): Promise<string> {
+  const id = randomUUID()
+  await getPool().query(
+    `INSERT INTO public.employee_vacation_balances
+       (id, company_id, employee_id, vacation_year_start, entitled_days, taken_days, saved_days)
+     VALUES ($1, $2, $3, $4, 25, 3, '{"2025": 5}')`,
+    [id, params.companyId, params.employeeId, params.yearStart ?? '2026-01-01'],
+  )
+  return id
+}
+
+describe('employee_vacation_balances schema', () => {
+  it('table exists with RLS enabled and all four policies', async () => {
+    const rls = await getPool().query<{ relrowsecurity: boolean }>(
+      `SELECT relrowsecurity FROM pg_class WHERE relname = 'employee_vacation_balances'`,
+    )
+    expect(rls.rows).toHaveLength(1)
+    expect(rls.rows[0].relrowsecurity).toBe(true)
+
+    const policies = await getPool().query<{ cmd: string }>(
+      `SELECT cmd FROM pg_policies
+        WHERE schemaname = 'public' AND tablename = 'employee_vacation_balances'`,
+    )
+    expect(policies.rows.map((r) => r.cmd).sort()).toEqual(['DELETE', 'INSERT', 'SELECT', 'UPDATE'])
+  })
+
+  it('enforces one row per (company, employee, vacation year)', async () => {
+    const seed = await seedEmployee()
+    await insertBalance(seed)
+    await expect(insertBalance(seed)).rejects.toThrow()
+    // A different vacation year is fine.
+    await insertBalance({ ...seed, yearStart: '2027-01-01' })
+  })
+
+  it('rejects negative day counts and non-object saved_days', async () => {
+    const seed = await seedEmployee()
+    await expect(
+      getPool().query(
+        `INSERT INTO public.employee_vacation_balances
+           (id, company_id, employee_id, vacation_year_start, entitled_days)
+         VALUES ($1, $2, $3, '2026-01-01', -1)`,
+        [randomUUID(), seed.companyId, seed.employeeId],
+      ),
+    ).rejects.toThrow()
+    await expect(
+      getPool().query(
+        `INSERT INTO public.employee_vacation_balances
+           (id, company_id, employee_id, vacation_year_start, saved_days)
+         VALUES ($1, $2, $3, '2026-01-01', '[]')`,
+        [randomUUID(), seed.companyId, seed.employeeId],
+      ),
+    ).rejects.toThrow()
+  })
+
+  it('is isolated per company via RLS', async () => {
+    const a = await seedEmployee()
+    await insertBalance(a)
+
+    const outsider = await insertAuthUser()
+    const outsiderCompany = await insertCompany({ createdBy: outsider })
+    await insertCompanyMember({ companyId: outsiderCompany, userId: outsider, role: 'owner' })
+
+    const visibleToOwner = await withUserContext(a.userId, async (client) => {
+      const res = await client.query(
+        `SELECT id FROM public.employee_vacation_balances WHERE company_id = $1`,
+        [a.companyId],
+      )
+      return res.rows.length
+    })
+    expect(visibleToOwner).toBe(1)
+
+    const visibleToOutsider = await withUserContext(outsider, async (client) => {
+      const res = await client.query(
+        `SELECT id FROM public.employee_vacation_balances WHERE company_id = $1`,
+        [a.companyId],
+      )
+      return res.rows.length
+    })
+    expect(visibleToOutsider).toBe(0)
+  })
+})
+
+describe('vacation_year_closures schema', () => {
+  it('has SELECT/INSERT/UPDATE policies but deliberately NO DELETE policy', async () => {
+    const rls = await getPool().query<{ relrowsecurity: boolean }>(
+      `SELECT relrowsecurity FROM pg_class WHERE relname = 'vacation_year_closures'`,
+    )
+    expect(rls.rows[0].relrowsecurity).toBe(true)
+
+    const policies = await getPool().query<{ cmd: string }>(
+      `SELECT cmd FROM pg_policies
+        WHERE schemaname = 'public' AND tablename = 'vacation_year_closures'`,
+    )
+    expect(policies.rows.map((r) => r.cmd).sort()).toEqual(['INSERT', 'SELECT', 'UPDATE'])
+  })
+
+  it('enforces one closure per (company, vacation year): the replay anchor', async () => {
+    const seed = await seedEmployee()
+    const insertClosure = () =>
+      getPool().query(
+        `INSERT INTO public.vacation_year_closures
+           (id, company_id, vacation_year_start, closed_by, report)
+         VALUES ($1, $2, '2026-01-01', $3, '{"rows": []}')`,
+        [randomUUID(), seed.companyId, seed.userId],
+      )
+    await insertClosure()
+    await expect(insertClosure()).rejects.toThrow()
+  })
+})
+
+describe('company_settings.salary_vacation_year_basis', () => {
+  it('defaults to calendar and rejects unknown values', async () => {
+    const seed = await seedEmployee()
+    // company_settings row may not exist for a bare fixture company; insert one.
+    await getPool().query(
+      `INSERT INTO public.company_settings (company_id, user_id)
+       VALUES ($1, $2)
+       ON CONFLICT (company_id) DO NOTHING`,
+      [seed.companyId, seed.userId],
+    )
+    const row = await getPool().query<{ salary_vacation_year_basis: string }>(
+      `SELECT salary_vacation_year_basis FROM public.company_settings WHERE company_id = $1`,
+      [seed.companyId],
+    )
+    expect(row.rows[0].salary_vacation_year_basis).toBe('calendar')
+
+    await expect(
+      getPool().query(
+        `UPDATE public.company_settings SET salary_vacation_year_basis = 'anniversary' WHERE company_id = $1`,
+        [seed.companyId],
+      ),
+    ).rejects.toThrow()
+
+    await getPool().query(
+      `UPDATE public.company_settings SET salary_vacation_year_basis = 'statutory_apr_mar' WHERE company_id = $1`,
+      [seed.companyId],
+    )
+  })
+})
@@ -0,0 +1,327 @@
+/**
+ * pg-real test for get_vat_declaration_totals.
+ *
+ * The RPC backs the momsdeklaration and the settlement proposal: one SQL
+ * pass returns per-account totals, settlement-shaped entries, and per-
+ * source_type entry counts. The settlement-shape exclusion (#984) used to
+ * live in JS (lib/reports/vat-declaration.ts) with mocked-client unit
+ * tests; the behavior now lives here, against real Postgres:
+ *
+ *   - tagged vat_settlement entries never reach the totals;
+ *   - an untagged entry touching BOTH a declaration account and 2650/1650
+ *     is "shaped": excluded from totals, surfaced in
+ *     settlement_shaped_entries;
+ *   - opening-balance entries are exempt from shaping (carried-in 26xx
+ *     balances are unsettled VAT);
+ *   - a plain 2650 payment (no declaration account) is NOT shaped;
+ *   - source_type_counts covers all posted/reversed entries in the period,
+ *     including tagged settlements.
+ */
+import { describe, it, expect } from 'vitest'
+import { randomUUID } from 'node:crypto'
+import { getPool } from './setup'
+import { insertAuthUser, insertCompany, insertFiscalPeriod } from './fixtures'
+
+// Mirrors the TS call site (lib/reports/vat-declaration.ts): a small
+// representative slice of ACCOUNT_RUTA is enough since the full list is a
+// parameter, not baked into the SQL.
+const RUTA_ACCOUNTS = ['2611', '2621', '2641', '2645', '3001']
+const NET_ACCOUNTS = ['2650', '1650']
+const ALL_ACCOUNTS = [...RUTA_ACCOUNTS, ...NET_ACCOUNTS]
+
+interface RpcPayload {
+  totals: Array<{ account_number: string; debit: number; credit: number }>
+  settlement_shaped_entries: Array<{
+    id: string
+    status: string
+    entry_date: string
+    source_type: string | null
+    voucher_series: string | null
+    voucher_number: number | null
+  }>
+  source_type_counts: Record<string, number>
+}
+
+async function callRpc(
+  companyId: string,
+  start = '2026-01-01',
+  end = '2026-12-31',
+): Promise<RpcPayload> {
+  const { rows } = await getPool().query(
+    `SELECT public.get_vat_declaration_totals($1, $2, $3, $4, $5, $6) AS payload`,
+    [companyId, start, end, ALL_ACCOUNTS, RUTA_ACCOUNTS, NET_ACCOUNTS],
+  )
+  return rows[0].payload as RpcPayload
+}
+
+function totalsByAccount(payload: RpcPayload) {
+  return new Map(payload.totals.map((t) => [t.account_number, t]))
+}
+
+async function insertJournalEntry(params: {
+  userId: string
+  companyId: string
+  fiscalPeriodId: string
+  voucherNumber: number
+  status?: 'draft' | 'posted' | 'reversed'
+  sourceType?: string
+  entryDate?: string
+  lines: Array<{ account: string; debit: number; credit: number }>
+}): Promise<string> {
+  const id = randomUUID()
+  // Insert directly, bypassing commit_journal_entry's voucher sequencing —
+  // fine for a read-side RPC that only aggregates line/account references.
+  await getPool().query(
+    `INSERT INTO public.journal_entries
+       (id, user_id, company_id, fiscal_period_id, voucher_number, voucher_series,
+        entry_date, description, source_type, status)
+     VALUES ($1, $2, $3, $4, $5, 'A', $6, 'VAT RPC test', $7, $8)`,
+    [
+      id,
+      params.userId,
+      params.companyId,
+      params.fiscalPeriodId,
+      params.voucherNumber,
+      params.entryDate ?? '2026-03-15',
+      params.sourceType ?? 'manual',
+      params.status ?? 'posted',
+    ],
+  )
+  for (const line of params.lines) {
+    await getPool().query(
+      `INSERT INTO public.journal_entry_lines
+         (journal_entry_id, account_number, debit_amount, credit_amount)
+       VALUES ($1, $2, $3, $4)`,
+      [id, line.account, line.debit, line.credit],
+    )
+  }
+  return id
+}
+
+async function seedCompany() {
+  const userId = await insertAuthUser()
+  const companyId = await insertCompany({ createdBy: userId })
+  const fiscalPeriodId = await insertFiscalPeriod({ userId, companyId })
+  return { userId, companyId, fiscalPeriodId }
+}
+
+describe('get_vat_declaration_totals RPC', () => {
+  it('aggregates per-account debit/credit sums for posted entries', async () => {
+    const ctx = await seedCompany()
+
+    await insertJournalEntry({
+      ...ctx, voucherNumber: 1, sourceType: 'invoice_created',
+      lines: [
+        { account: '3001', debit: 0, credit: 10000 },
+        { account: '2611', debit: 0, credit: 2500 },
+        { account: '1930', debit: 12500, credit: 0 },
+      ],
+    })
+    await insertJournalEntry({
+      ...ctx, voucherNumber: 2, sourceType: 'bank_transaction',
+      lines: [
+        { account: '2641', debit: 250, credit: 0 },
+        { account: '1930', debit: 0, credit: 1250 },
+        { account: '6110', debit: 1000, credit: 0 },
+      ],
+    })
+
+    const payload = await callRpc(ctx.companyId)
+    const totals = totalsByAccount(payload)
+
+    expect(totals.get('3001')).toMatchObject({ debit: 0, credit: 10000 })
+    expect(totals.get('2611')).toMatchObject({ debit: 0, credit: 2500 })
+    expect(totals.get('2641')).toMatchObject({ debit: 250, credit: 0 })
+    // Non-VAT accounts (1930, 6110) never appear: they are outside p_accounts.
+    expect(totals.has('1930')).toBe(false)
+    expect(totals.has('6110')).toBe(false)
+    expect(payload.settlement_shaped_entries).toEqual([])
+    expect(payload.source_type_counts).toEqual({
+      invoice_created: 1,
+      bank_transaction: 1,
+    })
+  })
+
+  it('excludes draft entries and entries outside the period', async () => {
+    const ctx = await seedCompany()
+
+    await insertJournalEntry({
+      ...ctx, voucherNumber: 1, status: 'draft',
+      lines: [{ account: '2611', debit: 0, credit: 999 }],
+    })
+    await insertJournalEntry({
+      ...ctx, voucherNumber: 2, entryDate: '2025-12-31',
+      lines: [{ account: '2611', debit: 0, credit: 777 }],
+    })
+    await insertJournalEntry({
+      ...ctx, voucherNumber: 3, entryDate: '2026-06-30',
+      lines: [{ account: '2611', debit: 0, credit: 100 }],
+    })
+
+    const payload = await callRpc(ctx.companyId, '2026-01-01', '2026-12-31')
+    expect(totalsByAccount(payload).get('2611')).toMatchObject({ debit: 0, credit: 100 })
+    expect(payload.source_type_counts).toEqual({ manual: 1 })
+  })
+
+  it('excludes tagged vat_settlement entries from totals without shaping them', async () => {
+    const ctx = await seedCompany()
+
+    await insertJournalEntry({
+      ...ctx, voucherNumber: 1, sourceType: 'invoice_created',
+      lines: [{ account: '2611', debit: 0, credit: 2500 }],
+    })
+    // The app's own settlement flow: tagged, filtered by source_type alone.
+    await insertJournalEntry({
+      ...ctx, voucherNumber: 2, sourceType: 'vat_settlement',
+      lines: [
+        { account: '2611', debit: 2500, credit: 0 },
+        { account: '2650', debit: 0, credit: 2500 },
+      ],
+    })
+
+    const payload = await callRpc(ctx.companyId)
+    expect(totalsByAccount(payload).get('2611')).toMatchObject({ debit: 0, credit: 2500 })
+    expect(payload.settlement_shaped_entries).toEqual([])
+    // The metadata scan always counted tagged settlements: preserved.
+    expect(payload.source_type_counts).toEqual({
+      invoice_created: 1,
+      vat_settlement: 1,
+    })
+  })
+
+  it('shapes an untagged manual momsomföring: excluded from totals, surfaced for gating (#984)', async () => {
+    const ctx = await seedCompany()
+
+    await insertJournalEntry({
+      ...ctx, voucherNumber: 1, sourceType: 'invoice_created',
+      lines: [
+        { account: '2611', debit: 0, credit: 2500 },
+        { account: '2641', debit: 1000, credit: 0 },
+        { account: '3001', debit: 0, credit: 10000 },
+      ],
+    })
+    // Manual settlement clearing the period to 2650, booked without the
+    // vat_settlement source_type (e.g. before #980 shipped).
+    const shapedId = await insertJournalEntry({
+      ...ctx, voucherNumber: 2, sourceType: 'manual', entryDate: '2026-03-31',
+      lines: [
+        { account: '2611', debit: 2500, credit: 0 },
+        { account: '2641', debit: 0, credit: 1000 },
+        { account: '2650', debit: 0, credit: 1500 },
+      ],
+    })
+
+    const payload = await callRpc(ctx.companyId)
+    const totals = totalsByAccount(payload)
+
+    // Without the shape exclusion every ruta reads 0 after the settlement.
+    expect(totals.get('2611')).toMatchObject({ debit: 0, credit: 2500 })
+    expect(totals.get('2641')).toMatchObject({ debit: 1000, credit: 0 })
+    expect(totals.get('3001')).toMatchObject({ debit: 0, credit: 10000 })
+    // The shaped entry's 2650 line is excluded along with the rest of it.
+    expect(totals.has('2650')).toBe(false)
+
+    expect(payload.settlement_shaped_entries).toHaveLength(1)
+    expect(payload.settlement_shaped_entries[0]).toMatchObject({
+      id: shapedId,
+      status: 'posted',
+      source_type: 'manual',
+      voucher_series: 'A',
+      voucher_number: 2,
+    })
+  })
+
+  it('shapes a storno of a settlement so annullera never re-inflates the rutor', async () => {
+    const ctx = await seedCompany()
+
+    await insertJournalEntry({
+      ...ctx, voucherNumber: 1, sourceType: 'invoice_created',
+      lines: [{ account: '2611', debit: 0, credit: 100 }],
+    })
+    // The tagged settlement itself is filtered by source_type; its storno
+    // reversal is untagged and would otherwise re-credit 2611.
+    await insertJournalEntry({
+      ...ctx, voucherNumber: 2, sourceType: 'storno',
+      lines: [
+        { account: '2611', debit: 0, credit: 100 },
+        { account: '2650', debit: 100, credit: 0 },
+      ],
+    })
+
+    const payload = await callRpc(ctx.companyId)
+    expect(totalsByAccount(payload).get('2611')).toMatchObject({ debit: 0, credit: 100 })
+    expect(payload.settlement_shaped_entries).toHaveLength(1)
+    expect(payload.settlement_shaped_entries[0]).toMatchObject({ source_type: 'storno' })
+  })
+
+  it('keeps opening-balance entries: carried-in 26xx balances are unsettled VAT', async () => {
+    const ctx = await seedCompany()
+
+    // Migrating company: undeclared input VAT and a prior VAT debt carried
+    // in through the same opening-balance entry. Touches both a declaration
+    // account and 2650, but the shape rule exempts opening balances.
+    await insertJournalEntry({
+      ...ctx, voucherNumber: 1, sourceType: 'opening_balance', entryDate: '2026-01-01',
+      lines: [
+        { account: '2641', debit: 500, credit: 0 },
+        { account: '2650', debit: 0, credit: 300 },
+        { account: '1930', debit: 0, credit: 200 },
+      ],
+    })
+
+    const payload = await callRpc(ctx.companyId)
+    const totals = totalsByAccount(payload)
+    expect(totals.get('2641')).toMatchObject({ debit: 500, credit: 0 })
+    expect(totals.get('2650')).toMatchObject({ debit: 0, credit: 300 })
+    expect(payload.settlement_shaped_entries).toEqual([])
+  })
+
+  it('does not shape a plain VAT payment on 2650 (no declaration account touched)', async () => {
+    const ctx = await seedCompany()
+
+    await insertJournalEntry({
+      ...ctx, voucherNumber: 1, sourceType: 'invoice_created',
+      lines: [{ account: '2611', debit: 0, credit: 100 }],
+    })
+    // Paying last period's VAT debt: 2650 against the bank account.
+    await insertJournalEntry({
+      ...ctx, voucherNumber: 2, sourceType: 'bank_transaction',
+      lines: [
+        { account: '2650', debit: 75, credit: 0 },
+        { account: '1930', debit: 0, credit: 75 },
+      ],
+    })
+
+    const payload = await callRpc(ctx.companyId)
+    const totals = totalsByAccount(payload)
+    expect(totals.get('2611')).toMatchObject({ debit: 0, credit: 100 })
+    expect(totals.get('2650')).toMatchObject({ debit: 75, credit: 0 })
+    expect(payload.settlement_shaped_entries).toEqual([])
+  })
+
+  it('scopes everything to the requested company', async () => {
+    const a = await seedCompany()
+    const b = await seedCompany()
+
+    await insertJournalEntry({
+      ...a, voucherNumber: 1,
+      lines: [{ account: '2611', debit: 0, credit: 100 }],
+    })
+    await insertJournalEntry({
+      ...b, voucherNumber: 1,
+      lines: [{ account: '2611', debit: 0, credit: 999 }],
+    })
+
+    const payload = await callRpc(a.companyId)
+    expect(totalsByAccount(payload).get('2611')).toMatchObject({ debit: 0, credit: 100 })
+    expect(payload.source_type_counts).toEqual({ manual: 1 })
+  })
+
+  it('returns empty sections for a company without entries', async () => {
+    const ctx = await seedCompany()
+    const payload = await callRpc(ctx.companyId)
+    expect(payload.totals).toEqual([])
+    expect(payload.settlement_shaped_entries).toEqual([])
+    expect(payload.source_type_counts).toEqual({})
+  })
+})