Files
pages/internal/server/public_navigation.go
Anya Tokugawa d5d21b7841
Build and publish container images / images (push) Successful in 9m34s
Release container images / release (push) Successful in 36s
Refactor architecture into eight components and consolidate reliability work
Extract Grammaratur, Dregarnuhr, Geduldh, Mestionora, Ordoschnellic, Schutzaria, Kunstzeal and Seheweit behind compatible application contracts.

Include accumulated editor resilience, navigation and theme UX, remote CLI, storage/schema and DR groundwork, tests and design/operations documentation.

Verified: uncached full Go suite; go vet ./...; race tests for all eight components; 11 targeted Chromium tests; Node suites; 19 Python CLI tests; reproducible editor build. No push, release tag or deployment in this checkpoint.
2026-11-01 15:23:31 +09:00

491 lines
16 KiB
Go

package server
import (
"context"
"html"
"html/template"
"net/http"
"net/url"
"path"
"sort"
"strconv"
"strings"
"pageswiki/internal/store"
)
type publicNavigationKey struct{}
type publicNavigationSnapshot struct {
pages map[string]store.Revision
paths []string
branches map[string]bool
}
func publicNavigationFor(r *http.Request) *publicNavigationSnapshot {
v, _ := r.Context().Value(publicNavigationKey{}).(*publicNavigationSnapshot)
return v
}
func (p *publicNavigationSnapshot) allows(target string) bool { _, ok := p.pages[target]; return ok }
func (p *publicNavigationSnapshot) href(target string) string {
if p.allows(target) {
return cityPageHref(target)
}
return cityPageHref("/v/tree" + strings.TrimRight(target, "/"))
}
func (s *Server) withPublicNavigation(r *http.Request) (*http.Request, error) {
pages, err := s.publicNavigation(r.Context(), s.domainUUIDForRequest(r))
if err != nil {
return r, err
}
return s.withPublishedNavigation(r, pages)
}
func (s *Server) withPublishedNavigation(r *http.Request, pages []store.PublishedNavigationPage) (*http.Request, error) {
p := &publicNavigationSnapshot{pages: map[string]store.Revision{}, branches: map[string]bool{}}
priority := map[string]int{}
for i, lang := range s.revisionLanguageCandidates(r) {
priority[lang] = i + 1
}
for _, e := range pages {
if strings.Count(e.Path, "/") > 128 {
return r, store.ErrNavigationBudget
}
old, ok := p.pages[e.Path]
rank := priority[e.Revision.Language]
if rank == 0 {
rank = 10000
}
oldRank := priority[old.Language]
if oldRank == 0 {
oldRank = 10000
}
if !ok || rank < oldRank {
p.pages[e.Path] = e.Revision
}
if !ok {
p.paths = append(p.paths, e.Path)
for at := e.Path; ; at = path.Dir(at) {
p.branches[at] = true
if len(p.branches) > store.MaxNavigationEntries {
return r, store.ErrNavigationBudget
}
if at == "/" {
break
}
}
}
}
r = r.WithContext(context.WithValue(r.Context(), anonymousProjectionKey{}, true))
return r.WithContext(context.WithValue(r.Context(), publicNavigationKey{}, p)), nil
}
func publicNavigationRoute(target string) bool {
return target == "/v/children" || target == "/v/tree" || strings.HasPrefix(target, "/v/tree/") || target == "/v/browser" || strings.HasPrefix(target, "/v/browser/") || target == "/v/city" || target == "/_/api/v1/city/map"
}
func (s *Server) servePublicNavigation(w http.ResponseWriter, r *http.Request) bool {
if !publicNavigationRoute(r.URL.Path) {
return false
}
r, err := s.withPublicNavigation(r)
if err != nil {
http.Error(w, "navigation unavailable", 503)
return true
}
s.renderPublicNavigationRoute(w, r)
return true
}
func (s *Server) renderPublicNavigationRoute(w http.ResponseWriter, r *http.Request) {
p := publicNavigationFor(r)
privateCityResponse(w)
w.Header().Add("Vary", "Accept-Language")
switch {
case r.URL.Path == "/v/children":
args := parseChildrenMacroArgs("", r.URL.Query().Get("path"))
args.Excludes = splitExcludePatterns(r.URL.Query().Get("exclude"))
args.View = r.URL.Query().Get("view")
args.Offset, _ = strconv.Atoi(r.URL.Query().Get("offset"))
args.Limit, _ = strconv.Atoi(r.URL.Query().Get("limit"))
if args.Limit <= 0 || args.Limit > 400 {
args.Limit = 120
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
if r.Method != "HEAD" {
_, _ = w.Write([]byte(s.renderPublicChildren(r, args)))
}
case r.URL.Path == "/_/api/v1/city/map":
city, err := s.publicCityProjection(r)
if err != nil {
http.Error(w, "navigation unavailable", 503)
return
}
writeEventJSON(w, 200, city)
case r.URL.Path == "/v/city":
s.render(w, "city_map.gohtml", map[string]any{"Context": s.BuildRequestContext(r), "Locale": s.getLocale(s.domainUUIDForRequest(r)), "PublicNavigation": true, "CanPlan": false})
default:
prefix := "/v/tree"
directory := strings.HasPrefix(r.URL.Path, "/v/browser")
if directory {
prefix = "/v/browser"
}
scope := path.Clean("/" + strings.TrimPrefix(r.URL.Path, prefix))
if scope != "/" && !p.branches[scope] {
http.NotFound(w, r)
return
}
s.renderPublicDirectory(w, r, scope, directory)
}
}
func publicFolderHref(scope string) string {
return cityPageHref("/v/browser" + strings.TrimRight(scope, "/"))
}
func (s *Server) publicNavigationData(r *http.Request, scope string) map[string]any {
p := publicNavigationFor(r)
data := map[string]any{"Context": s.BuildRequestContext(r), "Locale": s.getLocale(s.domainUUIDForRequest(r)), "Path": scope, "PublicBreadcrumbs": publicBreadcrumbs(p, scope), "PublicFolderHref": publicFolderHref(scope), "PublicTreeHref": cityPageHref("/v/tree" + strings.TrimRight(scope, "/")), "PublicHasChildren": p.hasChildren(scope)}
if p.allows(scope) {
data["PublicPageHref"] = p.href(scope)
}
if scope != "/" {
data["PublicParentHref"] = publicFolderHref(path.Dir(scope))
}
return data
}
func (s *Server) renderPublicDirectory(w http.ResponseWriter, r *http.Request, scope string, directory bool) {
data := s.publicNavigationData(r, scope)
data["Directory"] = directory
if directory {
args := childrenMacroArgs{TargetPath: scope, Limit: 120, View: "list"}
args.Excludes = splitExcludePatterns(r.URL.Query().Get("exclude"))
if limit, _ := strconv.Atoi(r.URL.Query().Get("limit")); limit > 0 && limit <= 400 {
args.Limit = limit
}
args.Offset, _ = strconv.Atoi(r.URL.Query().Get("offset"))
if args.Offset < 0 || args.Offset > store.MaxNavigationEntries {
args.Offset = 0
}
data["PublicChildren"] = template.HTML(s.renderPublicChildren(r, args))
query := url.Values{"path": {scope}, "offset": {strconv.Itoa(args.Offset)}, "limit": {strconv.Itoa(args.Limit)}}
if len(args.Excludes) > 0 {
query.Set("exclude", strings.Join(args.Excludes, ","))
}
data["PublicChildrenSource"] = "/v/children?" + query.Encode()
if args.Offset > 0 {
query.Del("path")
query.Set("offset", strconv.Itoa(max(0, args.Offset-args.Limit)))
data["PublicPreviousBatch"] = publicFolderHref(scope) + "?" + query.Encode()
}
} else {
data["Nodes"] = publicTreeNodes(publicNavigationFor(r), scope)
}
privateCityResponse(w)
w.Header().Add("Vary", "Accept-Language")
s.render(w, "public_tree.gohtml", data)
}
func (p *publicNavigationSnapshot) hasChildren(scope string) bool {
prefix := strings.TrimRight(scope, "/") + "/"
for _, item := range p.paths {
if item != scope && strings.HasPrefix(item, prefix) {
return true
}
}
return false
}
type publicNavigationLink struct{ Name, Href string }
func publicBreadcrumbs(p *publicNavigationSnapshot, target string) []publicNavigationLink {
links := []publicNavigationLink{}
for at := target; ; at = path.Dir(at) {
if p.branches[at] {
name := path.Base(at)
if at == "/" {
name = "/"
}
links = append(links, publicNavigationLink{name, p.href(at)})
}
if at == "/" {
break
}
}
for i, j := 0, len(links)-1; i < j; i, j = i+1, j-1 {
links[i], links[j] = links[j], links[i]
}
return links
}
type publicTreeNode struct {
Name, Path, Href, FolderHref string
Depth int
IsDir bool
HasChildren bool
}
func publicTreeNodes(p *publicNavigationSnapshot, scope string) []publicTreeNode {
keys := []string{}
for item := range p.branches {
if item != scope && strings.HasPrefix(item, strings.TrimRight(scope, "/")+"/") {
keys = append(keys, item)
}
}
// Compare path components, not raw bytes: /a/x must precede /a-b.
// Tree collapse/keyboard navigation requires contiguous descendants.
order := make(map[string]string, len(keys))
for _, item := range keys {
order[item] = strings.ReplaceAll(item, "/", "\x00")
}
sort.Slice(keys, func(i, j int) bool { return order[keys[i]] < order[keys[j]] })
nodes := []publicTreeNode{}
parents := map[string]bool{}
for _, item := range keys {
parents[path.Dir(item)] = true
}
for _, item := range keys {
nodes = append(nodes, publicTreeNode{Name: path.Base(item), Path: item, Href: p.href(item), FolderHref: publicFolderHref(item), Depth: strings.Count(strings.TrimPrefix(item, strings.TrimRight(scope, "/")+"/"), "/"), IsDir: !p.allows(item), HasChildren: parents[item]})
}
return nodes
}
func (s *Server) renderPublicChildren(r *http.Request, args childrenMacroArgs) string {
p := publicNavigationFor(r)
if p == nil {
return ""
}
scope := path.Clean(args.TargetPath)
prefix := strings.TrimRight(scope, "/") + "/"
children := map[string]bool{}
hasChildren := map[string]bool{}
for _, item := range p.paths {
if !strings.HasPrefix(item, prefix) || item == scope || isExcludedPath(item, args.Excludes) {
continue
}
child := prefix + strings.Split(strings.TrimPrefix(item, prefix), "/")[0]
if !isExcludedPath(child, args.Excludes) {
children[child] = true
if item != child {
hasChildren[child] = true
}
}
}
keys := []string{}
for child := range children {
keys = append(keys, child)
}
sort.Strings(keys)
start := args.Offset
if start < 0 {
start = 0
}
if start > len(keys) {
start = len(keys)
}
limit := args.Limit
if limit <= 0 || limit > 400 {
limit = 120
}
end := min(start+limit, len(keys))
var out strings.Builder
browseLabel := translate(s.getLocale(s.domainUUIDForRequest(r)), "public.navigation.browse")
class := "public-children-list"
if args.View == "icon" {
class = "public-children-icons"
} else if args.View == "detail" {
class = "public-children-details"
}
out.WriteString(`<ul class="` + class + `">`)
for _, child := range keys[start:end] {
icon := "📄"
if !p.allows(child) {
icon = "📁"
}
out.WriteString(`<li><a class="public-child-link" href="` + html.EscapeString(p.href(child)) + `"><span aria-hidden="true">` + icon + `</span><span>` + html.EscapeString(path.Base(child)) + `</span></a>`)
if hasChildren[child] {
out.WriteString(`<a class="public-child-folder" href="` + html.EscapeString(publicFolderHref(child)) + `" aria-label="` + html.EscapeString(browseLabel+": "+path.Base(child)) + `" title="` + html.EscapeString(browseLabel) + `">▤</a>`)
}
if args.View == "detail" {
out.WriteString(` <small>` + html.EscapeString(child) + `</small>`)
}
out.WriteString(`</li>`)
}
out.WriteString(`</ul>`)
if len(keys) == 0 {
out.WriteString(`<p class="muted">` + html.EscapeString(translate(s.getLocale(s.domainUUIDForRequest(r)), "public.navigation.empty")) + `</p>`)
}
args.TargetPath = scope
args.Limit = limit
if end < len(keys) {
query := url.Values{"path": {scope}, "view": {args.View}, "offset": {strconv.Itoa(end)}, "limit": {strconv.Itoa(limit)}}
if len(args.Excludes) > 0 {
query.Set("exclude", strings.Join(args.Excludes, ","))
}
// The link works without JavaScript; enhanced views replace it with
// automatic lazy continuation. The next URL never counts private rows.
out.WriteString(`<div class="children-next" data-children-next="` + html.EscapeString("/v/children?"+query.Encode()) + `">`)
query.Del("path")
out.WriteString(`<a href="` + html.EscapeString(publicFolderHref(scope)+"?"+query.Encode()) + `">` + html.EscapeString(translate(s.getLocale(s.domainUUIDForRequest(r)), "public.navigation.next_batch")) + `</a></div>`)
}
return out.String()
}
func (s *Server) expandPublicMacro(r *http.Request, macro, currentPath string) string {
p := publicNavigationFor(r)
if p == nil {
return macro
}
if strings.HasPrefix(macro, "{{children") {
match := childrenMacroRe.FindStringSubmatch(macro)
if len(match) < 2 {
return macro
}
args := parseChildrenMacroArgs(match[1], currentPath)
fallback := `<a href="` + html.EscapeString(publicFolderHref(args.TargetPath)) + `">` + html.EscapeString(translate(s.getLocale(s.domainUUIDForRequest(r)), "public.navigation.browse")) + `</a>`
return strings.Replace(s.expandChildrenMacros(macro, currentPath), `<div class="children-loading" role="status">Loading…</div>`, fallback, 1)
}
if macro == "{{city-breadcrumbs}}" {
var out strings.Builder
out.WriteString(`<nav>`)
for _, link := range publicBreadcrumbs(p, currentPath) {
out.WriteString(`<a href="` + html.EscapeString(link.Href) + `">` + html.EscapeString(link.Name) + `</a> / `)
}
out.WriteString(`</nav>`)
return out.String()
}
if macro == "{{city}}" {
return `<a href="/v/city">` + html.EscapeString(translate(s.getLocale(s.domainUUIDForRequest(r)), "city.map")) + `</a>`
}
match := cityMacroRe.FindStringSubmatch(macro)
if len(match) > 1 && (match[1] == "quartier" || match[1] == "street" || match[1] == "spot" || match[1] == "spot-pages") {
city, err := s.publicCityProjection(r)
if err != nil {
return macro
}
within := func(scope string) bool {
return currentPath == scope || strings.HasPrefix(currentPath, strings.TrimRight(scope, "/")+"/")
}
link := func(href, label string) string {
return `<a href="` + html.EscapeString(href) + `">` + html.EscapeString(label) + `</a>`
}
for _, q := range city.Quartiers {
if !within(q.PathPrefix) {
continue
}
if match[1] == "quartier" {
return link(q.DetailHref, q.Title)
}
for _, st := range q.Streets {
if !within(st.PathPrefix) {
continue
}
if match[1] == "street" {
return link(st.DetailHref, st.Title)
}
for _, sp := range st.Spots {
has := within(sp.PathPrefix)
for _, page := range sp.Pages {
if page.Path == currentPath {
has = true
}
}
if !has {
continue
}
if match[1] == "spot" {
return link(sp.DetailHref, sp.DisplayTitle)
}
var out strings.Builder
out.WriteString(`<ul>`)
for _, page := range sp.Pages {
out.WriteString(`<li>` + link(cityPageHref(page.Path), page.Label) + `</li>`)
}
out.WriteString(`</ul>`)
return out.String()
}
}
}
return `<span>—</span>`
}
return macro
}
func (s *Server) publicCityProjection(r *http.Request) (store.CityMap, error) {
p := publicNavigationFor(r)
city, err := s.navigationCity(r.Context(), s.domainUUIDForRequest(r))
if err != nil {
return city, err
}
// The hierarchy comes from actual topology, but labels/links/counts only
// disclose approved semantic Paths. A private parent's custom prose is not
// published merely because it contains an approved descendant.
visible := map[string]bool{}
for item := range p.branches {
visible[item] = true
}
for _, q := range city.Quartiers {
for _, st := range q.Streets {
for _, sp := range st.Spots {
for _, page := range sp.Pages {
if p.allows(page.Path) && strings.HasPrefix(page.Path, strings.TrimRight(st.PathPrefix, "/")+"/") && strings.HasSuffix(sp.PathPrefix, "/_undefined") {
visible[sp.PathPrefix] = true
}
}
}
}
}
city = filterCityProjection(city, func(item string) bool { return visible[item] })
city.Relations = []store.CitySpotRelation{}
for qi := range city.Quartiers {
q := &city.Quartiers[qi]
q.Name = path.Base(q.PathPrefix)
q.Title = q.Name
q.Description = ""
q.State = "active"
q.SortKey = 0
q.DetailHref = "/v/city?quartier=" + url.QueryEscape(q.UUID)
for si := range q.Streets {
st := &q.Streets[si]
st.Name = path.Base(st.PathPrefix)
st.Title = st.Name
st.Description = ""
st.State = "active"
st.SortKey = 0
st.DetailHref = "/v/city?street=" + url.QueryEscape(st.UUID)
for pi := range st.Spots {
sp := &st.Spots[pi]
sp.Name = path.Base(sp.PathPrefix)
sp.Title = sp.Name
// Recompute from public-safe fields; the authenticated display
// projection can contain a private custom title.
sp.DisplayTitle = store.CitySpotDisplayTitle(sp.Name, sp.Name, sp.PathPrefix, st.Name)
sp.Summary = ""
sp.State = "active"
sp.SortKey = 0
sp.DetailHref = "/v/city?spot=" + url.QueryEscape(sp.UUID)
sp.PortalPath = ""
sp.PortalPageUUID = ""
pages := []store.CityPagePlacement{}
seen := map[string]bool{}
for _, page := range sp.Pages {
if !p.allows(page.Path) {
continue
}
page = store.CityPagePlacement{Path: page.Path, PageUUID: p.pages[page.Path].ObjectUUID, Label: path.Base(page.Path), EdgeType: "primary"}
pages = append(pages, page)
seen[page.PageUUID] = true
if sp.PortalPath == "" || page.Path == sp.PathPrefix {
sp.PortalPath = page.Path
sp.PortalPageUUID = page.PageUUID
}
}
sp.Pages = pages
sp.PageCount = len(seen)
}
}
}
return city, nil
}