Repository Public
1// SP Mail Next — essais de la logique pure de la recherche : pastilles ⇄ requête (à l'identique du serveur), erreurs, panneau, pages.2import assert from "node:assert/strict"3import { test } from "node:test"4import { parseQuery } from "../../../server/src/next/query"5import {6 applyPanel, chipToken, chipsToQuery, commitOnSpace, completeDraft, draftContext, draftWithKey, emptyPanel, errorCode, fullQuery, inRole, isState, keywordMap, layoutChips, mapErrors, mergePage,7 normalizeQuery, panelFromChips, queryToChips, readErrors, splitTrailingText, readSummaries, resultsKey, rowKey, savedScope, searchParams, sizeBytes, sortSaved, termChip, textChip, toEmailSummary, visibleErrors,8 type Chip, type SavedSearch,9} from "./search"10import type { MessageSummary } from "./types"1112const chip = (op: Chip["op"], value = "", o: Partial<Chip> = {}): Chip => ({ op, value, negated: false, phrase: false, ...o })13/** Ce que le serveur comprend d'une requête, sans les positions. */14const meaning = (q: string) => {15 const p = parseQuery(q, { now: new Date("2026-11-20T12:00:00Z"), tz: "America/Toronto" })16 return { terms: p.terms.map((t) => ({ op: t.op, value: t.value, negated: t.negated, phrase: !!t.phrase, group: t.group })), errors: p.errors.map((e) => e.code).sort() }17}1819test("queryToChips : opérateurs, synonymes français, accents", () => {20 assert.deepEqual(queryToChips("from:alice de:bob Expéditeur:carl À:dan sujet:devis"), [chip("from", "alice"), chip("from", "bob"), chip("from", "carl"), chip("to", "dan"), chip("subject", "devis")])21 assert.deepEqual(queryToChips("étiquette:Clients après:2026-01-01 libellé:\"À suivre\""), [chip("label", "Clients"), chip("after", "2026-01-01"), chip("label", "À suivre")])22})2324test("queryToChips : guillemets, négation, OR, clés inconnues", () => {25 assert.deepEqual(queryToChips('subject:"rapport final" "phrase exacte" -facture -"pas ça" -has:attachment'), [26 chip("subject", "rapport final"), chip("text", "phrase exacte", { phrase: true }), chip("text", "facture", { negated: true }), chip("text", "pas ça", { negated: true, phrase: true }), chip("has", "attachment", { negated: true }),27 ])28 assert.deepEqual(queryToChips("from:alice OR from:bob OU devis"), [chip("from", "alice"), chip("or"), chip("from", "bob"), chip("or"), chip("text", "devis")])29 // clé inconnue : le jeton entier est du texte libre ; « -OR » et « "OR" » ne sont pas l'opérateur30 assert.deepEqual(queryToChips("note:abc https://exemple.test/x 12:30 -note:x -OR \"OR\""), [31 chip("text", "note:abc"), chip("text", "https://exemple.test/x"), chip("text", "12:30"), chip("text", "note:x", { negated: true }), chip("text", "OR", { negated: true }), chip("text", "OR", { phrase: true }),32 ])33 // ce que le serveur ignore disparaît ; un guillemet non fermé vaut expression ; une clé sans valeur reste (le serveur la signale)34 assert.deepEqual(queryToChips(' - "" "ouvert sans fin'), [chip("text", "ouvert sans fin", { phrase: true })])35 assert.deepEqual(queryToChips("from:"), [chip("from", "")])36 assert.deepEqual(queryToChips(""), [])37 assert.deepEqual(queryToChips(undefined as unknown as string), [])38})3940test("chipsToQuery : clé canonique, guillemets seulement si nécessaire", () => {41 assert.equal(chipsToQuery([chip("from", "alice"), chip("subject", "rapport final"), chip("text", "deux mots", { phrase: true }), chip("or"), chip("text", "x", { negated: true }), chip("label", "À suivre", { negated: true })]), 'from:alice subject:"rapport final" "deux mots" OR -x -label:"À suivre"')42 assert.equal(chipToken(termChip("from", ' "Alice Martin" ')), 'from:"Alice Martin"')43 assert.deepEqual(textChip("deux mots"), chip("text", "deux mots", { phrase: true }))44 assert.deepEqual(textChip("mot", true), chip("text", "mot", { negated: true }))45})4647test("aller-retour : chipsToQuery(queryToChips(q)) est la forme normalisée, stable, et de même sens pour le serveur", () => {48 const cases: [string, string][] = [49 [" de:alice sujet:\"rapport final\" ", 'from:alice subject:"rapport final"'],50 ['-"pas ça" OU avec:pj est:non-lu', '-"pas ça" OR has:pj is:non-lu'],51 ["from:alice OR from:bob devis -in:sent", "from:alice OR from:bob devis -in:sent"],52 ["note:abc https://a.test 12:30", "note:abc https://a.test 12:30"],53 ["étiquette:Clients AVANT:2026-01-15 après:7j plusgrand:5mo fichier:devis.pdf", "label:Clients before:2026-01-15 after:7j larger:5mo filename:devis.pdf"],54 ['"ouvert sans fin', '"ouvert sans fin"'],55 ["dans:corbeille cci:x@y.test corps:bonjour", "in:corbeille bcc:x@y.test body:bonjour"],56 ["OR from:a OR", "OR from:a OR"],57 ["before:notadate is:bogus from:", "before:notadate is:bogus from:"],58 ["- \"\" x", "x"],59 ]60 for (const [q, normal] of cases) {61 assert.equal(chipsToQuery(queryToChips(q)), normal, q)62 assert.equal(normalizeQuery(q), normal)63 // stable : normaliser une requête normalisée ne la change plus64 assert.equal(normalizeQuery(normal), normal, `idempotence ${q}`)65 // même sens : le serveur lit les mêmes termes, groupes et erreurs dans la forme normalisée66 assert.deepEqual(meaning(normal), meaning(q), `sens ${q}`)67 }68})6970test("le découpage suit le serveur jeton par jeton (positions comprises pour la forme normalisée)", () => {71 const q = 'from:alice -"pas ça" OR note:x has:attachment "a b" -to:"Jean Roy"'72 const { spans } = layoutChips(queryToChips(q))73 const server = parseQuery(q).terms74 // OR n'est pas un terme du serveur : on compare les pastilles hors OR75 const mine = queryToChips(q).map((c, i) => ({ c, span: spans[i] })).filter((x) => x.c.op !== "or")76 assert.equal(mine.length, server.length)77 server.forEach((t, i) => {78 assert.equal(mine[i].c.op, t.op)79 assert.equal(mine[i].c.negated, t.negated)80 assert.deepEqual([mine[i].span.start, mine[i].span.end], [t.start, t.end])81 })82})8384test("fullQuery, commitOnSpace : les opérateurs deviennent pastilles, les mots libres restent du texte", () => {85 assert.equal(fullQuery([chip("from", "alice")], " devis "), "from:alice devis")86 assert.equal(fullQuery([], "devis"), "devis")87 assert.equal(fullQuery([chip("from", "alice")], ""), "from:alice")88 assert.deepEqual(commitOnSpace("from:alice "), [chip("from", "alice")])89 assert.deepEqual(commitOnSpace("devis has:attachment "), [chip("text", "devis"), chip("has", "attachment")])90 assert.equal(commitOnSpace("devis "), null)91 assert.equal(commitOnSpace("from:alice"), null)92 assert.equal(commitOnSpace('subject:"rapport '), null, "guillemet ouvert : l'espace fait partie de la valeur")93 assert.equal(commitOnSpace("from: "), null, "clé sans valeur")94 assert.equal(commitOnSpace("a OR "), null)95})9697test("splitTrailingText : les mots libres de la fin restent du texte, le reste est en pastilles", () => {98 const split = (q: string) => {99 const r = splitTrailingText(queryToChips(q))100 // quoi qu'il arrive, le champ redonne la requête normalisée101 assert.equal(fullQuery(r.chips, r.draft), normalizeQuery(q), q)102 return [chipsToQuery(r.chips), r.draft]103 }104 assert.deepEqual(split("devis de toiture"), ["", "devis de toiture"])105 assert.deepEqual(split("de:alice devis toiture"), ["from:alice", "devis toiture"])106 assert.deepEqual(split("devis from:alice"), ["devis from:alice", ""])107 assert.deepEqual(split('from:alice "deux mots"'), ['from:alice "deux mots"', ""])108 assert.deepEqual(split("from:alice -facture devis"), ["from:alice -facture", "devis"])109 assert.deepEqual(split("a OR b"), ["a OR", "b"])110 assert.deepEqual(split("has:attachment note:x 12:30"), ["has:attachment", "note:x 12:30"])111 assert.deepEqual(split(""), ["", ""])112})113114test("draftContext, completeDraft, draftWithKey", () => {115 assert.deepEqual(draftContext("devis fro"), { head: "devis ", token: "fro", negated: false, op: null, needle: "fro" })116 assert.deepEqual(draftContext("devis from:ali"), { head: "devis ", token: "from:ali", negated: false, op: "from", needle: "ali" })117 assert.deepEqual(draftContext('-de:"Jean R'), { head: "", token: '-de:"Jean R', negated: true, op: "from", needle: "Jean R" })118 assert.deepEqual(draftContext("note:x"), { head: "", token: "note:x", negated: false, op: null, needle: "note:x" })119 assert.deepEqual(draftContext("libellé:"), { head: "", token: "libellé:", negated: false, op: "label", needle: "" })120 assert.deepEqual(draftContext(""), { head: "", token: "", negated: false, op: null, needle: "" })121 assert.deepEqual(completeDraft("devis from:ali", termChip("from", "alice@exemple.test")), [chip("text", "devis"), chip("from", "alice@exemple.test")])122 assert.deepEqual(completeDraft("-label:cl", termChip("label", "Clients VIP")), [chip("label", "Clients VIP", { negated: true })])123 assert.equal(draftWithKey("devis fr", "from"), "devis from:")124 assert.equal(draftWithKey("-su", "subject"), "-subject:")125})126127test("mapErrors : chaque erreur du serveur retrouve sa pastille ; le texte en cours et les erreurs globales sont à part", () => {128 const chips = queryToChips("from:alice before:notadate is:bogus OR")129 const draft = "larger:xx"130 const q = fullQuery(chips, draft)131 const errors = readErrors(parseQuery(q).errors)132 // un OR suivi d'un terme invalide ne relie plus rien : le serveur ne le signale pas133 assert.deepEqual(errors.map((e) => e.code).sort(), ["invalid_date", "invalid_size", "invalid_value"])134 const m = mapErrors(chips, errors)135 assert.equal(m.byChip.get(1)?.code, "invalid_date")136 assert.equal(m.byChip.get(1)?.token, "before:notadate")137 assert.equal(m.byChip.get(2)?.code, "invalid_value")138 assert.equal(mapErrors(chips, readErrors(parseQuery(chipsToQuery(chips)).errors)).byChip.get(3)?.code, "dangling_or")139 assert.equal(m.byChip.has(0), false)140 assert.deepEqual(m.draft.map((e) => e.code), ["invalid_size"])141 assert.deepEqual(mapErrors(chips, [{ token: "", start: 1000, end: 1200, code: "query_too_long", message: "" }]).rest.map((e) => e.code), ["query_too_long"])142 assert.equal(errorCode("invalid_date"), "invalid_date")143 assert.equal(errorCode("nouveau_code"), "generic")144 assert.deepEqual(readErrors("non"), [])145 assert.deepEqual(readErrors([null, { code: 3 }, { code: "x", start: 0, end: 1 }]), [{ token: "", start: 0, end: 1, code: "x", message: "" }])146})147148test("visibleErrors : une clé encore sans valeur en fin de frappe n'est pas signalée ; pas de doublon", () => {149 const typing = "devis from:"150 assert.deepEqual(visibleErrors(typing, readErrors(parseQuery(typing).errors)), [])151 const middle = "from: devis"152 assert.deepEqual(visibleErrors(middle, readErrors(parseQuery(middle).errors)).map((e) => e.code), ["empty_value"])153 const e = { token: "is:x", start: 0, end: 4, code: "invalid_value", message: "" }154 assert.equal(visibleErrors("is:x", [e, { ...e }]).length, 1)155})156157test("panneau de filtres : lu depuis les pastilles", () => {158 const chips = queryToChips('devis from:alice to:bob after:2026-01-01 before:7d has:pj larger:5m smaller:500k label:"À suivre" dans:corbeille -from:carl from:x OR from:y')159 assert.deepEqual(panelFromChips(chips), { from: "alice", to: "bob", subject: "", after: "2026-01-01", before: "", hasAttachment: true, minSize: "5", maxSize: "0.49", label: "À suivre", folder: "trash" })160 assert.deepEqual(panelFromChips([]), emptyPanel())161 // négation et groupe OR : hors du panneau162 assert.deepEqual(panelFromChips(queryToChips("-from:carl from:x OR from:y -has:attachment")), emptyPanel())163 assert.equal(panelFromChips(queryToChips("in:Projets")).folder, "Projets")164})165166test("panneau de filtres : il édite les pastilles (ajout, remplacement, retrait) sans toucher au reste", () => {167 const start = queryToChips("devis -from:carl from:alice after:7d x OR y")168 const p = panelFromChips(start)169 // rien de changé : rien ne bouge (after:7d, non représentable, est conservé)170 assert.equal(chipsToQuery(applyPanel(start, p)), "devis -from:carl from:alice after:7d x OR y")171 // remplacement sur place, ajouts en fin172 assert.equal(chipsToQuery(applyPanel(start, { ...p, from: "Alice Martin", hasAttachment: true, minSize: "2,5", label: "Clients", folder: "sent" })), 'devis -from:carl from:"Alice Martin" after:7d x OR y larger:2.5m label:Clients in:sent has:attachment')173 // une date choisie remplace le terme relatif174 assert.equal(chipsToQuery(applyPanel(start, { ...p, after: "2026-02-01" })), "devis -from:carl from:alice after:2026-02-01 x OR y")175 // retrait176 assert.equal(chipsToQuery(applyPanel(start, { ...p, from: "" })), "devis -from:carl after:7d x OR y")177 const withAtt = queryToChips("avec:pj to:bob")178 assert.equal(chipsToQuery(applyPanel(withAtt, { ...panelFromChips(withAtt), hasAttachment: false, to: " " })), "")179 // aller-retour : ce que le panneau écrit, il le relit180 const full = { from: "a@b.test", to: "c", subject: "rapport final", after: "2026-01-01", before: "2026-12-31", hasAttachment: true, minSize: "1", maxSize: "20", label: "Clients", folder: "archive" }181 assert.deepEqual(panelFromChips(applyPanel([], full)), full)182 assert.equal(sizeBytes("1,5mo"), 1572864)183 assert.equal(sizeBytes("abc"), null)184 assert.equal(isState("non-lu"), "unread")185 assert.equal(isState("bogus"), null)186 assert.equal(inRole("Corbeille"), "trash")187 assert.equal(inRole("Projets"), null)188})189190const msg = (mailbox_id: string, email_id: string, o: Partial<MessageSummary> = {}): MessageSummary => ({ mailbox_id, email_id, thread_id: `t${email_id}`, from: [{ email: "a@b.test", name: "A" }], to: [], subject: `s${email_id}`, preview: "", received_at: "2026-11-20T10:00:00Z", keywords: [], mailbox_ids: ["f1"], has_attachment: false, size: 10, folder_roles: ["inbox"], ...o })191192test("mergePage : pages cumulées sans doublon (boîte + message), remplacement à la première page", () => {193 const p1 = [msg("m1", "a"), msg("m2", "a"), msg("m1", "b")]194 const p2 = [msg("m1", "b", { subject: "doublon" }), msg("m1", "c"), msg("m2", "a"), msg("m2", "d")]195 const all = mergePage(mergePage([], p1, true), p2)196 assert.deepEqual(all.map(rowKey), ["m1:a", "m2:a", "m1:b", "m1:c", "m2:d"])197 assert.equal(all[2].subject, "sb", "le premier exemplaire est gardé")198 assert.deepEqual(mergePage(all, [msg("m3", "z"), msg("m3", "z")], true).map(rowKey), ["m3:z"])199 assert.equal(mergePage(all, []).length, 5)200})201202test("formes d'API : paramètres, clé de liste, résultats, résumé JMAP", () => {203 assert.deepEqual(searchParams({ q: "from:a", scope: "all", threads: true, tz: "America/Toronto" }), { q: "from:a", mailboxes: "all", limit: 50, threads: true, tz: "America/Toronto", cursor: undefined })204 assert.deepEqual(searchParams({ q: "x", scope: "mb-1", threads: false, tz: "UTC", cursor: "c1", limit: 20 }), { q: "x", mailboxes: "mb-1", limit: 20, threads: false, tz: "UTC", cursor: "c1" })205 assert.notEqual(resultsKey({ q: "x", scope: "all", threads: true }), resultsKey({ q: "x", scope: "all", threads: false }))206 assert.notEqual(resultsKey({ q: "x", scope: "all", threads: true }), resultsKey({ q: "x", scope: "m1", threads: true }))207 assert.notEqual(resultsKey({ q: "x", scope: "all", threads: true }), resultsKey({ q: "x", scope: "all", threads: true, semantic: true }))208 assert.deepEqual(keywordMap(["$seen", "lbl_1"]), { $seen: true, lbl_1: true })209 assert.deepEqual(readSummaries("x"), [])210 const read = readSummaries([null, { mailbox_id: "m" }, { mailbox_id: "m", email_id: "e", thread_id: "t", subject: null, received_at: "2026-01-01T00:00:00Z", has_attachment: true, size: 3 }])211 assert.equal(read.length, 1)212 assert.deepEqual([read[0].from, read[0].keywords, read[0].subject, read[0].folder_roles], [[], [], "", []])213 const e = toEmailSummary(msg("m1", "a", { keywords: ["$seen"], mailbox_ids: ["f1", "f2"], has_attachment: true }))214 assert.deepEqual([e.id, e.threadId, e.mailboxIds, e.keywords, e.hasAttachment, e.subject], ["a", "ta", { f1: true, f2: true }, { $seen: true }, true, "sa"])215})216217test("recherches enregistrées : ordre (épinglées d'abord) et portée", () => {218 const s = (id: string, o: Partial<SavedSearch>): SavedSearch => ({ id, name: id, query: "x", mailbox_ids: null, icon: null, color: null, pinned: false, position: 0, notify: false, updated_at: "", ...o })219 assert.deepEqual(sortSaved([s("a", { position: 0 }), s("b", { position: 1, pinned: true }), s("c", { position: 2 }), s("d", { position: 3, pinned: true })]).map((x) => x.id), ["b", "d", "a", "c"])220 assert.equal(savedScope(s("a", {}), ["m1"]), "all")221 assert.equal(savedScope(s("a", { mailbox_ids: ["m1"] }), ["m1", "m2"]), "m1")222 assert.equal(savedScope(s("a", { mailbox_ids: ["gone"] }), ["m1"]), "all", "boîte retirée : toutes")223 assert.equal(savedScope(s("a", { mailbox_ids: ["m1", "m2"] }), ["m1", "m2"]), "all")224})225