Files
pages/internal/store/city.go
T
2026-11-15 05:47:14 +09:00

858 lines
40 KiB
Go

package store
import (
"context"
"database/sql"
"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 {
if s.sqlBackend == storePostgreSQL {
if err := s.ensurePostgreSQLCityFoundation(context.Background()); err != nil {
return err
}
return s.ensurePublicationSchema()
}
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) {
return (&Store{}).validateCityPathPrefix(tx, domainUUID, kind, pathPrefix)
}
func (s *Store) validateCityPathPrefix(tx *sql.Tx, domainUUID, kind, pathPrefix string) (string, error) {
pathPrefix = normalizePath(pathPrefix)
if pathPrefix == "/" && kind != "quartier" {
return "", namespaceValidationError("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 ` + s.sqlParam(1) + ` AS candidate) input WHERE domain_uuid=` + s.sqlParam(2) + ` AND state!='archived' AND ` + s.pathOverlapSQL("path_prefix", "input.candidate")
if kind != "spot" {
query += ` AND kind=` + s.sqlParam(3)
}
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 "", namespaceValidationError("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 namespaceValidationError("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 namespaceValidationError("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 namespaceValidationError("Spot Path must be a strict descendant of its Street Path")
}
}
}
return nil
}
func loadCityBoundaries(tx *sql.Tx, domainUUID string) ([]cityPathBoundary, error) {
return (&Store{}).loadCityBoundaries(tx, domainUUID)
}
func (s *Store) 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=`+s.sqlParam(1)+` 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=`+s.sqlParam(2)+` AND s.state!='archived' LIMIT `+s.sqlParam(3), domainUUID, domainUUID, MaxCityMapNodes+1)
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)
if len(items) > MaxCityMapNodes {
return nil, ErrCityMapBudget
}
}
return items, rows.Err()
}
func renameCityPathPrefixesTx(tx *sql.Tx, domainUUID, oldPath, newPath string) (int, error) {
return (&Store{}).renameCityPathPrefixesTx(tx, domainUUID, oldPath, newPath)
}
func (s *Store) renameCityPathPrefixesTx(tx *sql.Tx, domainUUID, oldPath, newPath string) (int, error) {
items, err := s.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=`+s.sqlParam(1)+`,version=version+1,updated_at_ms=`+s.sqlParam(2)+` WHERE uuid=`+s.sqlParam(3)+` AND domain_uuid=`+s.sqlParam(4), path, now, item.id, domainUUID); err != nil {
return 0, err
}
}
return len(changed), nil
}
func (s *Store) UpdateCityNodePath(domainUUID, actor, kind, id, pathPrefix string) (resultErr error) {
defer func() { resultErr = s.cityMutationError("update city path", resultErr) }()
pathPrefix = normalizePath(pathPrefix)
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
if err != nil {
return err
}
defer tx.Rollback()
items, err := s.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=`+s.sqlParam(1)+`,version=version+1,updated_at_ms=`+s.sqlParam(2)+` WHERE uuid=`+s.sqlParam(3)+` AND domain_uuid=`+s.sqlParam(4)+` 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 := s.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 "", namespaceValidationError("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 {
return (&Store{}).bumpTopologyVersion(tx, domainUUID, actor, operation, targetType, targetUUID)
}
func (s *Store) 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(`+s.sqlParam(1)+`,2,`+s.sqlParam(2)+`) ON CONFLICT(domain_uuid) DO UPDATE SET version=domain_topology_versions.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=`+s.sqlParam(1), 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(`+s.sqlValues(7)+`)`, 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=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+``, 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) (result string, resultErr error) {
defer func() { resultErr = s.sqlError("city mutation", resultErr) }()
name, err := normalizeCityName(name)
if err != nil {
return "", err
}
kind = strings.ToLower(strings.TrimSpace(kind))
if kind != "quartier" && kind != "street" {
return "", namespaceValidationError("zone kind must be quartier or street")
}
if strings.TrimSpace(title) == "" {
title = name
}
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
if err != nil {
return "", err
}
defer tx.Rollback()
if strings.TrimSpace(pathPrefix) == "" {
pathPrefix = "/" + name
}
pathPrefix, err = s.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=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+` AND state!='archived'`, parentUUID, domainUUID).Scan(&parentKind, &parentPath); err != nil || parentKind != "quartier" {
return "", namespaceValidationError("street parent must be an active Quartier")
}
if !cityPathContains(parentPath, pathPrefix) {
return "", namespaceValidationError("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=`+s.sqlParam(1)+` WHERE domain_uuid=`+s.sqlParam(2)+` AND kind=`+s.sqlParam(3)+` AND parent_uuid IS NULL AND name=`+s.sqlParam(4)+` 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=`+s.sqlParam(1)+` WHERE domain_uuid=`+s.sqlParam(2)+` AND kind=`+s.sqlParam(3)+` AND parent_uuid=`+s.sqlParam(4)+` AND name=`+s.sqlParam(5)+` 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(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`,`+s.sqlParam(7)+`,`+s.sqlParam(8)+`,'draft',`+s.sqlParam(9)+`,`+s.sqlParam(10)+`)`, id, domainUUID, kind, parent, name, strings.TrimSpace(title), strings.TrimSpace(description), pathPrefix, now, now); err != nil {
return "", err
}
if err := s.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=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+``, 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) (result string, resultErr error) {
defer func() { resultErr = s.sqlError("city mutation", resultErr) }()
name, err := normalizeCityName(name)
if err != nil {
return "", err
}
if strings.TrimSpace(title) == "" {
title = name
}
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
if err != nil {
return "", err
}
defer tx.Rollback()
if strings.TrimSpace(pathPrefix) == "" {
pathPrefix = "/" + name
}
pathPrefix, err = s.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=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+` AND state!='archived'`, streetUUID, domainUUID).Scan(&kind, &streetPath); err != nil || kind != "street" {
return "", namespaceValidationError("spot placement must be an active Street")
}
if !cityPathContains(streetPath, pathPrefix) {
return "", namespaceValidationError("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=`+s.sqlParam(1)+` WHERE domain_uuid=`+s.sqlParam(2)+` AND name=`+s.sqlParam(3)+` 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(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`,'draft',`+s.sqlParam(7)+`,`+s.sqlParam(8)+`)`, 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(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`)`, streetUUID, id, now); err != nil {
return "", err
}
if err := s.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) (resultErr error) {
defer func() { resultErr = s.sqlError("city mutation", resultErr) }()
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 namespaceValidationError("invalid SpotPage edge type")
}
if pageUUID == "" {
var err error
pageUUID, err = s.ResolvePathInDomain(domainUUID, path)
if err != nil {
return err
}
}
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
if err != nil {
return err
}
defer tx.Rollback()
var validTarget bool
if err := tx.QueryRow(`SELECT EXISTS(SELECT 1 FROM spots WHERE uuid=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+` AND state!='archived') AND EXISTS(SELECT 1 FROM paths WHERE domain_uuid=`+s.sqlParam(3)+` AND object_uuid=`+s.sqlParam(4)+`)`, spotUUID, domainUUID, domainUUID, pageUUID).Scan(&validTarget); err != nil || !validTarget {
return namespaceValidationError("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(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`) 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 := s.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) (resultErr error) {
defer func() { resultErr = s.sqlError("city mutation", resultErr) }()
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
if err != nil {
return err
}
defer tx.Rollback()
result, err := tx.Exec(`DELETE FROM spot_pages WHERE spot_uuid=`+s.sqlParam(1)+` AND page_uuid=`+s.sqlParam(2)+` AND edge_type=`+s.sqlParam(3)+` AND EXISTS(SELECT 1 FROM spots WHERE uuid=`+s.sqlParam(4)+` AND domain_uuid=`+s.sqlParam(5)+`)`, spotUUID, pageUUID, edgeType, spotUUID, domainUUID)
if err != nil {
return err
}
changed, _ := result.RowsAffected()
if changed == 0 {
return sql.ErrNoRows
}
if err := s.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 s.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) {
return (&Store{}).listSpotPages(db, domainUUID, spotUUID, limit)
}
func (s *Store) listSpotPages(db cityQuerier, domainUUID, spotUUID string, limit int) ([]CityPagePlacement, error) {
var limitArg any = limit
if s.sqlBackend == storePostgreSQL && limit < 0 {
limitArg = nil
}
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=`+s.sqlParam(1)+` 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=`+s.sqlParam(2)+` WHERE sp.spot_uuid=`+s.sqlParam(3)+`
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=`+s.sqlParam(4)+` AND s.domain_uuid=p.domain_uuid AND s.state!='archived'
WHERE p.domain_uuid=`+s.sqlParam(5)+` AND `+s.pathScopeSQL("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
) placements ORDER BY featured DESC,sort_key,edge_type,path LIMIT `+s.sqlParam(6), domainUUID, domainUUID, spotUUID, spotUUID, domainUUID, limitArg)
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=`+s.sqlParam(1)+` AND s.state!='archived' WHERE sp.page_uuid=`+s.sqlParam(2)+`
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=`+s.sqlParam(3)+` AND `+s.pathScopeSQL("s.path_prefix", "p.path")+`
WHERE s.domain_uuid=`+s.sqlParam(4)+` AND s.state!='archived' AND NOT EXISTS(SELECT 1 FROM spot_pages explicit WHERE explicit.spot_uuid=s.uuid AND explicit.page_uuid=`+s.sqlParam(5)+`)
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=`+s.sqlParam(6)+` 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) (resultErr error) {
defer func() { resultErr = s.sqlError("city mutation", resultErr) }()
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 namespaceValidationError("invalid Spot relation")
}
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
if err != nil {
return err
}
defer tx.Rollback()
var count int
if err := tx.QueryRow(`SELECT COUNT(*) FROM spots WHERE domain_uuid=`+s.sqlParam(1)+` AND uuid IN (`+s.sqlParam(2)+`,`+s.sqlParam(3)+`) AND state!='archived'`, domainUUID, sourceUUID, targetUUID).Scan(&count); err != nil || count != 2 {
return namespaceValidationError("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(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`) ON CONFLICT DO NOTHING`, sourceUUID, targetUUID, relationType, time.Now().UnixMilli()); err != nil {
return err
}
if err := s.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) (resultErr error) {
defer func() { resultErr = s.sqlError("city mutation", resultErr) }()
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
if err != nil {
return err
}
defer tx.Rollback()
result, err := tx.Exec(`DELETE FROM spot_relations WHERE source_spot_uuid=`+s.sqlParam(1)+` AND target_spot_uuid=`+s.sqlParam(2)+` AND relation_type=`+s.sqlParam(3)+` AND EXISTS(SELECT 1 FROM spots WHERE uuid=`+s.sqlParam(4)+` AND domain_uuid=`+s.sqlParam(5)+`)`, sourceUUID, targetUUID, relationType, sourceUUID, domainUUID)
if err != nil {
return err
}
changed, _ := result.RowsAffected()
if changed == 0 {
return sql.ErrNoRows
}
if err := s.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) (resultErr error) {
defer func() { resultErr = s.sqlError("city mutation", resultErr) }()
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
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=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+` AND state!='archived'`, quartierUUID, domainUUID).Scan(&parentKind, &parentPath); err != nil || parentKind != "quartier" {
return namespaceValidationError("destination must be an active Quartier")
}
if err := tx.QueryRow(`SELECT path_prefix FROM zones WHERE uuid=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+` AND kind='street' AND state!='archived'`, streetUUID, domainUUID).Scan(&streetPath); err != nil {
return err
}
if !cityPathContains(parentPath, streetPath) {
return namespaceValidationError("Street Path is outside the destination Quartier Path; change its boundary first")
}
result, err := tx.Exec(`UPDATE zones SET parent_uuid=`+s.sqlParam(1)+`,sort_key=`+s.sqlParam(2)+`,version=version+1,updated_at_ms=`+s.sqlParam(3)+` WHERE uuid=`+s.sqlParam(4)+` AND domain_uuid=`+s.sqlParam(5)+` 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 := s.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) (resultErr error) {
defer func() { resultErr = s.sqlError("city mutation", resultErr) }()
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
if err != nil {
return err
}
defer tx.Rollback()
var kind, streetPath string
if err := tx.QueryRow(`SELECT kind,path_prefix FROM zones WHERE uuid=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+` AND state!='archived'`, streetUUID, domainUUID).Scan(&kind, &streetPath); err != nil || kind != "street" {
return namespaceValidationError("destination must be an active Street")
}
var spotDomain, spotPath string
if err := tx.QueryRow(`SELECT domain_uuid,path_prefix FROM spots WHERE uuid=`+s.sqlParam(1)+` AND state!='archived'`, spotUUID).Scan(&spotDomain, &spotPath); err != nil || spotDomain != domainUUID {
return namespaceValidationError("Spot must belong to the current Domain")
}
if !cityPathContains(streetPath, spotPath) {
return namespaceValidationError("Spot Path is outside the destination Street Path; change its boundary first")
}
result, err := tx.Exec(`UPDATE street_spots SET street_uuid=`+s.sqlParam(1)+`,sort_key=`+s.sqlParam(2)+` WHERE spot_uuid=`+s.sqlParam(3)+``, 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=`+s.sqlParam(1)+` WHERE uuid=`+s.sqlParam(2)+``, time.Now().UnixMilli(), spotUUID); err != nil {
return err
}
if err := s.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) (resultErr error) {
defer func() { resultErr = s.sqlError("city mutation", resultErr) }()
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
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=`+s.sqlParam(1)+` WHERE uuid=`+s.sqlParam(2)+` AND domain_uuid=`+s.sqlParam(3)+` AND state!='archived'`, now, id, domainUUID)
if err != nil {
return err
}
changed, _ = result.RowsAffected()
if changed > 0 {
if _, err := tx.Exec(`DELETE FROM street_spots WHERE spot_uuid=`+s.sqlParam(1), id); err != nil {
return err
}
if _, err := tx.Exec(`DELETE FROM spot_pages WHERE spot_uuid=`+s.sqlParam(1), id); err != nil {
return err
}
if _, err := tx.Exec(`DELETE FROM spot_relations WHERE source_spot_uuid=`+s.sqlParam(1)+` OR target_spot_uuid=`+s.sqlParam(2), id, id); err != nil {
return err
}
}
case "street", "quartier":
var actual string
if err := tx.QueryRow(`SELECT kind FROM zones WHERE uuid=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+` 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=`+s.sqlParam(1)+` AND kind='street' AND parent_uuid=`+s.sqlParam(2)+` AND state!='archived' LIMIT `+s.sqlParam(3), domainUUID, id, MaxCityMapNodes+1)
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 len(streetIDs) > MaxCityMapNodes {
rows.Close()
return ErrCityMapBudget
}
}
if err := rows.Err(); err != nil {
rows.Close()
return err
}
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=`+s.sqlParam(1)+`)`, 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=`+s.sqlParam(1)+`) OR target_spot_uuid IN (SELECT spot_uuid FROM street_spots WHERE street_uuid=`+s.sqlParam(2)+`)`, streetID, streetID)
if err != nil {
return err
}
_, err = tx.Exec(`UPDATE spots SET state='archived',version=version+1,updated_at_ms=`+s.sqlParam(1)+` WHERE uuid IN (SELECT spot_uuid FROM street_spots WHERE street_uuid=`+s.sqlParam(2)+`) AND domain_uuid=`+s.sqlParam(3)+``, now, streetID, domainUUID)
if err != nil {
return err
}
_, err = tx.Exec(`DELETE FROM street_spots WHERE street_uuid=`+s.sqlParam(1)+``, streetID)
if err != nil {
return err
}
}
if kind == "quartier" {
_, err = tx.Exec(`UPDATE zones SET state='archived',version=version+1,updated_at_ms=`+s.sqlParam(1)+` WHERE domain_uuid=`+s.sqlParam(2)+` AND kind='street' AND parent_uuid=`+s.sqlParam(3)+` 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=`+s.sqlParam(1)+` WHERE uuid=`+s.sqlParam(2)+` AND domain_uuid=`+s.sqlParam(3)+` AND kind=`+s.sqlParam(4)+` AND state!='archived'`, now, id, domainUUID, kind)
if err != nil {
return err
}
changed, _ = result.RowsAffected()
default:
return namespaceValidationError("invalid City element kind")
}
if changed == 0 {
return sql.ErrNoRows
}
if err := s.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 ` + s.sqlParam(1) + ` AS candidate) input WHERE s.domain_uuid=` + s.sqlParam(2) + ` AND ss.street_uuid=` + s.sqlParam(3) + ` AND s.state!='archived' AND ` + s.pathOverlapSQL("s.path_prefix", "input.candidate") +
` ORDER BY CASE WHEN s.path_prefix=input.candidate THEN 0 WHEN ` + s.pathScopeSQL("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 ` + s.sqlParam(1) + ` AS candidate) input WHERE domain_uuid=` + s.sqlParam(2) + ` AND kind=` + s.sqlParam(3) + ` AND state!='archived' AND ` + s.pathOverlapSQL("path_prefix", "input.candidate")
args := []any{pathPrefix, domainUUID, kind}
if kind == "street" {
query += ` AND parent_uuid=` + s.sqlParam(4)
args = append(args, parentUUID)
}
query += ` ORDER BY CASE WHEN path_prefix=input.candidate THEN 0 WHEN ` + s.pathScopeSQL("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
}