后台管理重塑 + 主题 / 皮肤双轴 + a11y 与编辑器增强

Backend
- Post 加 cover_url，Tag 加 color；老库 ALTER 兼容
- admin API: GET /api/admin/dashboard，POST /bulk，POST /tags/:id/merge，
  PUT /tags/:id 接 {name,color}，Settings 加 light_skin_id（兼容老 theme_id）
- 白名单兜底（非法 light_skin_id 落 paper）
- 新增合并 / Dashboard / Theme 测试覆盖

Frontend
- AdminLayout 改为侧边栏布局；新增 Dashboard 总览页
- PostsView 卡片化预览 + 筛选 chip + 批量操作 + 排序
- EditorView 增强：封面图 / WYSIWYG↔MD 双模式 / 实时大纲 / 字数统计 /
  自动保存条 / ⌘S / unsaved 守卫（beforeunload + beforeRouteLeave）
- TagsView 加色板 + 合并到目标
- SettingsView 主题外观改为「亮色皮肤」三选一 + 「暗色皮肤」固定墨色说明
- 新增 CommandPalette（⌘K）+ ShortcutsPanel（?）
- api.js 接新接口；router.js 拆 /admin → /admin/posts

主题 / 皮肤双轴
- site.js: themeMode（light/dark/auto）+ light_skin_id；data-theme 前台，
  data-admin-theme 后台（仅跟随 mode 切明暗）
- styles.css: :root[data-theme] 四套皮肤 + :root[data-admin-theme=dark] 后台墨感
- 修 sticky head / ThemeSwitcher / 表单 / 批量条 等 token 引用
- 后台用独立 --admin-* 系列，与前台主题解耦
- 左栏底部放 inline 形态 ThemeSwitcher（图标按钮 36×36），mobile 保留浮窗

a11y
- 全局 :focus-visible 描边（前后台跟随 token）
- prefers-reduced-motion 全局降级
- color-scheme 随主题切
- meta theme-color 双套（light/dark）
- 命令面板 / 快捷键面板：role=dialog aria-modal aria-label + 搜索框 aria-label
- icon-only 按钮加 aria-label（tag × / 清除选择 / 移除封面等）
- 输入框 aria-label + spellcheck=false
- PostsView 筛选同步 URL（可分享、可刷新保留）
- img width/height + loading=lazy
- utils.js 用 Intl.DateTimeFormat（zh-CN / sv-SE）

backend/internal/store/store.go

