Phase 7 abgeschlossen: Suche mit gestuftem Index, Facetten, Palette
Der bisherige Suchvektor enthielt nur, was jeder sehen darf. Das war leck-sicher und unbrauchbar zugleich: ab Stufe 1 fand die Suche nichts von dem, was einen Fall ausmacht. SearchIndex hält jetzt sechs Zeilen je Ziel, eine pro Freigabestufe. Die Zeile zur Stufe N enthält alles, was ein Leser dieser Stufe sehen darf. Eine Suche nimmt genau diese eine Zeile und kann deshalb nichts finden, was sie nicht lesen darf — auch keinen höher eingestuften Eintrag in einer sichtbaren Akte. Schwärzungen werden dabei stufenweise aufgelöst: strip_redactions_above entfernt nur, was über der Stufe liegt. Sonst fände ein Leser der Stufe 4 einen Namen nicht, den er auf der Seite im Klartext sieht, und ein Leser der Stufe 1 einen, den er dort nur als Balken sieht. Die Suchbedingung ist nicht die Zugriffsprüfung: der Volltext liefert Kandidaten, die Sichtbarkeit kommt aus visibleCaseWhere — derselben Funktion wie in der Fallliste, und Treffer, Trefferzahl und Facettenzähler entstehen gemeinsam in einer Abfrage. Eine in SQL nachgebaute Sichtbarkeitsregel wäre die Sorte Duplikat, die auseinanderläuft. Filter stehen in der Adresse. Damit ist jeder Zustand teilbar, der Zurück-Knopf tut das Richtige, und eine gespeicherte Ansicht ist ein Lesezeichen. Die mitgelieferten Ansichten stehen im Programm, weil sie von der Gegenwart abhängen. Strg+K öffnet die Kommandopalette. Im Grundgerüst steckt nur das Tastaturereignis, die Palette selbst wird beim Öffnen geholt — das kostet die anderen Seiten rund hundert Byte. Offen geblieben: "Zuletzt geöffnet" als Ansicht. Dafür müsste jeder Aufruf jeder Akte mitgeschrieben werden; das wäre eine Überwachungsfunktion, die niemand bestellt hat. In TASKS vermerkt. 165 Tests im Web-Paket, 17 in der Datenbank, 7 im Worker, 34 e2e. Grösste Route bei 119,7 kB gegen 120 erlaubte. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Harlekin
co-authored by
Claude Opus 5
Claude Opus 5
parent
34a8b96dd3
commit
71c20f4b95
@@ -0,0 +1,62 @@
|
||||
/**
|
||||
* Die Filter einer Suche, als Adressparameter und als Objekt.
|
||||
*
|
||||
* Ohne Abhängigkeiten: die Suchseite baut damit ihre Adresse, und gespeicherte
|
||||
* Ansichten sind nichts anderes als eine solche Adresse. Dass beides dieselbe
|
||||
* Darstellung benutzt, ist der Punkt — eine Ansicht ist ein Lesezeichen.
|
||||
*/
|
||||
|
||||
export const SEARCH_KINDS = ['case', 'document', 'personnel'] as const
|
||||
export type SearchKind = (typeof SEARCH_KINDS)[number]
|
||||
|
||||
export type SearchFilters = {
|
||||
q: string
|
||||
kind: SearchKind
|
||||
status?: string
|
||||
templateKey?: string
|
||||
classification?: number
|
||||
/** Nur Akten, an denen der Suchende beteiligt ist. */
|
||||
mine?: boolean
|
||||
/** Wiedervorlage bis einschliesslich diesem Tag. */
|
||||
dueBefore?: string
|
||||
/** Seit diesem Zeitpunkt geändert, ISO. */
|
||||
changedSince?: string
|
||||
/** Seit diesem Zeitpunkt **nicht** geändert, ISO. */
|
||||
idleSince?: string
|
||||
cursor?: string
|
||||
}
|
||||
|
||||
export function parseFilters(params: URLSearchParams | Record<string, string | undefined>): SearchFilters {
|
||||
const get = (name: string): string | undefined => {
|
||||
const wert = params instanceof URLSearchParams ? params.get(name) : params[name]
|
||||
return wert && wert.length > 0 ? wert : undefined
|
||||
}
|
||||
|
||||
const kind = get('kind')
|
||||
const stufe = get('classification')
|
||||
|
||||
return {
|
||||
q: (get('q') ?? '').slice(0, 200),
|
||||
kind: (SEARCH_KINDS as readonly string[]).includes(kind ?? '')
|
||||
? (kind as SearchKind)
|
||||
: 'case',
|
||||
status: get('status'),
|
||||
templateKey: get('templateKey'),
|
||||
classification: stufe !== undefined && /^[0-5]$/.test(stufe) ? Number(stufe) : undefined,
|
||||
mine: get('mine') === '1',
|
||||
dueBefore: get('dueBefore'),
|
||||
changedSince: get('changedSince'),
|
||||
idleSince: get('idleSince'),
|
||||
cursor: get('cursor'),
|
||||
}
|
||||
}
|
||||
|
||||
/** Zurück in eine Adresse. Leere Filter fallen weg, damit sie kurz bleibt. */
|
||||
export function toSearchParams(filters: Partial<SearchFilters>): string {
|
||||
const params = new URLSearchParams()
|
||||
for (const [name, wert] of Object.entries(filters)) {
|
||||
if (wert === undefined || wert === '' || wert === false) continue
|
||||
params.set(name, wert === true ? '1' : String(wert))
|
||||
}
|
||||
return params.toString()
|
||||
}
|
||||
@@ -0,0 +1,217 @@
|
||||
import { db } from '@/lib/db'
|
||||
import { visibleCaseWhere } from '@/lib/access/caseFilter'
|
||||
import { visibleDocumentWhere, visiblePersonnelWhere } from '@/lib/access/personnelFilter'
|
||||
import type { SearchFilters } from '@/lib/search/query'
|
||||
import type { EffectivePermissions } from '@/lib/auth/permissions'
|
||||
import type { Prisma } from '@afis/db'
|
||||
|
||||
/**
|
||||
* Volltextsuche über Postgres, deutsche Konfiguration. Kein Elasticsearch.
|
||||
*
|
||||
* Zwei Schritte, und der Unterschied ist wichtig:
|
||||
*
|
||||
* 1. **Was passt** — eine Abfrage auf `SearchIndex`, in der Zeile zur Stufe
|
||||
* des Suchenden. Sie kann nichts liefern, was er nicht lesen darf, weil
|
||||
* höher eingestufte Inhalte gar nicht erst in dieser Zeile stehen.
|
||||
* 2. **Was er sehen darf und wie viele es sind** — eine Abfrage mit
|
||||
* `visibleCaseWhere` und den Filtern. Treffer, Trefferzahl und die
|
||||
* Facettenzähler entstehen dort **gemeinsam**, damit sich aus einer Lücke
|
||||
* nichts ableiten lässt. Siehe docs/08-suche-und-export.md.
|
||||
*
|
||||
* Der erste Schritt ist die Suchbedingung, nicht die Zugriffsprüfung. Die
|
||||
* steht ausschliesslich im zweiten und stammt aus derselben Funktion wie in
|
||||
* der Fallliste — es gibt keine zweite Fassung davon.
|
||||
*/
|
||||
|
||||
/** So viele Treffer holt der Volltext höchstens, nach Rang sortiert. */
|
||||
const FTS_LIMIT = 500
|
||||
|
||||
export const PAGE_SIZE = 25
|
||||
|
||||
export type Facet = { value: string; count: number }
|
||||
|
||||
async function matchingIds(
|
||||
targetType: 'case' | 'document' | 'personnel',
|
||||
q: string,
|
||||
clearanceLevel: number,
|
||||
): Promise<string[] | null> {
|
||||
const begriff = q.trim()
|
||||
// Ohne Suchbegriff filtert die Seite nur — dann gibt es keine Vorauswahl.
|
||||
if (begriff.length === 0) return null
|
||||
|
||||
const rows = await db.$queryRaw<{ targetId: string }[]>`
|
||||
SELECT "targetId"
|
||||
FROM "SearchIndex"
|
||||
WHERE "targetType" = ${targetType}
|
||||
AND "minClearance" = ${Math.min(Math.max(clearanceLevel, 0), 5)}
|
||||
AND "vector" @@ websearch_to_tsquery('german', ${begriff})
|
||||
ORDER BY ts_rank("vector", websearch_to_tsquery('german', ${begriff})) DESC
|
||||
LIMIT ${FTS_LIMIT}
|
||||
`
|
||||
return rows.map((row) => row.targetId)
|
||||
}
|
||||
|
||||
function caseWhere(
|
||||
p: EffectivePermissions,
|
||||
filters: SearchFilters,
|
||||
ids: string[] | null,
|
||||
): Prisma.CaseWhereInput {
|
||||
const bedingungen: Prisma.CaseWhereInput[] = [visibleCaseWhere(p)]
|
||||
|
||||
if (ids !== null) bedingungen.push({ id: { in: ids } })
|
||||
if (filters.status) bedingungen.push({ status: filters.status as never })
|
||||
if (filters.templateKey) bedingungen.push({ templateKey: filters.templateKey })
|
||||
if (filters.classification !== undefined) {
|
||||
bedingungen.push({ classification: filters.classification })
|
||||
}
|
||||
if (filters.mine) bedingungen.push({ participants: { some: { userId: p.userId } } })
|
||||
if (filters.dueBefore) {
|
||||
bedingungen.push({ dueAt: { not: null, lte: new Date(filters.dueBefore) } })
|
||||
}
|
||||
if (filters.changedSince) bedingungen.push({ updatedAt: { gte: new Date(filters.changedSince) } })
|
||||
if (filters.idleSince) bedingungen.push({ updatedAt: { lt: new Date(filters.idleSince) } })
|
||||
|
||||
return { AND: bedingungen }
|
||||
}
|
||||
|
||||
export type CaseHit = {
|
||||
id: string
|
||||
caseNumber: string
|
||||
title: string
|
||||
status: string
|
||||
classification: number
|
||||
updatedAt: Date
|
||||
}
|
||||
|
||||
export async function searchCases(p: EffectivePermissions, filters: SearchFilters) {
|
||||
const ids = await matchingIds('case', filters.q, p.clearanceLevel)
|
||||
const where = caseWhere(p, filters, ids)
|
||||
|
||||
const cursorFilter: Prisma.CaseWhereInput = filters.cursor
|
||||
? (() => {
|
||||
const [at, id] = filters.cursor!.split('_')
|
||||
if (!at || !id) return {}
|
||||
const zeit = new Date(Number(at))
|
||||
return { OR: [{ updatedAt: { lt: zeit } }, { updatedAt: zeit, id: { lt: id } }] }
|
||||
})()
|
||||
: {}
|
||||
|
||||
const [treffer, total, nachStatus, nachArt, nachStufe] = await Promise.all([
|
||||
db.case.findMany({
|
||||
where: { AND: [where, cursorFilter] },
|
||||
orderBy: [{ updatedAt: 'desc' }, { id: 'desc' }],
|
||||
take: PAGE_SIZE + 1,
|
||||
select: {
|
||||
id: true,
|
||||
caseNumber: true,
|
||||
title: true,
|
||||
status: true,
|
||||
classification: true,
|
||||
updatedAt: true,
|
||||
},
|
||||
}),
|
||||
db.case.count({ where }),
|
||||
// Die Facetten laufen über **dieselbe** Bedingung. Ein Zähler, der mehr
|
||||
// zählt als die Liste zeigt, wäre selbst eine Information.
|
||||
db.case.groupBy({ by: ['status'], where, _count: { _all: true } }),
|
||||
db.case.groupBy({ by: ['templateKey'], where, _count: { _all: true } }),
|
||||
db.case.groupBy({ by: ['classification'], where, _count: { _all: true } }),
|
||||
])
|
||||
|
||||
const hasMore = treffer.length > PAGE_SIZE
|
||||
const page = hasMore ? treffer.slice(0, PAGE_SIZE) : treffer
|
||||
const last = page.at(-1)
|
||||
|
||||
return {
|
||||
hits: page as CaseHit[],
|
||||
total,
|
||||
cursor: hasMore && last ? `${last.updatedAt.getTime()}_${last.id}` : null,
|
||||
/** Bei einer Suche ohne Begriff sind alle sichtbaren Akten die Grundmenge. */
|
||||
truncated: ids !== null && ids.length === FTS_LIMIT,
|
||||
facets: {
|
||||
status: zuFacet(nachStatus, 'status'),
|
||||
templateKey: zuFacet(nachArt, 'templateKey'),
|
||||
classification: zuFacet(nachStufe, 'classification'),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
export async function searchDocuments(p: EffectivePermissions, filters: SearchFilters) {
|
||||
const ids = await matchingIds('document', filters.q, p.clearanceLevel)
|
||||
const where: Prisma.DocumentWhereInput = {
|
||||
AND: [
|
||||
visibleDocumentWhere(p),
|
||||
...(ids !== null ? [{ id: { in: ids } }] : []),
|
||||
...(filters.templateKey ? [{ templateKey: filters.templateKey }] : []),
|
||||
...(filters.classification !== undefined
|
||||
? [{ classification: filters.classification }]
|
||||
: []),
|
||||
],
|
||||
}
|
||||
|
||||
const [hits, total] = await Promise.all([
|
||||
db.document.findMany({
|
||||
where,
|
||||
orderBy: { updatedAt: 'desc' },
|
||||
take: PAGE_SIZE,
|
||||
select: {
|
||||
id: true,
|
||||
documentNumber: true,
|
||||
title: true,
|
||||
status: true,
|
||||
layout: true,
|
||||
classification: true,
|
||||
updatedAt: true,
|
||||
},
|
||||
}),
|
||||
db.document.count({ where }),
|
||||
])
|
||||
|
||||
return { hits, total, truncated: ids !== null && ids.length === FTS_LIMIT }
|
||||
}
|
||||
|
||||
export async function searchPersonnel(p: EffectivePermissions, filters: SearchFilters) {
|
||||
const ids = await matchingIds('personnel', filters.q, p.clearanceLevel)
|
||||
const where: Prisma.PersonnelFileWhereInput = {
|
||||
AND: [
|
||||
visiblePersonnelWhere(p),
|
||||
...(ids !== null ? [{ id: { in: ids } }] : []),
|
||||
...(filters.classification !== undefined
|
||||
? [{ classification: filters.classification }]
|
||||
: []),
|
||||
],
|
||||
}
|
||||
|
||||
const [hits, total] = await Promise.all([
|
||||
db.personnelFile.findMany({
|
||||
where,
|
||||
orderBy: { displayName: 'asc' },
|
||||
take: PAGE_SIZE,
|
||||
select: {
|
||||
id: true,
|
||||
displayName: true,
|
||||
rank: true,
|
||||
department: true,
|
||||
statusTags: true,
|
||||
classification: true,
|
||||
},
|
||||
}),
|
||||
db.personnelFile.count({ where }),
|
||||
])
|
||||
|
||||
return { hits, total, truncated: ids !== null && ids.length === FTS_LIMIT }
|
||||
}
|
||||
|
||||
/**
|
||||
* `groupBy` liefert je Zeile den gruppierten Wert und die Zahl. Welcher
|
||||
* Schlüssel das ist, weiss erst der Aufrufer, deshalb hier eine schmale
|
||||
* Umformung statt einer generischen Typakrobatik.
|
||||
*/
|
||||
function zuFacet(rows: { _count: { _all: number } }[], key: string): Facet[] {
|
||||
return rows
|
||||
.map((row) => ({
|
||||
value: String((row as unknown as Record<string, unknown>)[key]),
|
||||
count: row._count._all,
|
||||
}))
|
||||
.sort((a, b) => b.count - a.count)
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
import { toSearchParams } from '@/lib/search/query'
|
||||
|
||||
/**
|
||||
* Die mitgelieferten Ansichten aus docs/08-suche-und-export.md.
|
||||
*
|
||||
* Sie stehen im Programm und nicht in der Datenbank, weil sie von der
|
||||
* **Gegenwart** abhängen: „diese Woche" und „seit 14 Tagen" wären als
|
||||
* gespeicherte Zeitpunkte schon am nächsten Tag falsch. Selbst angelegte
|
||||
* Ansichten sind dagegen genau das — ein Lesezeichen auf eine Adresse.
|
||||
*/
|
||||
export type BuiltinView = { key: string; params: string }
|
||||
|
||||
export function builtinViews(now: Date = new Date()): BuiltinView[] {
|
||||
const inTagen = (tage: number): string => {
|
||||
const datum = new Date(now)
|
||||
datum.setDate(datum.getDate() + tage)
|
||||
return datum.toISOString().slice(0, 10)
|
||||
}
|
||||
|
||||
return [
|
||||
{ key: 'mine', params: toSearchParams({ mine: true }) },
|
||||
{ key: 'dueThisWeek', params: toSearchParams({ dueBefore: inTagen(7) }) },
|
||||
{
|
||||
key: 'idle',
|
||||
params: toSearchParams({
|
||||
idleSince: new Date(now.getTime() - 14 * 86_400_000).toISOString(),
|
||||
status: 'OPEN',
|
||||
}),
|
||||
},
|
||||
{ key: 'open', params: toSearchParams({ status: 'OPEN' }) },
|
||||
]
|
||||
}
|
||||
|
||||
/**
|
||||
* „Seit deinem letzten Besuch geändert" braucht die Lesemarke und steht
|
||||
* deshalb nicht in der Liste oben — die Seite ergänzt sie, wenn es eine gibt.
|
||||
*/
|
||||
export function sinceLastVisitView(lastReadAt: Date): BuiltinView {
|
||||
return { key: 'sinceLastVisit', params: toSearchParams({ changedSince: lastReadAt.toISOString() }) }
|
||||
}
|
||||
Reference in New Issue
Block a user