Files
pages/internal/store/city.go
T
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

791 lines
35 KiB
Go

package store
import (
"database/sql"
"errors"
"regexp"
"strings"
"time"
"github.com/google/uuid"
)
var cityNamePattern = regexp.MustCompile(`^[a-z0-9][a-z0-9_-]{1,63}$`)
type CitySpot struct {
DisplayTitle string `json:"display_title,omitempty"`
DetailHref string `json:"detail_href,omitempty"`
UUID string `json:"uuid"`
Name string `json:"name"`
Title string `json:"title"`
Summary string `json:"summary"`
State string `json:"state"`
SortKey int `json:"sort_key"`
PageCount int `json:"page_count"`
Pages []CityPagePlacement `json:"pages"`
PathPrefix string `json:"path_prefix"`
PortalPath string `json:"portal_path"`
PortalPageUUID string `json:"portal_page_uuid"`
}
type CityStreet struct {
DetailHref string `json:"detail_href,omitempty"`
UUID string `json:"uuid"`
Name string `json:"name"`
Title string `json:"title"`
Description string `json:"description"`
State string `json:"state"`
SortKey int `json:"sort_key"`
Spots []CitySpot `json:"spots"`
PathPrefix string `json:"path_prefix"`
}
type CityQuartier struct {
DetailHref string `json:"detail_href,omitempty"`
UUID string `json:"uuid"`
Name string `json:"name"`
Title string `json:"title"`
Description string `json:"description"`
State string `json:"state"`
SortKey int `json:"sort_key"`
Streets []CityStreet `json:"streets"`
PathPrefix string `json:"path_prefix"`
}
type CityMap struct {
DomainUUID string `json:"domain_uuid"`
Version int64 `json:"version"`
Quartiers []CityQuartier `json:"quartiers"`
Relations []CitySpotRelation `json:"relations"`
}
type CitySpotRelation struct {
SourceSpotUUID string `json:"source_spot_uuid"`
TargetSpotUUID string `json:"target_spot_uuid"`
RelationType string `json:"relation_type"`
Weight float64 `json:"weight"`
}
type CityPagePlacement struct {
PageUUID string `json:"page_uuid"`
Path string `json:"path"`
EdgeType string `json:"edge_type"`
Label string `json:"label"`
SortKey int `json:"sort_key"`
Featured bool `json:"featured"`
Source string `json:"source"`
}
type CitySpotAppearance struct {
SpotUUID, SpotName, SpotTitle, EdgeType, Label, Source, PathPrefix string
DisplayTitle, StreetPath, QuartierPath string
}
type CityNodeDetail struct {
UUID, DomainUUID, Kind, ParentUUID, Name, Title, Description, State string
PathPrefix string
SortKey, Version int
Quartier *CityNodeAncestor `json:"quartier,omitempty"`
Street *CityNodeAncestor `json:"street,omitempty"`
}
func (s *Store) EnsureCitySchema() error {
statements := []string{
`CREATE TABLE IF NOT EXISTS domain_topology_versions (domain_uuid TEXT PRIMARY KEY,version INTEGER NOT NULL DEFAULT 1,updated_at_ms INTEGER NOT NULL)`,
`CREATE TABLE IF NOT EXISTS zones (uuid TEXT PRIMARY KEY,domain_uuid TEXT NOT NULL,kind TEXT NOT NULL,parent_uuid TEXT,name TEXT NOT NULL,title TEXT NOT NULL DEFAULT '',description TEXT NOT NULL DEFAULT '',path_prefix TEXT NOT NULL DEFAULT '',charter_json TEXT NOT NULL DEFAULT '{}',policy_json TEXT NOT NULL DEFAULT '{}',state TEXT NOT NULL DEFAULT 'draft',sort_key INTEGER NOT NULL DEFAULT 0,version INTEGER NOT NULL DEFAULT 1,created_at_ms INTEGER NOT NULL,updated_at_ms INTEGER NOT NULL,UNIQUE(domain_uuid,parent_uuid,name))`,
`CREATE UNIQUE INDEX IF NOT EXISTS idx_zones_quartier_name ON zones(domain_uuid,name) WHERE kind='quartier'`,
`CREATE INDEX IF NOT EXISTS idx_zones_parent ON zones(domain_uuid,parent_uuid,sort_key,name)`,
`CREATE TABLE IF NOT EXISTS spots (uuid TEXT PRIMARY KEY,domain_uuid TEXT NOT NULL,name TEXT NOT NULL,title TEXT NOT NULL DEFAULT '',summary TEXT NOT NULL DEFAULT '',path_prefix TEXT NOT NULL DEFAULT '',charter_json TEXT NOT NULL DEFAULT '{}',schema_json TEXT NOT NULL DEFAULT '{}',landing_json TEXT NOT NULL DEFAULT '{}',state TEXT NOT NULL DEFAULT 'draft',version INTEGER NOT NULL DEFAULT 1,created_at_ms INTEGER NOT NULL,updated_at_ms INTEGER NOT NULL,UNIQUE(domain_uuid,name))`,
`CREATE TABLE IF NOT EXISTS street_spots (street_uuid TEXT NOT NULL,spot_uuid TEXT NOT NULL UNIQUE,sort_key INTEGER NOT NULL DEFAULT 0,section TEXT NOT NULL DEFAULT '',created_at_ms INTEGER NOT NULL,PRIMARY KEY(street_uuid,spot_uuid))`,
`CREATE TABLE IF NOT EXISTS spot_pages (spot_uuid TEXT NOT NULL,page_uuid TEXT NOT NULL,edge_type TEXT NOT NULL DEFAULT 'primary',label TEXT NOT NULL DEFAULT '',sort_key INTEGER NOT NULL DEFAULT 0,featured INTEGER NOT NULL DEFAULT 0,source TEXT NOT NULL DEFAULT 'local',created_at_ms INTEGER NOT NULL,PRIMARY KEY(spot_uuid,page_uuid,edge_type))`,
`CREATE TABLE IF NOT EXISTS spot_relations (source_spot_uuid TEXT NOT NULL,target_spot_uuid TEXT NOT NULL,relation_type TEXT NOT NULL,weight REAL NOT NULL DEFAULT 1.0,created_at_ms INTEGER NOT NULL,PRIMARY KEY(source_spot_uuid,target_spot_uuid,relation_type))`,
`CREATE INDEX IF NOT EXISTS idx_spot_relations_target ON spot_relations(target_spot_uuid,source_spot_uuid,relation_type)`,
`CREATE TABLE IF NOT EXISTS street_inbox_pages (street_uuid TEXT NOT NULL,page_uuid TEXT NOT NULL,created_at_ms INTEGER NOT NULL,PRIMARY KEY(street_uuid,page_uuid))`,
`CREATE TABLE IF NOT EXISTS city_page_overrides (domain_uuid TEXT NOT NULL,page_uuid TEXT NOT NULL,spot_uuid TEXT NOT NULL,PRIMARY KEY(domain_uuid,page_uuid))`,
`CREATE INDEX IF NOT EXISTS idx_city_page_overrides_spot ON city_page_overrides(domain_uuid,spot_uuid,page_uuid)`,
`CREATE TABLE IF NOT EXISTS topology_events (id INTEGER PRIMARY KEY AUTOINCREMENT,domain_uuid TEXT NOT NULL,topology_version INTEGER NOT NULL,actor_principal_uuid TEXT NOT NULL DEFAULT '',operation TEXT NOT NULL,target_type TEXT NOT NULL,target_uuid TEXT NOT NULL,before_json TEXT NOT NULL DEFAULT '{}',after_json TEXT NOT NULL DEFAULT '{}',request_id TEXT NOT NULL DEFAULT '',created_at_ms INTEGER NOT NULL)`,
}
for _, statement := range statements {
if _, err := s.DB.Exec(statement); err != nil {
return err
}
}
if err := ensureCityColumn(s.DB, "zones", "path_prefix", "TEXT NOT NULL DEFAULT ''"); err != nil {
return err
}
if err := ensureCityColumn(s.DB, "spots", "path_prefix", "TEXT NOT NULL DEFAULT ''"); err != nil {
return err
}
return s.ensureCityGovernanceSchema()
}
func ensureCityColumn(db *sql.DB, table, column, declaration string) error {
rows, err := db.Query(`PRAGMA table_info(` + table + `)`)
if err != nil {
return err
}
found := false
for rows.Next() {
var cid int
var name, kind string
var notnull, pk int
var defaultValue any
if err := rows.Scan(&cid, &name, &kind, &notnull, &defaultValue, &pk); err != nil {
rows.Close()
return err
}
found = found || name == column
}
if err := rows.Close(); err != nil {
return err
}
if found {
return nil
}
_, err = db.Exec(`ALTER TABLE ` + table + ` ADD COLUMN ` + column + ` ` + declaration)
return err
}
func cityPathContains(parent, child string) bool {
parent, child = normalizePath(parent), normalizePath(child)
if parent == "/" {
return child != "/"
}
return child != parent && strings.HasPrefix(child, parent+"/")
}
func validateCityPathPrefix(tx *sql.Tx, domainUUID, kind, pathPrefix string) (string, error) {
pathPrefix = normalizePath(pathPrefix)
if pathPrefix == "/" && kind != "quartier" {
return "", errors.New("only a Quartier may bind the Domain root")
}
var conflicts int
table := "zones"
if kind == "spot" {
table = "spots"
}
query := `SELECT COUNT(*) FROM ` + table + ` CROSS JOIN (SELECT ? AS candidate) input WHERE domain_uuid=? AND state!='archived' AND ` + cityPathOverlapSQL("path_prefix", "input.candidate")
if kind != "spot" {
query += ` AND kind=?`
}
args := []any{pathPrefix, domainUUID}
if kind != "spot" {
args = append(args, kind)
}
if err := tx.QueryRow(query, args...).Scan(&conflicts); err != nil {
return "", err
}
if conflicts > 0 {
return "", errors.New("City Path boundaries of the same level must not overlap")
}
return pathPrefix, nil
}
type cityPathBoundary struct{ id, kind, parent, path string }
func validateCityBoundaryChanges(items []cityPathBoundary, changed map[string]bool) error {
byID := make(map[string]cityPathBoundary, len(items))
for _, item := range items {
byID[item.id] = item
}
for i, item := range items {
for j := i + 1; j < len(items); j++ {
other := items[j]
if (changed[item.id] || changed[other.id]) && item.kind == other.kind && (item.path == other.path || cityPathContains(item.path, other.path) || cityPathContains(other.path, item.path)) {
return errors.New("City Path boundaries of the same level must not overlap")
}
}
if item.kind == "street" && (changed[item.id] || changed[item.parent]) {
parent, ok := byID[item.parent]
if !ok || parent.kind != "quartier" || !cityPathContains(parent.path, item.path) {
return errors.New("Street Path must be a strict descendant of its Quartier Path")
}
}
if item.kind == "spot" && (changed[item.id] || changed[item.parent]) {
parent, ok := byID[item.parent]
if !ok || parent.kind != "street" || !cityPathContains(parent.path, item.path) {
return errors.New("Spot Path must be a strict descendant of its Street Path")
}
}
}
return nil
}
func loadCityBoundaries(tx *sql.Tx, domainUUID string) ([]cityPathBoundary, error) {
rows, err := tx.Query(`SELECT uuid,kind,COALESCE(parent_uuid,''),path_prefix FROM zones WHERE domain_uuid=? AND state!='archived' UNION ALL SELECT s.uuid,'spot',COALESCE(ss.street_uuid,''),s.path_prefix FROM spots s LEFT JOIN street_spots ss ON ss.spot_uuid=s.uuid WHERE s.domain_uuid=? AND s.state!='archived'`, domainUUID, domainUUID)
if err != nil {
return nil, err
}
defer rows.Close()
var items []cityPathBoundary
for rows.Next() {
var item cityPathBoundary
if err := rows.Scan(&item.id, &item.kind, &item.parent, &item.path); err != nil {
return nil, err
}
item.path = normalizePath(item.path)
items = append(items, item)
}
return items, rows.Err()
}
func renameCityPathPrefixesTx(tx *sql.Tx, domainUUID, oldPath, newPath string) (int, error) {
items, err := loadCityBoundaries(tx, domainUUID)
if err != nil {
return 0, err
}
changed := make(map[string]string)
changedIDs := make(map[string]bool)
for i := range items {
if items[i].path == oldPath || strings.HasPrefix(items[i].path, oldPath+"/") {
items[i].path = newPath + strings.TrimPrefix(items[i].path, oldPath)
changed[items[i].id] = items[i].path
changedIDs[items[i].id] = true
}
}
if len(changed) == 0 {
return 0, nil
}
if err := validateCityBoundaryChanges(items, changedIDs); err != nil {
return 0, err
}
now := time.Now().UnixMilli()
for _, item := range items {
path, ok := changed[item.id]
if !ok {
continue
}
table := "zones"
if item.kind == "spot" {
table = "spots"
}
if _, err := tx.Exec(`UPDATE `+table+` SET path_prefix=?,version=version+1,updated_at_ms=? WHERE uuid=? AND domain_uuid=?`, path, now, item.id, domainUUID); err != nil {
return 0, err
}
}
return len(changed), nil
}
func (s *Store) UpdateCityNodePath(domainUUID, actor, kind, id, pathPrefix string) error {
pathPrefix = normalizePath(pathPrefix)
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
items, err := loadCityBoundaries(tx, domainUUID)
if err != nil {
return err
}
found := false
changed := map[string]bool{id: true}
for i := range items {
if items[i].id == id && items[i].kind == kind {
items[i].path, found = pathPrefix, true
}
}
if !found {
return sql.ErrNoRows
}
if err := validateCityBoundaryChanges(items, changed); err != nil {
return err
}
table := "zones"
if kind == "spot" {
table = "spots"
}
result, err := tx.Exec(`UPDATE `+table+` SET path_prefix=?,version=version+1,updated_at_ms=? WHERE uuid=? AND domain_uuid=? AND state!='archived'`, pathPrefix, time.Now().UnixMilli(), id, domainUUID)
if err != nil {
return err
}
if changed, _ := result.RowsAffected(); changed != 1 {
return sql.ErrNoRows
}
if err := bumpTopologyVersion(tx, domainUUID, actor, "city.node.path_updated", kind, id); err != nil {
return err
}
return tx.Commit()
}
func normalizeCityName(name string) (string, error) {
name = strings.ToLower(strings.TrimSpace(name))
if !cityNamePattern.MatchString(name) {
return "", errors.New("city name must be 2-64 lowercase letters, digits, underscores, or hyphens")
}
return name, nil
}
func bumpTopologyVersion(tx *sql.Tx, domainUUID, actor, operation, targetType, targetUUID string) error {
now := time.Now().UnixMilli()
_, err := tx.Exec(`INSERT INTO domain_topology_versions(domain_uuid,version,updated_at_ms) VALUES(?,2,?) ON CONFLICT(domain_uuid) DO UPDATE SET version=version+1,updated_at_ms=excluded.updated_at_ms`, domainUUID, now)
if err != nil {
return err
}
var version int64
if err := tx.QueryRow(`SELECT version FROM domain_topology_versions WHERE domain_uuid=?`, domainUUID).Scan(&version); err != nil {
return err
}
_, err = tx.Exec(`INSERT INTO topology_events(domain_uuid,topology_version,actor_principal_uuid,operation,target_type,target_uuid,created_at_ms) VALUES(?,?,?,?,?,?,?)`, domainUUID, version, actor, operation, targetType, targetUUID, now)
return err
}
func (s *Store) CreateZone(domainUUID, actor, kind, parentUUID, name, title, description string) (string, error) {
pathPrefix := "/" + strings.ToLower(strings.TrimSpace(name))
if strings.EqualFold(kind, "street") {
var parentPath string
if s.DB.QueryRow(`SELECT path_prefix FROM zones WHERE uuid=? AND domain_uuid=?`, parentUUID, domainUUID).Scan(&parentPath) == nil {
pathPrefix = normalizePath(parentPath) + "/" + strings.ToLower(strings.TrimSpace(name))
}
}
return s.CreateZoneAtPath(domainUUID, actor, kind, parentUUID, name, title, description, pathPrefix)
}
func (s *Store) CreateZoneAtPath(domainUUID, actor, kind, parentUUID, name, title, description, pathPrefix string) (string, error) {
name, err := normalizeCityName(name)
if err != nil {
return "", err
}
kind = strings.ToLower(strings.TrimSpace(kind))
if kind != "quartier" && kind != "street" {
return "", errors.New("zone kind must be quartier or street")
}
if strings.TrimSpace(title) == "" {
title = name
}
tx, err := s.DB.Begin()
if err != nil {
return "", err
}
defer tx.Rollback()
if strings.TrimSpace(pathPrefix) == "" {
pathPrefix = "/" + name
}
pathPrefix, err = validateCityPathPrefix(tx, domainUUID, kind, pathPrefix)
if err != nil {
return "", err
}
if kind == "quartier" {
parentUUID = ""
} else {
var parentKind, parentPath string
if err := tx.QueryRow(`SELECT kind,path_prefix FROM zones WHERE uuid=? AND domain_uuid=? AND state!='archived'`, parentUUID, domainUUID).Scan(&parentKind, &parentPath); err != nil || parentKind != "quartier" {
return "", errors.New("street parent must be an active Quartier")
}
if !cityPathContains(parentPath, pathPrefix) {
return "", errors.New("Street Path must be a strict descendant of its Quartier Path")
}
}
id, now := uuid.NewString(), time.Now().UnixMilli()
var parent any
if parentUUID == "" {
parent = nil
} else {
parent = parentUUID
}
// Archived nodes retain their UUID and audit history, but must not reserve
// a human-facing name forever. Move an old conflicting name aside before
// inserting the replacement node.
if kind == "quartier" {
if _, err := tx.Exec(`UPDATE zones SET name=name||'~archived-'||substr(uuid,1,8),updated_at_ms=? WHERE domain_uuid=? AND kind=? AND parent_uuid IS NULL AND name=? AND state='archived'`, time.Now().UnixMilli(), domainUUID, kind, name); err != nil {
return "", err
}
} else {
if _, err := tx.Exec(`UPDATE zones SET name=name||'~archived-'||substr(uuid,1,8),updated_at_ms=? WHERE domain_uuid=? AND kind=? AND parent_uuid=? AND name=? AND state='archived'`, time.Now().UnixMilli(), domainUUID, kind, parentUUID, name); err != nil {
return "", err
}
}
if _, err := tx.Exec(`INSERT INTO zones(uuid,domain_uuid,kind,parent_uuid,name,title,description,path_prefix,state,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?,?,?,'draft',?,?)`, id, domainUUID, kind, parent, name, strings.TrimSpace(title), strings.TrimSpace(description), pathPrefix, now, now); err != nil {
return "", err
}
if err := bumpTopologyVersion(tx, domainUUID, actor, "city.zone.created", kind, id); err != nil {
return "", err
}
return id, tx.Commit()
}
func (s *Store) CreateSpot(domainUUID, actor, streetUUID, name, title, summary string) (string, error) {
pathPrefix := "/" + strings.ToLower(strings.TrimSpace(name))
var streetPath string
if s.DB.QueryRow(`SELECT path_prefix FROM zones WHERE uuid=? AND domain_uuid=?`, streetUUID, domainUUID).Scan(&streetPath) == nil {
pathPrefix = normalizePath(streetPath) + "/" + strings.ToLower(strings.TrimSpace(name))
}
return s.CreateSpotAtPath(domainUUID, actor, streetUUID, name, title, summary, pathPrefix)
}
func (s *Store) CreateSpotAtPath(domainUUID, actor, streetUUID, name, title, summary, pathPrefix string) (string, error) {
name, err := normalizeCityName(name)
if err != nil {
return "", err
}
if strings.TrimSpace(title) == "" {
title = name
}
tx, err := s.DB.Begin()
if err != nil {
return "", err
}
defer tx.Rollback()
if strings.TrimSpace(pathPrefix) == "" {
pathPrefix = "/" + name
}
pathPrefix, err = validateCityPathPrefix(tx, domainUUID, "spot", pathPrefix)
if err != nil {
return "", err
}
var kind, streetPath string
if err := tx.QueryRow(`SELECT kind,path_prefix FROM zones WHERE uuid=? AND domain_uuid=? AND state!='archived'`, streetUUID, domainUUID).Scan(&kind, &streetPath); err != nil || kind != "street" {
return "", errors.New("spot placement must be an active Street")
}
if !cityPathContains(streetPath, pathPrefix) {
return "", errors.New("Spot Path must be a strict descendant of its Street Path")
}
id, now := uuid.NewString(), time.Now().UnixMilli()
if _, err := tx.Exec(`UPDATE spots SET name=name||'~archived-'||substr(uuid,1,8),updated_at_ms=? WHERE domain_uuid=? AND name=? AND state='archived'`, now, domainUUID, name); err != nil {
return "", err
}
if _, err := tx.Exec(`INSERT INTO spots(uuid,domain_uuid,name,title,summary,path_prefix,state,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?,'draft',?,?)`, id, domainUUID, name, strings.TrimSpace(title), strings.TrimSpace(summary), pathPrefix, now, now); err != nil {
return "", err
}
if _, err := tx.Exec(`INSERT INTO street_spots(street_uuid,spot_uuid,created_at_ms) VALUES(?,?,?)`, streetUUID, id, now); err != nil {
return "", err
}
if err := bumpTopologyVersion(tx, domainUUID, actor, "city.spot.created", "spot", id); err != nil {
return "", err
}
return id, tx.Commit()
}
func (s *Store) AddSpotPage(domainUUID, actor, spotUUID, pageUUID, path, edgeType, label string) error {
edgeType = strings.ToLower(strings.TrimSpace(edgeType))
valid := map[string]bool{"primary": true, "guide": true, "reference": true, "example": true, "attachment": true, "related": true}
if !valid[edgeType] {
return errors.New("invalid SpotPage edge type")
}
if pageUUID == "" {
var err error
pageUUID, err = s.ResolvePathInDomain(domainUUID, path)
if err != nil {
return err
}
}
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
var validTarget int
if err := tx.QueryRow(`SELECT EXISTS(SELECT 1 FROM spots WHERE uuid=? AND domain_uuid=? AND state!='archived') AND EXISTS(SELECT 1 FROM paths WHERE domain_uuid=? AND object_uuid=?)`, spotUUID, domainUUID, domainUUID, pageUUID).Scan(&validTarget); err != nil || validTarget == 0 {
return errors.New("Spot and Page must belong to the current Domain")
}
_, err = tx.Exec(`INSERT INTO spot_pages(spot_uuid,page_uuid,edge_type,label,created_at_ms) VALUES(?,?,?,?,?) ON CONFLICT(spot_uuid,page_uuid,edge_type) DO UPDATE SET label=excluded.label`, spotUUID, pageUUID, edgeType, strings.TrimSpace(label), time.Now().UnixMilli())
if err != nil {
return err
}
if err := bumpTopologyVersion(tx, domainUUID, actor, "city.spot_page.added", "spot", spotUUID); err != nil {
return err
}
return tx.Commit()
}
func (s *Store) RemoveSpotPage(domainUUID, actor, spotUUID, pageUUID, edgeType string) error {
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
result, err := tx.Exec(`DELETE FROM spot_pages WHERE spot_uuid=? AND page_uuid=? AND edge_type=? AND EXISTS(SELECT 1 FROM spots WHERE uuid=? AND domain_uuid=?)`, spotUUID, pageUUID, edgeType, spotUUID, domainUUID)
if err != nil {
return err
}
changed, _ := result.RowsAffected()
if changed == 0 {
return sql.ErrNoRows
}
if err := bumpTopologyVersion(tx, domainUUID, actor, "city.spot_page.removed", "spot", spotUUID); err != nil {
return err
}
return tx.Commit()
}
func (s *Store) ListSpotPages(domainUUID, spotUUID string) ([]CityPagePlacement, error) {
return listSpotPages(s.DB, domainUUID, spotUUID, -1)
}
type cityQuerier interface {
Query(string, ...any) (*sql.Rows, error)
}
func listSpotPages(db cityQuerier, domainUUID, spotUUID string, limit int) ([]CityPagePlacement, error) {
rows, err := db.Query(`SELECT page_uuid,path,edge_type,label,sort_key,featured,source FROM (
SELECT sp.page_uuid AS page_uuid,COALESCE((SELECT path FROM paths WHERE domain_uuid=? AND object_uuid=sp.page_uuid ORDER BY is_primary DESC,path LIMIT 1),'') AS path,sp.edge_type AS edge_type,sp.label AS label,sp.sort_key AS sort_key,sp.featured AS featured,sp.source AS source
FROM spot_pages sp JOIN spots s ON s.uuid=sp.spot_uuid AND s.domain_uuid=? WHERE sp.spot_uuid=?
AND EXISTS(SELECT 1 FROM paths local WHERE local.domain_uuid=s.domain_uuid AND local.object_uuid=sp.page_uuid)
UNION ALL
SELECT p.object_uuid,MIN(p.path),'path','',0,0,'path' FROM paths p JOIN spots s ON s.uuid=? AND s.domain_uuid=p.domain_uuid AND s.state!='archived'
WHERE p.domain_uuid=? AND `+cityPathScopeSQL("s.path_prefix", "p.path")+`
AND NOT EXISTS(SELECT 1 FROM city_page_overrides ov JOIN spots dest ON dest.uuid=ov.spot_uuid AND dest.domain_uuid=ov.domain_uuid AND dest.state!='archived' WHERE ov.domain_uuid=p.domain_uuid AND ov.page_uuid=p.object_uuid AND ov.spot_uuid!=s.uuid)
AND NOT EXISTS(SELECT 1 FROM spot_pages explicit WHERE explicit.spot_uuid=s.uuid AND explicit.page_uuid=p.object_uuid)
GROUP BY p.object_uuid
) ORDER BY featured DESC,sort_key,edge_type,path LIMIT ?`, domainUUID, domainUUID, spotUUID, spotUUID, domainUUID, limit)
if err != nil {
return nil, err
}
defer rows.Close()
var out []CityPagePlacement
for rows.Next() {
var item CityPagePlacement
if err := rows.Scan(&item.PageUUID, &item.Path, &item.EdgeType, &item.Label, &item.SortKey, &item.Featured, &item.Source); err != nil {
return nil, err
}
out = append(out, item)
}
return out, rows.Err()
}
func (s *Store) ListPageSpotAppearances(domainUUID, pageUUID string) ([]CitySpotAppearance, error) {
rows, err := s.DB.Query(`SELECT a.uuid,a.name,a.title,a.edge_type,a.label,a.source,a.path_prefix,COALESCE(NULLIF(st.title,''),st.name),st.path_prefix,q.path_prefix FROM (
SELECT s.uuid,s.name,s.title,sp.edge_type,sp.label,sp.source,s.path_prefix FROM spot_pages sp JOIN spots s ON s.uuid=sp.spot_uuid AND s.domain_uuid=? AND s.state!='archived' WHERE sp.page_uuid=?
UNION ALL
SELECT s.uuid,s.name,s.title,'path','','path',s.path_prefix FROM spots s JOIN paths p ON p.domain_uuid=s.domain_uuid AND p.object_uuid=? AND `+cityPathScopeSQL("s.path_prefix", "p.path")+`
WHERE s.domain_uuid=? AND s.state!='archived' AND NOT EXISTS(SELECT 1 FROM spot_pages explicit WHERE explicit.spot_uuid=s.uuid AND explicit.page_uuid=?)
AND NOT EXISTS(SELECT 1 FROM city_page_overrides ov JOIN spots dest ON dest.uuid=ov.spot_uuid AND dest.domain_uuid=ov.domain_uuid AND dest.state!='archived' WHERE ov.domain_uuid=p.domain_uuid AND ov.page_uuid=p.object_uuid AND ov.spot_uuid!=s.uuid)
) a JOIN street_spots ss ON ss.spot_uuid=a.uuid
JOIN zones st ON st.uuid=ss.street_uuid AND st.domain_uuid=? AND st.kind='street' AND st.state!='archived'
JOIN zones q ON q.uuid=st.parent_uuid AND q.domain_uuid=st.domain_uuid AND q.kind='quartier' AND q.state!='archived'
ORDER BY lower(a.title),a.edge_type`, domainUUID, pageUUID, pageUUID, domainUUID, pageUUID, domainUUID)
if err != nil {
return nil, err
}
defer rows.Close()
var out []CitySpotAppearance
for rows.Next() {
var item CitySpotAppearance
var parentTitle string
if err := rows.Scan(&item.SpotUUID, &item.SpotName, &item.SpotTitle, &item.EdgeType, &item.Label, &item.Source, &item.PathPrefix, &parentTitle, &item.StreetPath, &item.QuartierPath); err != nil {
return nil, err
}
item.DisplayTitle = CitySpotDisplayTitle(item.SpotName, item.SpotTitle, item.PathPrefix, parentTitle)
out = append(out, item)
}
return out, rows.Err()
}
func (s *Store) AddSpotRelation(domainUUID, actor, sourceUUID, targetUUID, relationType string) error {
relationType = strings.ToLower(strings.TrimSpace(relationType))
valid := map[string]bool{"related": true, "depends_on": true, "supersedes": true, "implements": true, "learn_before": true, "operated_by": true}
if !valid[relationType] || sourceUUID == targetUUID {
return errors.New("invalid Spot relation")
}
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
var count int
if err := tx.QueryRow(`SELECT COUNT(*) FROM spots WHERE domain_uuid=? AND uuid IN (?,?) AND state!='archived'`, domainUUID, sourceUUID, targetUUID).Scan(&count); err != nil || count != 2 {
return errors.New("both Spots must belong to the current Domain")
}
if _, err := tx.Exec(`INSERT INTO spot_relations(source_spot_uuid,target_spot_uuid,relation_type,created_at_ms) VALUES(?,?,?,?) ON CONFLICT DO NOTHING`, sourceUUID, targetUUID, relationType, time.Now().UnixMilli()); err != nil {
return err
}
if err := bumpTopologyVersion(tx, domainUUID, actor, "city.spot_relation.added", "spot", sourceUUID); err != nil {
return err
}
return tx.Commit()
}
func (s *Store) RemoveSpotRelation(domainUUID, actor, sourceUUID, targetUUID, relationType string) error {
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
result, err := tx.Exec(`DELETE FROM spot_relations WHERE source_spot_uuid=? AND target_spot_uuid=? AND relation_type=? AND EXISTS(SELECT 1 FROM spots WHERE uuid=? AND domain_uuid=?)`, sourceUUID, targetUUID, relationType, sourceUUID, domainUUID)
if err != nil {
return err
}
changed, _ := result.RowsAffected()
if changed == 0 {
return sql.ErrNoRows
}
if err := bumpTopologyVersion(tx, domainUUID, actor, "city.spot_relation.removed", "spot", sourceUUID); err != nil {
return err
}
return tx.Commit()
}
func (s *Store) MoveStreet(domainUUID, actor, streetUUID, quartierUUID string, sortKey int) error {
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
var parentKind, parentPath, streetPath string
if err := tx.QueryRow(`SELECT kind,path_prefix FROM zones WHERE uuid=? AND domain_uuid=? AND state!='archived'`, quartierUUID, domainUUID).Scan(&parentKind, &parentPath); err != nil || parentKind != "quartier" {
return errors.New("destination must be an active Quartier")
}
if err := tx.QueryRow(`SELECT path_prefix FROM zones WHERE uuid=? AND domain_uuid=? AND kind='street' AND state!='archived'`, streetUUID, domainUUID).Scan(&streetPath); err != nil {
return err
}
if !cityPathContains(parentPath, streetPath) {
return errors.New("Street Path is outside the destination Quartier Path; change its boundary first")
}
result, err := tx.Exec(`UPDATE zones SET parent_uuid=?,sort_key=?,version=version+1,updated_at_ms=? WHERE uuid=? AND domain_uuid=? AND kind='street' AND state!='archived'`, quartierUUID, sortKey, time.Now().UnixMilli(), streetUUID, domainUUID)
if err != nil {
return err
}
changed, _ := result.RowsAffected()
if changed != 1 {
return sql.ErrNoRows
}
if err := bumpTopologyVersion(tx, domainUUID, actor, "city.street.moved", "street", streetUUID); err != nil {
return err
}
return tx.Commit()
}
func (s *Store) MoveSpot(domainUUID, actor, spotUUID, streetUUID string, sortKey int) error {
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
var kind, streetPath string
if err := tx.QueryRow(`SELECT kind,path_prefix FROM zones WHERE uuid=? AND domain_uuid=? AND state!='archived'`, streetUUID, domainUUID).Scan(&kind, &streetPath); err != nil || kind != "street" {
return errors.New("destination must be an active Street")
}
var spotDomain, spotPath string
if err := tx.QueryRow(`SELECT domain_uuid,path_prefix FROM spots WHERE uuid=? AND state!='archived'`, spotUUID).Scan(&spotDomain, &spotPath); err != nil || spotDomain != domainUUID {
return errors.New("Spot must belong to the current Domain")
}
if !cityPathContains(streetPath, spotPath) {
return errors.New("Spot Path is outside the destination Street Path; change its boundary first")
}
result, err := tx.Exec(`UPDATE street_spots SET street_uuid=?,sort_key=? WHERE spot_uuid=?`, streetUUID, sortKey, spotUUID)
if err != nil {
return err
}
changed, _ := result.RowsAffected()
if changed != 1 {
return sql.ErrNoRows
}
if _, err := tx.Exec(`UPDATE spots SET version=version+1,updated_at_ms=? WHERE uuid=?`, time.Now().UnixMilli(), spotUUID); err != nil {
return err
}
if err := bumpTopologyVersion(tx, domainUUID, actor, "city.spot.moved", "spot", spotUUID); err != nil {
return err
}
return tx.Commit()
}
// DeleteCityNode archives a City element and removes topology edges which can
// no longer be reached. Deleting a zone recursively archives its descendants;
// documents themselves are never deleted.
func (s *Store) DeleteCityNode(domainUUID, actor, kind, id string) error {
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
now := time.Now().UnixMilli()
var changed int64
switch kind {
case "spot":
result, err := tx.Exec(`UPDATE spots SET state='archived',version=version+1,updated_at_ms=? WHERE uuid=? AND domain_uuid=? AND state!='archived'`, now, id, domainUUID)
if err != nil {
return err
}
changed, _ = result.RowsAffected()
if changed > 0 {
_, _ = tx.Exec(`DELETE FROM street_spots WHERE spot_uuid=?`, id)
_, _ = tx.Exec(`DELETE FROM spot_pages WHERE spot_uuid=?`, id)
_, _ = tx.Exec(`DELETE FROM spot_relations WHERE source_spot_uuid=? OR target_spot_uuid=?`, id, id)
}
case "street", "quartier":
var actual string
if err := tx.QueryRow(`SELECT kind FROM zones WHERE uuid=? AND domain_uuid=? AND state!='archived'`, id, domainUUID).Scan(&actual); err != nil || actual != kind {
return sql.ErrNoRows
}
streetIDs := []string{}
if kind == "street" {
streetIDs = append(streetIDs, id)
} else {
rows, err := tx.Query(`SELECT uuid FROM zones WHERE domain_uuid=? AND kind='street' AND parent_uuid=? AND state!='archived'`, domainUUID, id)
if err != nil {
return err
}
for rows.Next() {
var streetID string
if err := rows.Scan(&streetID); err != nil {
rows.Close()
return err
}
streetIDs = append(streetIDs, streetID)
}
if err := rows.Close(); err != nil {
return err
}
}
for _, streetID := range streetIDs {
_, err = tx.Exec(`DELETE FROM spot_pages WHERE spot_uuid IN (SELECT spot_uuid FROM street_spots WHERE street_uuid=?)`, streetID)
if err != nil {
return err
}
_, err = tx.Exec(`DELETE FROM spot_relations WHERE source_spot_uuid IN (SELECT spot_uuid FROM street_spots WHERE street_uuid=?) OR target_spot_uuid IN (SELECT spot_uuid FROM street_spots WHERE street_uuid=?)`, streetID, streetID)
if err != nil {
return err
}
_, err = tx.Exec(`UPDATE spots SET state='archived',version=version+1,updated_at_ms=? WHERE uuid IN (SELECT spot_uuid FROM street_spots WHERE street_uuid=?) AND domain_uuid=?`, now, streetID, domainUUID)
if err != nil {
return err
}
_, err = tx.Exec(`DELETE FROM street_spots WHERE street_uuid=?`, streetID)
if err != nil {
return err
}
}
if kind == "quartier" {
_, err = tx.Exec(`UPDATE zones SET state='archived',version=version+1,updated_at_ms=? WHERE domain_uuid=? AND kind='street' AND parent_uuid=? AND state!='archived'`, now, domainUUID, id)
if err != nil {
return err
}
}
result, err := tx.Exec(`UPDATE zones SET state='archived',version=version+1,updated_at_ms=? WHERE uuid=? AND domain_uuid=? AND kind=? AND state!='archived'`, now, id, domainUUID, kind)
if err != nil {
return err
}
changed, _ = result.RowsAffected()
default:
return errors.New("invalid City element kind")
}
if changed == 0 {
return sql.ErrNoRows
}
if err := bumpTopologyVersion(tx, domainUUID, actor, "city.node.deleted", kind, id); err != nil {
return err
}
return tx.Commit()
}
// CityNodeOverlappingPath resolves the active locality which already owns an
// exact, ancestor, or descendant boundary. parentUUID scopes Streets and Spots
// so an import cannot silently move a locality across its planned parent.
func (s *Store) CityNodeOverlappingPath(domainUUID, kind, parentUUID, pathPrefix string) (CityNodeDetail, error) {
pathPrefix = normalizePath(pathPrefix)
var detail CityNodeDetail
if kind == "spot" {
query := `SELECT s.uuid,s.domain_uuid,'spot',ss.street_uuid,s.name,s.title,s.summary,s.state,s.path_prefix,ss.sort_key,s.version FROM spots s JOIN street_spots ss ON ss.spot_uuid=s.uuid
JOIN zones st ON st.uuid=ss.street_uuid AND st.domain_uuid=s.domain_uuid AND st.kind='street' AND st.state!='archived'
CROSS JOIN (SELECT ? AS candidate) input WHERE s.domain_uuid=? AND ss.street_uuid=? AND s.state!='archived' AND ` + cityPathOverlapSQL("s.path_prefix", "input.candidate") +
` ORDER BY CASE WHEN s.path_prefix=input.candidate THEN 0 WHEN ` + cityPathScopeSQL("s.path_prefix", "input.candidate") + ` THEN 1 ELSE 2 END,LENGTH(s.path_prefix),s.uuid LIMIT 1`
err := s.DB.QueryRow(query, pathPrefix, domainUUID, parentUUID).Scan(&detail.UUID, &detail.DomainUUID, &detail.Kind, &detail.ParentUUID, &detail.Name, &detail.Title, &detail.Description, &detail.State, &detail.PathPrefix, &detail.SortKey, &detail.Version)
return detail, err
}
query := `SELECT uuid,domain_uuid,kind,COALESCE(parent_uuid,''),name,title,description,state,path_prefix,sort_key,version FROM zones CROSS JOIN (SELECT ? AS candidate) input WHERE domain_uuid=? AND kind=? AND state!='archived' AND ` + cityPathOverlapSQL("path_prefix", "input.candidate")
args := []any{pathPrefix, domainUUID, kind}
if kind == "street" {
query += ` AND parent_uuid=?`
args = append(args, parentUUID)
}
query += ` ORDER BY CASE WHEN path_prefix=input.candidate THEN 0 WHEN ` + cityPathScopeSQL("path_prefix", "input.candidate") + ` THEN 1 ELSE 2 END,LENGTH(path_prefix),uuid LIMIT 1`
err := s.DB.QueryRow(query, args...).Scan(&detail.UUID, &detail.DomainUUID, &detail.Kind, &detail.ParentUUID, &detail.Name, &detail.Title, &detail.Description, &detail.State, &detail.PathPrefix, &detail.SortKey, &detail.Version)
return detail, err
}