@@ -44,6 +44,7 @@ func (s *Store) migrate() error {
 			title           TEXT NOT NULL DEFAULT '',
 			slug            TEXT NOT NULL,
 			summary         TEXT NOT NULL DEFAULT '',
+			cover_url       TEXT NOT NULL DEFAULT '',
 			content_md      TEXT NOT NULL DEFAULT '',
 			content_html    TEXT NOT NULL DEFAULT '',
 			status          TEXT NOT NULL DEFAULT 'draft',
@@ -53,9 +54,10 @@ func (s *Store) migrate() error {
 			reading_minutes INTEGER NOT NULL DEFAULT 1
 		)`, ai),
 		fmt.Sprintf(`CREATE TABLE IF NOT EXISTS tags (
-			id   %s,
-			name TEXT NOT NULL,
-			slug TEXT NOT NULL
+			id    %s,
+			name  TEXT NOT NULL,
+			slug  TEXT NOT NULL,
+			color TEXT NOT NULL DEFAULT ''
 		)`, ai),
 		`CREATE TABLE IF NOT EXISTS post_tags (
 			post_id INTEGER NOT NULL,
@@ -73,6 +75,20 @@ func (s *Store) migrate() error {
 		}
 	}
 
+	// Lightweight column-add migrations for older databases. SQLite supports
+	// ADD COLUMN; Postgres doesn't support IF NOT EXISTS on column add, so we
+	// swallow "already exists" errors either way.
+	columnAdds := []string{
+		`ALTER TABLE posts ADD COLUMN cover_url TEXT NOT NULL DEFAULT ''`,
+		`ALTER TABLE tags  ADD COLUMN color     TEXT NOT NULL DEFAULT ''`,
+	}
+	for _, q := range columnAdds {
+		if _, err := s.db.Exec(s.db.Q(q)); err != nil && !strings.Contains(err.Error(), "already exists") &&
+			!strings.Contains(err.Error(), "duplicate column") {
+			return fmt.Errorf("migrate column: %w", err)
+		}
+	}
+
 	// Indexes/unique constraints need dialect-specific "IF NOT EXISTS" support.
 	indexes := []struct{ name, ddl string }{
 		{"idx_posts_slug", `CREATE UNIQUE INDEX IF NOT EXISTS idx_posts_slug ON posts(slug)`},
@@ -144,6 +160,18 @@ func settingsFromMap(m map[string]string) model.Settings {
 		ICPLicense:   m["icp"],
 		PostsPerPage: 10,
 	}
+	// LightSkinID is the new canonical name; fall back to legacy theme_id
+	// for clients that haven't been updated, and finally to "paper".
+	st.LightSkinID = m["light_skin_id"]
+	if st.LightSkinID == "" {
+		st.LightSkinID = m["theme_id"]
+	}
+	if st.LightSkinID == "" {
+		st.LightSkinID = "paper"
+	}
+	// Mirror the value into ThemeID so legacy API consumers still see it
+	// in the JSON response.
+	st.ThemeID = st.LightSkinID
 	if n := atoi(m["posts_per_page"]); n > 0 {
 		st.PostsPerPage = n
 	}
@@ -161,10 +189,21 @@ func atoi(v string) int {
 	return n
 }
 
+// ValidLightSkins is the whitelist of light-side skin ids the API accepts.
+// Anything outside this set falls back to "paper" on write.
+var ValidLightSkins = map[string]bool{
+	"paper": true,
+	"sage":  true,
+	"rose":  true,
+}
+
 func (s *Store) UpdateSettings(st model.Settings) error {
 	if st.PostsPerPage <= 0 {
 		st.PostsPerPage = 10
 	}
+	if !ValidLightSkins[st.LightSkinID] {
+		st.LightSkinID = "paper"
+	}
 	sets := map[string]string{
 		"site_title":     st.SiteTitle,
 		"site_desc":      st.SiteDesc,
@@ -173,6 +212,9 @@ func (s *Store) UpdateSettings(st model.Settings) error {
 		"footer_note":    st.FooterNote,
 		"icp":            st.ICPLicense,
 		"posts_per_page": fmt.Sprint(st.PostsPerPage),
+		"light_skin_id":  st.LightSkinID,
+		// Mirror to theme_id so any older client still sees something.
+		"theme_id": st.LightSkinID,
 	}
 	for k, v := range sets {
 		if s.db.Dialect == db.Postgres {
@@ -202,13 +244,13 @@ type ListOptions struct {
 	OrderBy string
 }
 
-const postCols = `id, kind, title, slug, summary, content_md, content_html, status,
+const postCols = `id, kind, title, slug, summary, cover_url, content_md, content_html, status,
 	published_at, created_at, updated_at, reading_minutes`
 
 func scanPost(rows interface{ Scan(...any) error }) (model.Post, error) {
 	var p model.Post
-	err := rows.Scan(&p.ID, &p.Kind, &p.Title, &p.Slug, &p.Summary, &p.ContentMd,
-		&p.ContentHTML, &p.Status, &p.PublishedAt, &p.CreatedAt, &p.UpdatedAt, &p.ReadingMinutes)
+	err := rows.Scan(&p.ID, &p.Kind, &p.Title, &p.Slug, &p.Summary, &p.CoverURL,
+		&p.ContentMd, &p.ContentHTML, &p.Status, &p.PublishedAt, &p.CreatedAt, &p.UpdatedAt, &p.ReadingMinutes)
 	p.Tags = []string{}
 	return p, err
 }
@@ -340,8 +382,8 @@ func (s *Store) GetBySlug(slug string) (model.Post, error) {
 }
 
 func scanPostInto(row *sql.Row, p *model.Post) error {
-	err := row.Scan(&p.ID, &p.Kind, &p.Title, &p.Slug, &p.Summary, &p.ContentMd,
-		&p.ContentHTML, &p.Status, &p.PublishedAt, &p.CreatedAt, &p.UpdatedAt, &p.ReadingMinutes)
+	err := row.Scan(&p.ID, &p.Kind, &p.Title, &p.Slug, &p.Summary, &p.CoverURL,
+		&p.ContentMd, &p.ContentHTML, &p.Status, &p.PublishedAt, &p.CreatedAt, &p.UpdatedAt, &p.ReadingMinutes)
 	if err == sql.ErrNoRows {
 		return ErrNotFound
 	}
@@ -386,11 +428,12 @@ func (s *Store) uniqueSlug(base string, excludeID int64) string {
 
 func (s *Store) Create(in model.PostInput) (model.Post, error) {
 	p := model.Post{
-		Kind:   in.Kind,
-		Title:  strings.TrimSpace(in.Title),
-		Slug:   in.Slug,
-		Status: in.Status,
-		Tags:   []string{},
+		Kind:     in.Kind,
+		Title:    strings.TrimSpace(in.Title),
+		Slug:     in.Slug,
+		Status:   in.Status,
+		CoverURL: strings.TrimSpace(in.CoverURL),
+		Tags:     []string{},
 	}
 	if p.Kind == "" {
 		p.Kind = model.KindLong
@@ -428,17 +471,17 @@ func (s *Store) Create(in model.PostInput) (model.Post, error) {
 	}
 
 	var id int64
-	q := s.db.Q(`INSERT INTO posts (kind,title,slug,summary,content_md,content_html,status,
+	q := s.db.Q(`INSERT INTO posts (kind,title,slug,summary,cover_url,content_md,content_html,status,
 		published_at,created_at,updated_at,reading_minutes)
-		VALUES (?,?,?,?,?,?,?,?,?,?,?)`)
+		VALUES (?,?,?,?,?,?,?,?,?,?,?,?)`)
 	if s.db.Dialect == db.Postgres {
-		err := s.db.QueryRow(q, p.Kind, p.Title, p.Slug, p.Summary, p.ContentMd, p.ContentHTML,
+		err := s.db.QueryRow(q, p.Kind, p.Title, p.Slug, p.Summary, p.CoverURL, p.ContentMd, p.ContentHTML,
 			p.Status, p.PublishedAt, p.CreatedAt, p.UpdatedAt, p.ReadingMinutes).Scan(&id)
 		if err != nil {
 			return p, err
 		}
 	} else {
-		res, err := s.db.Exec(q, p.Kind, p.Title, p.Slug, p.Summary, p.ContentMd, p.ContentHTML,
+		res, err := s.db.Exec(q, p.Kind, p.Title, p.Slug, p.Summary, p.CoverURL, p.ContentMd, p.ContentHTML,
 			p.Status, p.PublishedAt, p.CreatedAt, p.UpdatedAt, p.ReadingMinutes)
 		if err != nil {
 			return p, err
@@ -483,6 +526,10 @@ func (s *Store) Update(id int64, in model.PostInput) (model.Post, error) {
 	if in.PublishedAt != "" {
 		p.PublishedAt = in.PublishedAt
 	}
+	// CoverURL is taken verbatim from input. The frontend always sends the
+	// current value (empty string included), so any update round-trips with
+	// whatever the user last saved.
+	p.CoverURL = strings.TrimSpace(in.CoverURL)
 	p.UpdatedAt = now()
 	if in.ReadingMinutes != nil && *in.ReadingMinutes > 0 {
 		p.ReadingMinutes = *in.ReadingMinutes
@@ -490,9 +537,9 @@ func (s *Store) Update(id int64, in model.PostInput) (model.Post, error) {
 		p.ReadingMinutes = readingMinutes(in.ContentMd)
 	}
 
-	if _, err := s.db.Exec(s.db.Q(`UPDATE posts SET kind=?,title=?,slug=?,summary=?,content_md=?,
+	if _, err := s.db.Exec(s.db.Q(`UPDATE posts SET kind=?,title=?,slug=?,summary=?,cover_url=?,content_md=?,
 		content_html=?,status=?,published_at=?,updated_at=?,reading_minutes=? WHERE id=?`),
-		p.Kind, p.Title, p.Slug, p.Summary, p.ContentMd, p.ContentHTML, p.Status,
+		p.Kind, p.Title, p.Slug, p.Summary, p.CoverURL, p.ContentMd, p.ContentHTML, p.Status,
 		p.PublishedAt, p.UpdatedAt, p.ReadingMinutes, id); err != nil {
 		return p, err
 	}
@@ -504,6 +551,37 @@ func (s *Store) Update(id int64, in model.PostInput) (model.Post, error) {
 	return s.Get(id)
 }
 
+// BulkUpdateStatus flips the status of many posts in a single transaction.
+func (s *Store) BulkUpdateStatus(ids []int64, status string) (int, error) {
+	if len(ids) == 0 {
+		return 0, nil
+	}
+	status = NormalizeStatus(status)
+	placeholders := strings.TrimSuffix(strings.Repeat("?,", len(ids)), ",")
+	args := []any{status, now()}
+	for _, id := range ids {
+		args = append(args, id)
+	}
+	q := s.db.Q(`UPDATE posts SET status=?, updated_at=? WHERE id IN (` + placeholders + `)`)
+	res, err := s.db.Exec(q, args...)
+	if err != nil {
+		return 0, err
+	}
+	n, _ := res.RowsAffected()
+	return int(n), nil
+}
+
+// NormalizeStatus coerces an arbitrary input string into a known post status
+// value, defaulting to draft when nothing matches.
+func NormalizeStatus(s string) string {
+	switch strings.ToLower(strings.TrimSpace(s)) {
+	case model.StatusDraft, model.StatusPublished:
+		return strings.ToLower(strings.TrimSpace(s))
+	default:
+		return model.StatusDraft
+	}
+}
+
 func (s *Store) Delete(id int64) error {
 	if _, err := s.db.Exec(s.db.Q(`DELETE FROM post_tags WHERE post_id = ?`), id); err != nil {
 		return err
@@ -568,9 +646,9 @@ func (s *Store) upsertTag(name string) (int64, error) {
 }
 
 func (s *Store) ListTags() ([]model.Tag, error) {
-	q := s.db.Q(`SELECT t.id, t.name, t.slug, COUNT(pt.post_id) AS c
+	q := s.db.Q(`SELECT t.id, t.name, t.slug, t.color, COUNT(pt.post_id) AS c
 		FROM tags t LEFT JOIN post_tags pt ON pt.tag_id = t.id
-		GROUP BY t.id, t.name, t.slug ORDER BY c DESC, t.name`)
+		GROUP BY t.id, t.name, t.slug, t.color ORDER BY c DESC, t.name`)
 	rows, err := s.db.Query(q)
 	if err != nil {
 		return nil, err
@@ -579,7 +657,7 @@ func (s *Store) ListTags() ([]model.Tag, error) {
 	out := []model.Tag{}
 	for rows.Next() {
 		var t model.Tag
-		if err := rows.Scan(&t.ID, &t.Name, &t.Slug, &t.Count); err != nil {
+		if err := rows.Scan(&t.ID, &t.Name, &t.Slug, &t.Color, &t.Count); err != nil {
 			return nil, err
 		}
 		out = append(out, t)
@@ -599,6 +677,59 @@ func (s *Store) CreateTag(name string) (model.Tag, error) {
 	return model.Tag{ID: id, Name: name, Slug: Slugify(name)}, nil
 }
 
+// CreateTagFull is used by the admin API when color is supplied.
+func (s *Store) CreateTagFull(name, color string) (model.Tag, error) {
+	name = strings.TrimSpace(name)
+	if name == "" {
+		return model.Tag{}, errors.New("tag name required")
+	}
+	slug := Slugify(name)
+	if slug == "" {
+		return model.Tag{}, errors.New("tag slug required")
+	}
+	var id int64
+	err := s.db.QueryRow(s.db.Q(`SELECT id FROM tags WHERE slug = ?`), slug).Scan(&id)
+	if err != nil && err != sql.ErrNoRows {
+		return model.Tag{}, err
+	}
+	if err == nil {
+		// already exists — update color and return
+		if _, err := s.db.Exec(s.db.Q(`UPDATE tags SET color=? WHERE id=?`), color, id); err != nil {
+			return model.Tag{}, err
+		}
+		return s.getTag(id)
+	}
+	color = strings.TrimSpace(color)
+	if s.db.Dialect == db.Postgres {
+		err := s.db.QueryRow(s.db.Q(`INSERT INTO tags(name,slug,color) VALUES (?,?,?) RETURNING id`),
+			name, slug, color).Scan(&id)
+		if err != nil {
+			return model.Tag{}, err
+		}
+	} else {
+		res, err := s.db.Exec(s.db.Q(`INSERT INTO tags(name,slug,color) VALUES (?,?,?)`), name, slug, color)
+		if err != nil {
+			return model.Tag{}, err
+		}
+		id, err = res.LastInsertId()
+		if err != nil {
+			return model.Tag{}, err
+		}
+	}
+	return s.getTag(id)
+}
+
+func (s *Store) getTag(id int64) (model.Tag, error) {
+	var t model.Tag
+	err := s.db.QueryRow(s.db.Q(`SELECT t.id, t.name, t.slug, t.color, COUNT(pt.post_id)
+		FROM tags t LEFT JOIN post_tags pt ON pt.tag_id = t.id
+		WHERE t.id = ? GROUP BY t.id`), id).Scan(&t.ID, &t.Name, &t.Slug, &t.Color, &t.Count)
+	if err == sql.ErrNoRows {
+		return t, ErrNotFound
+	}
+	return t, err
+}
+
 func (s *Store) RenameTag(id int64, name string) (model.Tag, error) {
 	name = strings.TrimSpace(name)
 	slug := Slugify(name)
@@ -608,13 +739,49 @@ func (s *Store) RenameTag(id int64, name string) (model.Tag, error) {
 	if _, err := s.db.Exec(s.db.Q(`UPDATE tags SET name=?, slug=? WHERE id=?`), name, slug, id); err != nil {
 		return model.Tag{}, err
 	}
-	var t model.Tag
-	err := s.db.QueryRow(s.db.Q(`SELECT id, name, slug, 0 FROM tags WHERE id = ?`), id).
-		Scan(&t.ID, &t.Name, &t.Slug, &t.Count)
-	if err == sql.ErrNoRows {
-		return t, ErrNotFound
+	return s.getTag(id)
+}
+
+// UpdateTag is the combined rename + recolor used by the admin UI.
+func (s *Store) UpdateTag(id int64, name, color string) (model.Tag, error) {
+	name = strings.TrimSpace(name)
+	slug := Slugify(name)
+	if name == "" {
+		return model.Tag{}, errors.New("tag name required")
 	}
-	return t, err
+	color = strings.TrimSpace(color)
+	if _, err := s.db.Exec(s.db.Q(`UPDATE tags SET name=?, slug=?, color=? WHERE id=?`), name, slug, color, id); err != nil {
+		return model.Tag{}, err
+	}
+	return s.getTag(id)
+}
+
+// MergeTags moves every post from fromID to toID, then deletes fromID. It is a
+// no-op if the ids are equal or either doesn't exist.
+func (s *Store) MergeTags(fromID, toID int64) (model.Tag, error) {
+	if fromID == toID {
+		return model.Tag{}, errors.New("source and target are the same tag")
+	}
+	if _, err := s.getTag(fromID); err != nil {
+		return model.Tag{}, err
+	}
+	if _, err := s.getTag(toID); err != nil {
+		return model.Tag{}, err
+	}
+	// De-duplicate before the move so we don't end up with two rows pointing
+	// at the same post.
+	if _, err := s.db.Exec(s.db.Q(`DELETE FROM post_tags
+		WHERE post_id IN (SELECT post_id FROM post_tags WHERE tag_id = ?)
+		AND tag_id = ?`), toID, toID); err != nil {
+		return model.Tag{}, err
+	}
+	if _, err := s.db.Exec(s.db.Q(`UPDATE post_tags SET tag_id=? WHERE tag_id=?`), toID, fromID); err != nil {
+		return model.Tag{}, err
+	}
+	if _, err := s.db.Exec(s.db.Q(`DELETE FROM tags WHERE id=?`), fromID); err != nil {
+		return model.Tag{}, err
+	}
+	return s.getTag(toID)
 }
 
 func (s *Store) DeleteTag(id int64) error {
@@ -667,3 +834,133 @@ func splitDate(rfc3339 string) (string, string) {
 	}
 	return rfc3339[0:4], rfc3339[5:7]
 }
+
+// ---------- dashboard ----------
+
+// Dashboard produces the snapshot rendered on the admin home page.
+func (s *Store) Dashboard() (model.Dashboard, error) {
+	d := model.Dashboard{
+		RecentPosts:       []model.Post{},
+		RecentDrafts:      []model.Post{},
+		TopTags:           []model.Tag{},
+		PublishedByMonth:  []model.MonthBucket{},
+	}
+
+	// status / kind counts --------------------------------------------------
+	rows, err := s.db.Query(s.db.Q(`SELECT status, kind, COUNT(*) FROM posts GROUP BY status, kind`))
+	if err != nil {
+		return d, err
+	}
+	for rows.Next() {
+		var status, kind string
+		var n int
+		if err := rows.Scan(&status, &kind, &n); err != nil {
+			rows.Close()
+			return d, err
+		}
+		d.TotalPosts += n
+		switch status {
+		case model.StatusPublished:
+			d.PublishedPosts += n
+		case model.StatusDraft:
+			d.DraftPosts += n
+		}
+		switch kind {
+		case model.KindShort:
+			d.ShortPosts += n
+		case model.KindLong:
+			d.LongPosts += n
+		}
+	}
+	rows.Close()
+
+	// total tag count -------------------------------------------------------
+	if err := s.db.QueryRow(s.db.Q(`SELECT COUNT(*) FROM tags`)).Scan(&d.TotalTags); err != nil {
+		return d, err
+	}
+
+	// total word count: sum of content_md length ----------------------------
+	if err := s.db.QueryRow(s.db.Q(`SELECT COALESCE(SUM(LENGTH(content_md)),0) FROM posts`)).Scan(&d.TotalWords); err != nil {
+		return d, err
+	}
+
+	// recent published posts (5) --------------------------------------------
+	if err := s.scanPostsInto(s.db.Q(`SELECT `+postCols+` FROM posts
+		WHERE status=? ORDER BY published_at DESC LIMIT 5`), []any{model.StatusPublished}, &d.RecentPosts); err != nil {
+		return d, err
+	}
+
+	// recent drafts (5) -----------------------------------------------------
+	if err := s.scanPostsInto(s.db.Q(`SELECT `+postCols+` FROM posts
+		WHERE status=? ORDER BY updated_at DESC LIMIT 5`), []any{model.StatusDraft}, &d.RecentDrafts); err != nil {
+		return d, err
+	}
+
+	// top tags (10) ---------------------------------------------------------
+	if err := s.db.QueryRow(s.db.Q(`SELECT COUNT(*) FROM tags`)).Scan(&d.TotalTags); err != nil {
+		return d, err
+	}
+	tagRows, err := s.db.Query(s.db.Q(`SELECT t.id, t.name, t.slug, t.color, COUNT(pt.post_id) AS c
+		FROM tags t LEFT JOIN post_tags pt ON pt.tag_id = t.id
+		GROUP BY t.id, t.name, t.slug, t.color ORDER BY c DESC, t.name LIMIT 10`))
+	if err != nil {
+		return d, err
+	}
+	for tagRows.Next() {
+		var t model.Tag
+		if err := tagRows.Scan(&t.ID, &t.Name, &t.Slug, &t.Color, &t.Count); err != nil {
+			tagRows.Close()
+			return d, err
+		}
+		d.TopTags = append(d.TopTags, t)
+	}
+	tagRows.Close()
+
+	// published_by_month — last 12 months -----------------------------------
+	monthRows, err := s.db.Query(s.db.Q(`SELECT substr(published_at,1,7) AS m, COUNT(*) AS c
+		FROM posts WHERE status=? AND length(published_at) >= 7
+		GROUP BY m ORDER BY m DESC LIMIT 12`), model.StatusPublished)
+	if err != nil {
+		return d, err
+	}
+	defer monthRows.Close()
+	for monthRows.Next() {
+		var b model.MonthBucket
+		if err := monthRows.Scan(&b.Month, &b.Count); err != nil {
+			return d, err
+		}
+		d.PublishedByMonth = append(d.PublishedByMonth, b)
+	}
+	// reverse so we can render left-to-right on the chart
+	for i, j := 0, len(d.PublishedByMonth)-1; i < j; i, j = i+1, j-1 {
+		d.PublishedByMonth[i], d.PublishedByMonth[j] = d.PublishedByMonth[j], d.PublishedByMonth[i]
+	}
+
+	return d, nil
+}
+
+// scanPostsInto is a small helper that runs a query and scans rows into the
+// given slice, attaching tags at the end.
+func (s *Store) scanPostsInto(query string, args []any, dst *[]model.Post) error {
+	rows, err := s.db.Query(query, args...)
+	if err != nil {
+		return err
+	}
+	defer rows.Close()
+	out := []model.Post{}
+	for rows.Next() {
+		p, err := scanPost(rows)
+		if err != nil {
+			return err
+		}
+		out = append(out, p)
+	}
+	if err := rows.Err(); err != nil {
+		return err
+	}
+	if err := s.attachTags(out); err != nil {
+		return err
+	}
+	*dst = out
+	return nil
+}