feat(noter): en delt note tager de noter med, den peger på
Den anden halvdel af den melding, der begyndte det her: linkene i en delt note førte ingen steder hen, fordi det, de pegede på, ikke var delt. At dele en note er at dele det, den *siger*, og et link er en del af det. note_shares får en `linked`-søjle. 0 er en deling, nogen har valgt; 1 er en, der er udledt af et link. Skellet er hele modellen. Fladen kan sige *hvorfor* en person har en note — "fulgte med" er en anden sætning end "du delte den" — og de udledte rækker kan regnes forfra efter hver ændring, uden at røre dem, ejeren selv har sat. SyncLinkedShares regner billedet om fra bunden efter enhver af ejerens egne handlinger: en deling, en fjernet deling, en gemning der har ændret links eller titel, en sletning. Hele kæden følger med, ikke kun første led, med et loft på hundrede noter — "del denne ene note" må ikke kunne blive til fire hundrede. Rollen arves fra den note, man kom fra, og stærkest vinder, når en note kan nås ad to veje. Kun ejerens egne noter følger med, og det er ikke en optimering: et link peger på en titel, og en medredaktør må skrive titler. Kunne et link hente hvad som helst, kunne den, man har delt med, skrive [[Bankoplysninger]] og læse med. Derfor slås der kun op blandt ejerens egne noter, og derfor regner kun ejerens egne gemninger om. Begge dele har en Go-prøve. Det lukker ikke hullet helt: skriver medredaktøren linket, og gemmer ejeren bagefter sin egen note, følger den note med dér. Det, der står imod, er synlighed — linket står som tekst i ejerens egen note, og panelet viser hver note, der er fulgt med, og hvem der har den. Udregningen åbner hver af ejerens noter, fordi titlerne er forseglet. Derfor to værn: har man ikke delt noget, svares der med det samme ud fra ét EXISTS, og en gemning regner kun om, når links eller titel faktisk har flyttet sig. Uden det første kostede "Ny note" halvfems millisekunder, og i det hul nåede e2e-prøven for monospace at taste sin titel ind i den forrige note, som editoren så tegnede væk. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013r4DxpUZcSShxfCZZaeMGZ
This commit is contained in:
kristianwind
co-authored by
Claude Opus 5
Claude Opus 5
parent
ff75302cf8
commit
916a0c0224
@@ -204,9 +204,49 @@ func (s *Server) handleCreateNote(w http.ResponseWriter, r *http.Request) {
|
||||
s.internal(w, r, "create note", err)
|
||||
return
|
||||
}
|
||||
// En ny note kan være den, en delt note hele tiden har peget på: linket er
|
||||
// skrevet som en titel, og titlen fandtes ikke før nu.
|
||||
//
|
||||
// Kun når der står noget i den. En tom note har ingen titel, og et link peger på
|
||||
// en titel — så der er intet at regne, og det kostede alligevel: udregningen
|
||||
// åbner hver eneste af ejerens noter, og den lå her mellem "Ny note" og det
|
||||
// svar, fladen venter på for at kunne tegne editoren. Halvfems millisekunder er
|
||||
// nok til at nå at taste den første linje ind i den forrige note, som så blev
|
||||
// tegnet væk. Målt i e2e-prøven for monospace, der begyndte at tabe sin titel.
|
||||
if strings.TrimSpace(n.Body) != "" {
|
||||
s.followLinks(r, n)
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, n)
|
||||
}
|
||||
|
||||
// followLinks holder de udledte delinger i takt med teksten.
|
||||
//
|
||||
// De noter, en delt note peger på, følger med — og teksten kan ændre sig, efter
|
||||
// delingen er sat. Et link skrevet i dag i en note, der blev delt i går, skal føre
|
||||
// samme sted hen for begge.
|
||||
//
|
||||
// Kun ejerens egne gemninger regner om, og det er ikke en optimering. Et link
|
||||
// peger på en titel, og en medredaktør må skrive i teksten — så hvis enhver
|
||||
// gemning talte med, kunne den, man har delt en note med, skrive
|
||||
// `[[Bankoplysninger]]` ind i den og dermed dele den med sig selv.
|
||||
//
|
||||
// Det lukker ikke hullet helt, og det skal siges frem for at lyde lukket: skriver
|
||||
// medredaktøren linket, og gemmer ejeren bagefter sin egen note, følger den note
|
||||
// med dér. Det, der står tilbage mod det, er synlighed — linket står som tekst i
|
||||
// ejerens egen note, og delingspanelet viser hver note, der er fulgt med, og hvem
|
||||
// der har den. En stille eskalering er det ikke; en, man kan overse, er den.
|
||||
//
|
||||
// Fejler det, siges det i loggen og ikke til den, der gemte: noten *er* gemt, og
|
||||
// et svar, der lyder som om den ikke er, ville få dem til at skrive den igen.
|
||||
func (s *Server) followLinks(r *http.Request, n *store.Note) {
|
||||
if n == nil || n.CreatedBy != userFrom(r.Context()).ID {
|
||||
return
|
||||
}
|
||||
if _, err := s.db.SyncLinkedShares(r.Context(), n.CreatedBy); err != nil {
|
||||
s.log.Error("sync linked shares", "err", err, "note", n.ID)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *Server) handleUpdateNote(w http.ResponseWriter, r *http.Request) {
|
||||
var body noteBody
|
||||
if err := decodeJSON(w, r, &body); err != nil {
|
||||
@@ -242,6 +282,7 @@ func (s *Server) handleUpdateNote(w http.ResponseWriter, r *http.Request) {
|
||||
}
|
||||
n.ProjectID = *body.ProjectID
|
||||
}
|
||||
before := n.Body
|
||||
if body.Body != nil {
|
||||
n.Body = *body.Body
|
||||
}
|
||||
@@ -249,13 +290,41 @@ func (s *Server) handleUpdateNote(w http.ResponseWriter, r *http.Request) {
|
||||
n.Pinned = *body.Pinned
|
||||
}
|
||||
|
||||
// Læst før gemningen, sammenlignet efter. En gemning er en tastepause, ikke en
|
||||
// begivenhed, så de fleste af dem ændrer intet af det her — og udregningen
|
||||
// åbner hver eneste af ejerens noter, fordi titlerne er forseglet. Den skal
|
||||
// køre, når svaret kan være blevet et andet, og ellers ikke.
|
||||
wasLinking := store.LinksIn(before)
|
||||
wasTitled := n.Title
|
||||
|
||||
if err := s.db.SaveNote(r.Context(), n); err != nil {
|
||||
s.internal(w, r, "update note", err)
|
||||
return
|
||||
}
|
||||
// Titlen tæller med: den *er* første linje, så en omskrevet overskrift flytter
|
||||
// det, andres links peger på, uden at et eneste link er rørt.
|
||||
if n.Title != wasTitled || !sameLinks(wasLinking, store.LinksIn(n.Body)) {
|
||||
s.followLinks(r, n)
|
||||
}
|
||||
writeJSON(w, http.StatusOK, n)
|
||||
}
|
||||
|
||||
func sameLinks(a, b []store.NoteLink) bool {
|
||||
if len(a) != len(b) {
|
||||
return false
|
||||
}
|
||||
in := make(map[store.NoteLink]bool, len(a))
|
||||
for _, l := range a {
|
||||
in[l] = true
|
||||
}
|
||||
for _, l := range b {
|
||||
if !in[l] {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func (s *Server) handleDeleteNote(w http.ResponseWriter, r *http.Request) {
|
||||
n, err := s.db.Note(r.Context(), chi.URLParam(r, "noteID"))
|
||||
if err != nil {
|
||||
@@ -279,6 +348,9 @@ func (s *Server) handleDeleteNote(w http.ResponseWriter, r *http.Request) {
|
||||
s.internal(w, r, "delete note", err)
|
||||
return
|
||||
}
|
||||
// En note i papirkurven er ikke længere et udgangspunkt for noget. Det, den tog
|
||||
// med sig, skal derfor heller ikke blive stående hos dem, den blev delt med.
|
||||
s.followLinks(r, n)
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
}
|
||||
|
||||
|
||||
@@ -77,12 +77,37 @@ func (s *Server) handleListNoteShares(w http.ResponseWriter, r *http.Request) {
|
||||
s.internal(w, r, "list note shares", err)
|
||||
return
|
||||
}
|
||||
// Regnet forfra, én gang, og læst to veje ud af det samme svar: hvem der har
|
||||
// *denne* note, fordi en anden peger på den, og hvilke noter der omvendt følger
|
||||
// med den her. To udregninger af det samme er to, der kan blive uenige.
|
||||
//
|
||||
// Og forfra frem for læst af basen, så panelet viser det, der gælder nu — også
|
||||
// når linkene er skrevet af en anden og delingerne derfor ikke er regnet om
|
||||
// siden.
|
||||
following, err := s.db.SyncLinkedShares(r.Context(), userFrom(r.Context()).ID)
|
||||
if err != nil {
|
||||
s.internal(w, r, "sync linked shares", err)
|
||||
return
|
||||
}
|
||||
via := map[string]string{}
|
||||
for _, l := range following {
|
||||
if l.NoteID == n.ID {
|
||||
via[l.UserID] = l.Via
|
||||
}
|
||||
}
|
||||
|
||||
out := make([]noteShareJSON, 0, len(shares))
|
||||
already := map[string]bool{}
|
||||
for _, sh := range shares {
|
||||
// Panelet skal kunne sige forskel: en deling, nogen har valgt, tages tilbage
|
||||
// ved at fjerne den — en, der er fulgt med, ved at fjerne linket eller den
|
||||
// deling, den kom fra. En knap, der lover det første og gør det andet, er
|
||||
// værre end ingen knap.
|
||||
out = append(out, noteShareJSON{
|
||||
User: personJSON{ID: sh.User.ID, Name: sh.User.Name, AvatarColor: sh.User.AvatarColor},
|
||||
Role: string(sh.Role),
|
||||
User: personJSON{ID: sh.User.ID, Name: sh.User.Name, AvatarColor: sh.User.AvatarColor},
|
||||
Role: string(sh.Role),
|
||||
Linked: via[sh.User.ID] != "",
|
||||
Via: via[sh.User.ID],
|
||||
})
|
||||
already[sh.User.ID] = true
|
||||
}
|
||||
@@ -103,12 +128,41 @@ func (s *Server) handleListNoteShares(w http.ResponseWriter, r *http.Request) {
|
||||
cand = append(cand, personJSON{ID: p.ID, Name: p.Name, AvatarColor: p.AvatarColor})
|
||||
}
|
||||
|
||||
writeJSON(w, http.StatusOK, map[string]any{"shares": out, "candidates": cand})
|
||||
writeJSON(w, http.StatusOK, map[string]any{
|
||||
"shares": out,
|
||||
"candidates": cand,
|
||||
"follows": followsOf(following, n.ID),
|
||||
})
|
||||
}
|
||||
|
||||
// followsOf er de noter, der følger med *denne* note — én linje pr. note, ikke én
|
||||
// pr. note og person. Panelet spørger på vegne af noten, og svaret "Prisliste
|
||||
// følger med" er det samme, hvem det så end deles med.
|
||||
func followsOf(all []store.LinkedShare, noteID string) []followJSON {
|
||||
seen := map[string]bool{}
|
||||
out := []followJSON{}
|
||||
for _, l := range all {
|
||||
if l.ViaID != noteID || seen[l.NoteID] {
|
||||
continue
|
||||
}
|
||||
seen[l.NoteID] = true
|
||||
out = append(out, followJSON{NoteID: l.NoteID, Title: l.Title})
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
type followJSON struct {
|
||||
NoteID string `json:"note_id"`
|
||||
Title string `json:"title"`
|
||||
}
|
||||
|
||||
type noteShareJSON struct {
|
||||
User personJSON `json:"user"`
|
||||
Role string `json:"role"`
|
||||
// Sat, når personen har noten, fordi en anden delt note peger på den — ikke
|
||||
// fordi nogen har delt netop den. `via` er den note, der peger.
|
||||
Linked bool `json:"linked"`
|
||||
Via string `json:"via,omitempty"`
|
||||
}
|
||||
|
||||
type shareNoteRequest struct {
|
||||
@@ -159,7 +213,15 @@ func (s *Server) handleShareNote(w http.ResponseWriter, r *http.Request) {
|
||||
s.storeError(w, r, "share note", err)
|
||||
return
|
||||
}
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
|
||||
// Og det, noten peger på, følger med. Svaret siger hvad — en deling, der stille
|
||||
// tog tre noter mere med, ville være rigtig og alligevel ikke til at overskue.
|
||||
followed, err := s.db.SyncLinkedShares(r.Context(), userFrom(r.Context()).ID)
|
||||
if err != nil {
|
||||
s.internal(w, r, "sync linked shares", err)
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, map[string]any{"follows": followsOf(followed, n.ID)})
|
||||
}
|
||||
|
||||
// handleUnshareNote takes a person's access away again.
|
||||
@@ -177,5 +239,12 @@ func (s *Server) handleUnshareNote(w http.ResponseWriter, r *http.Request) {
|
||||
s.internal(w, r, "unshare note", err)
|
||||
return
|
||||
}
|
||||
// Det, der fulgte med, følger også med tilbage. Regnet forfra: de udledte rækker
|
||||
// skrives om fra bunden, så en note, der stadig kan nås fra en anden deling,
|
||||
// bliver stående, og en, der ikke kan, forsvinder.
|
||||
if _, err := s.db.SyncLinkedShares(r.Context(), userFrom(r.Context()).ID); err != nil {
|
||||
s.internal(w, r, "sync linked shares", err)
|
||||
return
|
||||
}
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
}
|
||||
|
||||
@@ -46,7 +46,7 @@ func TestSharedNoteReachesTheOtherPerson(t *testing.T) {
|
||||
// Share it as a viewer.
|
||||
resp, _ := owner.do(t, "POST", "/api/v1/notes/"+noteID+"/shares",
|
||||
map[string]string{"user_id": sofie, "role": "viewer"})
|
||||
if resp.StatusCode != http.StatusNoContent {
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
t.Fatalf("share: status %d", resp.StatusCode)
|
||||
}
|
||||
|
||||
@@ -92,7 +92,7 @@ func TestSharedEditorCanWriteButNotGiveAway(t *testing.T) {
|
||||
|
||||
noteID := owner.createNote(t, "# Delt\noprindelig")
|
||||
if resp, _ := owner.do(t, "POST", "/api/v1/notes/"+noteID+"/shares",
|
||||
map[string]string{"user_id": sofie, "role": "editor"}); resp.StatusCode != http.StatusNoContent {
|
||||
map[string]string{"user_id": sofie, "role": "editor"}); resp.StatusCode != http.StatusOK {
|
||||
t.Fatalf("share as editor failed")
|
||||
}
|
||||
|
||||
@@ -193,7 +193,104 @@ func TestShareRejectsUnknownAndSelf(t *testing.T) {
|
||||
t.Errorf("sharing with oneself: %d, want 422", resp.StatusCode)
|
||||
}
|
||||
if resp, _ := owner.do(t, "POST", "/api/v1/notes/"+noteID+"/shares",
|
||||
map[string]string{"user_id": me, "role": "owner"}); resp.StatusCode == http.StatusNoContent {
|
||||
map[string]string{"user_id": me, "role": "owner"}); resp.StatusCode == http.StatusOK {
|
||||
t.Error("a note was shared at the owner role")
|
||||
}
|
||||
}
|
||||
|
||||
// De noter, en delt note peger på, følger med — og holder op igen.
|
||||
//
|
||||
// Det var meldt som en fejl den anden vej rundt: linkene i en delt note førte
|
||||
// ingen steder hen, fordi det, de pegede på, ikke var delt. Prøven går hele vejen
|
||||
// rundt om svaret på det — dybden, teksten der ændrer sig bagefter, det der ikke
|
||||
// må følge med, og vejen tilbage.
|
||||
func TestSharedNoteTakesItsLinksWithIt(t *testing.T) {
|
||||
owner := newTestServer(t)
|
||||
owner.bootstrap(t)
|
||||
other := owner.newUser(t, "sofie@example.dk", "Sofie")
|
||||
sofie := userID(t, owner, "sofie@example.dk")
|
||||
|
||||
// Prisliste peger videre på Leveringstider, så kæden er to led lang.
|
||||
deep := owner.createNote(t, "# Leveringstider\nfire dage")
|
||||
linked := owner.createNote(t, "# Prisliste\nog [[Leveringstider]]")
|
||||
apart := owner.createNote(t, "# Bankoplysninger\nikke til deling")
|
||||
noteID := owner.createNote(t, "# Aftale om levering\nse [[Prisliste]]")
|
||||
|
||||
reachable := func(id string) bool {
|
||||
resp, _ := other.do(t, "GET", "/api/v1/notes/"+id, nil)
|
||||
return resp.StatusCode == http.StatusOK
|
||||
}
|
||||
|
||||
resp, out := owner.do(t, "POST", "/api/v1/notes/"+noteID+"/shares",
|
||||
map[string]string{"user_id": sofie, "role": "viewer"})
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
t.Fatalf("share: status %d", resp.StatusCode)
|
||||
}
|
||||
// Svaret siger, hvad der fulgte med — hele kæden, ikke kun første led. En
|
||||
// deling, der stille tog to noter mere med, ville være rigtig og alligevel ikke
|
||||
// til at overskue.
|
||||
follows, _ := out["follows"].([]any)
|
||||
if len(follows) != 2 {
|
||||
t.Fatalf("delingen nævnte %d noter, der fulgte med, want 2: %v", len(follows), out["follows"])
|
||||
}
|
||||
|
||||
if !reachable(linked) {
|
||||
t.Error("noten, den delte note peger på, fulgte ikke med")
|
||||
}
|
||||
if !reachable(deep) {
|
||||
t.Error("kæden stoppede efter ét led")
|
||||
}
|
||||
if reachable(apart) {
|
||||
t.Error("en note, ingen peger på, blev delt")
|
||||
}
|
||||
|
||||
// Skrevet bagefter tæller også. Et link i dag i en note delt i går skal føre
|
||||
// samme sted hen for begge.
|
||||
senere := owner.createNote(t, "# Rabatter\nti procent")
|
||||
if reachable(senere) {
|
||||
t.Fatal("en helt ny note var delt, før noget pegede på den")
|
||||
}
|
||||
if resp, _ := owner.do(t, "PATCH", "/api/v1/notes/"+noteID,
|
||||
map[string]any{"body": "# Aftale om levering\nse [[Prisliste]] og [[Rabatter]]"}); resp.StatusCode != http.StatusOK {
|
||||
t.Fatal("kunne ikke skrive videre i den delte note")
|
||||
}
|
||||
if !reachable(senere) {
|
||||
t.Error("et link skrevet efter delingen fulgte ikke med")
|
||||
}
|
||||
|
||||
// Og vejen tilbage: tages delingen tilbage, følger det med, den tog med sig.
|
||||
if resp, _ := owner.do(t, "DELETE", "/api/v1/notes/"+noteID+"/shares/"+sofie, nil); resp.StatusCode != http.StatusNoContent {
|
||||
t.Fatalf("unshare: status %d", resp.StatusCode)
|
||||
}
|
||||
if reachable(linked) || reachable(deep) || reachable(senere) {
|
||||
t.Error("det, der fulgte med delingen, blev stående, da den blev taget tilbage")
|
||||
}
|
||||
}
|
||||
|
||||
// En medredaktør kan ikke dele ejerens noter med sig selv ved at skrive et link.
|
||||
//
|
||||
// Det er den ene vej, "linkene følger med" kunne blive til en rettighedsfejl: et
|
||||
// link peger på en titel, og enhver, der må rette i en delt note, kan skrive en
|
||||
// titel. Derfor regnes delingerne kun om, når ejeren selv har gemt.
|
||||
func TestAnEditorCannotShareTheOwnersNotesWithThemselves(t *testing.T) {
|
||||
owner := newTestServer(t)
|
||||
owner.bootstrap(t)
|
||||
other := owner.newUser(t, "sofie@example.dk", "Sofie")
|
||||
sofie := userID(t, owner, "sofie@example.dk")
|
||||
|
||||
secret := owner.createNote(t, "# Bankoplysninger\nreg og konto")
|
||||
noteID := owner.createNote(t, "# Fælles\nintet link her")
|
||||
if resp, _ := owner.do(t, "POST", "/api/v1/notes/"+noteID+"/shares",
|
||||
map[string]string{"user_id": sofie, "role": "editor"}); resp.StatusCode != http.StatusOK {
|
||||
t.Fatal("share as editor failed")
|
||||
}
|
||||
|
||||
// Hun skriver linket selv, i den note hun har fået lov at rette i.
|
||||
if resp, _ := other.do(t, "PATCH", "/api/v1/notes/"+noteID,
|
||||
map[string]any{"body": "# Fælles\nse [[Bankoplysninger]]"}); resp.StatusCode != http.StatusOK {
|
||||
t.Fatal("medredaktøren kunne ikke skrive")
|
||||
}
|
||||
if resp, _ := other.do(t, "GET", "/api/v1/notes/"+secret, nil); resp.StatusCode == http.StatusOK {
|
||||
t.Error("en medredaktør delte ejerens note med sig selv ved at skrive et link")
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user