merge: Google Kalender som menupunkt, med Verdandes egen kalender lagt over

Læs bredt, skriv snævert — decision 5 i planen, og kun den første halvdel: kalenderen læses, og der skrives ingenting tilbage. **OAuth-blokeringen er reel og blev ikke gået udenom.** En klient registreret som *Internal* tager kun konti i sit eget workspace — også til kalendere, ikke kun Gmail. Andreas' private konto bliver afvist med `org_internal`, og det er klienten, der virker efter hensigten, ikke en fejl. Fladen siger det nu med ord, man kan handle på, frem for at vise Googles egen skærm, der ikke gør. Vejen udenom, som ikke er bygget: kalenderens egen hemmelige ICS-adresse. Ingen OAuth, virker for enhver konto, og `internal/ics` findes allerede. Det er det næste stykke, og det eneste, der låser den private konto op. `internal/google` er flyttet ud af `internal/gmail`, fordi de to er det samme flow, der er uenige om én streng. Egen callback-adresse frem for at dele Gmails: én callback, der finder ud af hvilken token-butik den skal skrive i, går galt ved at overskrive en Gmail-forbindelse, der virkede. Egne tabeller frem for `mailboxes`. `trigger_kind`, `seen` og `last_uid` svarer alle på "hvad gør en besked til en opgave", og ingenting her bliver til en opgave; én konto har mange kalendere, og `mailboxes` har ikke plads til en en-til-mange. Afgørende i praksis: `mailboxes.kind` har en CHECK, og SQLite kan ikke ændre en — en tredje værdi koster den tabelombygning, som migration 0021 skulle igennem. Begivenheder erstattes pr. kalender pr. vindue frem for at flettes med et sync-token: et vindue, der slettes og skrives forfra, kan ikke komme ud af trit, og et sync-token er endnu en ting, der skal være rigtig for altid, for at gitteret ikke stille viser noget forkert. `CalendarView` er udvidet, ikke kopieret. En begivenhed er et fyldt bånd, hvor en opgave er et kort med en farvet kant, så de to læses forskelligt før et ord er læst — og den kan ikke trækkes og er aldrig en knap: der er ikke noget at gøre færdigt ved en andens møde. To værn på det, der kommer fra Google: farven skal matche et hex-mønster, før den må stå i en style, og linket bliver kun til et href, hvis det begynder med https. Konflikten i jobs.go var to nye jobs skrevet på samme linje. Begge skal med. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-20 07:39:12 +02:00
parent 6b2cd0f259 dcd66b415e
commit bdde9cc6a5
34 changed files with 4294 additions and 365 deletions
@@ -0,0 +1,380 @@
+package store
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"time"
+)
+
+// CalendarAccount is one connected account belonging to one person.
+type CalendarAccount struct {
+	ID       string `json:"id"`
+	UserID   string `json:"-"`
+	Provider string `json:"provider"`
+	Account  string `json:"account,omitempty"`
+
+	RefreshToken string    `json:"-"` // never leaves the server
+	AccessToken  string    `json:"-"`
+	ExpiresAt    time.Time `json:"-"`
+
+	LastSyncAt time.Time `json:"last_sync_at,omitempty"`
+	CreatedAt  time.Time `json:"created_at"`
+}
+
+// Calendar is one calendar inside an account, shown or not.
+type Calendar struct {
+	ID        string `json:"id"`
+	AccountID string `json:"-"`
+	RemoteID  string `json:"remote_id"`
+	Name      string `json:"name"`
+	Colour    string `json:"colour,omitempty"`
+	TimeZone  string `json:"time_zone,omitempty"`
+	Primary   bool   `json:"primary"`
+	// Writable says the connected account could write to it. Nothing does — the
+	// scope is read-only — and it is stored so the day something can, the interface
+	// knows which calendars could even be offered.
+	Writable  bool `json:"writable"`
+	Shown     bool `json:"shown"`
+	SortOrder int  `json:"-"`
+}
+
+// CalendarEvent is one occurrence, in the shape a grid asks about: days at both
+// ends, inclusive.
+type CalendarEvent struct {
+	ID         string `json:"id"`
+	CalendarID string `json:"calendar_id"`
+	RemoteID   string `json:"-"`
+	Summary    string `json:"summary"`
+	StartsAt   string `json:"starts_at,omitempty"`
+	EndsAt     string `json:"ends_at,omitempty"`
+	StartDay   string `json:"start_day"`
+	EndDay     string `json:"end_day"`
+	AllDay     bool   `json:"all_day"`
+	Location   string `json:"location,omitempty"`
+	URL        string `json:"url,omitempty"`
+
+	// CalendarName and Colour ride along with the event rather than being looked up
+	// per row by the caller. Same reasoning as the assignee names on a task list:
+	// the chip has to be drawn in the calendar's own colour, and a second request
+	// per event to learn it is a request per event.
+	CalendarName string `json:"calendar_name,omitempty"`
+	Colour       string `json:"colour,omitempty"`
+}
+
+const calendarAccountColumns = `id, user_id, provider, account, refresh_token,
+	access_token, expires_at, last_sync_at, created_at`
+
+// CalendarAccountFor returns a person's connection to one provider, or nil.
+func (db *DB) CalendarAccountFor(ctx context.Context, userID, provider string) (*CalendarAccount, error) {
+	row := db.QueryRowContext(ctx, `SELECT `+calendarAccountColumns+`
+		FROM calendar_accounts WHERE user_id = ? AND provider = ?`, userID, provider)
+	a, err := db.scanCalendarAccount(row)
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &a, nil
+}
+
+// SaveCalendarAccount writes one, sealing the two columns that must not travel
+// with a backup. Called by hand rather than by the settings tables' own seal,
+// which does not reach this table.
+func (db *DB) SaveCalendarAccount(ctx context.Context, a *CalendarAccount) error {
+	if a.ID == "" {
+		a.ID = NewID()
+	}
+	if a.Provider == "" {
+		a.Provider = "google"
+	}
+	if a.CreatedAt.IsZero() {
+		a.CreatedAt = time.Now()
+	}
+
+	refresh, err := db.sealValue(a.RefreshToken)
+	if err != nil {
+		return fmt.Errorf("seal refresh_token: %w", err)
+	}
+	access, err := db.sealValue(a.AccessToken)
+	if err != nil {
+		return fmt.Errorf("seal access_token: %w", err)
+	}
+
+	// The conflict is on the pair, not on the id: a reconnect builds a fresh
+	// struct with no id in it, and matching on the id would insert a second row
+	// that the unique index then refuses — which reads to the person as "connecting
+	// failed" when what happened is that it already had.
+	_, err = db.ExecContext(ctx, `
+		INSERT INTO calendar_accounts (`+calendarAccountColumns+`)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+		ON CONFLICT (user_id, provider) DO UPDATE SET
+		    account = excluded.account,
+		    refresh_token = excluded.refresh_token,
+		    access_token = excluded.access_token,
+		    expires_at = excluded.expires_at,
+		    last_sync_at = excluded.last_sync_at`,
+		a.ID, a.UserID, a.Provider, a.Account, refresh, access,
+		unixOrZero(a.ExpiresAt), unixOrZero(a.LastSyncAt), a.CreatedAt.Unix())
+	if err != nil {
+		return err
+	}
+
+	// The row that is actually there wins. On a reconnect the insert above updated
+	// an existing row, so the id in hand is one nothing points at — and the
+	// calendars are hung off the id, so writing them against it would attach them
+	// to nothing.
+	return db.QueryRowContext(ctx,
+		`SELECT id FROM calendar_accounts WHERE user_id = ? AND provider = ?`,
+		a.UserID, a.Provider).Scan(&a.ID)
+}
+
+// MarkCalendarSynced records how far a run got. Written separately from the rest
+// so a sync never rewrites the credentials it is holding in memory.
+func (db *DB) MarkCalendarSynced(ctx context.Context, accountID string, at time.Time) error {
+	_, err := db.ExecContext(ctx,
+		`UPDATE calendar_accounts SET last_sync_at = ? WHERE id = ?`, at.Unix(), accountID)
+	return err
+}
+
+// DeleteCalendarAccount disconnects one. The calendars and their events go with it
+// — unlike the tasks a mailbox made, none of this is the person's own work; it is
+// a copy of somebody else's calendar and it has no meaning without the account.
+func (db *DB) DeleteCalendarAccount(ctx context.Context, userID, id string) error {
+	_, err := db.ExecContext(ctx,
+		`DELETE FROM calendar_accounts WHERE id = ? AND user_id = ?`, id, userID)
+	return err
+}
+
+// UsersWithCalendars returns everybody the sweep has to visit.
+func (db *DB) UsersWithCalendars(ctx context.Context) ([]string, error) {
+	rows, err := db.QueryContext(ctx, `SELECT DISTINCT user_id FROM calendar_accounts`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var ids []string
+	for rows.Next() {
+		var id string
+		if err := rows.Scan(&id); err != nil {
+			return nil, err
+		}
+		ids = append(ids, id)
+	}
+	return ids, rows.Err()
+}
+
+// Calendars returns what one account holds, in the order the provider listed them.
+func (db *DB) Calendars(ctx context.Context, accountID string) ([]Calendar, error) {
+	rows, err := db.QueryContext(ctx, `
+		SELECT id, account_id, remote_id, name, colour, time_zone, primary_one,
+		       writable, shown, sort_order
+		FROM calendars WHERE account_id = ? ORDER BY sort_order, name`, accountID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var out []Calendar
+	for rows.Next() {
+		var c Calendar
+		if err := rows.Scan(&c.ID, &c.AccountID, &c.RemoteID, &c.Name, &c.Colour,
+			&c.TimeZone, &c.Primary, &c.Writable, &c.Shown, &c.SortOrder); err != nil {
+			return nil, err
+		}
+		out = append(out, c)
+	}
+	return out, rows.Err()
+}
+
+// ReplaceCalendars writes the list the provider just gave, keeping what the person
+// chose.
+//
+// The choice survives because it is not in the list: Google says which calendars
+// exist and what they are called, and only verdande knows which of them somebody
+// wants to look at. Merged rather than deleted and rewritten, so ticking a calendar
+// on does not come undone the next time the sweep runs.
+//
+// A calendar that has disappeared from the account is removed, and its events go
+// with it — a calendar somebody was unshared from should stop being drawn, not
+// stay behind as a frozen copy of what it held on the last good day.
+func (db *DB) ReplaceCalendars(ctx context.Context, accountID string, list []Calendar) error {
+	return db.Tx(ctx, func(tx *sql.Tx) error {
+		keep := map[string]bool{}
+		for i, c := range list {
+			keep[c.RemoteID] = true
+			// The insert cannot carry `shown`: on conflict it would overwrite the
+			// choice with the default. A new calendar starts hidden — an account
+			// with a dozen shared calendars in it should not fill somebody's grid
+			// the moment they connect it.
+			if _, err := tx.ExecContext(ctx, `
+				INSERT INTO calendars
+				    (id, account_id, remote_id, name, colour, time_zone, primary_one,
+				     writable, shown, sort_order)
+				VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+				ON CONFLICT (account_id, remote_id) DO UPDATE SET
+				    name = excluded.name,
+				    colour = excluded.colour,
+				    time_zone = excluded.time_zone,
+				    primary_one = excluded.primary_one,
+				    writable = excluded.writable,
+				    sort_order = excluded.sort_order`,
+				NewID(), accountID, c.RemoteID, c.Name, c.Colour, c.TimeZone,
+				c.Primary, c.Writable, c.Shown, i); err != nil {
+				return err
+			}
+		}
+
+		rows, err := tx.QueryContext(ctx,
+			`SELECT id, remote_id FROM calendars WHERE account_id = ?`, accountID)
+		if err != nil {
+			return err
+		}
+		var gone []string
+		for rows.Next() {
+			var id, remote string
+			if err := rows.Scan(&id, &remote); err != nil {
+				rows.Close()
+				return err
+			}
+			if !keep[remote] {
+				gone = append(gone, id)
+			}
+		}
+		// Closed before the next statement runs on this transaction. An open result
+		// set with a query behind it is the deadlock the pool comment in store.go
+		// exists to make slow rather than fatal.
+		rows.Close()
+		if err := rows.Err(); err != nil {
+			return err
+		}
+
+		for _, id := range gone {
+			if _, err := tx.ExecContext(ctx, `DELETE FROM calendars WHERE id = ?`, id); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+}
+
+// ShowCalendars sets which of an account's calendars are drawn.
+//
+// The whole set in one write rather than one flip at a time, for the reason the
+// projects' order is written the same way: a person has a handful of calendars, the
+// question is "these ones", and a list that can only be built by several requests
+// can land half applied.
+func (db *DB) ShowCalendars(ctx context.Context, accountID string, shown []string) error {
+	return db.Tx(ctx, func(tx *sql.Tx) error {
+		if _, err := tx.ExecContext(ctx,
+			`UPDATE calendars SET shown = 0 WHERE account_id = ?`, accountID); err != nil {
+			return err
+		}
+		for _, id := range shown {
+			// Scoped in the SQL rather than checked first: an id read in one step
+			// and written in the next is a window, and the account is the whole of
+			// the permission here.
+			if _, err := tx.ExecContext(ctx,
+				`UPDATE calendars SET shown = 1 WHERE id = ? AND account_id = ?`,
+				id, accountID); err != nil {
+				return err
+			}
+		}
+		// Events of a calendar nobody is looking at are dead weight in a table the
+		// grid queries. They come back with the next sync if it is turned on again.
+		_, err := tx.ExecContext(ctx, `
+			DELETE FROM calendar_events WHERE calendar_id IN
+			    (SELECT id FROM calendars WHERE account_id = ? AND shown = 0)`, accountID)
+		return err
+	})
+}
+
+// ReplaceCalendarEvents swaps one calendar's events inside a window.
+//
+// Replaced rather than merged, and no sync token. Google offers incremental sync,
+// and it would save bytes verdande is not short of while costing the one thing it
+// cannot afford: a token that has to be right, forever, for the grid not to be
+// quietly wrong. A window that is deleted and rewritten cannot drift — an event
+// somebody moved out of the window disappears because it is not in the answer, not
+// because verdande remembered to delete it.
+//
+// Bounded by the window at both ends, so a sync of September does not throw away
+// August.
+func (db *DB) ReplaceCalendarEvents(ctx context.Context, calendarID, from, to string, events []CalendarEvent) error {
+	return db.Tx(ctx, func(tx *sql.Tx) error {
+		if _, err := tx.ExecContext(ctx, `
+			DELETE FROM calendar_events
+			WHERE calendar_id = ? AND end_day >= ? AND start_day <= ?`,
+			calendarID, from, to); err != nil {
+			return err
+		}
+		for _, e := range events {
+			if _, err := tx.ExecContext(ctx, `
+				INSERT INTO calendar_events
+				    (id, calendar_id, remote_id, summary, starts_at, ends_at,
+				     start_day, end_day, all_day, location, url)
+				VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+				NewID(), calendarID, e.RemoteID, e.Summary, e.StartsAt, e.EndsAt,
+				e.StartDay, e.EndDay, e.AllDay, e.Location, e.URL); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+}
+
+// CalendarEvents returns everything one person can see between two days,
+// inclusive at both ends.
+//
+// Scoped to the caller in the join rather than checked afterwards: the events of
+// somebody else's calendar are somebody else's, and a filter applied after the read
+// is a filter that can be forgotten.
+func (db *DB) CalendarEvents(ctx context.Context, userID, from, to string) ([]CalendarEvent, error) {
+	rows, err := db.QueryContext(ctx, `
+		SELECT e.id, e.calendar_id, e.remote_id, e.summary, e.starts_at, e.ends_at,
+		       e.start_day, e.end_day, e.all_day, e.location, e.url, c.name, c.colour
+		FROM calendar_events e
+		JOIN calendars c ON c.id = e.calendar_id
+		JOIN calendar_accounts a ON a.id = c.account_id
+		WHERE a.user_id = ? AND c.shown = 1 AND e.end_day >= ? AND e.start_day <= ?
+		ORDER BY e.start_day, e.all_day DESC, e.starts_at`, userID, from, to)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var out []CalendarEvent
+	for rows.Next() {
+		var e CalendarEvent
+		if err := rows.Scan(&e.ID, &e.CalendarID, &e.RemoteID, &e.Summary, &e.StartsAt,
+			&e.EndsAt, &e.StartDay, &e.EndDay, &e.AllDay, &e.Location, &e.URL,
+			&e.CalendarName, &e.Colour); err != nil {
+			return nil, err
+		}
+		out = append(out, e)
+	}
+	return out, rows.Err()
+}
+
+func (db *DB) scanCalendarAccount(row scanner) (CalendarAccount, error) {
+	var a CalendarAccount
+	var expires, lastSync, created int64
+	err := row.Scan(&a.ID, &a.UserID, &a.Provider, &a.Account, &a.RefreshToken,
+		&a.AccessToken, &expires, &lastSync, &created)
+	if err != nil {
+		return a, err
+	}
+	for _, field := range []*string{&a.RefreshToken, &a.AccessToken} {
+		plain, err := db.unsealValue(*field)
+		if err != nil {
+			return a, err
+		}
+		*field = plain
+	}
+	a.ExpiresAt = timeOrZero(expires)
+	a.LastSyncAt = timeOrZero(lastSync)
+	a.CreatedAt = time.Unix(created, 0)
+	return a, nil
+}
@@ -0,0 +1,358 @@
+package store
+
+import (
+	"context"
+	"strings"
+	"testing"
+	"time"
+)
+
+func connectedAccount(t *testing.T, db *DB, userID string) *CalendarAccount {
+	t.Helper()
+	a := &CalendarAccount{
+		UserID: userID, Provider: "google", Account: "kw@nolimit.dk",
+		RefreshToken: "1//0-a-real-looking-refresh-token", AccessToken: "ya29.access",
+		ExpiresAt: time.Now().Add(time.Hour),
+	}
+	if err := db.SaveCalendarAccount(context.Background(), a); err != nil {
+		t.Fatal(err)
+	}
+	return a
+}
+
+// The same claim the mailbox tokens have to meet: what is written must not be
+// readable in the file a backup copies.
+func TestCalendarTokensAreNotStoredInTheClear(t *testing.T) {
+	db, userID := sealedStore(t)
+	ctx := context.Background()
+	a := connectedAccount(t, db, userID)
+
+	var refresh, access string
+	if err := db.QueryRowContext(ctx,
+		`SELECT refresh_token, access_token FROM calendar_accounts WHERE id = ?`,
+		a.ID).Scan(&refresh, &access); err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(refresh, "real-looking") || strings.Contains(access, "ya29") {
+		t.Fatalf("a token is in the row as written: %q %q", refresh, access)
+	}
+	// The address stays readable, which is the reason for sealing named columns
+	// rather than the whole row.
+	var account string
+	if err := db.QueryRowContext(ctx,
+		`SELECT account FROM calendar_accounts WHERE id = ?`, a.ID).Scan(&account); err != nil {
+		t.Fatal(err)
+	}
+	if account != "kw@nolimit.dk" {
+		t.Errorf("the address was sealed too: %q", account)
+	}
+
+	back, err := db.CalendarAccountFor(ctx, userID, "google")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if back.RefreshToken != a.RefreshToken || back.AccessToken != a.AccessToken {
+		t.Errorf("the tokens did not survive the round trip: %+v", back)
+	}
+}
+
+// Connecting again must replace what was there, not fail. It is the same OAuth
+// flow run a second time, and the person's word for it is "connect", not "add".
+func TestConnectingAgainReplacesTheAccount(t *testing.T) {
+	db, userID := sealedStore(t)
+	ctx := context.Background()
+	first := connectedAccount(t, db, userID)
+
+	second := &CalendarAccount{
+		UserID: userID, Provider: "google", Account: "kw@nolimit.dk",
+		RefreshToken: "1//0-fresh", AccessToken: "ya29.fresh",
+	}
+	if err := db.SaveCalendarAccount(ctx, second); err != nil {
+		t.Fatalf("connecting a second time failed: %v", err)
+	}
+	// And the id in hand is the row that is actually there. The calendars hang off
+	// it, so an id nothing points at would attach them to nothing.
+	if second.ID != first.ID {
+		t.Errorf("the second connect came back with id %q, want the existing %q",
+			second.ID, first.ID)
+	}
+
+	back, err := db.CalendarAccountFor(ctx, userID, "google")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if back.RefreshToken != "1//0-fresh" {
+		t.Errorf("the token came back as %q", back.RefreshToken)
+	}
+}
+
+// Google says which calendars exist; only verdande knows which ones somebody wants
+// to look at. A refresh that came back with the same list must not undo the choice.
+func TestRefreshingTheListKeepsWhatWasChosen(t *testing.T) {
+	db, userID := sealedStore(t)
+	ctx := context.Background()
+	a := connectedAccount(t, db, userID)
+
+	list := []Calendar{
+		{RemoteID: "primary", Name: "kw@nolimit.dk", Colour: "#3f51b5", Primary: true},
+		{RemoteID: "fam", Name: "Familien", Colour: "#0b8043"},
+		{RemoteID: "old", Name: "Et delt"},
+	}
+	if err := db.ReplaceCalendars(ctx, a.ID, list); err != nil {
+		t.Fatal(err)
+	}
+
+	// Nothing is shown to begin with: an account with a dozen shared calendars in
+	// it should not fill somebody's grid the moment they connect it.
+	stored, err := db.Calendars(ctx, a.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(stored) != 3 {
+		t.Fatalf("got %d calendars, want 3", len(stored))
+	}
+	for _, c := range stored {
+		if c.Shown {
+			t.Errorf("%q was shown without anybody asking for it", c.Name)
+		}
+	}
+
+	var famID string
+	for _, c := range stored {
+		if c.RemoteID == "fam" {
+			famID = c.ID
+		}
+	}
+	if err := db.ShowCalendars(ctx, a.ID, []string{famID}); err != nil {
+		t.Fatal(err)
+	}
+
+	// The sweep runs again, and one calendar has been renamed and one has gone.
+	if err := db.ReplaceCalendars(ctx, a.ID, []Calendar{
+		{RemoteID: "primary", Name: "kw@nolimit.dk", Colour: "#3f51b5", Primary: true},
+		{RemoteID: "fam", Name: "Familien og hunden", Colour: "#0b8043"},
+	}); err != nil {
+		t.Fatal(err)
+	}
+
+	stored, err = db.Calendars(ctx, a.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(stored) != 2 {
+		t.Fatalf("got %d calendars; one that has left the account should stop being drawn",
+			len(stored))
+	}
+	for _, c := range stored {
+		switch c.RemoteID {
+		case "fam":
+			if !c.Shown {
+				t.Error("the choice was undone by a refresh of the list")
+			}
+			if c.Name != "Familien og hunden" {
+				t.Errorf("the new name did not arrive: %q", c.Name)
+			}
+			if c.ID != famID {
+				t.Error("the row was rebuilt rather than updated; its id is what was chosen")
+			}
+		case "primary":
+			if c.Shown {
+				t.Error("a calendar nobody chose became shown")
+			}
+		}
+	}
+}
+
+// A window is replaced, not merged. An event moved out of it has to disappear
+// because it is absent from the answer — and the months on either side must not go
+// with it.
+func TestReplacingAWindowLeavesTheMonthsAroundItAlone(t *testing.T) {
+	db, userID := sealedStore(t)
+	ctx := context.Background()
+	a := connectedAccount(t, db, userID)
+
+	if err := db.ReplaceCalendars(ctx, a.ID, []Calendar{{RemoteID: "primary", Name: "Min"}}); err != nil {
+		t.Fatal(err)
+	}
+	stored, _ := db.Calendars(ctx, a.ID)
+	cal := stored[0]
+	if err := db.ShowCalendars(ctx, a.ID, []string{cal.ID}); err != nil {
+		t.Fatal(err)
+	}
+
+	july := CalendarEvent{RemoteID: "j", Summary: "Juli", StartDay: "2026-07-15", EndDay: "2026-07-15"}
+	august := CalendarEvent{RemoteID: "a", Summary: "August", StartDay: "2026-08-15", EndDay: "2026-08-15"}
+	if err := db.ReplaceCalendarEvents(ctx, cal.ID, "2026-07-01", "2026-07-31",
+		[]CalendarEvent{july}); err != nil {
+		t.Fatal(err)
+	}
+	if err := db.ReplaceCalendarEvents(ctx, cal.ID, "2026-08-01", "2026-08-31",
+		[]CalendarEvent{august}); err != nil {
+		t.Fatal(err)
+	}
+
+	got, err := db.CalendarEvents(ctx, userID, "2026-07-01", "2026-08-31")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got) != 2 {
+		t.Fatalf("got %d events, want both months: %+v", len(got), got)
+	}
+
+	// August is synced again and the meeting has been cancelled. July stays.
+	if err := db.ReplaceCalendarEvents(ctx, cal.ID, "2026-08-01", "2026-08-31", nil); err != nil {
+		t.Fatal(err)
+	}
+	got, err = db.CalendarEvents(ctx, userID, "2026-07-01", "2026-08-31")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got) != 1 || got[0].Summary != "Juli" {
+		t.Fatalf("got %+v; syncing August threw away July", got)
+	}
+}
+
+// The grid asks "which cells does this cover", so an event that straddles the edge
+// of the question has to come back.
+func TestAnEventThatStraddlesTheWindowIsFound(t *testing.T) {
+	db, userID := sealedStore(t)
+	ctx := context.Background()
+	a := connectedAccount(t, db, userID)
+	if err := db.ReplaceCalendars(ctx, a.ID, []Calendar{{RemoteID: "c", Name: "Min", Colour: "#0b8043"}}); err != nil {
+		t.Fatal(err)
+	}
+	stored, _ := db.Calendars(ctx, a.ID)
+	if err := db.ShowCalendars(ctx, a.ID, []string{stored[0].ID}); err != nil {
+		t.Fatal(err)
+	}
+	if err := db.ReplaceCalendarEvents(ctx, stored[0].ID, "2026-08-01", "2026-09-30",
+		[]CalendarEvent{
+			{RemoteID: "trip", Summary: "Aarhus", StartDay: "2026-08-28", EndDay: "2026-09-02", AllDay: true},
+		}); err != nil {
+		t.Fatal(err)
+	}
+
+	// A week that contains neither end of it.
+	got, err := db.CalendarEvents(ctx, userID, "2026-08-31", "2026-09-01")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got) != 1 {
+		t.Fatalf("got %+v; an event covering the whole week was not found", got)
+	}
+	// The calendar's own colour rides along, or the chip has to ask for it per row.
+	if got[0].Colour != "#0b8043" || got[0].CalendarName != "Min" {
+		t.Errorf("the calendar did not come with the event: %+v", got[0])
+	}
+}
+
+// Somebody else's calendar is somebody else's.
+func TestOnlyTheOwnersEventsComeBack(t *testing.T) {
+	db, userID := sealedStore(t)
+	ctx := context.Background()
+
+	other := &User{Email: "andreas@example.dk", Name: "Andreas"}
+	if err := db.CreateUser(ctx, other, "Indbakke"); err != nil {
+		t.Fatal(err)
+	}
+	theirs := &CalendarAccount{UserID: other.ID, Provider: "google", RefreshToken: "r"}
+	if err := db.SaveCalendarAccount(ctx, theirs); err != nil {
+		t.Fatal(err)
+	}
+	if err := db.ReplaceCalendars(ctx, theirs.ID, []Calendar{{RemoteID: "c", Name: "Deres"}}); err != nil {
+		t.Fatal(err)
+	}
+	stored, _ := db.Calendars(ctx, theirs.ID)
+	if err := db.ShowCalendars(ctx, theirs.ID, []string{stored[0].ID}); err != nil {
+		t.Fatal(err)
+	}
+	if err := db.ReplaceCalendarEvents(ctx, stored[0].ID, "2026-08-01", "2026-08-31",
+		[]CalendarEvent{{RemoteID: "x", Summary: "Privat", StartDay: "2026-08-10", EndDay: "2026-08-10"}}); err != nil {
+		t.Fatal(err)
+	}
+
+	got, err := db.CalendarEvents(ctx, userID, "2026-08-01", "2026-08-31")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got) != 0 {
+		t.Fatalf("somebody else's calendar came back: %+v", got)
+	}
+}
+
+// A calendar turned off stops being drawn, and stops costing the grid anything.
+func TestTurningACalendarOffRemovesItsEvents(t *testing.T) {
+	db, userID := sealedStore(t)
+	ctx := context.Background()
+	a := connectedAccount(t, db, userID)
+	if err := db.ReplaceCalendars(ctx, a.ID, []Calendar{{RemoteID: "c", Name: "Min"}}); err != nil {
+		t.Fatal(err)
+	}
+	stored, _ := db.Calendars(ctx, a.ID)
+	if err := db.ShowCalendars(ctx, a.ID, []string{stored[0].ID}); err != nil {
+		t.Fatal(err)
+	}
+	if err := db.ReplaceCalendarEvents(ctx, stored[0].ID, "2026-08-01", "2026-08-31",
+		[]CalendarEvent{{RemoteID: "x", Summary: "Møde", StartDay: "2026-08-10", EndDay: "2026-08-10"}}); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := db.ShowCalendars(ctx, a.ID, nil); err != nil {
+		t.Fatal(err)
+	}
+	var count int
+	if err := db.QueryRowContext(ctx, `SELECT count(*) FROM calendar_events`).Scan(&count); err != nil {
+		t.Fatal(err)
+	}
+	if count != 0 {
+		t.Errorf("%d events of a calendar nobody is looking at are still in the table", count)
+	}
+}
+
+// Disconnecting takes the calendars and the events with it. Unlike the tasks a
+// mailbox made, none of this is the person's own work — it is a copy of somebody
+// else's calendar and it means nothing without the account.
+func TestDisconnectingTakesEverythingWithIt(t *testing.T) {
+	db, userID := sealedStore(t)
+	ctx := context.Background()
+	a := connectedAccount(t, db, userID)
+	if err := db.ReplaceCalendars(ctx, a.ID, []Calendar{{RemoteID: "c", Name: "Min"}}); err != nil {
+		t.Fatal(err)
+	}
+	stored, _ := db.Calendars(ctx, a.ID)
+	if err := db.ShowCalendars(ctx, a.ID, []string{stored[0].ID}); err != nil {
+		t.Fatal(err)
+	}
+	if err := db.ReplaceCalendarEvents(ctx, stored[0].ID, "2026-08-01", "2026-08-31",
+		[]CalendarEvent{{RemoteID: "x", Summary: "Møde", StartDay: "2026-08-10", EndDay: "2026-08-10"}}); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := db.DeleteCalendarAccount(ctx, userID, a.ID); err != nil {
+		t.Fatal(err)
+	}
+	for _, table := range []string{"calendar_accounts", "calendars", "calendar_events"} {
+		var count int
+		if err := db.QueryRowContext(ctx, `SELECT count(*) FROM `+table).Scan(&count); err != nil {
+			t.Fatal(err)
+		}
+		if count != 0 {
+			t.Errorf("%s still holds %d rows after disconnecting", table, count)
+		}
+	}
+}
+
+// The sweep finds people by the presence of an account, so it has to keep working
+// now that the credential in it is ciphertext.
+func TestTheSweepFindsAConnectedCalendar(t *testing.T) {
+	db, userID := sealedStore(t)
+	connectedAccount(t, db, userID)
+
+	users, err := db.UsersWithCalendars(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(users) != 1 || users[0] != userID {
+		t.Fatalf("the sweep found %v", users)
+	}
+}
@@ -0,0 +1,111 @@
+-- Calendars read from somewhere else: the account, the calendars in it, and the
+-- events they hold.
+--
+-- Not in `mailboxes`, and it was the first thing considered. The two look alike
+-- from a distance — a person connects a Google account over OAuth, tokens are
+-- sealed, a sweep polls it — and every column past that disagrees. `trigger_kind`,
+-- `seen`, `last_uid` and `project_id` all answer "what turns a message into a
+-- task", and nothing here turns into a task. What is here instead is a *set*:
+-- one account holds many calendars, and a person picks which of them to look at.
+-- `mailboxes` has no room for a one-to-many, and giving it one would push the
+-- other kind's columns onto rows that can never use them.
+--
+-- The decisive part is smaller and more practical. `mailboxes.kind` carries
+-- `CHECK (kind IN ('gmail', 'imap'))`, and SQLite cannot alter a CHECK — adding a
+-- third value means rebuilding the table with foreign keys off, which is the
+-- expensive, careful thing migration 0021 had to do for a reason. Paying that to
+-- store something that shares no column with the table is the wrong trade.
+--
+-- Hence no CHECK on `provider` here. CalDAV is the next source to read, and it
+-- should cost a row, not a rebuild.
+
+-- One connected account per person per provider. The tokens live here rather than
+-- on each calendar: a refresh token copied onto ten rows is ten copies of one
+-- secret, ten refreshes racing each other, and ten places to miss when access is
+-- revoked.
+--
+-- `refresh_token` and `access_token` are written sealed; see internal/secret. The
+-- store's own seal/unseal only covers the settings tables, so this table's methods
+-- call them by hand — the same fact worth knowing that migration 0014 wrote down.
+CREATE TABLE calendar_accounts (
+    id            TEXT PRIMARY KEY,
+    user_id       TEXT NOT NULL REFERENCES users (id) ON DELETE CASCADE,
+    provider      TEXT NOT NULL DEFAULT 'google',
+    -- The address the account reports, so the settings page can say which one is
+    -- connected rather than only that one is.
+    account       TEXT NOT NULL DEFAULT '',
+
+    refresh_token TEXT NOT NULL DEFAULT '',
+    access_token  TEXT NOT NULL DEFAULT '',
+    expires_at    INTEGER NOT NULL DEFAULT 0,
+
+    last_sync_at  INTEGER NOT NULL DEFAULT 0,
+    created_at    INTEGER NOT NULL
+);
+
+-- Connecting again replaces what was there, the way Gmail's does: the OAuth flow
+-- is one account at a time, so a second row for the same provider would be a
+-- second set of tokens for the same grant and no way to say which is live.
+CREATE UNIQUE INDEX calendar_accounts_once ON calendar_accounts (user_id, provider);
+
+-- One row per calendar the account can see, kept whether or not it is shown.
+--
+-- `shown` rather than deleting the ones that are not: a person who turns a calendar
+-- off and on again should get the same row back, and the list is refreshed from
+-- Google on every sync — so a calendar that only existed while it was ticked would
+-- lose its choice every time somebody added a new one.
+--
+-- `colour` is Google's own hex for the calendar. Not one of verdande's ten named
+-- colours, which is the rule everywhere else in this database: those are names so
+-- the interface can restyle them per theme, and they are *verdande's* palette. A
+-- Google calendar is told apart by the colour the person already knows it by, and
+-- that colour belongs to Google.
+CREATE TABLE calendars (
+    id         TEXT PRIMARY KEY,
+    account_id TEXT NOT NULL REFERENCES calendar_accounts (id) ON DELETE CASCADE,
+    -- The id Google knows it by. Long, and an address for the primary calendar.
+    remote_id  TEXT NOT NULL,
+    name       TEXT NOT NULL DEFAULT '',
+    colour     TEXT NOT NULL DEFAULT '',
+    time_zone  TEXT NOT NULL DEFAULT '',
+    primary_one INTEGER NOT NULL DEFAULT 0,
+    writable   INTEGER NOT NULL DEFAULT 0,
+    shown      INTEGER NOT NULL DEFAULT 0,
+    sort_order INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE UNIQUE INDEX calendars_once ON calendars (account_id, remote_id);
+
+-- The events themselves, cached.
+--
+-- Cached rather than fetched per view, and the reason is what a month grid does:
+-- it pages. Asking Google on every arrow press means a token refresh, a round trip
+-- and a spinner for a question that was answered ninety seconds ago — and a
+-- calendar that is slower than the calendar it is showing is not worth having.
+-- The window is refreshed by the sweep and by the "fetch now" button.
+--
+-- Days rather than instants, and both ends inclusive. A grid asks one question —
+-- "which cells does this cover" — and `start_day <= ? AND end_day >= ?` is that
+-- question. `starts_at` is kept as Google wrote it, offset and all, because it is
+-- what the chip shows and reparsing it here would ask *this process* what time
+-- zone it is in. An all-day event has neither: it has a day, not a moment, and
+-- inventing midnight for it is how an event moves a day when a container moves
+-- time zone.
+CREATE TABLE calendar_events (
+    id          TEXT PRIMARY KEY,
+    calendar_id TEXT NOT NULL REFERENCES calendars (id) ON DELETE CASCADE,
+    remote_id   TEXT NOT NULL,
+    summary     TEXT NOT NULL DEFAULT '',
+    starts_at   TEXT NOT NULL DEFAULT '',
+    ends_at     TEXT NOT NULL DEFAULT '',
+    start_day   TEXT NOT NULL,
+    end_day     TEXT NOT NULL,
+    all_day     INTEGER NOT NULL DEFAULT 0,
+    location    TEXT NOT NULL DEFAULT '',
+    url         TEXT NOT NULL DEFAULT ''
+);
+
+-- The one query there is: everything a person can see, between two days. Ordered
+-- by the account so the join has somewhere to start, then by the days the grid
+-- compares against.
+CREATE INDEX calendar_events_by_day ON calendar_events (calendar_id, start_day, end_day);