feat(storage): add native PostgreSQL runtime and verified offline application import
Build and publish container images / images (push) Failing after 12m29s

This commit is contained in:
Anya Tokugawa committed 2026-11-15 05:47:14 +09:00
1 parent 96065d1e89
commit 0ba1dcfef0
243 files changed
+21441 -3090

No files matched your search

+66
View File
@@ -0,0 +1,66 @@
package calendar
import (
"context"
"database/sql"
"errors"
"fmt"
"time"
"github.com/jackc/pgx/v5/pgconn"
"pageswiki/internal/db"
)
// NewPostgreSQL initializes disposable indexes, not canonical calendar data.
// All writers sharing this DB must share Root and its working flock semantics.
// Separate replicas with independent filesystems are not a supported HA mode.
func NewPostgreSQL(ctx context.Context, root string, database *sql.DB) (*Repository, error) {
if root == "" || database == nil {
return nil, errors.New("calendar storage unavailable")
}
ctx, cancel := context.WithTimeout(ctx, 15*time.Second)
defer cancel()
err := db.ApplyPostgreSQLMigrations(ctx, database, "calendar-cache", []db.PostgreSQLMigration{{Version: 1, Name: "rebuildable monthly calendar indexes", Statements: []string{
`CREATE TABLE calendar_index_state(domain TEXT COLLATE "C" NOT NULL,calendar TEXT COLLATE "C" NOT NULL,version TEXT NOT NULL,PRIMARY KEY(domain,calendar))`,
`CREATE TABLE calendar_month_cache(domain TEXT COLLATE "C" NOT NULL,calendar TEXT COLLATE "C" NOT NULL,month TEXT COLLATE "C" NOT NULL,hash TEXT NOT NULL,PRIMARY KEY(domain,calendar,month))`,
`CREATE TABLE calendar_event_cache(domain TEXT COLLATE "C" NOT NULL,calendar TEXT COLLATE "C" NOT NULL,uid TEXT COLLATE "C" NOT NULL,month TEXT COLLATE "C" NOT NULL,start BIGINT NOT NULL,"end" BIGINT NOT NULL,etag TEXT NOT NULL,data TEXT NOT NULL,PRIMARY KEY(domain,calendar,uid))`,
`CREATE INDEX calendar_event_range ON calendar_event_cache(domain,calendar,start,"end")`,
}, Assertions: []string{
`SELECT domain,calendar,version FROM calendar_index_state WHERE 1=0`,
`SELECT domain,calendar,month,hash FROM calendar_month_cache WHERE 1=0`,
`SELECT domain,calendar,uid,month,start,"end",etag,data FROM calendar_event_cache WHERE 1=0`,
}}})
if err != nil {
return nil, err
}
return &Repository{Root: root, DB: database, postgres: true}, nil
}
// Compose source-owned SQL; never translate arbitrary SQL at runtime.
func (r *Repository) p(n int) string {
if r.postgres {
return fmt.Sprintf("$%d", n)
}
return "?"
}
func (r *Repository) failure(err error) error {
if !r.postgres || err == nil {
return err
}
for _, known := range []error{ErrForbidden, ErrConflict, ErrPreconditionRequired, ErrMissing, ErrLimit, ErrInvalid, ErrNameTaken, sql.ErrNoRows, context.Canceled, context.DeadlineExceeded} {
if errors.Is(err, known) {
return known
}
}
var safe *db.PostgreSQLError
if errors.As(err, &safe) {
return safe
}
var pg *pgconn.PgError
if errors.As(err, &pg) {
return &db.PostgreSQLError{Operation: "calendar cache", SQLState: pg.Code}
}
// Encoding/Scan errors can contain event contents too.
return errors.New("calendar operation failed")
}
+10 -6
View File
@@ -5,6 +5,8 @@ import (
"database/sql"
"encoding/base64"
"strings"
"unicode"
"unicode/utf8"
)
func DAVFilename(c Calendar, uid string) string {
@@ -36,7 +38,7 @@ func DAVUID(c Calendar, name string) (string, error) {
}
}
b, err := base64.RawURLEncoding.DecodeString(strings.TrimSuffix(name, ".ics"))
if err != nil || len(b) == 0 || len(b) > 512 {
if err != nil || len(b) == 0 || len(b) > 512 || !utf8.Valid(b) || strings.IndexFunc(string(b), unicode.IsControl) >= 0 {
return "", ErrMissing
}
return string(b), nil
@@ -44,7 +46,8 @@ func DAVUID(c Calendar, name string) (string, error) {
// DAVSnapshot is complete or fails; a truncated listing can cause client deletes.
// The metadata lock keeps href mappings and event generations in one snapshot.
func (r *Repository) DAVSnapshot(ctx context.Context, domain, id, actor string, withData bool) (Calendar, []Event, error) {
func (r *Repository) DAVSnapshot(ctx context.Context, domain, id, actor string, withData bool) (result Calendar, itemsResult []Event, resultErr error) {
defer func() { resultErr = r.failure(resultErr) }()
c, _, unlock, err := r.locked(ctx, domain, id, actor)
if err != nil {
return c, nil, err
@@ -54,7 +57,7 @@ func (r *Repository) DAVSnapshot(ctx context.Context, domain, id, actor string,
if withData {
cols = "uid,etag,data"
}
rows, err := r.DB.QueryContext(ctx, `SELECT `+cols+` FROM calendar_event_cache WHERE domain=? AND calendar=? ORDER BY uid LIMIT 10001`, domain, id)
rows, err := r.DB.QueryContext(ctx, `SELECT `+cols+` FROM calendar_event_cache WHERE domain=`+r.p(1)+` AND calendar=`+r.p(2)+` ORDER BY uid LIMIT 10001`, domain, id)
if err != nil {
return c, nil, err
}
@@ -77,7 +80,8 @@ func (r *Repository) DAVSnapshot(ctx context.Context, domain, id, actor string,
// ChangeDAV reserves resource identities in the same manifest commit as the
// monthly snapshots. Existing resources still require an exact strong ETag.
func (r *Repository) ChangeDAV(ctx context.Context, domain, id, actor, name, match string, item *Event, authorize func() error) (Event, bool, error) {
func (r *Repository) ChangeDAV(ctx context.Context, domain, id, actor, name, match string, item *Event, authorize func() error) (eventResult Event, created bool, resultErr error) {
defer func() { resultErr = r.failure(resultErr) }()
if !ValidDAVFilename(name) {
return Event{}, false, ErrInvalid
}
@@ -94,7 +98,7 @@ func (r *Repository) ChangeDAV(ctx context.Context, domain, id, actor, name, mat
uid, _ := DAVUID(c, name)
var exists bool
if uid != "" {
if err = r.DB.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM calendar_event_cache WHERE domain=? AND calendar=? AND uid=?)`, domain, id, uid).Scan(&exists); err != nil {
if err = r.DB.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM calendar_event_cache WHERE domain=`+r.p(1)+` AND calendar=`+r.p(2)+` AND uid=`+r.p(3)+`)`, domain, id, uid).Scan(&exists); err != nil {
return Event{}, false, err
}
}
@@ -114,7 +118,7 @@ func (r *Repository) ChangeDAV(ctx context.Context, domain, id, actor, name, mat
}
uid = item.UID
var tag string
err = r.DB.QueryRowContext(ctx, `SELECT etag FROM calendar_event_cache WHERE domain=? AND calendar=? AND uid=?`, domain, id, uid).Scan(&tag)
err = r.DB.QueryRowContext(ctx, `SELECT etag FROM calendar_event_cache WHERE domain=`+r.p(1)+` AND calendar=`+r.p(2)+` AND uid=`+r.p(3), domain, id, uid).Scan(&tag)
if err == nil {
return Event{}, false, ErrConflict
}
+17
View File
@@ -2,6 +2,7 @@ package calendar
import (
"context"
"encoding/base64"
"errors"
"sync"
"testing"
@@ -9,6 +10,22 @@ import (
"github.com/google/uuid"
)
func TestDAVUIDRejectsBinaryFallback(t *testing.T) {
for _, raw := range []string{"\xff\xfe", "uid\x00value", "uid\nvalue"} {
name := base64.RawURLEncoding.EncodeToString([]byte(raw)) + ".ics"
if _, err := DAVUID(Calendar{}, name); !errors.Is(err, ErrMissing) {
t.Fatalf("binary UID accepted: %v", err)
}
}
name := "client.ics"
if _, err := DAVUID(Calendar{}, name); !errors.Is(err, ErrMissing) {
t.Fatal(err)
}
if uid, err := DAVUID(Calendar{DAVNames: map[string]string{"日本語@example.invalid": name}}, name); err != nil || uid != "日本語@example.invalid" {
t.Fatal(uid, err)
}
}
func TestCalendarDAVIdentityAtomicAndRebuild(t *testing.T) {
r, domain, actor, c := fixture(t)
ctx := context.Background()
+30 -20
View File
@@ -51,6 +51,7 @@ type Repository struct {
Root string
DB *sql.DB
PublicAllowed func(string) bool
postgres bool
}
func (r *Repository) canRead(domain string, c Calendar, actor string) bool {
@@ -66,8 +67,8 @@ func New(root string, db *sql.DB) (*Repository, error) {
}
_, err := db.Exec(`CREATE TABLE IF NOT EXISTS calendar_index_state(domain TEXT NOT NULL,calendar TEXT NOT NULL,version TEXT NOT NULL,PRIMARY KEY(domain,calendar));
CREATE TABLE IF NOT EXISTS calendar_month_cache(domain TEXT NOT NULL,calendar TEXT NOT NULL,month TEXT NOT NULL,hash TEXT NOT NULL,PRIMARY KEY(domain,calendar,month));
CREATE TABLE IF NOT EXISTS calendar_event_cache(domain TEXT NOT NULL,calendar TEXT NOT NULL,uid TEXT NOT NULL,month TEXT NOT NULL,start INTEGER NOT NULL,end INTEGER NOT NULL,etag TEXT NOT NULL,data TEXT NOT NULL,PRIMARY KEY(domain,calendar,uid));
CREATE INDEX IF NOT EXISTS calendar_event_range ON calendar_event_cache(domain,calendar,start,end);`)
CREATE TABLE IF NOT EXISTS calendar_event_cache(domain TEXT NOT NULL,calendar TEXT NOT NULL,uid TEXT NOT NULL,month TEXT NOT NULL,start INTEGER NOT NULL,"end" INTEGER NOT NULL,etag TEXT NOT NULL,data TEXT NOT NULL,PRIMARY KEY(domain,calendar,uid));
CREATE INDEX IF NOT EXISTS calendar_event_range ON calendar_event_cache(domain,calendar,start,"end");`)
return &Repository{Root: root, DB: db}, err
}
func validID(s string) bool { u, err := uuid.Parse(s); return err == nil && u.String() == s }
@@ -347,7 +348,10 @@ func (r *Repository) Settings(ctx context.Context, domain, id, actor, version, n
// with event/source writes. Cache rows are disposable, but deleting them
// before the atomic directory rename means a failed rename can safely rebuild
// them from the still-visible canonical files on the next access.
func (r *Repository) Delete(ctx context.Context, domain, id, actor, version string) error {
func (r *Repository) Delete(ctx context.Context, domain, id, actor, version string) (resultErr error) {
defer func() { resultErr = r.failure(resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
defer cancel()
dir, err := r.dir(domain, id)
if err != nil {
return err
@@ -382,7 +386,7 @@ func (r *Repository) Delete(ctx context.Context, domain, id, actor, version stri
}
defer tx.Rollback()
for _, table := range []string{"calendar_event_cache", "calendar_month_cache", "calendar_index_state"} {
if _, err = tx.ExecContext(ctx, `DELETE FROM `+table+` WHERE domain=? AND calendar=?`, domain, id); err != nil {
if _, err = tx.ExecContext(ctx, `DELETE FROM `+table+` WHERE domain=`+r.p(1)+` AND calendar=`+r.p(2), domain, id); err != nil {
return err
}
}
@@ -413,9 +417,12 @@ func syncDirectory(path string) error {
// refresh reconciles only changed monthly generations. A crash after manifest
// commit but before index commit repairs itself on the next request.
func (r *Repository) refresh(ctx context.Context, domain string, c Calendar, dir string) error {
func (r *Repository) refresh(ctx context.Context, domain string, c Calendar, dir string) (resultErr error) {
defer func() { resultErr = r.failure(resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
defer cancel()
var version string
if err := r.DB.QueryRowContext(ctx, `SELECT version FROM calendar_index_state WHERE domain=? AND calendar=?`, domain, c.ID).Scan(&version); err == nil && version == c.Version {
if err := r.DB.QueryRowContext(ctx, `SELECT version FROM calendar_index_state WHERE domain=`+r.p(1)+` AND calendar=`+r.p(2), domain, c.ID).Scan(&version); err == nil && version == c.Version {
return nil
} else if err != nil && err != sql.ErrNoRows {
return err
@@ -425,7 +432,7 @@ func (r *Repository) refresh(ctx context.Context, domain string, c Calendar, dir
return e
}
defer tx.Rollback()
rows, e := tx.QueryContext(ctx, `SELECT month,hash FROM calendar_month_cache WHERE domain=? AND calendar=?`, domain, c.ID)
rows, e := tx.QueryContext(ctx, `SELECT month,hash FROM calendar_month_cache WHERE domain=`+r.p(1)+` AND calendar=`+r.p(2), domain, c.ID)
if e != nil {
return e
}
@@ -445,10 +452,10 @@ func (r *Repository) refresh(ctx context.Context, domain string, c Calendar, dir
}
for m, h := range known {
if c.Months[m] != h {
if _, e = tx.ExecContext(ctx, `DELETE FROM calendar_event_cache WHERE domain=? AND calendar=? AND month=?`, domain, c.ID, m); e != nil {
if _, e = tx.ExecContext(ctx, `DELETE FROM calendar_event_cache WHERE domain=`+r.p(1)+` AND calendar=`+r.p(2)+` AND month=`+r.p(3), domain, c.ID, m); e != nil {
return e
}
if _, e = tx.ExecContext(ctx, `DELETE FROM calendar_month_cache WHERE domain=? AND calendar=? AND month=?`, domain, c.ID, m); e != nil {
if _, e = tx.ExecContext(ctx, `DELETE FROM calendar_month_cache WHERE domain=`+r.p(1)+` AND calendar=`+r.p(2)+` AND month=`+r.p(3), domain, c.ID, m); e != nil {
return e
}
}
@@ -480,15 +487,15 @@ func (r *Repository) refresh(ctx context.Context, domain string, c Calendar, dir
if e != nil {
return e
}
if _, e = tx.ExecContext(ctx, `INSERT INTO calendar_event_cache(domain,calendar,uid,month,start,end,etag,data) VALUES(?,?,?,?,?,?,?,?)`, domain, c.ID, event.UID, m, event.Start.Unix(), event.End.Unix(), event.ETag, event.Data); e != nil {
if _, e = tx.ExecContext(ctx, `INSERT INTO calendar_event_cache(domain,calendar,uid,month,start,"end",etag,data) VALUES(`+r.p(1)+`,`+r.p(2)+`,`+r.p(3)+`,`+r.p(4)+`,`+r.p(5)+`,`+r.p(6)+`,`+r.p(7)+`,`+r.p(8)+`)`, domain, c.ID, event.UID, m, event.Start.Unix(), event.End.Unix(), event.ETag, event.Data); e != nil {
return e
}
}
if _, e = tx.ExecContext(ctx, `INSERT INTO calendar_month_cache(domain,calendar,month,hash) VALUES(?,?,?,?)`, domain, c.ID, m, h); e != nil {
if _, e = tx.ExecContext(ctx, `INSERT INTO calendar_month_cache(domain,calendar,month,hash) VALUES(`+r.p(1)+`,`+r.p(2)+`,`+r.p(3)+`,`+r.p(4)+`)`, domain, c.ID, m, h); e != nil {
return e
}
}
if _, e = tx.ExecContext(ctx, `INSERT INTO calendar_index_state(domain,calendar,version) VALUES(?,?,?) ON CONFLICT(domain,calendar) DO UPDATE SET version=excluded.version`, domain, c.ID, c.Version); e != nil {
if _, e = tx.ExecContext(ctx, `INSERT INTO calendar_index_state(domain,calendar,version) VALUES(`+r.p(1)+`,`+r.p(2)+`,`+r.p(3)+`) ON CONFLICT(domain,calendar) DO UPDATE SET version=excluded.version`, domain, c.ID, c.Version); e != nil {
return e
}
return tx.Commit()
@@ -540,7 +547,8 @@ func (r *Repository) query(ctx context.Context, domain, id, actor string, start,
func (r *Repository) Upcoming(ctx context.Context, domain, id, actor string, start, end time.Time) ([]Event, error) {
return r.queryLimit(ctx, domain, id, actor, start, end, true, 20)
}
func (r *Repository) queryLimit(ctx context.Context, domain, id, actor string, start, end time.Time, withData bool, limit int) ([]Event, error) {
func (r *Repository) queryLimit(ctx context.Context, domain, id, actor string, start, end time.Time, withData bool, limit int) (result []Event, resultErr error) {
defer func() { resultErr = r.failure(resultErr) }()
if !end.After(start) || end.Sub(start) > 370*24*time.Hour {
return nil, ErrInvalid
}
@@ -553,7 +561,7 @@ func (r *Repository) queryLimit(ctx context.Context, domain, id, actor string, s
if withData {
columns = "data"
}
rows, e := r.DB.QueryContext(ctx, `SELECT `+columns+` FROM calendar_event_cache WHERE domain=? AND calendar=? AND start<? AND (end>? OR (start=end AND start>=?)) ORDER BY start,uid LIMIT ?`, domain, id, end.Unix(), start.Unix(), start.Unix(), limit)
rows, e := r.DB.QueryContext(ctx, `SELECT `+columns+` FROM calendar_event_cache WHERE domain=`+r.p(1)+` AND calendar=`+r.p(2)+` AND start<`+r.p(3)+` AND ("end">`+r.p(4)+` OR (start="end" AND start>=`+r.p(5)+`)) ORDER BY start,uid LIMIT `+r.p(6), domain, id, end.Unix(), start.Unix(), start.Unix(), limit)
if e != nil {
return nil, e
}
@@ -583,14 +591,15 @@ func (r *Repository) queryLimit(ctx context.Context, domain, id, actor string, s
}
return out, rows.Err()
}
func (r *Repository) Event(ctx context.Context, domain, id, actor, uid string) (Event, error) {
func (r *Repository) Event(ctx context.Context, domain, id, actor, uid string) (result Event, resultErr error) {
defer func() { resultErr = r.failure(resultErr) }()
_, _, unlock, e := r.locked(ctx, domain, id, actor)
if e != nil {
return Event{}, e
}
defer unlock()
var data string
e = r.DB.QueryRowContext(ctx, `SELECT data FROM calendar_event_cache WHERE domain=? AND calendar=? AND uid=?`, domain, id, uid).Scan(&data)
e = r.DB.QueryRowContext(ctx, `SELECT data FROM calendar_event_cache WHERE domain=`+r.p(1)+` AND calendar=`+r.p(2)+` AND uid=`+r.p(3), domain, id, uid).Scan(&data)
if e == sql.ErrNoRows {
e = ErrMissing
}
@@ -611,13 +620,14 @@ func (r *Repository) Change(ctx context.Context, domain, id, actor, uid, match s
return r.changeLocked(ctx, domain, actor, uid, match, item, c, dir)
}
func (r *Repository) changeLocked(ctx context.Context, domain, actor, uid, match string, item *Event, c Calendar, dir string) (Event, error) {
func (r *Repository) changeLocked(ctx context.Context, domain, actor, uid, match string, item *Event, c Calendar, dir string) (result Event, resultErr error) {
defer func() { resultErr = r.failure(resultErr) }()
id := c.ID
if !c.CanWrite(actor) {
return Event{}, ErrForbidden
}
var oldData, oldMonth, oldTag string
e := r.DB.QueryRowContext(ctx, `SELECT data,month,etag FROM calendar_event_cache WHERE domain=? AND calendar=? AND uid=?`, domain, id, uid).Scan(&oldData, &oldMonth, &oldTag)
e := r.DB.QueryRowContext(ctx, `SELECT data,month,etag FROM calendar_event_cache WHERE domain=`+r.p(1)+` AND calendar=`+r.p(2)+` AND uid=`+r.p(3), domain, id, uid).Scan(&oldData, &oldMonth, &oldTag)
exists := e == nil
if e != nil && e != sql.ErrNoRows {
return Event{}, e
@@ -650,7 +660,7 @@ func (r *Repository) changeLocked(ctx context.Context, domain, actor, uid, match
months[newMonth] = true
}
for month := range months {
rows, e := r.DB.QueryContext(ctx, `SELECT data FROM calendar_event_cache WHERE domain=? AND calendar=? AND month=? AND uid<>? ORDER BY uid`, domain, id, month, uid)
rows, e := r.DB.QueryContext(ctx, `SELECT data FROM calendar_event_cache WHERE domain=`+r.p(1)+` AND calendar=`+r.p(2)+` AND month=`+r.p(3)+` AND uid<>`+r.p(4)+` ORDER BY uid`, domain, id, month, uid)
if e != nil {
return Event{}, e
}
@@ -717,7 +727,7 @@ func (r *Repository) changeLocked(ctx context.Context, domain, actor, uid, match
_ = os.Remove(file)
}
}
// The committed files, not SQLite, determine success. A subsequent read
// The committed files, not the database cache, determine success. A subsequent read
// reconciles the cache; retries with the old ETag correctly get 412.
return next, nil
}
+3 -2
View File
@@ -25,14 +25,15 @@ func (r *Repository) ReadPersonalLocalIndex(ctx context.Context, domain, id, act
// TaskBlock gets a current event, or creates it if absent and a draft is supplied.
// Retries NEVER overwrite an event moved/edited in the calendar. Metadata policy
// is checked under the same lock as snapshot access and the eventual commit.
func (r *Repository) TaskBlock(ctx context.Context, domain, id, actor, uid string, draft *Event) (Calendar, Event, error) {
func (r *Repository) TaskBlock(ctx context.Context, domain, id, actor, uid string, draft *Event) (calendarResult Calendar, eventResult Event, resultErr error) {
defer func() { resultErr = r.failure(resultErr) }()
c, dir, unlock, err := r.lockedWithGuard(ctx, domain, id, actor, func(c Calendar) bool { return c.PersonalLocal(actor) })
if err != nil {
return Calendar{}, Event{}, err
}
defer unlock()
var data string
err = r.DB.QueryRowContext(ctx, `SELECT data FROM calendar_event_cache WHERE domain=? AND calendar=? AND uid=?`, domain, id, uid).Scan(&data)
err = r.DB.QueryRowContext(ctx, `SELECT data FROM calendar_event_cache WHERE domain=`+r.p(1)+` AND calendar=`+r.p(2)+` AND uid=`+r.p(3), domain, id, uid).Scan(&data)
if err == nil {
event, e := Parse(data)
return c, event, e
+108
View File
@@ -0,0 +1,108 @@
package db
import (
"context"
"database/sql"
"errors"
"fmt"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/stdlib"
)
// PostgreSQLOptions is an instance-level secret-bearing configuration. Do not
// log it. Application startup additionally requires a verified full-import
// receipt; opening a connection alone does not authorize backend cutover.
type PostgreSQLOptions struct {
DSN string
MaxOpenConns int
MaxIdleConns int
ConnectTimeout time.Duration
// AllowInsecure permits plaintext or unverified TLS for isolated development
// only. Production defaults require verified TLS and no plaintext fallback.
AllowInsecure bool
}
// PostgreSQLError deliberately excludes server messages, SQL, connection
// strings and constraint details, all of which can contain credentials or data.
// SQLState remains available for retry/conflict classification.
type PostgreSQLError struct {
Operation string
SQLState string
}
func (e *PostgreSQLError) Error() string {
if e.SQLState != "" {
return fmt.Sprintf("PostgreSQL %s failed (SQLSTATE %s)", e.Operation, e.SQLState)
}
return "PostgreSQL " + e.Operation + " failed"
}
func postgresError(operation string, err error) error {
if errors.Is(err, context.Canceled) {
return context.Canceled
}
if errors.Is(err, context.DeadlineExceeded) {
return context.DeadlineExceeded
}
var pgErr *pgconn.PgError
result := &PostgreSQLError{Operation: operation}
if errors.As(err, &pgErr) {
result.SQLState = pgErr.Code
}
return result
}
func OpenPostgreSQL(ctx context.Context, options PostgreSQLOptions) (*sql.DB, error) {
if options.DSN == "" {
return nil, fmt.Errorf("PostgreSQL DSN is required")
}
if options.MaxOpenConns < 0 || options.MaxIdleConns < 0 || options.ConnectTimeout < 0 {
return nil, fmt.Errorf("invalid PostgreSQL pool or timeout configuration")
}
config, err := pgx.ParseConfig(options.DSN)
if err != nil {
return nil, postgresError("configuration", err)
}
if !options.AllowInsecure {
if config.TLSConfig == nil || config.TLSConfig.InsecureSkipVerify {
return nil, fmt.Errorf("PostgreSQL requires verified TLS; use sslmode=verify-full")
}
for _, fallback := range config.Fallbacks {
if fallback.TLSConfig == nil || fallback.TLSConfig.InsecureSkipVerify {
return nil, fmt.Errorf("PostgreSQL insecure connection fallback is not allowed")
}
}
}
timeout := options.ConnectTimeout
if timeout == 0 {
timeout = 10 * time.Second
}
config.ConnectTimeout = timeout
config.RuntimeParams["application_name"] = "pageswiki"
database := stdlib.OpenDB(*config)
maxOpen := options.MaxOpenConns
if maxOpen == 0 {
maxOpen = 10
}
maxIdle := options.MaxIdleConns
if maxIdle == 0 {
maxIdle = 2
}
if maxIdle > maxOpen {
maxIdle = maxOpen
}
database.SetMaxOpenConns(maxOpen)
database.SetMaxIdleConns(maxIdle)
database.SetConnMaxLifetime(30 * time.Minute)
database.SetConnMaxIdleTime(5 * time.Minute)
pingCtx, cancel := context.WithTimeout(ctx, timeout)
defer cancel()
if err := database.PingContext(pingCtx); err != nil {
_ = database.Close()
return nil, postgresError("connect", err)
}
return database, nil
}
+120
View File
@@ -0,0 +1,120 @@
package db
import (
"context"
"crypto/sha256"
"database/sql"
"encoding/hex"
"encoding/json"
"fmt"
"strings"
"time"
)
// PostgreSQLMigration contains native PostgreSQL SQL ($1 parameters, BIGINT
// timestamps). SQLite migration definitions must not be translated implicitly.
// Definitions are append-only after release. Assertions return no rows on success.
type PostgreSQLMigration struct {
Version int
Name string
Statements []string
Assertions []string `json:",omitempty"`
}
func postgresMigrationChecksum(step PostgreSQLMigration) string {
encoded, _ := json.Marshal(step)
sum := sha256.Sum256(encoded)
return hex.EncodeToString(sum[:])
}
// ApplyPostgreSQLMigrations uses one transaction-scoped advisory lock for the
// migration namespace, including ledger creation. Component-specific locks
// would race concurrent first creation of the shared ledger. READ COMMITTED
// ensures a waiter sees the previous owner's committed migration history.
// Callers must use the same search_path and lock convention for a database.
func ApplyPostgreSQLMigrations(ctx context.Context, database *sql.DB, component string, steps []PostgreSQLMigration) error {
if strings.TrimSpace(component) == "" {
return fmt.Errorf("migration component is required")
}
for i, step := range steps {
if step.Version != i+1 || strings.TrimSpace(step.Name) == "" || len(step.Statements)+len(step.Assertions) == 0 {
return fmt.Errorf("invalid PostgreSQL migration sequence for %s", component)
}
}
tx, err := database.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelReadCommitted})
if err != nil {
return postgresError("migration begin", err)
}
defer tx.Rollback()
// Stable application-specific key, independent of Go hashes and versions.
if _, err := tx.ExecContext(ctx, `SELECT pg_advisory_xact_lock(1885431653, 1835624306)`); err != nil {
return postgresError("migration lock", err)
}
if _, err := tx.ExecContext(ctx, `CREATE TABLE IF NOT EXISTS schema_migration_steps (
component TEXT NOT NULL, version INTEGER NOT NULL, name TEXT NOT NULL,
checksum TEXT NOT NULL, applied_at_ms BIGINT NOT NULL,
PRIMARY KEY(component,version))`); err != nil {
return postgresError("migration ledger", err)
}
rows, err := tx.QueryContext(ctx, `SELECT version,name,checksum FROM schema_migration_steps WHERE component=$1 ORDER BY version`, component)
if err != nil {
return postgresError("migration history", err)
}
applied := 0
for rows.Next() {
var version int
var name, checksum string
if err := rows.Scan(&version, &name, &checksum); err != nil {
rows.Close()
return postgresError("migration history", err)
}
if version != applied+1 || version > len(steps) || steps[version-1].Name != name || postgresMigrationChecksum(steps[version-1]) != checksum {
rows.Close()
return fmt.Errorf("PostgreSQL migration history mismatch: component=%s version=%d", component, version)
}
applied++
}
err = rows.Err()
closeErr := rows.Close()
if err != nil {
return postgresError("migration history", err)
}
if closeErr != nil {
return postgresError("migration history close", closeErr)
}
for _, step := range steps[applied:] {
for i, statement := range step.Statements {
if _, err := tx.ExecContext(ctx, statement); err != nil {
return postgresError(fmt.Sprintf("migration %s/%d statement %d", component, step.Version, i+1), err)
}
}
if _, err := tx.ExecContext(ctx, `INSERT INTO schema_migration_steps(component,version,name,checksum,applied_at_ms) VALUES($1,$2,$3,$4,$5)`, component, step.Version, step.Name, postgresMigrationChecksum(step), time.Now().UnixMilli()); err != nil {
return postgresError("migration record", err)
}
}
if len(steps) > 0 {
step := steps[len(steps)-1]
for i, assertion := range step.Assertions {
rows, err := tx.QueryContext(ctx, assertion)
if err != nil {
return postgresError("schema assertion", err)
}
violated := rows.Next()
err = rows.Err()
closeErr := rows.Close()
if err != nil {
return postgresError("schema assertion", err)
}
if closeErr != nil {
return postgresError("schema assertion close", closeErr)
}
if violated {
return fmt.Errorf("PostgreSQL schema contract %s/%d assertion %d failed", component, step.Version, i+1)
}
}
}
if err := tx.Commit(); err != nil {
return postgresError("migration commit", err)
}
return nil
}
+194
View File
@@ -0,0 +1,194 @@
package db
import (
"context"
"database/sql"
"errors"
"fmt"
"net/url"
"os"
"strings"
"sync"
"testing"
"time"
"github.com/google/uuid"
"github.com/jackc/pgx/v5/pgconn"
)
func TestPostgreSQLConfigurationAndRedaction(t *testing.T) {
for _, options := range []PostgreSQLOptions{
{}, {DSN: "postgres://test:secret@localhost/db", MaxOpenConns: -1},
{DSN: "postgres://test:secret@localhost/db?sslmode=disable"},
{DSN: "postgres://test:secret@localhost/db?sslmode=require"},
{DSN: "postgres://test:secret@localhost/db?sslmode=prefer"},
{DSN: "postgres://test:secret@localhost/db?sslmode=invalid"},
} {
database, err := OpenPostgreSQL(context.Background(), options)
if database != nil || err == nil {
t.Fatal("invalid configuration accepted")
}
if strings.Contains(err.Error(), "secret") {
t.Fatal("password disclosed")
}
}
err := postgresError("write", &pgconn.PgError{Code: "23505", Message: "secret", Detail: "private row"})
var safe *PostgreSQLError
if !errors.As(err, &safe) || safe.SQLState != "23505" || strings.Contains(err.Error(), "secret") {
t.Fatal("unsafe error classification")
}
if !errors.Is(postgresError("read", context.Canceled), context.Canceled) {
t.Fatal("cancellation lost")
}
ctx, cancel := context.WithCancel(context.Background())
cancel()
database, err := OpenPostgreSQL(ctx, PostgreSQLOptions{DSN: "postgres://test:secret@127.0.0.1:1/db?sslmode=disable", AllowInsecure: true})
if database != nil || !errors.Is(err, context.Canceled) {
t.Fatal("connection cancellation lost")
}
}
// These tests create and drop only a random schema. Use a disposable database
// and URL DSN, never a production connection. No fixtures contain real events.
func postgresTestDatabase(t *testing.T) *sql.DB {
t.Helper()
dsn := os.Getenv("PAGESWIKI_TEST_POSTGRES_DSN")
if dsn == "" {
t.Skip("set PAGESWIKI_TEST_POSTGRES_DSN to a disposable PostgreSQL URL")
}
u, err := url.Parse(dsn)
if err != nil || (u.Scheme != "postgres" && u.Scheme != "postgresql") {
t.Fatal("test DSN must be a PostgreSQL URL")
}
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
root, err := OpenPostgreSQL(ctx, PostgreSQLOptions{DSN: dsn, AllowInsecure: true})
if err != nil {
t.Fatal(err)
}
schema := "pageswiki_test_" + strings.ReplaceAll(uuid.NewString(), "-", "")
if _, err := root.ExecContext(ctx, `CREATE SCHEMA "`+schema+`"`); err != nil {
root.Close()
t.Fatal(postgresError("test schema", err))
}
t.Cleanup(func() {
cleanup, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if _, err := root.ExecContext(cleanup, `DROP SCHEMA "`+schema+`" CASCADE`); err != nil {
t.Error(postgresError("test cleanup", err))
}
root.Close()
})
query := u.Query()
query.Set("search_path", schema)
u.RawQuery = query.Encode()
database, err := OpenPostgreSQL(ctx, PostgreSQLOptions{DSN: u.String(), AllowInsecure: true, MaxOpenConns: 6})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { database.Close() })
return database
}
func TestPostgreSQLMigrationConcurrencyAndHistory(t *testing.T) {
database := postgresTestDatabase(t)
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
defer cancel()
steps := []PostgreSQLMigration{{Version: 1, Name: "initial", Statements: []string{
`CREATE TABLE sample (uuid TEXT PRIMARY KEY, created_at_ms BIGINT NOT NULL)`,
`INSERT INTO sample VALUES ('synthetic', 1800000000000)`,
}, Assertions: []string{`SELECT 1 WHERE NOT EXISTS (SELECT 1 FROM sample WHERE created_at_ms=1800000000000)`}}}
var wg sync.WaitGroup
errs := make(chan error, 6)
for i := 0; i < 6; i++ {
wg.Add(1)
go func() { defer wg.Done(); errs <- ApplyPostgreSQLMigrations(ctx, database, "test", steps) }()
}
wg.Wait()
close(errs)
for err := range errs {
if err != nil {
t.Fatal(err)
}
}
var count int
if err := database.QueryRowContext(ctx, `SELECT count(*) FROM sample`).Scan(&count); err != nil || count != 1 {
t.Fatalf("rows=%d error=%v", count, err)
}
if err := ApplyPostgreSQLMigrations(ctx, database, "test", nil); err == nil {
t.Fatal("downgrade accepted")
}
changed := append([]PostgreSQLMigration(nil), steps...)
changed[0].Name = "changed"
if err := ApplyPostgreSQLMigrations(ctx, database, "test", changed); err == nil {
t.Fatal("changed history accepted")
}
changed = append([]PostgreSQLMigration(nil), steps...)
changed[0].Statements = []string{`SELECT 1`}
if err := ApplyPostgreSQLMigrations(ctx, database, "test", changed); err == nil {
t.Fatal("changed SQL checksum accepted")
}
if err := ApplyPostgreSQLMigrations(ctx, database, "other", []PostgreSQLMigration{{Version: 2, Name: "gap", Statements: []string{`SELECT 1`}}}); err == nil {
t.Fatal("version gap accepted")
}
// Assertions are checked again even when no migrations remain to apply.
if _, err := database.ExecContext(ctx, `DELETE FROM sample`); err != nil {
t.Fatal(err)
}
if err := ApplyPostgreSQLMigrations(ctx, database, "test", steps); err == nil {
t.Fatal("schema assertion skipped")
}
}
func TestPostgreSQLMigrationRollbackAndLockCancellation(t *testing.T) {
database := postgresTestDatabase(t)
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
defer cancel()
broken := []PostgreSQLMigration{{Version: 1, Name: "broken", Statements: []string{`CREATE TABLE partial (id INTEGER)`, `NOT VALID SQL`}}}
if err := ApplyPostgreSQLMigrations(ctx, database, "test", broken); err == nil {
t.Fatal("SQL error ignored")
}
var name sql.NullString
if err := database.QueryRowContext(ctx, `SELECT to_regclass('partial')::text`).Scan(&name); err != nil || name.Valid {
t.Fatal("DDL not rolled back", err)
}
if err := database.QueryRowContext(ctx, `SELECT to_regclass('schema_migration_steps')::text`).Scan(&name); err != nil || name.Valid {
t.Fatal("ledger not rolled back", err)
}
broken[0].Statements = broken[0].Statements[:1]
if err := ApplyPostgreSQLMigrations(ctx, database, "test", broken); err != nil {
t.Fatal("retry failed", err)
}
assertionFailure := append(append([]PostgreSQLMigration(nil), broken...), PostgreSQLMigration{
Version: 2, Name: "assertion failure", Statements: []string{`CREATE TABLE should_rollback (id INTEGER)`}, Assertions: []string{`SELECT 1`},
})
if err := ApplyPostgreSQLMigrations(ctx, database, "test", assertionFailure); err == nil {
t.Fatal("assertion failure ignored")
}
if err := database.QueryRowContext(ctx, `SELECT to_regclass('should_rollback')::text`).Scan(&name); err != nil || name.Valid {
t.Fatal("assertion DDL not rolled back", err)
}
var version int
if err := database.QueryRowContext(ctx, `SELECT max(version) FROM schema_migration_steps WHERE component=$1`, "test").Scan(&version); err != nil || version != 1 {
t.Fatal("assertion ledger not rolled back", err)
}
tx, err := database.BeginTx(ctx, nil)
if err != nil {
t.Fatal(err)
}
defer tx.Rollback()
if _, err = tx.ExecContext(ctx, `SELECT pg_advisory_xact_lock(1885431653, 1835624306)`); err != nil {
t.Fatal(err)
}
waitCtx, stop := context.WithTimeout(ctx, 100*time.Millisecond)
defer stop()
if err := ApplyPostgreSQLMigrations(waitCtx, database, "test", broken); err == nil {
t.Fatal("blocked migration ignored deadline")
}
if err := tx.Rollback(); err != nil {
t.Fatal(err)
}
if err := ApplyPostgreSQLMigrations(ctx, database, "test", broken); err != nil {
t.Fatal(fmt.Sprintf("lock not released: %v", err))
}
}
+140
View File
@@ -0,0 +1,140 @@
// Package documentrefs freezes mutable Asset references without interpreting
// ordinary text or code examples. Resolvers must authorize the source Domain.
package documentrefs
import (
"bytes"
"context"
"encoding/hex"
"errors"
"fmt"
"io"
"mime"
"strings"
"golang.org/x/net/html"
)
var ErrUnavailable = errors.New("embedded asset is unavailable")
type Resolver func(context.Context, string) (string, error)
// Freeze retains original bytes for unchanged tokens and deduplicates hashes
// in appearance order. Repeated addresses resolve only once per payload.
func Freeze(ctx context.Context, payload []byte, contentType string, resolve Resolver) ([]byte, []string, error) {
if err := ctx.Err(); err != nil {
return nil, nil, err
}
mediaType, _, err := mime.ParseMediaType(contentType)
if err != nil || !strings.EqualFold(mediaType, "text/html") {
return payload, nil, nil
}
z := html.NewTokenizer(bytes.NewReader(payload))
var output bytes.Buffer
seen := map[string]bool{}
resolved := map[string]string{}
var hashes []string
lookup := func(address string) (string, error) {
if hash := resolved[address]; hash != "" {
return hash, nil
}
if resolve == nil {
return "", ErrUnavailable
}
hash, err := resolve(ctx, address)
if err != nil {
return "", err
}
if len(hash) != 64 {
return "", fmt.Errorf("%w: %s", ErrUnavailable, address)
}
if _, err := hex.DecodeString(hash); err != nil {
return "", fmt.Errorf("%w: %s", ErrUnavailable, address)
}
hash = strings.ToLower(hash)
resolved[address] = hash
if !seen[hash] {
seen[hash] = true
hashes = append(hashes, hash)
}
return hash, nil
}
for {
if err := ctx.Err(); err != nil {
return nil, nil, err
}
typ := z.Next()
if typ == html.ErrorToken {
if errors.Is(z.Err(), io.EOF) {
return output.Bytes(), hashes, nil
}
return nil, nil, z.Err()
}
if typ != html.StartTagToken && typ != html.SelfClosingTagToken {
output.Write(z.Raw())
continue
}
// Token() may alter the tokenizer buffer. Copy original bytes first.
raw := append([]byte(nil), z.Raw()...)
token := z.Token()
changed := false
assetRef := attribute(token.Attr, "asset-ref")
legacy := attribute(token.Attr, "immutable-ref")
if assetRef == "" && strings.HasPrefix(legacy, "asset:") {
assetRef = legacy
}
if strings.HasPrefix(assetRef, "asset:") {
hash, err := lookup(assetRef)
if err != nil {
return nil, nil, err
}
setAttribute(&token, "asset-ref", assetRef)
setAttribute(&token, "immutable-ref", "sha256:"+hash)
changed = true
}
for _, name := range []string{"src", "href", "poster", "data"} {
provenance := "data-pageswiki-asset-" + name
address := attribute(token.Attr, provenance)
if address == "" {
candidate := attribute(token.Attr, name)
if strings.HasPrefix(candidate, "asset:") {
address = candidate
}
}
if !strings.HasPrefix(address, "asset:") {
continue
}
hash, err := lookup(address)
if err != nil {
return nil, nil, err
}
setAttribute(&token, provenance, address)
setAttribute(&token, name, "/_/obj/sha256:"+hash)
changed = true
}
if changed {
output.WriteString(token.String())
} else {
output.Write(raw)
}
}
}
func attribute(attrs []html.Attribute, name string) string {
for _, a := range attrs {
if strings.EqualFold(a.Key, name) {
return strings.TrimSpace(a.Val)
}
}
return ""
}
func setAttribute(token *html.Token, name, value string) {
for i := range token.Attr {
if strings.EqualFold(token.Attr[i].Key, name) {
token.Attr[i].Key = name
token.Attr[i].Val = value
return
}
}
token.Attr = append(token.Attr, html.Attribute{Key: name, Val: value})
}
+55
View File
@@ -0,0 +1,55 @@
package documentrefs
import (
"context"
"errors"
"strings"
"testing"
)
func TestFreezePreservesUnchangedHTML(t *testing.T) {
body := `<!DOCTYPE html><!-- sample --><DIV class='A' title="&amp;">日本語<code>&lt;img src="asset:image:example"&gt;</code><script>const x="asset:image:sample";</script><a HREF='/plain?a=1&amp;b=2'>Link</a></DIV>`
got, refs, err := Freeze(context.Background(), []byte(body), "text/html; charset=utf-8", func(context.Context, string) (string, error) { t.Fatal("ordinary text resolved"); return "", nil })
if err != nil || string(got) != body || len(refs) != 0 {
t.Fatal("unchanged HTML lost bytes", err, string(got))
}
for _, mime := range []string{"text/plain", "application/octet-stream", "text/html-not-really"} {
got, refs, err := Freeze(context.Background(), []byte(`<img src="asset:image:sample">`), mime, nil)
if err != nil || len(refs) != 0 || string(got) != `<img src="asset:image:sample">` {
t.Fatal("non-HTML modified", mime, err)
}
}
}
func TestFreezeDeduplicatesAndFollowsProvenance(t *testing.T) {
hash := strings.Repeat("a", 64)
calls := 0
resolve := func(context.Context, string) (string, error) { calls++; return hash, nil }
body := `<img src="asset:image:a"><video poster="asset:image:a"></video><object data="asset:image:b"></object><a href="asset:image:a">a</a><embedded-object immutable-ref="asset:image:a"></embedded-object>`
got, refs, err := Freeze(context.Background(), []byte(body), "text/html", resolve)
if err != nil || len(refs) != 1 || refs[0] != hash || calls != 2 {
t.Fatal("deduplication", err, refs, calls)
}
if !strings.Contains(string(got), `immutable-ref="sha256:`+hash+`"`) || !strings.Contains(string(got), `data-pageswiki-asset-src="asset:image:a"`) {
t.Fatal("provenance missing")
}
hash = strings.Repeat("b", 64)
calls = 0
updated, refs, err := Freeze(context.Background(), got, "text/html", resolve)
if err != nil || len(refs) != 1 || refs[0] != hash || calls != 2 || strings.Contains(string(updated), strings.Repeat("a", 64)) {
t.Fatal("resave did not follow HEAD", err)
}
}
func TestFreezeRejectsMissingInvalidAndCanceled(t *testing.T) {
for _, hash := range []string{"", strings.Repeat("x", 64)} {
if _, _, err := Freeze(context.Background(), []byte(`<img src="asset:image:a">`), "text/html", func(context.Context, string) (string, error) { return hash, nil }); !errors.Is(err, ErrUnavailable) {
t.Fatal("invalid hash accepted", err)
}
}
ctx, cancel := context.WithCancel(context.Background())
cancel()
if _, _, err := Freeze(ctx, []byte("text"), "text/plain", nil); !errors.Is(err, context.Canceled) {
t.Fatal("cancellation ignored", err)
}
}
+43 -3
View File
@@ -32,6 +32,12 @@ type Runner struct {
registry *Registry
opts RunnerOptions
mu sync.Mutex
stopping bool
stopCtx context.Context
cancel context.CancelFunc
workers sync.WaitGroup
stopOnce sync.Once
done chan struct{}
}
func NewRunner(queue Queue, registry *Registry, opts RunnerOptions) *Runner {
@@ -41,7 +47,30 @@ func NewRunner(queue Queue, registry *Registry, opts RunnerOptions) *Runner {
if opts.Active == nil {
opts.Active = new(atomic.Int64)
}
return &Runner{queue: queue, registry: registry, opts: opts}
ctx, cancel := context.WithCancel(context.Background())
return &Runner{queue: queue, registry: registry, opts: opts, stopCtx: ctx, cancel: cancel, done: make(chan struct{})}
}
// Stop closes admission permanently, cancels handlers and waits for persisted
// completions. A timeout does not mean workers have exited: callers must keep
// ownership/database resources alive and may call Stop again to await them.
func (r *Runner) Stop(ctx context.Context) error {
r.stopOnce.Do(func() {
r.cancel()
go func() {
r.mu.Lock()
r.stopping = true
r.mu.Unlock()
r.workers.Wait()
close(r.done)
}()
})
select {
case <-r.done:
return nil
case <-ctx.Done():
return ctx.Err()
}
}
func (r *Runner) report(stage string, job *Job, err error) {
@@ -57,7 +86,10 @@ func (r *Runner) Running() int64 { return r.opts.Active.Load() }
func (r *Runner) Dispatch(ctx context.Context) {
r.mu.Lock()
defer r.mu.Unlock()
for n := 0; n < 32 && ctx.Err() == nil; n++ {
if r.stopping || r.stopCtx.Err() != nil {
return
}
for n := 0; n < 32 && ctx.Err() == nil && r.stopCtx.Err() == nil; n++ {
settings, err := r.queue.Settings(ctx)
if err != nil {
r.report("settings", nil, err)
@@ -81,7 +113,15 @@ func (r *Runner) Dispatch(ctx context.Context) {
}
r.opts.Active.Add(1)
r.report("start-log", job, r.queue.Started(ctx, job))
go r.execute(ctx, job)
workerCtx, cancel := context.WithCancel(ctx)
stop := context.AfterFunc(r.stopCtx, cancel)
r.workers.Add(1)
go func() {
defer r.workers.Done()
defer cancel()
defer stop()
r.execute(workerCtx, job)
}()
}
}
+47
View File
@@ -14,6 +14,53 @@ type finishedJob struct {
err error
at time.Time
}
func TestRunnerStopWaitsAndClosesAdmission(t *testing.T) {
q := newFakeQueue(1)
reg := &Registry{}
started := make(chan struct{})
cancelled := make(chan struct{})
exit := make(chan struct{})
if err := reg.Register("synthetic", func(ctx context.Context, _ *Job) error {
close(started)
<-ctx.Done()
close(cancelled)
<-exit // simulate cleanup that cannot be interrupted
return ctx.Err()
}); err != nil {
t.Fatal(err)
}
r := NewRunner(q, reg, RunnerOptions{})
r.Dispatch(context.Background())
receive(t, started)
ctx, cancel := context.WithCancel(context.Background())
cancel()
if err := r.Stop(ctx); !errors.Is(err, context.Canceled) {
t.Fatal(err)
}
receive(t, cancelled)
if r.Running() != 1 {
t.Fatal("worker exited before cleanup")
}
r.Dispatch(context.Background())
if q.claimed != 1 {
t.Fatal("admission remained open")
}
close(exit)
ctx, cancel = context.WithTimeout(context.Background(), time.Second)
defer cancel()
if err := r.Stop(ctx); err != nil {
t.Fatal(err)
}
receive(t, q.finished)
if r.Running() != 0 {
t.Fatal("worker slot retained after stop")
}
if err := r.Stop(ctx); err != nil {
t.Fatal("idempotent stop", err)
}
}
type fakeQueue struct {
mu sync.Mutex
settings Settings
+2
View File
@@ -13,6 +13,8 @@ var (
)
type Job struct {
// ClaimToken fences native database completion; never expose it to clients.
ClaimToken string `json:"-"`
UUID string `json:"uuid"`
EventUUID string `json:"event_uuid,omitempty"`
Type string `json:"event_type"`
+55 -17
View File
@@ -4,6 +4,7 @@ import (
"context"
"database/sql"
"errors"
"fmt"
"sort"
"strings"
"time"
@@ -36,6 +37,14 @@ type citySearchCandidate struct {
// Scope selects a locality's own boundary, not an ancestor of the scope. Every
// boundary in its parent chain must be readable before the result is exposed.
func (s *SQLite) SearchCityInDomain(parent context.Context, domainUUID, scope, query string, limit int, allowed func(string) bool, options SearchOptions) (found []CitySearchResult, searchErr error) {
return searchCity(s.db, false, parent, domainUUID, scope, query, limit, allowed, options)
}
func (s *PostgreSQL) SearchCityInDomain(parent context.Context, domainUUID, scope, query string, limit int, allowed func(string) bool, options SearchOptions) ([]CitySearchResult, error) {
return searchCity(s.db, true, parent, domainUUID, scope, query, limit, allowed, options)
}
func searchCity(database *sql.DB, native bool, parent context.Context, domainUUID, scope, query string, limit int, allowed func(string) bool, options SearchOptions) (found []CitySearchResult, searchErr error) {
if err := options.Validate(); err != nil {
return nil, err
}
@@ -58,7 +67,7 @@ func (s *SQLite) SearchCityInDomain(parent context.Context, domainUUID, scope, q
searchErr = ctx.Err()
}
}()
tx, err := s.db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
tx, err := database.BeginTx(ctx, &sql.TxOptions{ReadOnly: true, Isolation: sql.LevelRepeatableRead})
if err != nil {
return nil, err
}
@@ -70,22 +79,35 @@ func (s *SQLite) SearchCityInDomain(parent context.Context, domainUUID, scope, q
sql.Named("prefix", prefix), sql.Named("upper", upper),
sql.Named("query", query), sql.Named("limit", CitySearchCandidateLimit),
}
if native {
args = []any{domainUUID, scope, prefix, upper, query, CitySearchCandidateLimit}
}
dateColumn := "n.updated_at_ms"
if options.DateField == "created" {
dateColumn = "n.created_at_ms"
}
dateWhere := ""
if options.FromMS != nil {
dateWhere += " AND " + dateColumn + ">=:from_ms"
args = append(args, sql.Named("from_ms", *options.FromMS))
if native {
args = append(args, *options.FromMS)
dateWhere += " AND " + dateColumn + ">=" + fmt.Sprintf("$%d", len(args))
} else {
dateWhere += " AND " + dateColumn + ">=:from_ms"
args = append(args, sql.Named("from_ms", *options.FromMS))
}
}
if options.BeforeMS != nil {
dateWhere += " AND " + dateColumn + "<:before_ms"
args = append(args, sql.Named("before_ms", *options.BeforeMS))
if native {
args = append(args, *options.BeforeMS)
dateWhere += " AND " + dateColumn + "<" + fmt.Sprintf("$%d", len(args))
} else {
dateWhere += " AND " + dateColumn + "<:before_ms"
args = append(args, sql.Named("before_ms", *options.BeforeMS))
}
}
candidates := make([]citySearchCandidate, 0)
for _, kind := range []string{"quartier", "street", "spot"} {
rows, err := tx.QueryContext(ctx, citySearchSQL(kind, dateWhere), args...)
rows, err := tx.QueryContext(ctx, citySearchDialectSQL(kind, dateWhere, native), args...)
if err != nil {
return nil, err
}
@@ -173,6 +195,18 @@ func citySearchKindOrder(kind string) int {
// All interpolated SQL fragments are package-owned constants. User input is
// bound, so %, _, quotes and backslashes are literal substring characters.
func citySearchSQL(kind, dateWhere string) string {
return citySearchDialectSQL(kind, dateWhere, false)
}
func citySearchDialectSQL(kind, dateWhere string, native bool) string {
domain, scope, prefix, upper, query, limit := ":domain", ":scope", ":prefix", ":upper", ":query", ":limit"
collation, position, greatest := " COLLATE BINARY", "instr", "max"
absolute := citySearchAbsolutePathSQL
if native {
domain, scope, prefix, upper, query, limit = "$1", "$2", "$3", "$4", "$5", "$6"
collation, position, greatest = ` COLLATE "C"`, "strpos", "greatest"
absolute = func(column string) string { return `(substr(` + column + `,1,1)='/' AND length(` + column + `)<=4096)` }
}
from, description := "zones n", "n.description"
navigationPath := "n.path_prefix"
parentColumns := "'','','','',''"
@@ -181,28 +215,32 @@ func citySearchSQL(kind, dateWhere string) string {
case "street":
from += ` JOIN zones q ON q.uuid=n.parent_uuid AND q.domain_uuid=n.domain_uuid AND q.kind='quartier' AND q.state!='archived'`
parentColumns = "substr(COALESCE(NULLIF(q.title,''),q.name),1,256),'',q.path_prefix,'',q.name"
where = "n.kind='street' AND " + citySearchAbsolutePathSQL("q.path_prefix")
where = "n.kind='street' AND " + absolute("q.path_prefix")
case "spot":
navigationPath = `CASE WHEN substr(n.path_prefix,-11)='/_undefined' THEN st.path_prefix ELSE n.path_prefix END`
if native {
navigationPath = `CASE WHEN right(n.path_prefix,11)='/_undefined' THEN st.path_prefix ELSE n.path_prefix END`
}
from = `spots n JOIN street_spots ss ON ss.spot_uuid=n.uuid
JOIN zones st ON st.uuid=ss.street_uuid AND st.domain_uuid=n.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'`
description = "n.summary"
parentColumns = "substr(COALESCE(NULLIF(q.title,''),q.name),1,256),substr(COALESCE(NULLIF(st.title,''),st.name),1,256),q.path_prefix,st.path_prefix,q.name"
where = citySearchAbsolutePathSQL("q.path_prefix") + " AND " + citySearchAbsolutePathSQL("st.path_prefix")
where = absolute("q.path_prefix") + " AND " + absolute("st.path_prefix")
}
nameMatch := `(:query!='' AND (instr(lower(n.name),lower(:query))>0 OR instr(lower(n.title),lower(:query))>0))`
pathMatch := `(:query!='' AND instr(lower(n.path_prefix),lower(:query))>0)`
descriptionMatch := `(:query!='' AND instr(lower(` + description + `),lower(:query))>0)`
contains := func(column string) string { return position + "(lower(" + column + "),lower(" + query + "))" }
nameMatch := `(` + query + `!='' AND (` + contains("n.name") + `>0 OR ` + contains("n.title") + `>0))`
pathMatch := `(` + query + `!='' AND ` + contains("n.path_prefix") + `>0)`
descriptionMatch := `(` + query + `!='' AND ` + contains(description) + `>0)`
return `SELECT n.uuid,substr(n.name,1,256),substr(n.title,1,256),
substr(` + description + `,max(1,instr(lower(` + description + `),lower(:query))-160),512),
substr(` + description + `,` + greatest + `(1,` + contains(description) + `-160),512),
n.path_prefix,n.created_at_ms,n.updated_at_ms,` + nameMatch + `,` + pathMatch + `,` + descriptionMatch + `,` + parentColumns + `,` + navigationPath + `,
EXISTS(SELECT 1 FROM paths cp WHERE cp.domain_uuid=n.domain_uuid AND cp.path=(` + navigationPath + `))
FROM ` + from + ` WHERE n.domain_uuid=:domain AND n.state!='archived' AND ` + where + `
AND ` + citySearchAbsolutePathSQL("n.path_prefix") + `
AND (n.path_prefix COLLATE BINARY=:scope OR (n.path_prefix COLLATE BINARY>=:prefix AND n.path_prefix COLLATE BINARY<:upper))
AND (:query='' OR ` + nameMatch + ` OR ` + pathMatch + ` OR ` + descriptionMatch + `)` + dateWhere + `
ORDER BY ` + nameMatch + ` DESC,` + pathMatch + ` DESC,n.path_prefix COLLATE BINARY,n.uuid LIMIT :limit`
FROM ` + from + ` WHERE n.domain_uuid=` + domain + ` AND n.state!='archived' AND ` + where + `
AND ` + absolute("n.path_prefix") + `
AND (n.path_prefix` + collation + `=` + scope + ` OR (n.path_prefix` + collation + `>=` + prefix + ` AND n.path_prefix` + collation + `<` + upper + `))
AND (` + query + `='' OR ` + nameMatch + ` OR ` + pathMatch + ` OR ` + descriptionMatch + `)` + dateWhere + `
ORDER BY ` + nameMatch + ` DESC,` + pathMatch + ` DESC,n.path_prefix` + collation + `,n.uuid LIMIT ` + limit
}
func citySearchAbsolutePathSQL(column string) string {
+134
View File
@@ -0,0 +1,134 @@
package mestionora
import (
"context"
"database/sql"
"errors"
"fmt"
"sort"
"strings"
"time"
)
// PostgreSQL's initial search profile is metadata-only. It deliberately does
// not scan canonical files or the legacy body column to emulate SQLite FTS.
// The caller owns the pool and must provision the native metadata schema.
type PostgreSQL struct{ db *sql.DB }
func NewPostgreSQL(db *sql.DB) *PostgreSQL { return &PostgreSQL{db: db} }
const pgSearchMIME = `lower(trim(split_part(COALESCE(r.content_type,''),';',1)))`
var pgSearchFileType = buildSearchFileTypeSQL(pgSearchMIME, func(suffixes ...string) string {
clauses := make([]string, 0, len(suffixes))
for _, suffix := range suffixes {
clauses = append(clauses, searchFilenameSQL+fmt.Sprintf(` LIKE '%%.%s'`, suffix))
}
return "(" + strings.Join(clauses, " OR ") + ")"
}, func(pattern string) string {
// Only the package-owned MIME glob constants above reach this function.
return pgSearchMIME + ` LIKE '` + strings.ReplaceAll(pattern, "*", "%") + `'`
})
func (s *PostgreSQL) SearchPathsInDomainWithOptions(ctx context.Context, domainUUID, scope, query string, limit int, allowed func(string) bool, options SearchOptions) (found []SearchResult, err error) {
if err := options.Validate(); err != nil {
return nil, err
}
scope, query = normalizePath(scope), strings.TrimSpace(query)
if allowed == nil || query == "" && !options.HasFilters() {
return nil, nil
}
if len(query) > 512 || len(strings.Fields(query)) > 16 {
return nil, errors.New("search query is too long")
}
if limit <= 0 || limit > 200 {
limit = 100
}
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
defer func() {
if ctx.Err() != nil {
found, err = nil, ctx.Err()
}
}()
var args []any
bind := func(v any) string { args = append(args, v); return fmt.Sprintf("$%d", len(args)) }
prefix := strings.TrimRight(scope, "/") + "/"
upper := prefix[:len(prefix)-1] + "0"
predicate := "p.domain_uuid=" + bind(domainUUID) + " AND (p.path=" + bind(scope) + " OR (p.path>=" + bind(prefix) + " AND p.path<" + bind(upper) + "))"
if query != "" {
q := bind(query)
predicate += " AND (strpos(lower(p.path),lower(" + q + "))>0 OR strpos(lower(COALESCE(r.filename,'')),lower(" + q + "))>0)"
}
date := "r.created_at_ms"
if options.DateField == "created" {
date = "(SELECT o.created_at*1000 FROM objects o WHERE o.uuid=p.object_uuid)"
}
if options.FromMS != nil {
predicate += " AND " + date + ">=" + bind(*options.FromMS)
}
if options.BeforeMS != nil {
predicate += " AND " + date + "<" + bind(*options.BeforeMS)
}
if options.Extension != "" {
ext := bind("." + options.Extension)
predicate += " AND right(" + searchFilenameSQL + ",length(" + ext + "))=" + ext
}
if options.FileType != "" {
predicate += " AND (" + pgSearchFileType + ")=" + bind(options.FileType)
}
rows, err := s.db.QueryContext(ctx, `SELECT p.path,COALESCE(r.content_type,''),COALESCE(r.filename,''),COALESCE(r.document_hash,''),COALESCE(r.uuid,''),COALESCE(r.created_at_ms/1000,0)
FROM paths p LEFT JOIN LATERAL (SELECT uuid,content_type,filename,document_hash,created_at_ms FROM revisions WHERE object_uuid=p.object_uuid ORDER BY created_at_ms DESC,uuid DESC LIMIT 1) r ON true
WHERE `+predicate+` ORDER BY p.path LIMIT `+bind(SearchCandidateLimit), args...)
if err != nil {
return nil, err
}
candidates := make([]SearchResult, 0)
for rows.Next() {
var result SearchResult
if err = rows.Scan(&result.Path, &result.ContentType, &result.Filename, &result.DocumentHash, &result.RevisionUUID, &result.UpdatedAt); err != nil {
rows.Close()
return nil, err
}
result.PathMatch = query != "" && strings.Contains(strings.ToLower(result.Path), strings.ToLower(query))
result.FilenameMatch = query != "" && strings.Contains(strings.ToLower(result.Filename), strings.ToLower(query))
candidates = append(candidates, result)
}
err = rows.Err()
rows.Close()
if err != nil {
return nil, err
}
// Release the cursor before policy callbacks: authorization may need the
// same single-connection pool. Never return a denied Path or load its body.
sort.Slice(candidates, func(i, j int) bool {
if len(candidates[i].Path) != len(candidates[j].Path) {
return len(candidates[i].Path) < len(candidates[j].Path)
}
return candidates[i].Path < candidates[j].Path
})
for _, candidate := range candidates {
if err = ctx.Err(); err != nil {
return nil, err
}
if allowed(candidate.Path) {
found = append(found, candidate)
if len(found) == limit {
break
}
}
}
return found, nil
}
func (s *PostgreSQL) SearchPathSuggestionsInDomain(ctx context.Context, domainUUID, scope, query string, limit int, allowed func(string) bool) ([]PathSuggestion, error) {
results, err := s.SearchPathsInDomainWithOptions(ctx, domainUUID, scope, query, limit, allowed, SearchOptions{})
if err != nil {
return nil, err
}
out := make([]PathSuggestion, 0, len(results))
for _, result := range results {
out = append(out, PathSuggestion{SearchResult: result})
}
return out, nil
}
+12 -4
View File
@@ -71,18 +71,25 @@ func searchSuffixesSQL(suffixes ...string) string {
// known suffix (e.g. a Python source uploaded as text/plain); unrecognized,
// specific MIME types stay Other instead of pretending to be a different type.
// This uses metadata only and never hydrates a Document to sniff its bytes.
var searchFileTypeSQL = `CASE
var searchFileTypeSQL = buildSearchFileTypeSQL(searchMIMESQL, searchSuffixesSQL, func(pattern string) string {
return searchMIMESQL + ` GLOB '` + pattern + `'`
})
// All patterns are package-owned constants. The dialect-specific builders do
// not translate incoming SQL or interpolate user input.
func buildSearchFileTypeSQL(searchMIMESQL string, searchSuffixesSQL func(...string) string, mimeGlob func(string) string) string {
return `CASE
WHEN ` + searchMIMESQL + ` IN ('text/html','application/xhtml+xml') THEN 'html'
WHEN ` + searchMIMESQL + `='application/pdf' THEN 'pdf'
WHEN ` + searchMIMESQL + ` LIKE 'image/%' THEN 'image'
WHEN ` + searchMIMESQL + ` LIKE 'audio/%' THEN 'audio'
WHEN ` + searchMIMESQL + ` LIKE 'video/%' THEN 'video'
WHEN ` + searchMIMESQL + ` IN ('text/csv','application/csv','text/tab-separated-values') THEN 'csv'
WHEN ` + searchMIMESQL + ` IN ('application/json','text/json') OR ` + searchMIMESQL + ` GLOB '*+json' THEN 'json'
WHEN ` + searchMIMESQL + ` IN ('application/json','text/json') OR ` + mimeGlob("*+json") + ` THEN 'json'
WHEN ` + searchMIMESQL + ` IN ('application/zip','application/x-zip-compressed','application/x-7z-compressed','application/vnd.rar','application/x-rar','application/x-rar-compressed','application/x-tar','application/gzip','application/x-gzip','application/x-xz','application/x-bzip2','application/zstd','application/x-zstd','application/x-compress','application/x-cpio') THEN 'archive'
WHEN ` + searchMIMESQL + ` IN ('application/msword','application/vnd.ms-excel','application/vnd.ms-powerpoint','application/rtf','text/rtf') OR ` + searchMIMESQL + ` GLOB 'application/vnd.openxmlformats-officedocument.*' OR ` + searchMIMESQL + ` GLOB 'application/vnd.oasis.opendocument.*' OR ` + searchMIMESQL + ` GLOB 'application/vnd.ms-*.macroenabled.*' THEN 'office'
WHEN ` + searchMIMESQL + ` IN ('application/msword','application/vnd.ms-excel','application/vnd.ms-powerpoint','application/rtf','text/rtf') OR ` + mimeGlob("application/vnd.openxmlformats-officedocument.*") + ` OR ` + mimeGlob("application/vnd.oasis.opendocument.*") + ` OR ` + mimeGlob("application/vnd.ms-*.macroenabled.*") + ` THEN 'office'
WHEN ` + searchMIMESQL + ` IN ('text/markdown','text/x-markdown') THEN 'text'
WHEN ` + searchMIMESQL + ` IN ('application/javascript','application/x-javascript','text/javascript','application/typescript','text/typescript','application/xml','text/xml','application/yaml','application/x-yaml','text/yaml','application/toml','application/x-sh','application/x-shellscript','application/x-python','application/x-python-code','application/x-httpd-php','application/sql','text/css') OR ` + searchMIMESQL + ` GLOB 'text/x-*' OR ` + searchMIMESQL + ` GLOB '*+xml' THEN 'code'
WHEN ` + searchMIMESQL + ` IN ('application/javascript','application/x-javascript','text/javascript','application/typescript','text/typescript','application/xml','text/xml','application/yaml','application/x-yaml','text/yaml','application/toml','application/x-sh','application/x-shellscript','application/x-python','application/x-python-code','application/x-httpd-php','application/sql','text/css') OR ` + mimeGlob("text/x-*") + ` OR ` + mimeGlob("*+xml") + ` THEN 'code'
WHEN ` + searchMIMESQL + ` NOT IN ('','text/plain','application/octet-stream','binary/octet-stream','application/x-empty') THEN CASE WHEN ` + searchMIMESQL + ` LIKE 'text/%' THEN 'text' ELSE 'other' END
WHEN ` + searchSuffixesSQL("html", "htm", "xhtml") + ` THEN 'html'
WHEN ` + searchSuffixesSQL("pdf") + ` THEN 'pdf'
@@ -96,6 +103,7 @@ var searchFileTypeSQL = `CASE
WHEN ` + searchSuffixesSQL("py", "pyw", "sh", "bash", "zsh", "fish", "ps1", "bat", "cmd", "js", "mjs", "cjs", "jsx", "ts", "tsx", "go", "rs", "c", "h", "cpp", "hpp", "cc", "cs", "java", "kt", "kts", "swift", "rb", "php", "pl", "pm", "lua", "r", "sql", "css", "scss", "sass", "less", "xml", "xsl", "yaml", "yml", "toml", "ini", "conf", "vue", "svelte", "dart", "ex", "exs", "erl", "hs", "scala", "clj", "lisp", "el", "vim", "wasm") + ` THEN 'code'
WHEN ` + searchMIMESQL + `='text/plain' OR ` + searchSuffixesSQL("txt", "text", "log", "md", "markdown", "rst", "adoc", "org") + ` THEN 'text'
ELSE 'other' END`
}
// The returned predicate is inserted before each candidate stream's LIMIT,
// including FTS-first streams. Filtering after their cap silently loses hits.
+88
View File
@@ -0,0 +1,88 @@
package metadata
import (
"context"
"database/sql"
"errors"
"strings"
"time"
"github.com/google/uuid"
)
type Asset struct {
DomainUUID string
Address string
ObjectUUID string
HeadDocumentHash string
ContentType string
Filename string
SizeBytes int64
CreatedAtMS int64
UpdatedAtMS int64
}
const assetColumns = `domain_uuid,address,object_uuid,head_document_hash,content_type,filename,size_bytes,created_at_ms,updated_at_ms`
func scanAsset(row interface{ Scan(...any) error }) (Asset, error) {
var a Asset
err := row.Scan(&a.DomainUUID, &a.Address, &a.ObjectUUID, &a.HeadDocumentHash, &a.ContentType, &a.Filename, &a.SizeBytes, &a.CreatedAtMS, &a.UpdatedAtMS)
return a, err
}
func (r *Repository) GetAsset(ctx context.Context, domain, address string) (Asset, error) {
a, err := scanAsset(r.database.QueryRowContext(ctx, `SELECT `+assetColumns+` FROM assets WHERE domain_uuid=`+r.p(1)+` AND address=`+r.p(2), domain, address))
return a, r.failure(err)
}
// PutAsset publishes an already-durable Document hash and appends its audit
// history in the same transaction. Empty expected is create-only; overwrites
// compare the previous hash and keep the asset's object UUID stable.
func (r *Repository) PutAsset(ctx context.Context, a Asset, expected, actor string) (Asset, error) {
a.Address = strings.TrimSpace(a.Address)
parts := strings.SplitN(a.Address, ":", 3)
if a.DomainUUID == "" || len(parts) != 3 || parts[0] != "asset" || strings.TrimSpace(parts[1]) == "" || strings.TrimSpace(parts[2]) == "" || strings.ContainsAny(a.Address, "\x00\r\n") || !validHash(a.HeadDocumentHash) || strings.TrimSpace(a.ContentType) == "" || a.SizeBytes < 0 {
return Asset{}, ErrInvalid
}
err := r.write(ctx, "domain/"+a.DomainUUID, func(tx *sql.Tx) error {
old, err := scanAsset(tx.QueryRowContext(ctx, `SELECT `+assetColumns+` FROM assets WHERE domain_uuid=`+r.p(1)+` AND address=`+r.p(2), a.DomainUUID, a.Address))
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return r.failure(err)
}
if old.HeadDocumentHash != expected {
return ErrConflict
}
if r.applicationNamespace && err == nil && old.HeadDocumentHash == a.HeadDocumentHash && old.ContentType == a.ContentType && old.Filename == a.Filename && old.SizeBytes == a.SizeBytes {
a = old
return nil
}
a.UpdatedAtMS = time.Now().UnixMilli()
if err == nil {
a.ObjectUUID = old.ObjectUUID
a.CreatedAtMS = old.CreatedAtMS
if a.UpdatedAtMS <= old.UpdatedAtMS {
a.UpdatedAtMS = old.UpdatedAtMS + 1
}
_, err = tx.ExecContext(ctx, `UPDATE assets SET head_document_hash=`+r.p(1)+`,content_type=`+r.p(2)+`,filename=`+r.p(3)+`,size_bytes=`+r.p(4)+`,updated_at_ms=`+r.p(5)+` WHERE domain_uuid=`+r.p(6)+` AND address=`+r.p(7), a.HeadDocumentHash, a.ContentType, a.Filename, a.SizeBytes, a.UpdatedAtMS, a.DomainUUID, a.Address)
} else {
a.ObjectUUID = uuid.NewString()
a.CreatedAtMS = a.UpdatedAtMS
if _, err = tx.ExecContext(ctx, `INSERT INTO objects(uuid,kind,created_at) VALUES (`+r.p(1)+`,'asset',`+r.p(2)+`)`, a.ObjectUUID, a.CreatedAtMS/1000); err != nil {
return r.failure(err)
}
if _, err = tx.ExecContext(ctx, `INSERT INTO object_origins(object_uuid,domain_uuid,created_at) VALUES (`+r.p(1)+`,`+r.p(2)+`,`+r.p(3)+`)`, a.ObjectUUID, a.DomainUUID, a.CreatedAtMS/1000); err != nil {
return r.failure(err)
}
_, err = tx.ExecContext(ctx, `INSERT INTO assets (`+assetColumns+`) VALUES (`+r.p(1)+`,`+r.p(2)+`,`+r.p(3)+`,`+r.p(4)+`,`+r.p(5)+`,`+r.p(6)+`,`+r.p(7)+`,`+r.p(8)+`,`+r.p(9)+`)`, a.DomainUUID, a.Address, a.ObjectUUID, a.HeadDocumentHash, a.ContentType, a.Filename, a.SizeBytes, a.CreatedAtMS, a.UpdatedAtMS)
}
if err != nil {
return r.failure(err)
}
_, err = tx.ExecContext(ctx, `INSERT INTO asset_head_history(domain_uuid,address,action,document_hash,content_type,filename,size_bytes,actor_uuid,created_at_ms) VALUES (`+r.p(1)+`,`+r.p(2)+`,'put',`+r.p(3)+`,`+r.p(4)+`,`+r.p(5)+`,`+r.p(6)+`,`+r.p(7)+`,`+r.p(8)+`)`, a.DomainUUID, a.Address, a.HeadDocumentHash, a.ContentType, a.Filename, a.SizeBytes, actor, a.UpdatedAtMS)
return r.failure(err)
})
if err != nil {
return Asset{}, err
}
return a, nil
}
+115
View File
@@ -0,0 +1,115 @@
package metadata
import (
"bytes"
"context"
"crypto/sha256"
"encoding/hex"
"errors"
"fmt"
"mime"
"pageswiki/internal/documentrefs"
"pageswiki/internal/geduldh"
)
type SavedDocument struct {
Revision Revision
Payload []byte
}
// RestoreDocument preserves the historical immutable embedded references; it
// must not parse Asset provenance and rebind it to today's mutable Asset HEAD.
func (r *Repository) RestoreDocument(ctx context.Context, documents geduldh.Store, domain, revision, expected, message, actor string) (Revision, error) {
if documents == nil {
return Revision{}, ErrInvalid
}
v, err := r.GetRevision(ctx, domain, revision)
if err != nil {
return Revision{}, err
}
refs, err := r.revisionReferences(ctx, domain, revision)
if err != nil {
return Revision{}, err
}
for _, hash := range append([]string{v.DocumentHash}, refs...) {
if err := documents.Verify(ctx, hash); err != nil {
return Revision{}, fmt.Errorf("verify restored Document: %w", err)
}
}
v.Message = message
return r.appendRevision(ctx, domain, v, expected, refs, actor)
}
// SaveDocument freezes Domain-local Asset HEADs, verifies embedded payloads,
// persists the immutable Document, then atomically publishes Revision, refs and
// outbox. No SQL transaction/lock is held during filesystem or remote I/O.
// A failed metadata commit may leave an unreferenced immutable blob; it must
// never delete that blob (another writer may already reference the same hash).
// Concurrent GC needs a separate pin protocol before this pipeline is enabled
// in a deployment with background deletion. This is not an authorization API.
func (r *Repository) SaveDocument(ctx context.Context, documents geduldh.Store, domain string, v Revision, payload []byte, expected, actor string) (SavedDocument, error) {
return r.saveDocument(ctx, documents, domain, v, payload, &expected, actor)
}
// SaveDocumentUnconditionally preserves append-without-CAS semantics for import
// and legacy clients. Concurrent saves still append immutable revisions with
// monotonic timestamps; it must not be used to silently retry a failed CAS.
func (r *Repository) SaveDocumentUnconditionally(ctx context.Context, documents geduldh.Store, domain string, v Revision, payload []byte, actor string) (SavedDocument, error) {
return r.saveDocument(ctx, documents, domain, v, payload, nil, actor)
}
func (r *Repository) saveDocument(ctx context.Context, documents geduldh.Store, domain string, v Revision, payload []byte, expected *string, actor string) (SavedDocument, error) {
if documents == nil {
return SavedDocument{}, ErrInvalid
}
lang, err := normalizedLanguage(v.Language)
if err != nil {
return SavedDocument{}, err
}
v.Language = lang
if _, _, err := mime.ParseMediaType(v.ContentType); err != nil {
return SavedDocument{}, ErrInvalid
}
var bound bool
if err := r.database.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM objects o WHERE o.uuid=`+r.p(1)+` AND (`+r.objectDomainScope("o.uuid", r.p(2))+`))`, v.ObjectUUID, domain).Scan(&bound); err != nil {
return SavedDocument{}, r.failure(err)
}
if !bound {
return SavedDocument{}, ErrNotFound
}
// Fail stale saves before expensive payload work; repeat CAS in the commit
// transaction because a different writer may commit after this preflight.
head, err := r.Head(ctx, domain, v.ObjectUUID, v.Language)
if err != nil && !errors.Is(err, ErrNotFound) {
return SavedDocument{}, err
}
if expected != nil && head.UUID != *expected {
return SavedDocument{}, ErrConflict
}
frozen, refs, err := documentrefs.Freeze(ctx, payload, v.ContentType, func(ctx context.Context, address string) (string, error) {
a, err := r.GetAsset(ctx, domain, address)
if errors.Is(err, ErrNotFound) {
return "", documentrefs.ErrUnavailable
}
return a.HeadDocumentHash, err
})
if err != nil {
return SavedDocument{}, err
}
for _, hash := range refs {
if err := documents.Verify(ctx, hash); err != nil {
return SavedDocument{}, fmt.Errorf("verify embedded Document: %w", err)
}
}
sum := sha256.Sum256(frozen)
v.DocumentHash = hex.EncodeToString(sum[:])
if err := documents.PutIfAbsent(ctx, v.DocumentHash, int64(len(frozen)), bytes.NewReader(frozen)); err != nil {
return SavedDocument{}, fmt.Errorf("persist Document: %w", err)
}
created, err := r.appendRevisionExpected(ctx, domain, v, expected, refs, actor)
if err != nil {
return SavedDocument{}, err
}
return SavedDocument{Revision: created, Payload: frozen}, nil
}
+257
View File
@@ -0,0 +1,257 @@
package metadata
import (
"bytes"
"context"
"encoding/json"
"errors"
"io"
"strings"
"sync"
"testing"
"time"
"pageswiki/internal/documentrefs"
"pageswiki/internal/geduldh"
)
type faultDocuments struct {
geduldh.Store
putErr error
verifyErr error
afterPut func()
}
func (f faultDocuments) PutIfAbsent(ctx context.Context, h string, n int64, reader io.Reader) error {
if f.putErr != nil {
return f.putErr
}
if err := f.Store.PutIfAbsent(ctx, h, n, reader); err != nil {
return err
}
if f.afterPut != nil {
f.afterPut()
}
return nil
}
func (f faultDocuments) Verify(ctx context.Context, h string) error {
if f.verifyErr != nil {
return f.verifyErr
}
return f.Store.Verify(ctx, h)
}
func documentFixture(t *testing.T, r *Repository) (geduldh.Store, string, Revision) {
t.Helper()
ctx := context.Background()
documents, err := geduldh.NewLocal(t.TempDir())
if err != nil {
t.Fatal(err)
}
content := []byte("synthetic image")
h := hash(string(content))
if err := documents.PutIfAbsent(ctx, h, int64(len(content)), bytes.NewReader(content)); err != nil {
t.Fatal(err)
}
if _, err := r.PutAsset(ctx, Asset{DomainUUID: "test", Address: "asset:image:cover", HeadDocumentHash: h, ContentType: "image/png", SizeBytes: int64(len(content))}, "", "actor"); err != nil {
t.Fatal(err)
}
object, err := r.CreatePage(ctx, "test", "/guide")
if err != nil {
t.Fatal(err)
}
return documents, h, Revision{ObjectUUID: object, Language: "ja", ContentType: "text/html; charset=utf-8", Message: "synthetic save"}
}
func TestDocumentSaveReferencesOutboxAndRestore(t *testing.T) {
for _, backend := range []Backend{SQLite, PostgreSQL} {
t.Run(string(backend), func(t *testing.T) {
r := testRepository(t, backend)
ctx := context.Background()
docs, assetHash, v := documentFixture(t, r)
body := []byte(`<h1>Guide</h1><img src="asset:image:cover"><img src="asset:image:cover">`)
if _, err := r.PutAsset(ctx, Asset{DomainUUID: "private-domain", Address: "asset:image:private", HeadDocumentHash: assetHash, ContentType: "image/png", SizeBytes: 15}, "", "actor"); err != nil {
t.Fatal(err)
}
if _, err := r.SaveDocument(ctx, docs, "test", v, []byte(`<img src="asset:image:private">`), "", "actor"); !errors.Is(err, documentrefs.ErrUnavailable) {
t.Fatal("foreign Asset resolved", err)
}
first, err := r.SaveDocument(ctx, docs, "test", v, body, "", "actor")
if err != nil {
t.Fatal(err)
}
if !strings.Contains(string(first.Payload), "/_/obj/sha256:"+assetHash) {
t.Fatal("mutable URL not frozen")
}
if err := docs.Verify(ctx, first.Revision.DocumentHash); err != nil {
t.Fatal("metadata published without durable Document", err)
}
refs, err := r.revisionReferences(ctx, "test", first.Revision.UUID)
if err != nil || len(refs) != 1 || refs[0] != assetHash {
t.Fatal("embedded reference", err, refs)
}
var eventDomain, target, payload, actor string
var sequence int64
if err := r.database.QueryRowContext(ctx, `SELECT domain_uuid,target_uuid,payload,actor_uuid,sequence FROM activity_outbox`).Scan(&eventDomain, &target, &payload, &actor, &sequence); err != nil {
t.Fatal(err)
}
var envelope map[string]string
if err := json.Unmarshal([]byte(payload), &envelope); err != nil || eventDomain != "test" || actor != "actor" || sequence != 1 || target != first.Revision.UUID || envelope["document_hash"] != first.Revision.DocumentHash {
t.Fatal("outbox envelope mismatch", err)
}
newContent := []byte("next synthetic image")
newHash := hash(string(newContent))
if err := docs.PutIfAbsent(ctx, newHash, int64(len(newContent)), bytes.NewReader(newContent)); err != nil {
t.Fatal(err)
}
if _, err := r.PutAsset(ctx, Asset{DomainUUID: "test", Address: "asset:image:cover", HeadDocumentHash: newHash, ContentType: "image/png", SizeBytes: int64(len(newContent))}, assetHash, "actor"); err != nil {
t.Fatal(err)
}
second, err := r.SaveDocument(ctx, docs, "test", v, first.Payload, first.Revision.UUID, "actor")
if err != nil {
t.Fatal(err)
}
if !strings.Contains(string(second.Payload), newHash) {
t.Fatal("provenance not refreshed")
}
restored, err := r.RestoreRevision(ctx, "test", first.Revision.UUID, second.Revision.UUID, "restore")
if err != nil {
t.Fatal(err)
}
refs, err = r.revisionReferences(ctx, "test", restored.UUID)
if err != nil || len(refs) != 1 || refs[0] != assetHash || restored.DocumentHash != first.Revision.DocumentHash {
t.Fatal("restore followed new Asset HEAD instead of historical refs", err)
}
var count int
if err := r.database.QueryRowContext(ctx, `SELECT count(*) FROM activity_outbox`).Scan(&count); err != nil || count != 3 {
t.Fatal("save/restore event count", count, err)
}
})
}
}
func TestDocumentSaveFailureIsAtomic(t *testing.T) {
for _, backend := range []Backend{SQLite, PostgreSQL} {
for _, stage := range []string{"references", "outbox"} {
t.Run(string(backend)+"/"+stage, func(t *testing.T) {
r := testRepository(t, backend)
ctx := context.Background()
docs, _, v := documentFixture(t, r)
body := []byte(`<img src="asset:image:cover">`)
first, err := r.SaveDocument(ctx, docs, "test", v, body, "", "actor")
if err != nil {
t.Fatal(err)
}
ddl := `CREATE UNIQUE INDEX synthetic_save_failure ON revision_document_refs(document_hash)`
if stage == "outbox" {
ddl = `CREATE UNIQUE INDEX synthetic_save_failure ON activity_outbox(domain_uuid)`
}
if _, err := r.database.ExecContext(ctx, ddl); err != nil {
t.Fatal(err)
}
if _, err := r.SaveDocument(ctx, docs, "test", v, append([]byte(`<p>change</p>`), body...), first.Revision.UUID, "actor"); !errors.Is(err, ErrConflict) {
t.Fatal("injected error ignored", err)
}
for _, table := range []string{"revisions", "revision_document_refs", "activity_outbox"} {
var n int
if err := r.database.QueryRowContext(ctx, `SELECT count(*) FROM `+table).Scan(&n); err != nil || n != 1 {
t.Fatal("partial commit", table, n, err)
}
}
var last int64
if err := r.database.QueryRowContext(ctx, `SELECT last_sequence FROM activity_outbox_heads WHERE domain_uuid='test'`).Scan(&last); err != nil || last != 1 {
t.Fatal("sequence advanced on failure", err)
}
if _, err := r.database.ExecContext(ctx, `DROP INDEX synthetic_save_failure`); err != nil {
t.Fatal(err)
}
if _, err := r.SaveDocument(ctx, docs, "test", v, body, first.Revision.UUID, "actor"); err != nil {
t.Fatal("retry after rollback", err)
}
})
}
}
}
func TestDocumentSavePersistenceFailureAndConcurrentEdit(t *testing.T) {
for _, backend := range []Backend{SQLite, PostgreSQL} {
t.Run(string(backend), func(t *testing.T) {
r := testRepository(t, backend)
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
defer cancel()
docs, _, v := documentFixture(t, r)
body := []byte(`<img src="asset:image:cover">`)
for _, failing := range []faultDocuments{{Store: docs, putErr: io.ErrClosedPipe}, {Store: docs, verifyErr: geduldh.ErrHashMismatch}} {
if _, err := r.SaveDocument(ctx, failing, "test", v, body, "", "actor"); err == nil {
t.Fatal("Document failure ignored")
}
var n int
if err := r.database.QueryRowContext(ctx, `SELECT count(*) FROM revisions`).Scan(&n); err != nil || n != 0 {
t.Fatal("failed persistence published revision", err)
}
}
first, err := r.SaveDocument(ctx, docs, "test", v, body, "", "actor")
if err != nil {
t.Fatal(err)
}
// The callback writes using a different transaction during Document I/O.
// It would deadlock if SaveDocument held SQL locks over the payload write.
race := faultDocuments{Store: docs, afterPut: func() {
peer, _ := New(r.database, backend)
competing := v
competing.DocumentHash = first.Revision.DocumentHash
if _, err := peer.AppendRevision(ctx, "test", competing, first.Revision.UUID); err != nil {
t.Fatal("I/O held metadata lock", err)
}
}}
if _, err := r.SaveDocument(ctx, race, "test", v, []byte("<p>stale</p>"), first.Revision.UUID, "actor"); !errors.Is(err, ErrConflict) {
t.Fatal("CAS not repeated after payload I/O", err)
}
var n int
if err := r.database.QueryRowContext(ctx, `SELECT count(*) FROM activity_outbox`).Scan(&n); err != nil || n != 2 {
t.Fatal("conflicting write emitted event", err)
}
})
}
}
func TestOutboxSequenceForConcurrentObjects(t *testing.T) {
for _, backend := range []Backend{SQLite, PostgreSQL} {
t.Run(string(backend), func(t *testing.T) {
r := testRepository(t, backend)
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
defer cancel()
objects := make([]string, 6)
for i := range objects {
var err error
objects[i], err = r.CreatePage(ctx, "test", "/"+strings.Repeat("a", i+1))
if err != nil {
t.Fatal(err)
}
}
var wg sync.WaitGroup
errs := make(chan error, len(objects))
for _, id := range objects {
wg.Add(1)
go func(id string) {
defer wg.Done()
peer, _ := New(r.database, backend)
_, err := peer.AppendRevision(ctx, "test", Revision{ObjectUUID: id, DocumentHash: hash(id), ContentType: "text/html"}, "")
errs <- err
}(id)
}
wg.Wait()
close(errs)
for err := range errs {
if err != nil {
t.Fatal(err)
}
}
var count int
var min, max int64
if err := r.database.QueryRowContext(ctx, `SELECT count(*),min(sequence),max(sequence) FROM activity_outbox`).Scan(&count, &min, &max); err != nil || count != 6 || min != 1 || max != 6 {
t.Fatal("invalid concurrent sequence", count, min, max, err)
}
})
}
}
+244
View File
@@ -0,0 +1,244 @@
package metadata
import (
"context"
"crypto/sha256"
"database/sql"
"encoding/hex"
"encoding/json"
"fmt"
"sort"
"strings"
)
// A core-compatible schema is a rehearsal scope, not an application readiness
// claim. New application tables and security triggers always block core-only
// copying; unknown data must never be silently dropped as a "cache".
type PortabilityReport struct {
Scope string `json:"scope"`
ApplicationReady bool `json:"application_ready"`
CoreCompatible bool `json:"core_compatible"`
Tables []TablePortability `json:"tables"`
Blockers []string `json:"blockers"`
}
type TablePortability struct {
Name string `json:"name"`
Component string `json:"component"`
State string `json:"state"`
}
type tableSpec struct {
name string
columns []string
keys []string
identity bool
}
// Explicit columns and primary-key order define an unambiguous streaming
// fingerprint and an FK-safe copy order. Migration ledgers stay backend-local.
var coreTables = []tableSpec{
{"objects", strings.Split("uuid,kind,created_at", ","), []string{"uuid"}, false},
{"object_origins", strings.Split("object_uuid,domain_uuid,created_at", ","), []string{"object_uuid"}, false},
{"paths", strings.Split("domain_uuid,path,object_uuid,created_at,is_primary", ","), []string{"domain_uuid", "path"}, false},
{"revisions", strings.Split(revisionColumns+",created_at,body", ","), []string{"uuid"}, false},
{"assets", strings.Split(assetColumns, ","), []string{"domain_uuid", "address"}, false},
{"asset_head_history", strings.Split("id,domain_uuid,address,action,document_hash,content_type,filename,size_bytes,actor_uuid,created_at_ms", ","), []string{"id"}, true},
{"revision_document_refs", []string{"revision_uuid", "document_hash"}, []string{"revision_uuid", "document_hash"}, false},
{"activity_outbox", strings.Split("uuid,domain_uuid,sequence,event_type,actor_uuid,target_kind,target_uuid,payload,idempotency_key,status,attempts,next_attempt_ms,last_error,created_at_ms,claimed_at_ms", ","), []string{"uuid"}, false},
{"activity_outbox_heads", []string{"domain_uuid", "event_type", "last_sequence"}, []string{"domain_uuid", "event_type"}, false},
}
func componentForTable(name string) string {
for _, prefix := range []string{"auth", "principal", "group", "membership", "task", "calendar", "event", "notification", "activity", "federation", "domain", "campus", "config", "import", "resource", "adapter", "user", "profile", "contact", "feed", "periodical", "search", "locality", "city"} {
if strings.HasPrefix(name, prefix) {
return prefix
}
}
if name == "zones" || name == "spots" || strings.HasPrefix(name, "spot_") || strings.HasPrefix(name, "street_") || name == "topology_events" {
return "city"
}
return "unclassified"
}
func (r *Repository) InspectPortability(ctx context.Context) (PortabilityReport, error) {
tx, err := r.database.BeginTx(ctx, &sql.TxOptions{ReadOnly: true, Isolation: sql.LevelRepeatableRead})
if err != nil {
return PortabilityReport{}, r.failure(err)
}
defer tx.Rollback()
return r.inspectPortability(ctx, tx)
}
func (r *Repository) inspectPortability(ctx context.Context, tx *sql.Tx) (PortabilityReport, error) {
report := PortabilityReport{Scope: "portable-core-rehearsal-only", Tables: []TablePortability{}, Blockers: []string{}}
known := map[string]tableSpec{}
for _, s := range coreTables {
known[s.name] = s
}
query := `SELECT name,type FROM sqlite_master WHERE type IN ('table','view','trigger') AND substr(name,1,7)!='sqlite_' ORDER BY name`
if r.backend == PostgreSQL {
query = `SELECT c.relname,CASE WHEN c.relkind IN ('r','p') THEN 'table' ELSE 'view' END FROM pg_class c JOIN pg_namespace n ON n.oid=c.relnamespace WHERE n.nspname=current_schema() AND c.relkind IN ('r','p','v','m','f')
UNION ALL SELECT t.tgname,'trigger' FROM pg_trigger t JOIN pg_class c ON c.oid=t.tgrelid JOIN pg_namespace n ON n.oid=c.relnamespace WHERE n.nspname=current_schema() AND NOT t.tgisinternal
UNION ALL SELECT p.proname,'routine' FROM pg_proc p JOIN pg_namespace n ON n.oid=p.pronamespace WHERE n.nspname=current_schema()
UNION ALL SELECT r.rulename,'rule' FROM pg_rewrite r JOIN pg_class c ON c.oid=r.ev_class JOIN pg_namespace n ON n.oid=c.relnamespace WHERE n.nspname=current_schema() AND r.rulename!='_RETURN'
UNION ALL SELECT c.relname,'sequence' FROM pg_class c JOIN pg_namespace n ON n.oid=c.relnamespace WHERE n.nspname=current_schema() AND c.relkind='S' AND NOT EXISTS(SELECT 1 FROM pg_depend d JOIN pg_class t ON t.oid=d.refobjid JOIN pg_namespace tn ON tn.oid=t.relnamespace WHERE d.objid=c.oid AND d.classid='pg_class'::regclass AND d.refclassid='pg_class'::regclass AND tn.nspname=current_schema() AND t.relname='asset_head_history' AND d.deptype='i') ORDER BY 1`
}
rows, err := tx.QueryContext(ctx, query)
if err != nil {
return report, r.failure(err)
}
types := map[string]string{}
for rows.Next() {
var name, kind string
if err := rows.Scan(&name, &kind); err != nil {
rows.Close()
return report, r.failure(err)
}
if kind != "table" {
report.Blockers = append(report.Blockers, fmt.Sprintf("unported %s: %s", kind, name))
continue
}
types[name] = kind
}
err = rows.Err()
rows.Close()
if err != nil {
return report, r.failure(err)
}
names := make([]string, 0, len(types))
for name := range types {
names = append(names, name)
}
sort.Strings(names)
for _, name := range names {
kind := types[name]
if kind != "table" {
report.Blockers = append(report.Blockers, fmt.Sprintf("unported %s: %s", kind, name))
continue
}
if name == "schema_migration_steps" {
continue
}
item := TablePortability{Name: name, Component: componentForTable(name), State: "unported"}
if _, ok := known[name]; ok {
item.Component = "core-metadata"
item.State = "shape-pending"
} else {
report.Blockers = append(report.Blockers, "unported table: "+name)
}
report.Tables = append(report.Tables, item)
}
for _, spec := range coreTables {
if types[spec.name] != "table" {
report.Blockers = append(report.Blockers, "missing core table: "+spec.name)
}
}
if types["schema_migration_steps"] != "table" {
report.Blockers = append(report.Blockers, "missing portable migration ledger")
} else {
if err := r.inspectCoreHistory(ctx, tx, &report); err != nil {
return report, err
}
}
for i := range report.Tables {
item := &report.Tables[i]
spec, ok := known[item.Name]
if !ok {
continue
}
columns, err := r.tableColumns(ctx, tx, item.Name)
if err != nil {
return report, err
}
actual := map[string]bool{}
for _, c := range columns {
actual[c] = true
}
matches := len(actual) == len(spec.columns)
for _, c := range spec.columns {
matches = matches && actual[c]
}
if !matches {
item.State = "schema-drift"
report.Blockers = append(report.Blockers, "column mismatch: "+item.Name)
} else {
item.State = "core-shape-compatible"
}
}
if err := r.inspectCatalog(ctx, tx, &report); err != nil {
return report, err
}
sort.Strings(report.Blockers)
report.CoreCompatible = len(report.Blockers) == 0
// This core-only report does not certify full-application readiness. Use
// the Store application importer for the production migration inventory.
// ApplicationReady intentionally remains false here because non-core
// repositories, canonical files and worker state are outside this check.
return report, nil
}
func (r *Repository) tableColumns(ctx context.Context, tx *sql.Tx, table string) ([]string, error) {
query := `SELECT name FROM pragma_table_info(` + r.p(1) + `) ORDER BY cid`
if r.backend == PostgreSQL {
query = `SELECT column_name FROM information_schema.columns WHERE table_schema=current_schema() AND table_name=$1 ORDER BY ordinal_position`
}
rows, err := tx.QueryContext(ctx, query, table)
if err != nil {
return nil, r.failure(err)
}
defer rows.Close()
var out []string
for rows.Next() {
var name string
if err := rows.Scan(&name); err != nil {
return nil, r.failure(err)
}
out = append(out, name)
}
return out, r.failure(rows.Err())
}
func (r *Repository) inspectCoreHistory(ctx context.Context, tx *sql.Tx, report *PortabilityReport) error {
sqliteSteps, pgSteps := r.migrationDefinitions()
checksums := map[int]string{}
names := map[int]string{}
add := func(version int, name string, step any) {
data, _ := json.Marshal(step)
sum := sha256.Sum256(data)
checksums[version] = hex.EncodeToString(sum[:])
names[version] = name
}
for _, s := range sqliteSteps {
add(s.Version, s.Name, s)
}
for _, s := range pgSteps {
add(s.Version, s.Name, s)
}
rows, err := tx.QueryContext(ctx, `SELECT component,version,name,checksum FROM schema_migration_steps ORDER BY component,version`)
if err != nil {
return r.failure(err)
}
defer rows.Close()
applied := 0
for rows.Next() {
var component, name, checksum string
var version int
if err := rows.Scan(&component, &version, &name, &checksum); err != nil {
return r.failure(err)
}
if component != "core-metadata" {
report.Blockers = append(report.Blockers, "unported migration component: "+component)
continue
}
if version != applied+1 || names[version] != name || checksums[version] != checksum {
report.Blockers = append(report.Blockers, "portable migration history mismatch")
}
applied++
}
if err := rows.Err(); err != nil {
return r.failure(err)
}
if applied != len(checksums) {
report.Blockers = append(report.Blockers, "portable migrations are not current")
}
return nil
}
+230
View File
@@ -0,0 +1,230 @@
package metadata
import (
"context"
"database/sql"
"fmt"
"strings"
)
// Only the owned portable-core schema is certified here. Existing application
// tables are NOT adopted by translating arbitrary SQLite DDL to PostgreSQL.
func (r *Repository) inspectCatalog(ctx context.Context, tx *sql.Tx, report *PortabilityReport) error {
if r.backend == SQLite {
return r.inspectSQLiteCatalog(ctx, tx, report)
}
return r.inspectPostgreSQLCatalog(ctx, tx, report)
}
func (r *Repository) inspectSQLiteCatalog(ctx context.Context, tx *sql.Tx, report *PortabilityReport) error {
steps, _ := r.migrationDefinitions()
expected := map[string]string{}
for _, step := range steps {
for _, statement := range step.Statements {
fields := strings.Fields(statement)
if len(fields) > 2 && fields[0] == "CREATE" && (fields[1] == "TABLE" || fields[1] == "INDEX") {
name := strings.SplitN(fields[2], "(", 2)[0]
expected[name] = strings.TrimSpace(statement)
}
}
}
rows, err := tx.QueryContext(ctx, `SELECT name,type,sql FROM sqlite_master WHERE type IN ('table','index') AND sql IS NOT NULL AND name!='schema_migration_steps' AND substr(name,1,7)!='sqlite_' ORDER BY name`)
if err != nil {
return r.failure(err)
}
defer rows.Close()
seen := map[string]bool{}
for rows.Next() {
var name, kind, ddl string
if err := rows.Scan(&name, &kind, &ddl); err != nil {
return r.failure(err)
}
if wanted, ok := expected[name]; ok {
seen[name] = true
if wanted != strings.TrimSpace(ddl) {
report.Blockers = append(report.Blockers, "catalog mismatch: "+name)
}
} else if kind == "index" {
report.Blockers = append(report.Blockers, "unported index: "+name)
}
}
if err := rows.Err(); err != nil {
return r.failure(err)
}
for name := range expected {
if !seen[name] {
report.Blockers = append(report.Blockers, "missing catalog object: "+name)
}
}
return nil
}
func numericColumn(column string) bool {
switch column {
case "created_at", "created_at_ms", "updated_at_ms", "is_primary", "size_bytes", "id", "sequence", "attempts", "next_attempt_ms", "claimed_at_ms", "last_sequence":
return true
}
return false
}
func (r *Repository) inspectPostgreSQLCatalog(ctx context.Context, tx *sql.Tx, report *PortabilityReport) error {
var ledgerPolicy bool
if err := tx.QueryRowContext(ctx, `SELECT COALESCE(bool_or(c.relrowsecurity OR c.relforcerowsecurity OR EXISTS(SELECT 1 FROM pg_policy p WHERE p.polrelid=c.oid)),false) FROM pg_class c JOIN pg_namespace n ON n.oid=c.relnamespace WHERE n.nspname=current_schema() AND c.relname='schema_migration_steps'`).Scan(&ledgerPolicy); err != nil {
return r.failure(err)
}
if ledgerPolicy {
report.Blockers = append(report.Blockers, "unported policy: schema_migration_steps")
}
defaults := map[string]string{
"paths.is_primary": "0", "revisions.filename": "''::text", "revisions.message": "''::text", "revisions.body": "''::text", "assets.filename": "''::text",
"activity_outbox.actor_uuid": "''::text", "activity_outbox.target_kind": "''::text", "activity_outbox.target_uuid": "''::text", "activity_outbox.payload": "''::text", "activity_outbox.status": "'pending'::text", "activity_outbox.attempts": "0", "activity_outbox.last_error": "''::text", "activity_outbox.claimed_at_ms": "0",
}
constraints := map[string][]string{
"objects": {"PRIMARY KEY (uuid)"},
"object_origins": {"PRIMARY KEY (object_uuid)", "FOREIGN KEY (object_uuid) REFERENCES objects(uuid)"},
"paths": {"PRIMARY KEY (domain_uuid, path)", "FOREIGN KEY (object_uuid) REFERENCES objects(uuid)"},
"revisions": {"PRIMARY KEY (uuid)", "FOREIGN KEY (object_uuid) REFERENCES objects(uuid)"},
"assets": {"PRIMARY KEY (domain_uuid, address)", "UNIQUE (object_uuid)", "FOREIGN KEY (object_uuid) REFERENCES objects(uuid)", "CHECK ((size_bytes >= 0))"},
"asset_head_history": {"PRIMARY KEY (id)", "CHECK ((size_bytes >= 0))"},
"revision_document_refs": {"PRIMARY KEY (revision_uuid, document_hash)", "FOREIGN KEY (revision_uuid) REFERENCES revisions(uuid)"},
"activity_outbox": {"PRIMARY KEY (uuid)", "UNIQUE (domain_uuid, sequence)", "UNIQUE (domain_uuid, idempotency_key)"},
"activity_outbox_heads": {"PRIMARY KEY (domain_uuid, event_type)"},
}
identityTablePresent := false
for _, spec := range coreTables {
var ordinary bool
if err := tx.QueryRowContext(ctx, `SELECT c.relkind='r' AND c.relpersistence='p' AND NOT c.relrowsecurity AND NOT c.relforcerowsecurity AND NOT EXISTS(SELECT 1 FROM pg_policy p WHERE p.polrelid=c.oid) AND NOT EXISTS(SELECT 1 FROM pg_inherits x WHERE x.inhrelid=c.oid OR x.inhparent=c.oid) FROM pg_class c JOIN pg_namespace n ON n.oid=c.relnamespace WHERE n.nspname=current_schema() AND c.relname=$1`, spec.name).Scan(&ordinary); err != nil {
if err == sql.ErrNoRows {
report.Blockers = append(report.Blockers, "missing table: "+spec.name)
continue
}
return r.failure(err)
}
if !ordinary {
report.Blockers = append(report.Blockers, "unported policy or table mode: "+spec.name)
}
if spec.identity {
identityTablePresent = true
}
rows, err := tx.QueryContext(ctx, `SELECT a.attname,format_type(a.atttypid,a.atttypmod),a.attnotnull,COALESCE(pg_get_expr(d.adbin,d.adrelid),''),a.attidentity,a.attgenerated,COALESCE(col.collname,'') FROM pg_attribute a JOIN pg_class c ON c.oid=a.attrelid JOIN pg_namespace n ON n.oid=c.relnamespace LEFT JOIN pg_attrdef d ON d.adrelid=a.attrelid AND d.adnum=a.attnum LEFT JOIN pg_collation col ON col.oid=a.attcollation WHERE n.nspname=current_schema() AND c.relname=$1 AND a.attnum>0 AND NOT a.attisdropped`, spec.name)
if err != nil {
return r.failure(err)
}
for rows.Next() {
var name, kind, def, identity, generated, collation string
var required bool
if err := rows.Scan(&name, &kind, &required, &def, &identity, &generated, &collation); err != nil {
rows.Close()
return r.failure(err)
}
wantType := "text"
if numericColumn(name) {
wantType = "bigint"
}
if name == "is_primary" || name == "attempts" {
wantType = "integer"
}
wantIdentity := ""
if spec.identity && name == "id" {
wantIdentity = "a"
}
wantCollation := ""
if wantType == "text" {
wantCollation = "default"
}
if spec.name == "paths" && name == "path" || spec.name == "assets" && name == "address" {
wantCollation = "C"
}
if kind != wantType || !required || def != defaults[spec.name+"."+name] || identity != wantIdentity || generated != "" || collation != wantCollation {
report.Blockers = append(report.Blockers, fmt.Sprintf("column contract mismatch: %s.%s", spec.name, name))
}
}
err = rows.Err()
rows.Close()
if err != nil {
return r.failure(err)
}
rows, err = tx.QueryContext(ctx, `SELECT pg_get_constraintdef(c.oid),c.convalidated,c.condeferrable,c.condeferred FROM pg_constraint c JOIN pg_class t ON t.oid=c.conrelid JOIN pg_namespace n ON n.oid=t.relnamespace WHERE n.nspname=current_schema() AND t.relname=$1`, spec.name)
if err != nil {
return r.failure(err)
}
wanted := map[string]bool{}
for _, s := range constraints[spec.name] {
wanted[s] = true
}
actual := map[string]bool{}
matches := true
constraintCount := 0
for rows.Next() {
constraintCount++
var def string
var valid, deferable, deferred bool
if err := rows.Scan(&def, &valid, &deferable, &deferred); err != nil {
rows.Close()
return r.failure(err)
}
actual[def] = true
matches = matches && valid && !deferable && !deferred && wanted[def]
}
err = rows.Err()
rows.Close()
if err != nil {
return r.failure(err)
}
if !matches || len(actual) != len(wanted) || constraintCount != len(wanted) {
report.Blockers = append(report.Blockers, "constraint contract mismatch: "+spec.name)
}
}
var schema string
if err := tx.QueryRowContext(ctx, `SELECT quote_ident(current_schema())`).Scan(&schema); err != nil {
return r.failure(err)
}
indexes := map[string]string{
"idx_paths_domain_object": "paths USING btree (domain_uuid, object_uuid)",
"idx_revisions_metadata_head": "revisions USING btree (object_uuid, lang, created_at_ms DESC, uuid DESC)",
"idx_asset_metadata_history": "asset_head_history USING btree (domain_uuid, address, id)",
"idx_metadata_document_refs": "revision_document_refs USING btree (document_hash, revision_uuid)",
"idx_metadata_outbox_pending": "activity_outbox USING btree (status, next_attempt_ms, domain_uuid, sequence)",
}
rows, err := tx.QueryContext(ctx, `SELECT i.relname,pg_get_indexdef(i.oid),x.indisvalid,x.indisready FROM pg_index x JOIN pg_class i ON i.oid=x.indexrelid JOIN pg_class t ON t.oid=x.indrelid JOIN pg_namespace n ON n.oid=t.relnamespace WHERE n.nspname=current_schema() AND t.relname!='schema_migration_steps' AND NOT EXISTS(SELECT 1 FROM pg_constraint con WHERE con.conindid=i.oid)`)
if err != nil {
return r.failure(err)
}
defer rows.Close()
seen := map[string]bool{}
for rows.Next() {
var name, def string
var valid, ready bool
if err := rows.Scan(&name, &def, &valid, &ready); err != nil {
return r.failure(err)
}
suffix, ok := indexes[name]
if !ok {
report.Blockers = append(report.Blockers, "unported index: "+name)
continue
}
seen[name] = true
if def != "CREATE INDEX "+name+" ON "+schema+"."+suffix || !valid || !ready {
report.Blockers = append(report.Blockers, "index contract mismatch: "+name)
}
}
if err := rows.Err(); err != nil {
return r.failure(err)
}
for name := range indexes {
if !seen[name] {
report.Blockers = append(report.Blockers, "missing index: "+name)
}
}
var sequenceMatches bool
if identityTablePresent {
err = tx.QueryRowContext(ctx, `SELECT seqstart=1 AND seqincrement=1 AND seqmin=1 AND seqmax=9223372036854775807 AND seqcache=1 AND NOT seqcycle FROM pg_sequence WHERE seqrelid=pg_get_serial_sequence('asset_head_history','id')::regclass`).Scan(&sequenceMatches)
}
if err != nil && err != sql.ErrNoRows {
return r.failure(err)
}
if !sequenceMatches {
report.Blockers = append(report.Blockers, "identity sequence contract mismatch: asset_head_history.id")
}
return nil
}
@@ -0,0 +1,69 @@
package metadata
import (
"context"
"testing"
)
func TestPortabilityRejectsIndexDrift(t *testing.T) {
for _, backend := range []Backend{SQLite, PostgreSQL} {
for _, change := range []string{"missing", "wrong", "extra"} {
t.Run(string(backend)+"/"+change, func(t *testing.T) {
r := testRepository(t, backend)
ctx := context.Background()
if change != "extra" {
if _, err := r.database.ExecContext(ctx, `DROP INDEX idx_paths_domain_object`); err != nil {
t.Fatal(err)
}
}
if change == "wrong" {
if _, err := r.database.ExecContext(ctx, `CREATE INDEX idx_paths_domain_object ON paths(object_uuid)`); err != nil {
t.Fatal(err)
}
}
if change == "extra" {
if _, err := r.database.ExecContext(ctx, `CREATE UNIQUE INDEX unported_unique_rule ON paths(object_uuid)`); err != nil {
t.Fatal(err)
}
}
report, err := r.InspectPortability(ctx)
if err != nil || report.CoreCompatible {
t.Fatal("index drift accepted", err, report)
}
})
}
}
}
func TestPostgreSQLPortabilityRejectsContractDrift(t *testing.T) {
changes := map[string]string{
"type": `ALTER TABLE assets ALTER COLUMN size_bytes TYPE INTEGER`,
"default": `ALTER TABLE revisions ALTER COLUMN message SET DEFAULT 'different'`,
"nullable": `ALTER TABLE revisions ALTER COLUMN content_type DROP NOT NULL`,
"foreign-key": `ALTER TABLE paths DROP CONSTRAINT paths_object_uuid_fkey`,
"collation": `ALTER TABLE paths ALTER COLUMN path TYPE TEXT COLLATE "default"`,
"identity-mode": `ALTER TABLE asset_head_history ALTER COLUMN id SET GENERATED BY DEFAULT`,
"identity-drop": `ALTER TABLE asset_head_history ALTER COLUMN id DROP IDENTITY`,
"missing-table": `DROP TABLE asset_head_history`,
"identity-step": `ALTER TABLE asset_head_history ALTER COLUMN id SET INCREMENT BY 7`,
"rls": `ALTER TABLE objects ENABLE ROW LEVEL SECURITY`,
"ledger-rls": `ALTER TABLE schema_migration_steps ENABLE ROW LEVEL SECURITY`,
"routine": `CREATE FUNCTION unported_routine() RETURNS INTEGER LANGUAGE SQL AS 'SELECT 1'`,
"sequence": `CREATE SEQUENCE unported_counter`,
"rule": `CREATE RULE unported_rule AS ON DELETE TO paths DO INSTEAD NOTHING`,
"duplicate-fk": `ALTER TABLE paths ADD CONSTRAINT duplicate_fk FOREIGN KEY (object_uuid) REFERENCES objects(uuid)`,
}
for name, q := range changes {
t.Run(name, func(t *testing.T) {
r := testRepository(t, PostgreSQL)
ctx := context.Background()
if _, err := r.database.ExecContext(ctx, q); err != nil {
t.Fatal(err)
}
report, err := r.InspectPortability(ctx)
if err != nil || report.CoreCompatible {
t.Fatal("contract drift accepted", err, report)
}
})
}
}
+471
View File
@@ -0,0 +1,471 @@
package metadata
import (
"context"
"crypto/sha256"
"database/sql"
"encoding/binary"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
hashpkg "hash"
"math"
"os"
"strconv"
"strings"
"unicode/utf8"
"pageswiki/internal/geduldh"
)
var (
ErrMigrationBlocked = errors.New("metadata migration blocked; inspect portability report")
ErrDestinationNotEmpty = errors.New("metadata migration destination is not empty")
ErrIntegrity = errors.New("metadata integrity check failed")
)
type TableFingerprint struct {
Table string `json:"table"`
Rows int64 `json:"rows"`
SHA256 string `json:"sha256"`
}
type CoreSnapshot struct {
Scope string `json:"scope"`
Tables []TableFingerprint `json:"tables"`
IdentityNext int64 `json:"asset_history_identity_next"`
SHA256 string `json:"sha256"`
}
type RehearsalOptions struct {
// Caller asserts that all writers and GC are stopped for both instances.
// A SQL snapshot alone is not a cross-store or online migration protocol.
Offline bool
Documents geduldh.Store
}
// CloneCoreForRehearsal copies only a compatible portable core into an already
// initialized, empty staging schema. It is deliberately not a production
// migration entry point. Unknown tables/triggers/views/columns/ledger entries
// block copying rather than silently losing application data or permissions.
// Canonical payloads are verified in the caller's retained Document store;
// calendar files, secrets, application configuration and blobs are NOT copied.
func CloneCoreForRehearsal(ctx context.Context, source, destination *Repository, options RehearsalOptions) (CoreSnapshot, error) {
if !options.Offline || options.Documents == nil || source == nil || destination == nil || source.database == destination.database {
return CoreSnapshot{}, ErrMigrationBlocked
}
if same, err := sameDatabase(ctx, source, destination); err != nil {
return CoreSnapshot{}, err
} else if same {
return CoreSnapshot{}, ErrMigrationBlocked
}
src, err := source.database.BeginTx(ctx, &sql.TxOptions{ReadOnly: true, Isolation: sql.LevelRepeatableRead})
if err != nil {
return CoreSnapshot{}, source.failure(err)
}
defer src.Rollback()
report, err := source.inspectPortability(ctx, src)
if err != nil {
return CoreSnapshot{}, err
}
if !report.CoreCompatible {
return CoreSnapshot{}, ErrMigrationBlocked
}
if err := source.verifyCoreRelations(ctx, src); err != nil {
return CoreSnapshot{}, err
}
// Reject an occupied/incompatible destination before verifying a large
// Document store. Recheck while holding destination locks before copying.
preflight, err := destination.database.BeginTx(ctx, &sql.TxOptions{ReadOnly: true, Isolation: sql.LevelRepeatableRead})
if err != nil {
return CoreSnapshot{}, destination.failure(err)
}
err = destination.checkEmpty(ctx, preflight)
_ = preflight.Rollback()
if err != nil {
return CoreSnapshot{}, err
}
if err := source.verifyDocuments(ctx, src, options.Documents); err != nil {
return CoreSnapshot{}, err
}
var result CoreSnapshot
err = destination.write(ctx, "migration/portable-core-rehearsal", func(dst *sql.Tx) error {
if destination.backend == PostgreSQL {
// Lock all tables, not just a cooperative advisory key: an accidental
// concurrent writer must not race the empty-destination check.
names := []string{`"schema_migration_steps"`}
for _, s := range coreTables {
names = append(names, quote(s.name))
}
if _, err := dst.ExecContext(ctx, `LOCK TABLE `+strings.Join(names, ",")+` IN ACCESS EXCLUSIVE MODE`); err != nil {
return destination.failure(err)
}
}
if err := destination.checkEmpty(ctx, dst); err != nil {
return err
}
var expected []TableFingerprint
for _, spec := range coreTables {
fingerprint, err := source.streamTable(ctx, src, spec, func(values []any) error {
marks := make([]string, len(values))
for i := range values {
marks[i] = destination.p(i + 1)
}
q := `INSERT INTO ` + quote(spec.name) + ` (` + quoted(spec.columns) + `)`
if spec.identity && destination.backend == PostgreSQL {
q += ` OVERRIDING SYSTEM VALUE`
}
_, err := dst.ExecContext(ctx, q+` VALUES (`+strings.Join(marks, ",")+`)`, values...)
return destination.failure(err)
})
if err != nil {
return err
}
expected = append(expected, fingerprint)
}
if err := destination.verifyCoreRelations(ctx, dst); err != nil {
return err
}
next, err := source.identityNext(ctx, src)
if err != nil {
return err
}
if err := destination.restoreIdentity(ctx, dst, next); err != nil {
return err
}
actual, err := destination.fingerprint(ctx, dst)
if err != nil {
return err
}
want := snapshot(expected, next)
if want.SHA256 != actual.SHA256 {
return ErrIntegrity
}
result = actual
return nil
})
if err != nil {
return CoreSnapshot{}, err
}
return result, nil
}
// FingerprintCore reads a single snapshot and never mutates the database. It
// identifies metadata content, not a backup of canonical payloads or secrets.
func (r *Repository) FingerprintCore(ctx context.Context) (CoreSnapshot, error) {
tx, err := r.database.BeginTx(ctx, &sql.TxOptions{ReadOnly: true, Isolation: sql.LevelRepeatableRead})
if err != nil {
return CoreSnapshot{}, r.failure(err)
}
defer tx.Rollback()
report, err := r.inspectPortability(ctx, tx)
if err != nil {
return CoreSnapshot{}, err
}
if !report.CoreCompatible {
return CoreSnapshot{}, ErrMigrationBlocked
}
if err := r.verifyCoreRelations(ctx, tx); err != nil {
return CoreSnapshot{}, err
}
return r.fingerprint(ctx, tx)
}
func (r *Repository) fingerprint(ctx context.Context, tx *sql.Tx) (CoreSnapshot, error) {
var tables []TableFingerprint
for _, spec := range coreTables {
f, err := r.streamTable(ctx, tx, spec, nil)
if err != nil {
return CoreSnapshot{}, err
}
tables = append(tables, f)
}
next, err := r.identityNext(ctx, tx)
if err != nil {
return CoreSnapshot{}, err
}
return snapshot(tables, next), nil
}
func snapshot(tables []TableFingerprint, next int64) CoreSnapshot {
data, _ := json.Marshal(struct {
Tables []TableFingerprint
IdentityNext int64
}{tables, next})
sum := sha256.Sum256(data)
return CoreSnapshot{Scope: "portable-core-rehearsal-only", Tables: tables, IdentityNext: next, SHA256: hex.EncodeToString(sum[:])}
}
func quote(s string) string { return `"` + strings.ReplaceAll(s, `"`, `""`) + `"` }
func quoted(names []string) string {
parts := make([]string, len(names))
for i, n := range names {
parts[i] = quote(n)
}
return strings.Join(parts, ",")
}
func frame(h hashpkg.Hash, data []byte) {
var size [8]byte
binary.BigEndian.PutUint64(size[:], uint64(len(data)))
h.Write(size[:])
h.Write(data)
}
func (r *Repository) streamTable(ctx context.Context, tx *sql.Tx, spec tableSpec, consume func([]any) error) (TableFingerprint, error) {
order := make([]string, len(spec.keys))
for i, k := range spec.keys {
order[i] = quote(k)
if !spec.identity {
if r.backend == PostgreSQL {
order[i] += ` COLLATE "C"`
} else {
order[i] += ` COLLATE BINARY`
}
}
}
rows, err := tx.QueryContext(ctx, `SELECT `+quoted(spec.columns)+` FROM `+quote(spec.name)+` ORDER BY `+strings.Join(order, ","))
if err != nil {
return TableFingerprint{}, r.failure(err)
}
defer rows.Close()
h := sha256.New()
frame(h, []byte(spec.name))
data, _ := json.Marshal(spec.columns)
frame(h, data)
var count int64
for rows.Next() {
if err := ctx.Err(); err != nil {
return TableFingerprint{}, err
}
values := make([]any, len(spec.columns))
pointers := make([]any, len(values))
for i := range values {
pointers[i] = &values[i]
}
if err := rows.Scan(pointers...); err != nil {
return TableFingerprint{}, r.failure(err)
}
for i, v := range values {
numeric := numericColumn(spec.columns[i])
switch value := v.(type) {
case string:
if numeric {
return TableFingerprint{}, fmt.Errorf("%w: noninteger in %s.%s", ErrIntegrity, spec.name, spec.columns[i])
}
if !utf8.ValidString(value) || strings.ContainsRune(value, 0) {
return TableFingerprint{}, fmt.Errorf("%w: nonportable text in %s.%s", ErrIntegrity, spec.name, spec.columns[i])
}
if (spec.columns[i] == "document_hash" || spec.columns[i] == "head_document_hash") && !validHash(value) {
return TableFingerprint{}, fmt.Errorf("%w: invalid hash in %s", ErrIntegrity, spec.name)
}
case int64:
if !numeric {
return TableFingerprint{}, fmt.Errorf("%w: nontext in %s.%s", ErrIntegrity, spec.name, spec.columns[i])
}
default:
return TableFingerprint{}, fmt.Errorf("%w: unsupported value type in %s.%s", ErrIntegrity, spec.name, spec.columns[i])
}
}
data, err := json.Marshal(values)
if err != nil {
return TableFingerprint{}, ErrIntegrity
}
frame(h, data)
if consume != nil {
if err := consume(values); err != nil {
return TableFingerprint{}, err
}
}
count++
}
if err := rows.Err(); err != nil {
return TableFingerprint{}, r.failure(err)
}
return TableFingerprint{Table: spec.name, Rows: count, SHA256: hex.EncodeToString(h.Sum(nil))}, nil
}
func (r *Repository) verifyCoreRelations(ctx context.Context, tx *sql.Tx) error {
checks := []struct{ name, query string }{
{"object origin", `SELECT 1 FROM objects o WHERE NOT EXISTS(SELECT 1 FROM object_origins x WHERE x.object_uuid=o.uuid) LIMIT 1`},
{"origin object", `SELECT 1 FROM object_origins x WHERE NOT EXISTS(SELECT 1 FROM objects o WHERE o.uuid=x.object_uuid) LIMIT 1`},
{"path object", `SELECT 1 FROM paths p WHERE NOT EXISTS(SELECT 1 FROM objects o WHERE o.uuid=p.object_uuid) LIMIT 1`},
{"revision object", `SELECT 1 FROM revisions r WHERE NOT EXISTS(SELECT 1 FROM objects o WHERE o.uuid=r.object_uuid) LIMIT 1`},
{"asset object", `SELECT 1 FROM assets a WHERE NOT EXISTS(SELECT 1 FROM objects o WHERE o.uuid=a.object_uuid) LIMIT 1`},
{"revision reference", `SELECT 1 FROM revision_document_refs x WHERE NOT EXISTS(SELECT 1 FROM revisions r WHERE r.uuid=x.revision_uuid) LIMIT 1`},
{"outbox watermark", `SELECT 1 FROM activity_outbox o WHERE o.sequence<1 OR NOT EXISTS(SELECT 1 FROM activity_outbox_heads h WHERE h.domain_uuid=o.domain_uuid AND h.event_type=o.event_type AND h.last_sequence>=o.sequence) LIMIT 1`},
{"revision event", `SELECT 1 FROM activity_outbox o WHERE o.event_type='revision.created' AND NOT EXISTS(SELECT 1 FROM revisions r WHERE r.uuid=o.target_uuid) LIMIT 1`},
{"asset history id", `SELECT 1 FROM asset_head_history WHERE id<1 LIMIT 1`},
}
for _, check := range checks {
var found int
err := tx.QueryRowContext(ctx, check.query).Scan(&found)
if err == nil {
return fmt.Errorf("%w: %s", ErrIntegrity, check.name)
}
if !errors.Is(err, sql.ErrNoRows) {
return r.failure(err)
}
}
return nil
}
func (r *Repository) verifyDocuments(ctx context.Context, tx *sql.Tx, documents geduldh.Store) error {
rows, err := tx.QueryContext(ctx, `SELECT document_hash FROM revisions UNION SELECT head_document_hash FROM assets UNION SELECT document_hash FROM asset_head_history UNION SELECT document_hash FROM revision_document_refs ORDER BY 1`)
if err != nil {
return r.failure(err)
}
defer rows.Close()
for rows.Next() {
var hash string
if err := rows.Scan(&hash); err != nil {
return r.failure(err)
}
if !validHash(hash) {
return ErrIntegrity
}
if err := documents.Verify(ctx, hash); err != nil {
if ctx.Err() != nil {
return ctx.Err()
}
return fmt.Errorf("%w: Document verification failed", ErrIntegrity)
}
}
return r.failure(rows.Err())
}
func (r *Repository) checkEmpty(ctx context.Context, tx *sql.Tx) error {
report, err := r.inspectPortability(ctx, tx)
if err != nil {
return err
}
if !report.CoreCompatible {
return ErrMigrationBlocked
}
for _, s := range coreTables {
var occupied bool
if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM `+quote(s.name)+`)`).Scan(&occupied); err != nil {
return r.failure(err)
}
if occupied {
return ErrDestinationNotEmpty
}
}
return nil
}
func (r *Repository) identityNext(ctx context.Context, tx *sql.Tx) (int64, error) {
var max sql.NullInt64
if err := tx.QueryRowContext(ctx, `SELECT max(id) FROM asset_head_history`).Scan(&max); err != nil {
return 0, r.failure(err)
}
if max.Int64 < 0 || max.Int64 == math.MaxInt64 {
return 0, ErrIntegrity
}
next := max.Int64 + 1
if r.backend == SQLite {
var seq sql.NullInt64
if err := tx.QueryRowContext(ctx, `SELECT max(seq) FROM sqlite_sequence WHERE name='asset_head_history'`).Scan(&seq); err != nil {
return 0, r.failure(err)
}
if seq.Int64 < 0 || seq.Int64 == math.MaxInt64 {
return 0, ErrIntegrity
}
if seq.Int64+1 > next {
next = seq.Int64 + 1
}
} else {
var schema, name string
if err := tx.QueryRowContext(ctx, `SELECT n.nspname,c.relname FROM pg_class c JOIN pg_namespace n ON n.oid=c.relnamespace WHERE c.oid=pg_get_serial_sequence('asset_head_history','id')::regclass`).Scan(&schema, &name); err != nil {
return 0, r.failure(err)
}
var last int64
var called bool
if err := tx.QueryRowContext(ctx, `SELECT last_value,is_called FROM `+quote(schema)+`.`+quote(name)).Scan(&last, &called); err != nil {
return 0, r.failure(err)
}
if last < 1 || last == math.MaxInt64 {
return 0, ErrIntegrity
}
if called {
last++
}
if last > next {
next = last
}
}
return next, nil
}
func (r *Repository) restoreIdentity(ctx context.Context, tx *sql.Tx, next int64) error {
if next < 1 {
return ErrIntegrity
}
if r.backend == PostgreSQL {
// RESTART rolls back with the transaction; setval would not.
_, err := tx.ExecContext(ctx, `ALTER TABLE asset_head_history ALTER COLUMN id RESTART WITH `+strconv.FormatInt(next, 10))
return r.failure(err)
}
result, err := tx.ExecContext(ctx, `UPDATE sqlite_sequence SET seq=? WHERE name='asset_head_history'`, next-1)
if err != nil {
return r.failure(err)
}
n, err := result.RowsAffected()
if err != nil {
return r.failure(err)
}
if n == 0 {
_, err = tx.ExecContext(ctx, `INSERT INTO sqlite_sequence(name,seq) VALUES ('asset_head_history',?)`, next-1)
}
return r.failure(err)
}
func sameDatabase(ctx context.Context, a, b *Repository) (bool, error) {
if a.backend != b.backend {
return false, nil
}
if a.backend == SQLite {
path := func(r *Repository) (string, error) {
var seq int
var name, file string
err := r.database.QueryRowContext(ctx, `SELECT seq,name,file FROM pragma_database_list WHERE name='main'`).Scan(&seq, &name, &file)
if err != nil {
return "", r.failure(err)
}
if file == "" {
return "", ErrMigrationBlocked
}
return file, nil
}
x, err := path(a)
if err != nil {
return false, err
}
y, err := path(b)
if err != nil {
return false, err
}
xInfo, err := os.Stat(x)
if err != nil {
return false, ErrMigrationBlocked
}
yInfo, err := os.Stat(y)
if err != nil {
return false, ErrMigrationBlocked
}
return os.SameFile(xInfo, yInfo), nil
}
type identity struct{ database, schema, start string }
read := func(r *Repository) (identity, error) {
var i identity
err := r.database.QueryRowContext(ctx, `SELECT current_database(),current_schema(),extract(epoch from pg_postmaster_start_time())::text`).Scan(&i.database, &i.schema, &i.start)
return i, r.failure(err)
}
x, err := read(a)
if err != nil {
return false, err
}
y, err := read(b)
if err != nil {
return false, err
}
return x == y, nil
}
+321
View File
@@ -0,0 +1,321 @@
package metadata
import (
"context"
"errors"
"net/url"
"os"
"strings"
"testing"
"time"
"pageswiki/internal/db"
"pageswiki/internal/geduldh"
)
func TestPortabilityIsFailClosed(t *testing.T) {
for _, backend := range []Backend{SQLite, PostgreSQL} {
for _, change := range []string{"table", "view", "column", "history", "component"} {
t.Run(string(backend)+"/"+change, func(t *testing.T) {
r := testRepository(t, backend)
ctx := context.Background()
report, err := r.InspectPortability(ctx)
if err != nil || !report.CoreCompatible || report.ApplicationReady {
t.Fatal("fresh core readiness", err, report)
}
q := map[string]string{
"table": `CREATE TABLE auth_private_users(secret TEXT)`,
"view": `CREATE VIEW private_view AS SELECT uuid FROM objects`,
"column": `ALTER TABLE objects ADD COLUMN unexpected TEXT`,
"history": `UPDATE schema_migration_steps SET checksum='tampered' WHERE version=1`,
"component": `INSERT INTO schema_migration_steps(component,version,name,checksum,applied_at_ms) VALUES ('future',1,'other','unknown',1)`,
}[change]
if _, err := r.database.ExecContext(ctx, q); err != nil {
t.Fatal(err)
}
report, err = r.InspectPortability(ctx)
if err != nil || report.CoreCompatible || len(report.Blockers) == 0 {
t.Fatal("unsupported state accepted", err, report)
}
if _, err := r.FingerprintCore(ctx); !errors.Is(err, ErrMigrationBlocked) {
t.Fatal("unsupported state fingerprinted as portable", err)
}
})
}
}
}
func TestPortabilityDoesNotHideSameNamedTrigger(t *testing.T) {
r := testRepository(t, SQLite)
ctx := context.Background()
if _, err := r.database.ExecContext(ctx, `CREATE TRIGGER objects AFTER UPDATE ON objects BEGIN SELECT 1; END`); err != nil {
t.Fatal(err)
}
report, err := r.InspectPortability(ctx)
if err != nil || report.CoreCompatible {
t.Fatal("security trigger hidden by table name", err)
}
if !strings.Contains(strings.Join(report.Blockers, " "), "trigger: objects") {
t.Fatal("trigger not identified", report)
}
}
func seedRehearsal(t *testing.T, r *Repository) (geduldh.Store, Revision) {
t.Helper()
ctx := context.Background()
docs, _, v := documentFixture(t, r)
first, err := r.SaveDocument(ctx, docs, "test", v, []byte(`<h1>移行</h1><img src="asset:image:cover">`), "", "actor")
if err != nil {
t.Fatal(err)
}
if err := r.BindPath(ctx, "test", "/alias", v.ObjectUUID); err != nil {
t.Fatal(err)
}
for _, path := range []string{"/日本語%_", "/Case", "/case", "/é", "/e\u0301"} {
if err := r.BindPath(ctx, "test", path, v.ObjectUUID); err != nil {
t.Fatal(err)
}
}
// Values above JavaScript's safe-integer range must never pass through
// float64 on the migration path. Also exercise identity/sequence recovery.
const large = int64(9007199254741011)
if _, err := r.database.ExecContext(ctx, `UPDATE asset_head_history SET id=`+r.p(1), large); err != nil {
t.Fatal(err)
}
if _, err := r.database.ExecContext(ctx, `UPDATE activity_outbox SET sequence=`+r.p(1)+`,status='failed',attempts=3,last_error='synthetic'`, large); err != nil {
t.Fatal(err)
}
if _, err := r.database.ExecContext(ctx, `UPDATE activity_outbox_heads SET last_sequence=`+r.p(1), large); err != nil {
t.Fatal(err)
}
return docs, first.Revision
}
func TestCoreFingerprintIncludesContentAndPurgedIdentity(t *testing.T) {
source := testRepository(t, SQLite)
target := testRepository(t, SQLite)
ctx := context.Background()
docs, v := seedRehearsal(t, source)
before, err := source.FingerprintCore(ctx)
if err != nil {
t.Fatal(err)
}
if _, err := source.database.ExecContext(ctx, `UPDATE objects SET kind='changed' WHERE uuid=?`, v.ObjectUUID); err != nil {
t.Fatal(err)
}
after, err := source.FingerprintCore(ctx)
if err != nil || after.SHA256 == before.SHA256 {
t.Fatal("same row counts hid content change", err)
}
// A retained generator high-water mark must survive even if the highest
// history rows have been purged. Reusing an old history URL is not safe.
if _, err := source.database.ExecContext(ctx, `UPDATE sqlite_sequence SET seq=9007199254741999 WHERE name='asset_head_history'`); err != nil {
t.Fatal(err)
}
result, err := CloneCoreForRehearsal(ctx, source, target, RehearsalOptions{Offline: true, Documents: docs})
if err != nil || result.IdentityNext != 9007199254742000 {
t.Fatal("purged sequence lost", err, result.IdentityNext)
}
a, err := target.GetAsset(ctx, "test", "asset:image:cover")
if err != nil {
t.Fatal(err)
}
if _, err := target.PutAsset(ctx, a, a.HeadDocumentHash, "actor"); err != nil {
t.Fatal(err)
}
var id int64
if err := target.database.QueryRowContext(ctx, `SELECT max(id) FROM asset_head_history`).Scan(&id); err != nil || id != result.IdentityNext {
t.Fatal("old history ID reused", err, id)
}
if _, err := source.database.ExecContext(ctx, `UPDATE objects SET created_at='not-an-integer'`); err != nil {
t.Fatal(err)
}
if _, err := source.FingerprintCore(ctx); !errors.Is(err, ErrIntegrity) {
t.Fatal("invalid integer type accepted", err)
}
}
func TestCoreRoundTripSQLitePostgreSQLSQLite(t *testing.T) {
source := testRepository(t, SQLite)
target := testRepository(t, PostgreSQL)
restored := testRepository(t, SQLite)
ctx := context.Background()
docs, first := seedRehearsal(t, source)
before, err := source.FingerprintCore(ctx)
if err != nil {
t.Fatal(err)
}
result, err := CloneCoreForRehearsal(ctx, source, target, RehearsalOptions{Offline: true, Documents: docs})
if err != nil || result.SHA256 != before.SHA256 {
t.Fatal("SQLite to PostgreSQL", err, result)
}
got, err := target.Head(ctx, "test", first.ObjectUUID, first.Language)
if err != nil || got != first {
t.Fatal("revision identity/content changed", err)
}
asset, err := target.GetAsset(ctx, "test", "asset:image:cover")
if err != nil {
t.Fatal(err)
}
asset.Filename = "new.png"
if _, err := target.PutAsset(ctx, asset, asset.HeadDocumentHash, "actor"); err != nil {
t.Fatal("identity sequence not repaired", err)
}
var id int64
if err := target.database.QueryRowContext(ctx, `SELECT max(id) FROM asset_head_history`).Scan(&id); err != nil || id != 9007199254741012 {
t.Fatal("identity precision/restart", id, err)
}
if _, err := target.database.ExecContext(ctx, `ALTER TABLE asset_head_history ALTER COLUMN id RESTART WITH 9007199254743000`); err != nil {
t.Fatal(err)
}
next, err := target.SaveDocument(ctx, docs, "test", first, []byte(`<h1>PostgreSQLで更新</h1>`), first.UUID, "actor")
if err != nil {
t.Fatal(err)
}
targetState, err := target.FingerprintCore(ctx)
if err != nil {
t.Fatal(err)
}
back, err := CloneCoreForRehearsal(ctx, target, restored, RehearsalOptions{Offline: true, Documents: docs})
if err != nil || back.SHA256 != targetState.SHA256 {
t.Fatal("PostgreSQL to SQLite", err)
}
if got, err := restored.Head(ctx, "test", first.ObjectUUID, first.Language); err != nil || got.UUID != next.Revision.UUID {
t.Fatal("post-cutover update lost on rollback", err)
}
if got, err := source.FingerprintCore(ctx); err != nil || got.SHA256 != before.SHA256 {
t.Fatal("source was modified", err)
}
if _, err := restored.PutAsset(ctx, asset, asset.HeadDocumentHash, "actor"); err != nil {
t.Fatal("SQLite sequence not recovered", err)
}
if err := restored.database.QueryRowContext(ctx, `SELECT max(id) FROM asset_head_history`).Scan(&id); err != nil || id != 9007199254743000 {
t.Fatal("PostgreSQL retained generator state lost", id, err)
}
}
func TestCoreCloneRejectsSameDatabaseThroughDifferentPools(t *testing.T) {
for _, backend := range []Backend{SQLite, PostgreSQL} {
t.Run(string(backend), func(t *testing.T) {
r := testRepository(t, backend)
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
var alias *Repository
if backend == SQLite {
var file string
if err := r.database.QueryRow(`SELECT file FROM pragma_database_list WHERE name='main'`).Scan(&file); err != nil {
t.Fatal(err)
}
database, err := db.Open(file)
if err != nil {
t.Fatal(err)
}
defer database.Close()
alias, _ = New(database, backend)
} else {
var schema string
if err := r.database.QueryRow(`SELECT current_schema()`).Scan(&schema); err != nil {
t.Fatal(err)
}
u, err := url.Parse(os.Getenv("PAGESWIKI_TEST_POSTGRES_DSN"))
if err != nil {
t.Fatal("invalid test DSN")
}
q := u.Query()
q.Set("search_path", schema)
u.RawQuery = q.Encode()
database, err := db.OpenPostgreSQL(ctx, db.PostgreSQLOptions{DSN: u.String(), AllowInsecure: true})
if err != nil {
t.Fatal(err)
}
defer database.Close()
alias, _ = New(database, backend)
}
documents, _ := geduldh.NewLocal(t.TempDir())
if _, err := CloneCoreForRehearsal(ctx, r, alias, RehearsalOptions{Offline: true, Documents: documents}); !errors.Is(err, ErrMigrationBlocked) {
t.Fatal("self-copy not rejected before locking", err)
}
})
}
}
func TestCoreCloneRejectsUnsafeConditionsAndRollsBack(t *testing.T) {
for _, backend := range []Backend{SQLite, PostgreSQL} {
t.Run(string(backend), func(t *testing.T) {
source := testRepository(t, SQLite)
target := testRepository(t, backend)
ctx := context.Background()
docs, _ := seedRehearsal(t, source)
if _, err := CloneCoreForRehearsal(ctx, source, target, RehearsalOptions{Documents: docs}); !errors.Is(err, ErrMigrationBlocked) {
t.Fatal("online migration permitted", err)
}
if _, err := CloneCoreForRehearsal(ctx, source, target, RehearsalOptions{Offline: true}); !errors.Is(err, ErrMigrationBlocked) {
t.Fatal("unverified Documents permitted", err)
}
empty, err := target.FingerprintCore(ctx)
if err != nil {
t.Fatal(err)
}
// Extra uniqueness rules must block the plan before any copying.
if _, err := target.database.ExecContext(ctx, `CREATE UNIQUE INDEX synthetic_rehearsal_failure ON paths(object_uuid)`); err != nil {
t.Fatal(err)
}
if _, err := CloneCoreForRehearsal(ctx, source, target, RehearsalOptions{Offline: true, Documents: docs}); !errors.Is(err, ErrMigrationBlocked) {
t.Fatal("unexpected unique index accepted", err)
}
if _, err := target.database.ExecContext(ctx, `DROP INDEX synthetic_rehearsal_failure`); err != nil {
t.Fatal(err)
}
if got, err := target.FingerprintCore(ctx); err != nil || got.SHA256 != empty.SHA256 {
t.Fatal("partial destination rows survived", err)
}
// SQLite can contain a BLOB despite a TEXT declaration. Detect it
// while streaming, after earlier tables have been inserted, and roll
// back every destination row instead of coercing or truncating it.
if _, err := source.database.ExecContext(ctx, `UPDATE paths SET path=CAST(path AS BLOB)`); err != nil {
t.Fatal(err)
}
if _, err := CloneCoreForRehearsal(ctx, source, target, RehearsalOptions{Offline: true, Documents: docs}); !errors.Is(err, ErrIntegrity) {
t.Fatal("nonportable row accepted", err)
}
if got, err := target.FingerprintCore(ctx); err != nil || got.SHA256 != empty.SHA256 {
t.Fatal("mid-copy failure left rows", err)
}
if _, err := source.database.ExecContext(ctx, `UPDATE paths SET path=CAST(path AS TEXT)`); err != nil {
t.Fatal(err)
}
if _, err := target.CreatePage(ctx, "test", "/do-not-overwrite"); err != nil {
t.Fatal(err)
}
occupied, err := target.FingerprintCore(ctx)
if err != nil {
t.Fatal(err)
}
if _, err := CloneCoreForRehearsal(ctx, source, target, RehearsalOptions{Offline: true, Documents: docs}); !errors.Is(err, ErrDestinationNotEmpty) {
t.Fatal("occupied destination overwritten", err)
}
if got, err := target.FingerprintCore(ctx); err != nil || got.SHA256 != occupied.SHA256 {
t.Fatal("occupied target changed", err)
}
})
}
}
func TestCoreCloneRejectsMissingDocumentsAndBrokenRelations(t *testing.T) {
r := testRepository(t, SQLite)
target := testRepository(t, SQLite)
ctx := context.Background()
docs, _ := seedRehearsal(t, r)
if _, err := r.database.ExecContext(ctx, `UPDATE paths SET object_uuid='missing'`); err != nil {
t.Fatal(err)
}
if _, err := CloneCoreForRehearsal(ctx, r, target, RehearsalOptions{Offline: true, Documents: docs}); !errors.Is(err, ErrIntegrity) {
t.Fatal("broken references copied", err)
}
r = testRepository(t, SQLite)
docs, _ = seedRehearsal(t, r)
missing, _ := geduldh.NewLocal(t.TempDir())
if _, err := CloneCoreForRehearsal(ctx, r, target, RehearsalOptions{Offline: true, Documents: missing}); !errors.Is(err, ErrIntegrity) {
t.Fatal("missing Document accepted", err)
}
}
+445
View File
@@ -0,0 +1,445 @@
// Package metadata contains the portable metadata persistence contract. It does
// not authorize requests, store payloads, run legacy Store initialization, or
// constitute a PostgreSQL-capable application. Payloads must be persisted and
// verified in Geduldh before publishing their hash here.
package metadata
import (
"context"
"crypto/sha256"
"database/sql"
"encoding/binary"
"errors"
"fmt"
"math"
"strings"
"time"
"unicode/utf8"
"github.com/google/uuid"
"github.com/jackc/pgx/v5/pgconn"
"golang.org/x/text/language"
"modernc.org/sqlite"
)
type Backend string
const (
SQLite Backend = "sqlite"
PostgreSQL Backend = "postgres"
)
var (
ErrNotFound = errors.New("metadata not found")
ErrConflict = errors.New("metadata conflict")
ErrInvalid = errors.New("invalid metadata")
)
type Repository struct {
database *sql.DB
backend Backend
applicationNamespace bool
}
// New never migrates a schema or creates keys. Ownership of database stays with
// the caller. Backend must match the actual connection; no fallback is allowed.
func New(database *sql.DB, backend Backend) (*Repository, error) {
if database == nil || (backend != SQLite && backend != PostgreSQL) {
return nil, ErrInvalid
}
return &Repository{database: database, backend: backend}, nil
}
// NewApplication uses the application's namespace/administration lock before
// the metadata Domain/Object locks. Namespace validation is repeated inside
// the commit transaction. This does not replace request authorization, perform
// migrations, or make an incomplete application Store ready to serve traffic.
func NewApplication(database *sql.DB, backend Backend) (*Repository, error) {
r, err := New(database, backend)
if err == nil {
r.applicationNamespace = true
}
return r, err
}
// p generates a placeholder, rather than rewriting arbitrary SQL (which can
// contain JSON operators, strings or comments with literal question marks).
func (r *Repository) p(n int) string {
if r.backend == PostgreSQL {
return fmt.Sprintf("$%d", n)
}
return "?"
}
func (r *Repository) failure(err error) error {
if err == nil {
return nil
}
if errors.Is(err, sql.ErrNoRows) {
return ErrNotFound
}
if errors.Is(err, context.Canceled) {
return context.Canceled
}
if errors.Is(err, context.DeadlineExceeded) {
return context.DeadlineExceeded
}
var pg *pgconn.PgError
if errors.As(err, &pg) {
if pg.Code == "23505" || pg.Code == "40001" || pg.Code == "40P01" {
return ErrConflict
}
return fmt.Errorf("PostgreSQL metadata operation failed (SQLSTATE %s)", pg.Code)
}
var se *sqlite.Error
if errors.As(err, &se) {
switch se.Code() {
case 1555, 2067:
return ErrConflict
}
return fmt.Errorf("SQLite metadata operation failed (code %d)", se.Code())
}
// Network errors may include a credential-bearing DSN or server addresses.
return errors.New("metadata database operation failed")
}
func canonicalPath(raw string) (string, error) {
p := strings.TrimSpace(raw)
if !strings.HasPrefix(p, "/") {
return "", ErrInvalid
}
if p != "/" {
p = strings.TrimRight(p, "/")
}
if p == "" || !utf8.ValidString(p) || strings.ContainsAny(p, "\x00\r\n") {
return "", ErrInvalid
}
if p != "/" {
for _, part := range strings.Split(p[1:], "/") {
if part == "" || part == "." || part == ".." {
return "", ErrInvalid
}
}
}
return p, nil
}
func validHash(hash string) bool {
if len(hash) != 64 {
return false
}
for _, c := range hash {
if !(c >= '0' && c <= '9' || c >= 'a' && c <= 'f') {
return false
}
}
return true
}
// write locks before any read. SQLite acquires its single-writer reservation;
// PostgreSQL locks a stable, namespaced key for the whole transaction. Path
// writers share a domain key; revisions additionally take an object key after
// the domain key, even when an object is bound in more than one domain.
func (r *Repository) write(ctx context.Context, key string, fn func(*sql.Tx) error) error {
tx, err := r.database.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelReadCommitted})
if err != nil {
return r.failure(err)
}
defer tx.Rollback()
if r.backend == PostgreSQL {
if r.applicationNamespace {
if _, err := tx.ExecContext(ctx, `SELECT pg_advisory_xact_lock(1885431653,1853058931)`); err != nil {
return r.failure(err)
}
}
err = r.lock(ctx, tx, key)
} else {
_, err = tx.ExecContext(ctx, `UPDATE paths SET created_at=created_at WHERE 0`)
}
if err != nil {
return r.failure(err)
}
if r.applicationNamespace {
if !strings.HasPrefix(key, "domain/") {
return ErrInvalid
}
var local bool
if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM domains d JOIN campuses c ON c.uuid=d.campus_uuid WHERE d.uuid=`+r.p(1)+` AND d.enabled=1 AND c.enabled=1 AND d.placement='local')`, strings.TrimPrefix(key, "domain/")).Scan(&local); err != nil {
return r.failure(err)
}
if !local {
return ErrNotFound
}
}
if err = fn(tx); err != nil {
return err
}
return r.failure(tx.Commit())
}
func (r *Repository) lock(ctx context.Context, tx *sql.Tx, key string) error {
if r.backend != PostgreSQL {
return nil
}
h := sha256.Sum256([]byte("pageswiki/metadata/" + key))
_, err := tx.ExecContext(ctx, `SELECT pg_advisory_xact_lock($1)`, int64(binary.BigEndian.Uint64(h[:8])))
return err
}
func (r *Repository) CreatePage(ctx context.Context, domain, path string) (string, error) {
p, err := canonicalPath(path)
if err != nil || strings.TrimSpace(domain) == "" {
return "", ErrInvalid
}
id := uuid.NewString()
err = r.write(ctx, "domain/"+domain, func(tx *sql.Tx) error {
now := time.Now().Unix()
for _, q := range []struct {
sql string
args []any
}{
{`INSERT INTO objects(uuid,kind,created_at) VALUES (` + r.p(1) + `,'page',` + r.p(2) + `)`, []any{id, now}},
{`INSERT INTO object_origins(object_uuid,domain_uuid,created_at) VALUES (` + r.p(1) + `,` + r.p(2) + `,` + r.p(3) + `)`, []any{id, domain, now}},
{`INSERT INTO paths(domain_uuid,path,object_uuid,created_at,is_primary) VALUES (` + r.p(1) + `,` + r.p(2) + `,` + r.p(3) + `,` + r.p(4) + `,1)`, []any{domain, p, id, now}},
} {
if _, err := tx.ExecContext(ctx, q.sql, q.args...); err != nil {
return r.failure(err)
}
}
if r.applicationNamespace {
return r.appendPageOutbox(ctx, tx, domain, p, id)
}
return nil
})
if err != nil {
return "", err
}
return id, nil
}
// CreateObject records provenance for the explicit create/save/bind API.
// It does not grant authority over an arbitrary unbound legacy Object.
func (r *Repository) CreateObject(ctx context.Context, domain, kind string) (string, error) {
if domain == "" || strings.TrimSpace(kind) == "" {
return "", ErrInvalid
}
id := uuid.NewString()
err := r.write(ctx, "domain/"+domain, func(tx *sql.Tx) error {
now := time.Now().Unix()
if _, err := tx.ExecContext(ctx, `INSERT INTO objects(uuid,kind,created_at) VALUES(`+r.p(1)+`,`+r.p(2)+`,`+r.p(3)+`)`, id, kind, now); err != nil {
return r.failure(err)
}
_, err := tx.ExecContext(ctx, `INSERT INTO object_origins(object_uuid,domain_uuid,created_at) VALUES(`+r.p(1)+`,`+r.p(2)+`,`+r.p(3)+`)`, id, domain, now)
return r.failure(err)
})
if err != nil {
return "", err
}
return id, nil
}
func (r *Repository) ResolvePath(ctx context.Context, domain, path string) (string, error) {
var id string
err := r.database.QueryRowContext(ctx, `SELECT object_uuid FROM paths WHERE domain_uuid=`+r.p(1)+` AND path=`+r.p(2), domain, path).Scan(&id)
return id, r.failure(err)
}
// BindPath creates an alias without replacing an existing binding. Cross-domain
// sharing requires a separate explicit authorization/import contract.
func (r *Repository) BindPath(ctx context.Context, domain, path, object string) error {
p, err := canonicalPath(path)
if err != nil || domain == "" || object == "" {
return ErrInvalid
}
return r.write(ctx, "domain/"+domain, func(tx *sql.Tx) error {
var count int
if err := tx.QueryRowContext(ctx, `SELECT count(*) FROM object_origins WHERE object_uuid=`+r.p(1)+` AND domain_uuid=`+r.p(2), object, domain).Scan(&count); err != nil {
return r.failure(err)
}
if count == 0 {
return ErrNotFound
}
_, err := tx.ExecContext(ctx, `INSERT INTO paths(domain_uuid,path,object_uuid,created_at,is_primary) VALUES (`+r.p(1)+`,`+r.p(2)+`,`+r.p(3)+`,`+r.p(4)+`,0)`, domain, p, object, time.Now().Unix())
return r.failure(err)
})
}
// RenameTree moves both real and virtual folders without LIKE wildcard or
// case-folding semantics. It does not merge into occupied destinations. City,
// ACL, activity outbox and cache invalidation must be coordinated by the future
// application-level transaction; do not substitute this for legacy UI rename yet.
func (r *Repository) RenameTree(ctx context.Context, domain, source, destination string) error {
from, e1 := canonicalPath(source)
to, e2 := canonicalPath(destination)
if e1 != nil || e2 != nil || domain == "" || from == "/" || to == "/" || from == to || strings.HasPrefix(to, from+"/") || strings.HasPrefix(from, to+"/") {
return ErrInvalid
}
return r.write(ctx, "domain/"+domain, func(tx *sql.Tx) error {
var occupied int
// Binary/C collation makes [prefix+'/', prefix+'0') an exact,
// indexable descendant range, including Unicode and literal %/_ names.
err := tx.QueryRowContext(ctx, `SELECT 1 FROM paths WHERE domain_uuid=`+r.p(1)+` AND (path=`+r.p(2)+` OR (path>=`+r.p(3)+` AND path<`+r.p(4)+`)) LIMIT 1`, domain, to, to+"/", to+"0").Scan(&occupied)
if err == nil {
return ErrConflict
}
if !errors.Is(err, sql.ErrNoRows) {
return r.failure(err)
}
// A single SQL update avoids loading the subtree or issuing one query
// per path. substr counts characters (not UTF-8 bytes) on both DBs.
result, err := tx.ExecContext(ctx, `UPDATE paths SET path=`+r.p(1)+` || substr(path,`+r.p(2)+`) WHERE domain_uuid=`+r.p(3)+` AND (path=`+r.p(4)+` OR (path>=`+r.p(5)+` AND path<`+r.p(6)+`))`, to, len([]rune(from))+1, domain, from, from+"/", from+"0")
if err != nil {
return r.failure(err)
}
count, err := result.RowsAffected()
if err != nil {
return r.failure(err)
}
if count == 0 {
return ErrNotFound
}
return nil
})
}
type Revision struct {
UUID string
ObjectUUID string
DocumentHash string
Language string
ContentType string
Filename string
Message string
CreatedAtMS int64
}
func normalizedLanguage(raw string) (string, error) {
if strings.TrimSpace(raw) == "" {
return "und", nil
}
tag, err := language.Parse(raw)
if err != nil {
return "", ErrInvalid
}
return tag.String(), nil
}
const revisionColumns = `uuid,object_uuid,document_hash,lang,content_type,filename,message,created_at_ms`
// Application create/save/bind records creation provenance before any Path.
// Provenance ceases to grant scope as soon as any live binding exists.
// Expressions are owned SQL identifiers/placeholders, never request strings.
func (r *Repository) objectDomainScope(object, domain string) string {
scope := `SELECT domain_uuid FROM paths WHERE object_uuid=` + object
if r.applicationNamespace {
scope += ` UNION ALL SELECT domain_uuid FROM object_origins WHERE object_uuid=` + object + ` AND NOT EXISTS(SELECT 1 FROM paths WHERE object_uuid=` + object + `)`
}
return domain + ` IN (` + scope + `)`
}
func scanRevision(row interface{ Scan(...any) error }) (Revision, error) {
var v Revision
err := row.Scan(&v.UUID, &v.ObjectUUID, &v.DocumentHash, &v.Language, &v.ContentType, &v.Filename, &v.Message, &v.CreatedAtMS)
return v, err
}
func (r *Repository) Head(ctx context.Context, domain, object, lang string) (Revision, error) {
l, err := normalizedLanguage(lang)
if err != nil {
return Revision{}, err
}
v, err := scanRevision(r.database.QueryRowContext(ctx, `SELECT `+revisionColumns+` FROM revisions r WHERE object_uuid=`+r.p(1)+` AND lang=`+r.p(2)+` AND (`+r.objectDomainScope("r.object_uuid", r.p(3))+`) ORDER BY created_at_ms DESC,uuid DESC LIMIT 1`, object, l, domain))
return v, r.failure(err)
}
func (r *Repository) GetRevision(ctx context.Context, domain, revisionUUID string) (Revision, error) {
v, err := scanRevision(r.database.QueryRowContext(ctx, `SELECT `+revisionColumns+` FROM revisions r WHERE uuid=`+r.p(1)+` AND (`+r.objectDomainScope("r.object_uuid", r.p(2))+`)`, revisionUUID, domain))
return v, r.failure(err)
}
// RestoreRevision appends a new revision pointing to the historical Document;
// it never rewrites old revision metadata or bypasses the exact-language CAS.
func (r *Repository) RestoreRevision(ctx context.Context, domain, revisionUUID, expected, message string) (Revision, error) {
v, err := r.GetRevision(ctx, domain, revisionUUID)
if err != nil {
return Revision{}, err
}
v.Message = message
refs, err := r.revisionReferences(ctx, domain, revisionUUID)
if err != nil {
return Revision{}, err
}
return r.appendRevision(ctx, domain, v, expected, refs, "")
}
// AppendRevision uses exact-language compare-and-swap. Empty expected means
// there is no previous revision in this language. All writes use this contract;
// monotonic timestamps remove dependence on SQLite's hidden rowid ordering.
func (r *Repository) AppendRevision(ctx context.Context, domain string, v Revision, expected string) (Revision, error) {
return r.appendRevision(ctx, domain, v, expected, nil, "")
}
func (r *Repository) appendRevision(ctx context.Context, domain string, v Revision, expected string, refs []string, actor string) (Revision, error) {
return r.appendRevisionExpected(ctx, domain, v, &expected, refs, actor)
}
func (r *Repository) appendRevisionExpected(ctx context.Context, domain string, v Revision, expected *string, refs []string, actor string) (Revision, error) {
lang, err := normalizedLanguage(v.Language)
if err != nil || !validHash(v.DocumentHash) || v.ObjectUUID == "" || strings.TrimSpace(v.ContentType) == "" {
return Revision{}, ErrInvalid
}
v.UUID = uuid.NewString()
v.Language = lang
err = r.write(ctx, "domain/"+domain, func(tx *sql.Tx) error {
// Always acquire Domain before Object. This also protects per-Domain
// outbox sequence allocation for different objects and languages.
if err := r.lock(ctx, tx, "object/"+v.ObjectUUID); err != nil {
return r.failure(err)
}
var bound bool
if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM objects o WHERE o.uuid=`+r.p(1)+` AND (`+r.objectDomainScope("o.uuid", r.p(2))+`))`, v.ObjectUUID, domain).Scan(&bound); err != nil {
return r.failure(err)
}
if !bound {
return ErrNotFound
}
var current string
var previous int64
err := tx.QueryRowContext(ctx, `SELECT uuid,created_at_ms FROM revisions WHERE object_uuid=`+r.p(1)+` AND lang=`+r.p(2)+` ORDER BY created_at_ms DESC,uuid DESC LIMIT 1`, v.ObjectUUID, lang).Scan(&current, &previous)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return r.failure(err)
}
if expected != nil && current != *expected {
return ErrConflict
}
if previous == math.MaxInt64 {
return ErrInvalid
}
v.CreatedAtMS = time.Now().UnixMilli()
if v.CreatedAtMS <= previous {
v.CreatedAtMS = previous + 1
}
_, err = tx.ExecContext(ctx, `INSERT INTO revisions(uuid,object_uuid,document_hash,lang,content_type,filename,message,created_at_ms,created_at,body) VALUES (`+r.p(1)+`,`+r.p(2)+`,`+r.p(3)+`,`+r.p(4)+`,`+r.p(5)+`,`+r.p(6)+`,`+r.p(7)+`,`+r.p(8)+`,`+r.p(9)+`,'')`, v.UUID, v.ObjectUUID, v.DocumentHash, v.Language, v.ContentType, v.Filename, v.Message, v.CreatedAtMS, v.CreatedAtMS/1000)
if err != nil {
return r.failure(err)
}
seen := map[string]bool{}
for _, hash := range refs {
if !validHash(hash) {
return ErrInvalid
}
if seen[hash] {
continue
}
seen[hash] = true
if _, err := tx.ExecContext(ctx, `INSERT INTO revision_document_refs(revision_uuid,document_hash) VALUES (`+r.p(1)+`,`+r.p(2)+`)`, v.UUID, hash); err != nil {
return r.failure(err)
}
}
return r.appendRevisionOutbox(ctx, tx, domain, actor, v)
})
if err != nil {
return Revision{}, err
}
return v, nil
}
+362
View File
@@ -0,0 +1,362 @@
package metadata
import (
"context"
"crypto/sha256"
"database/sql"
"encoding/hex"
"errors"
"net/url"
"os"
"path/filepath"
"strings"
"sync"
"testing"
"time"
"github.com/google/uuid"
"pageswiki/internal/db"
)
func testRepository(t *testing.T, backend Backend) *Repository {
t.Helper()
var database *sql.DB
var err error
if backend == SQLite {
database, err = db.Open(filepath.Join(t.TempDir(), "metadata.db"))
} else {
dsn := os.Getenv("PAGESWIKI_TEST_POSTGRES_DSN")
if dsn == "" {
t.Skip("set PAGESWIKI_TEST_POSTGRES_DSN to a disposable PostgreSQL URL")
}
u, e := url.Parse(dsn)
if e != nil || (u.Scheme != "postgres" && u.Scheme != "postgresql") {
t.Fatal("test DSN must be PostgreSQL URL")
}
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
root, e := db.OpenPostgreSQL(ctx, db.PostgreSQLOptions{DSN: dsn, AllowInsecure: true})
if e != nil {
t.Fatal(e)
}
schema := "pageswiki_metadata_test_" + strings.ReplaceAll(uuid.NewString(), "-", "")
if _, e = root.ExecContext(ctx, `CREATE SCHEMA "`+schema+`"`); e != nil {
root.Close()
t.Fatal("create synthetic test schema failed")
}
t.Cleanup(func() {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if _, e := root.ExecContext(ctx, `DROP SCHEMA "`+schema+`" CASCADE`); e != nil {
t.Error("drop synthetic test schema failed")
}
root.Close()
})
query := u.Query()
query.Set("search_path", schema)
u.RawQuery = query.Encode()
database, err = db.OpenPostgreSQL(ctx, db.PostgreSQLOptions{DSN: u.String(), AllowInsecure: true})
}
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { database.Close() })
r, err := New(database, backend)
if err != nil {
t.Fatal(err)
}
if err := r.InitializeFresh(context.Background()); err != nil {
t.Fatal(err)
}
if err := r.InitializeFresh(context.Background()); err != nil {
t.Fatal("repeated initialization", err)
}
return r
}
func hash(s string) string { v := sha256.Sum256([]byte(s)); return hex.EncodeToString(v[:]) }
func TestMetadataContract(t *testing.T) {
for _, backend := range []Backend{SQLite, PostgreSQL} {
t.Run(string(backend), func(t *testing.T) {
r := testRepository(t, backend)
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
defer cancel()
mustPage := func(domain, path string) string {
t.Helper()
id, err := r.CreatePage(ctx, domain, path)
if err != nil {
t.Fatal(err)
}
return id
}
id := mustPage("domain-a", "/学区%_/通り/本")
other := mustPage("domain-b", "/学区%_/通り/本")
if id == other {
t.Fatal("object UUID reused")
}
if got, err := r.ResolvePath(ctx, "domain-a", "/学区%_/通り/本"); err != nil || got != id {
t.Fatal("path resolution", err)
}
if _, err := r.ResolvePath(ctx, "unknown", "/学区%_/通り/本"); !errors.Is(err, ErrNotFound) {
t.Fatal("domain isolation", err)
}
if _, err := r.CreatePage(ctx, "domain-a", "/学区%_/通り/本"); !errors.Is(err, ErrConflict) {
t.Fatal("duplicate path accepted", err)
}
var count int
if err := r.database.QueryRowContext(ctx, `SELECT count(*) FROM objects`).Scan(&count); err != nil || count != 2 {
t.Fatal("failed create left orphan object", err, count)
}
if err := r.BindPath(ctx, "domain-a", "/alias", id); err != nil {
t.Fatal(err)
}
if err := r.BindPath(ctx, "domain-b", "/stolen", id); !errors.Is(err, ErrNotFound) {
t.Fatal("foreign alias accepted", err)
}
mustPage("domain-a", "/学区XX/通り/本")
mustPage("domain-a", "/学区%_suffix/本")
if err := r.RenameTree(ctx, "domain-a", "/学区%_", "/新しい学区"); err != nil {
t.Fatal("virtual folder rename", err)
}
if got, err := r.ResolvePath(ctx, "domain-a", "/新しい学区/通り/本"); err != nil || got != id {
t.Fatal("UUID not preserved", err)
}
for _, path := range []string{"/学区XX/通り/本", "/学区%_suffix/本"} {
if _, err := r.ResolvePath(ctx, "domain-a", path); err != nil {
t.Fatal("wildcard/boundary changed unrelated path", err)
}
}
if got, err := r.ResolvePath(ctx, "domain-b", "/学区%_/通り/本"); err != nil || got != other {
t.Fatal("rename crossed domain", err)
}
mustPage("domain-a", "/occupied/something")
if err := r.RenameTree(ctx, "domain-a", "/新しい学区", "/occupied"); !errors.Is(err, ErrConflict) {
t.Fatal("destination merged", err)
}
if _, err := r.ResolvePath(ctx, "domain-a", "/新しい学区/通り/本"); err != nil {
t.Fatal("failed move changed source", err)
}
if err := r.RenameTree(ctx, "domain-a", "/新しい学区", "/新しい学区/inside"); !errors.Is(err, ErrInvalid) {
t.Fatal("recursive destination accepted")
}
mustPage("domain-a", "/Case")
mustPage("domain-a", "/case")
real := mustPage("domain-a", "/real")
child := mustPage("domain-a", "/real/child")
if err := r.RenameTree(ctx, "domain-a", "/real", "/moved-real"); err != nil {
t.Fatal("real folder move", err)
}
for path, id := range map[string]string{"/moved-real": real, "/moved-real/child": child} {
if got, err := r.ResolvePath(ctx, "domain-a", path); err != nil || got != id {
t.Fatal("real subtree identity", err)
}
}
v := Revision{ObjectUUID: id, DocumentHash: hash("first"), Language: "ja", ContentType: "text/html", Message: "first"}
first, err := r.AppendRevision(ctx, "domain-a", v, "")
if err != nil {
t.Fatal(err)
}
if _, err := r.Head(ctx, "domain-b", id, "ja"); !errors.Is(err, ErrNotFound) {
t.Fatal("foreign revision readable", err)
}
if _, err := r.Head(ctx, "domain-a", id, "en"); !errors.Is(err, ErrNotFound) {
t.Fatal("language fallback leaked into exact head", err)
}
if _, err := r.AppendRevision(ctx, "domain-a", v, ""); !errors.Is(err, ErrConflict) {
t.Fatal("stale revision accepted", err)
}
v.Language = "en"
if _, err := r.AppendRevision(ctx, "domain-a", v, ""); err != nil {
t.Fatal("translation creation", err)
}
v.Language = "ja"
v.DocumentHash = hash("updated")
// Independent Repository objects simulate writers that cannot share a Go mutex.
wins := concurrent(t, 6, func() error {
peer, _ := New(r.database, backend)
_, err := peer.AppendRevision(ctx, "domain-a", v, first.UUID)
return err
})
if wins != 1 {
t.Fatal("CAS winners", wins)
}
head, err := r.Head(ctx, "domain-a", id, "ja")
if err != nil || head.UUID == first.UUID || head.CreatedAtMS <= first.CreatedAtMS {
t.Fatal("head ordering", err)
}
var originalHash string
if err := r.database.QueryRowContext(ctx, `SELECT document_hash FROM revisions WHERE uuid=`+r.p(1), first.UUID).Scan(&originalHash); err != nil || originalHash != first.DocumentHash {
t.Fatal("immutable revision changed", err)
}
if _, err := r.GetRevision(ctx, "domain-b", first.UUID); !errors.Is(err, ErrNotFound) {
t.Fatal("foreign revision UUID readable", err)
}
restored, err := r.RestoreRevision(ctx, "domain-a", first.UUID, head.UUID, "restore old document")
if err != nil || restored.UUID == first.UUID || restored.DocumentHash != first.DocumentHash || restored.CreatedAtMS <= head.CreatedAtMS {
t.Fatal("restore did not append immutable revision", err)
}
if _, err := r.RestoreRevision(ctx, "domain-a", first.UUID, head.UUID, "stale restore"); !errors.Is(err, ErrConflict) {
t.Fatal("restore ignored head conflict", err)
}
a := Asset{DomainUUID: "domain-a", Address: "asset:images:cover.png", HeadDocumentHash: hash("image1"), ContentType: "image/png", SizeBytes: 10}
initial, err := r.PutAsset(ctx, a, "", "actor")
if err != nil {
t.Fatal(err)
}
if _, err := r.GetAsset(ctx, "domain-b", a.Address); !errors.Is(err, ErrNotFound) {
t.Fatal("foreign asset readable", err)
}
a.HeadDocumentHash = hash("image2")
if wins := concurrent(t, 6, func() error {
peer, _ := New(r.database, backend)
_, err := peer.PutAsset(ctx, a, initial.HeadDocumentHash, "actor")
return err
}); wins != 1 {
t.Fatal("asset CAS winners", wins)
}
current, err := r.GetAsset(ctx, "domain-a", a.Address)
if err != nil || current.ObjectUUID != initial.ObjectUUID || current.UpdatedAtMS <= initial.UpdatedAtMS {
t.Fatal("asset identity/order", err)
}
if err := r.database.QueryRowContext(ctx, `SELECT count(*) FROM asset_head_history`).Scan(&count); err != nil || count != 2 {
t.Fatal("history not atomic", err, count)
}
a.DomainUUID = "domain-b"
if _, err := r.PutAsset(ctx, a, "", "actor"); err != nil {
t.Fatal("asset namespace not domain-scoped", err)
}
if _, err := r.AppendRevision(ctx, "domain-a", Revision{ObjectUUID: id, DocumentHash: "bad", ContentType: "text/html"}, head.UUID); !errors.Is(err, ErrInvalid) {
t.Fatal("invalid hash accepted", err)
}
canceled, stop := context.WithCancel(ctx)
stop()
if _, err := r.CreatePage(canceled, "domain-a", "/canceled"); !errors.Is(err, context.Canceled) {
t.Fatal("cancellation lost", err)
}
})
}
}
func TestMetadataInputValidation(t *testing.T) {
for _, path := range []string{"", "relative", "//", "///", "/a//b", "/a/../b", "/a/./b", "/a\x00b", "/a\nb", "/a\xffb"} {
if _, err := canonicalPath(path); !errors.Is(err, ErrInvalid) {
t.Fatalf("invalid path accepted: %q", path)
}
}
for _, path := range []string{"/", "/日本語/📚", "/name%_", "/a/b/"} {
if _, err := canonicalPath(path); err != nil {
t.Fatalf("valid path rejected: %q", path)
}
}
if _, err := New(nil, SQLite); !errors.Is(err, ErrInvalid) {
t.Fatal("nil database accepted")
}
// Do not expose data carried by a wrapped cancellation error.
r := Repository{}
err := r.failure(errors.Join(errors.New("secret"), context.Canceled))
if !errors.Is(err, context.Canceled) || strings.Contains(err.Error(), "secret") {
t.Fatal("unsafe cancellation error")
}
}
func concurrent(t *testing.T, n int, fn func() error) int {
t.Helper()
var wg sync.WaitGroup
results := make(chan error, n)
for i := 0; i < n; i++ {
wg.Add(1)
go func() { defer wg.Done(); results <- fn() }()
}
wg.Wait()
close(results)
wins := 0
for err := range results {
if err == nil {
wins++
} else if !errors.Is(err, ErrConflict) {
t.Fatal("unexpected concurrent write error", err)
}
}
return wins
}
func TestMetadataRefusesLegacyAdoption(t *testing.T) {
for _, backend := range []Backend{SQLite, PostgreSQL} {
t.Run(string(backend), func(t *testing.T) {
r := testRepository(t, backend)
ctx := context.Background()
if _, err := r.database.ExecContext(ctx, `DELETE FROM schema_migration_steps WHERE component='core-metadata'`); err != nil {
t.Fatal(err)
}
if _, err := r.CreatePage(ctx, "test", "/preserved"); err != nil {
t.Fatal(err)
}
if err := r.InitializeFresh(ctx); err == nil {
t.Fatal("unversioned schema silently adopted")
}
if _, err := r.ResolvePath(ctx, "test", "/preserved"); err != nil {
t.Fatal("existing data changed", err)
}
})
}
}
func TestMetadataAssetHistoryFailureIsAtomic(t *testing.T) {
for _, backend := range []Backend{SQLite, PostgreSQL} {
t.Run(string(backend), func(t *testing.T) {
r := testRepository(t, backend)
ctx := context.Background()
a := Asset{DomainUUID: "test", Address: "asset:images:original.png", HeadDocumentHash: hash("original"), ContentType: "image/png", SizeBytes: 8}
original, err := r.PutAsset(ctx, a, "", "actor")
if err != nil {
t.Fatal(err)
}
// Force a history write failure after the asset HEAD write. The
// synthetic unique index is solely fault injection, not the real schema.
if _, err := r.database.ExecContext(ctx, `CREATE UNIQUE INDEX synthetic_history_failure ON asset_head_history(domain_uuid)`); err != nil {
t.Fatal(err)
}
a.HeadDocumentHash = hash("changed")
if _, err := r.PutAsset(ctx, a, original.HeadDocumentHash, "actor"); !errors.Is(err, ErrConflict) {
t.Fatal("injected history failure ignored", err)
}
got, err := r.GetAsset(ctx, "test", a.Address)
if err != nil || got.HeadDocumentHash != original.HeadDocumentHash || got.UpdatedAtMS != original.UpdatedAtMS {
t.Fatal("partial HEAD update", err)
}
a.Address = "asset:images:new.png"
if _, err := r.PutAsset(ctx, a, "", "actor"); !errors.Is(err, ErrConflict) {
t.Fatal("injected creation failure ignored", err)
}
if _, err := r.GetAsset(ctx, "test", a.Address); !errors.Is(err, ErrNotFound) {
t.Fatal("partial asset created", err)
}
for _, table := range []string{"objects", "object_origins", "assets", "asset_head_history"} {
var count int
if err := r.database.QueryRowContext(ctx, `SELECT count(*) FROM `+table).Scan(&count); err != nil || count != 1 {
t.Fatal("rollback failed", table, count, err)
}
}
})
}
}
func TestMetadataDetectsMissingColumnWithoutRepair(t *testing.T) {
for _, backend := range []Backend{SQLite, PostgreSQL} {
t.Run(string(backend), func(t *testing.T) {
r := testRepository(t, backend)
ctx := context.Background()
if _, err := r.database.ExecContext(ctx, `ALTER TABLE revisions RENAME COLUMN filename TO misplaced_filename`); err != nil {
t.Fatal(err)
}
if err := r.InitializeFresh(ctx); err == nil {
t.Fatal("missing column ignored")
}
var value string
if err := r.database.QueryRowContext(ctx, `SELECT misplaced_filename FROM revisions LIMIT 1`).Scan(&value); !errors.Is(err, sql.ErrNoRows) {
t.Fatal("drift silently repaired", err)
}
})
}
}
+65
View File
@@ -0,0 +1,65 @@
package metadata
import (
"context"
"database/sql"
"encoding/json"
"math"
"time"
"github.com/google/uuid"
)
// appendRevisionOutbox requires the Domain write lock. Sequence allocation uses
// small per-type watermarks, not MAX over the ever-growing event journal.
// This writes pending events only; delivery/leases remain a separate port.
func (r *Repository) appendRevisionOutbox(ctx context.Context, tx *sql.Tx, domain, actor string, v Revision) error {
payload, err := json.Marshal(map[string]string{"revision_uuid": v.UUID, "object_uuid": v.ObjectUUID, "document_hash": v.DocumentHash, "content_type": v.ContentType, "filename": v.Filename})
if err != nil {
return ErrInvalid
}
return r.appendOutbox(ctx, tx, domain, actor, "revision.created", "revision", v.UUID, string(payload))
}
func (r *Repository) appendPageOutbox(ctx context.Context, tx *sql.Tx, domain, path, object string) error {
payload, err := json.Marshal(map[string]string{"path": path, "object_uuid": object})
if err != nil {
return ErrInvalid
}
return r.appendOutbox(ctx, tx, domain, "", "page.created", "page", object, string(payload))
}
// Caller holds the Domain lock; metadata and the pending event commit together.
func (r *Repository) appendOutbox(ctx context.Context, tx *sql.Tx, domain, actor, eventType, targetKind, targetUUID, payload string) error {
var last int64
if err := tx.QueryRowContext(ctx, `SELECT COALESCE(MAX(last_sequence),0) FROM activity_outbox_heads WHERE domain_uuid=`+r.p(1), domain).Scan(&last); err != nil {
return r.failure(err)
}
if last == math.MaxInt64 {
return ErrInvalid
}
now := time.Now().UnixMilli()
_, err := tx.ExecContext(ctx, `INSERT INTO activity_outbox(uuid,domain_uuid,sequence,event_type,actor_uuid,target_kind,target_uuid,payload,idempotency_key,next_attempt_ms,created_at_ms) VALUES (`+r.p(1)+`,`+r.p(2)+`,`+r.p(3)+`,`+r.p(4)+`,`+r.p(5)+`,`+r.p(6)+`,`+r.p(7)+`,`+r.p(8)+`,`+r.p(9)+`,`+r.p(10)+`,`+r.p(11)+`)`, uuid.NewString(), domain, last+1, eventType, actor, targetKind, targetUUID, payload, eventType+":"+targetUUID, now, now)
if err != nil {
return r.failure(err)
}
_, err = tx.ExecContext(ctx, `INSERT INTO activity_outbox_heads(domain_uuid,event_type,last_sequence) VALUES (`+r.p(1)+`,`+r.p(2)+`,`+r.p(3)+`) ON CONFLICT(domain_uuid,event_type) DO UPDATE SET last_sequence=excluded.last_sequence`, domain, eventType, last+1)
return r.failure(err)
}
func (r *Repository) revisionReferences(ctx context.Context, domain, revisionUUID string) ([]string, error) {
rows, err := r.database.QueryContext(ctx, `SELECT document_hash FROM revision_document_refs WHERE revision_uuid=`+r.p(1)+` AND EXISTS (SELECT 1 FROM revisions r WHERE r.uuid=`+r.p(2)+` AND (`+r.objectDomainScope("r.object_uuid", r.p(3))+`)) ORDER BY document_hash`, revisionUUID, revisionUUID, domain)
if err != nil {
return nil, r.failure(err)
}
defer rows.Close()
var hashes []string
for rows.Next() {
var h string
if err := rows.Scan(&h); err != nil {
return nil, r.failure(err)
}
hashes = append(hashes, h)
}
return hashes, r.failure(rows.Err())
}
+75
View File
@@ -0,0 +1,75 @@
package metadata
import (
"context"
"pageswiki/internal/db"
)
// InitializeFresh bootstraps an empty database/schema and is idempotent after
// its first successful migration. Existing unversioned application tables are
// deliberately rejected, not adopted or converted. Production import and
// legacy schema reconciliation require a separate, verified migration plan.
func (r *Repository) InitializeFresh(ctx context.Context) error {
sqliteSteps, postgresSteps := r.migrationDefinitions()
if r.backend == PostgreSQL {
return db.ApplyPostgreSQLMigrations(ctx, r.database, "core-metadata", postgresSteps)
}
return db.ApplySQLiteMigrations(ctx, r.database, "core-metadata", sqliteSteps)
}
// Keep the exact released definitions shared by initialization and offline
// compatibility inspection. Neither inspection nor copying runs migrations.
func (r *Repository) migrationDefinitions() ([]db.SQLMigration, []db.PostgreSQLMigration) {
identity := "INTEGER PRIMARY KEY AUTOINCREMENT"
addressType := "TEXT"
if r.backend == PostgreSQL {
identity = "BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY"
// Path/asset identity must not depend on database locale or an ICU
// nondeterministic collation chosen by the database administrator.
addressType = `TEXT COLLATE "C"`
}
statements := []string{
`CREATE TABLE objects(uuid TEXT PRIMARY KEY,kind TEXT NOT NULL,created_at BIGINT NOT NULL)`,
`CREATE TABLE object_origins(object_uuid TEXT PRIMARY KEY REFERENCES objects(uuid),domain_uuid TEXT NOT NULL,created_at BIGINT NOT NULL)`,
`CREATE TABLE paths(domain_uuid TEXT NOT NULL,path ` + addressType + ` NOT NULL,object_uuid TEXT NOT NULL REFERENCES objects(uuid),created_at BIGINT NOT NULL,is_primary INTEGER NOT NULL DEFAULT 0,PRIMARY KEY(domain_uuid,path))`,
`CREATE INDEX idx_paths_domain_object ON paths(domain_uuid,object_uuid)`,
`CREATE TABLE revisions(uuid TEXT PRIMARY KEY,object_uuid TEXT NOT NULL REFERENCES objects(uuid),document_hash TEXT NOT NULL,lang TEXT NOT NULL,content_type TEXT NOT NULL,filename TEXT NOT NULL DEFAULT '',message TEXT NOT NULL DEFAULT '',created_at_ms BIGINT NOT NULL,created_at BIGINT NOT NULL,body TEXT NOT NULL DEFAULT '')`,
`CREATE INDEX idx_revisions_metadata_head ON revisions(object_uuid,lang,created_at_ms DESC,uuid DESC)`,
`CREATE TABLE assets(domain_uuid TEXT NOT NULL,address ` + addressType + ` NOT NULL,object_uuid TEXT NOT NULL UNIQUE REFERENCES objects(uuid),head_document_hash TEXT NOT NULL,content_type TEXT NOT NULL,filename TEXT NOT NULL DEFAULT '',size_bytes BIGINT NOT NULL CHECK(size_bytes>=0),created_at_ms BIGINT NOT NULL,updated_at_ms BIGINT NOT NULL,PRIMARY KEY(domain_uuid,address))`,
`CREATE TABLE asset_head_history(id ` + identity + `,domain_uuid TEXT NOT NULL,address TEXT NOT NULL,action TEXT NOT NULL,document_hash TEXT NOT NULL,content_type TEXT NOT NULL,filename TEXT NOT NULL,size_bytes BIGINT NOT NULL CHECK(size_bytes>=0),actor_uuid TEXT NOT NULL,created_at_ms BIGINT NOT NULL)`,
`CREATE INDEX idx_asset_metadata_history ON asset_head_history(domain_uuid,address,id)`,
}
// Minimal shape checks also run on subsequent initialization. Full catalog
// assertions for types, collation, constraints and indexes are a separate
// adoption gate before this schema can replace a legacy production store.
assertions := []string{
`SELECT uuid,kind,created_at FROM objects WHERE 1=0`,
`SELECT object_uuid,domain_uuid,created_at FROM object_origins WHERE 1=0`,
`SELECT domain_uuid,path,object_uuid,created_at,is_primary FROM paths WHERE 1=0`,
`SELECT ` + revisionColumns + `,created_at,body FROM revisions WHERE 1=0`,
`SELECT ` + assetColumns + ` FROM assets WHERE 1=0`,
`SELECT id,domain_uuid,address,action,document_hash,content_type,filename,size_bytes,actor_uuid,created_at_ms FROM asset_head_history WHERE 1=0`,
}
referenceStatements := []string{
`CREATE TABLE revision_document_refs(revision_uuid TEXT NOT NULL REFERENCES revisions(uuid),document_hash TEXT NOT NULL,PRIMARY KEY(revision_uuid,document_hash))`,
`CREATE INDEX idx_metadata_document_refs ON revision_document_refs(document_hash,revision_uuid)`,
`CREATE TABLE activity_outbox(uuid TEXT PRIMARY KEY,domain_uuid TEXT NOT NULL,sequence BIGINT NOT NULL,event_type TEXT NOT NULL,actor_uuid TEXT NOT NULL DEFAULT '',target_kind TEXT NOT NULL DEFAULT '',target_uuid TEXT NOT NULL DEFAULT '',payload TEXT NOT NULL DEFAULT '',idempotency_key TEXT NOT NULL,status TEXT NOT NULL DEFAULT 'pending',attempts INTEGER NOT NULL DEFAULT 0,next_attempt_ms BIGINT NOT NULL,last_error TEXT NOT NULL DEFAULT '',created_at_ms BIGINT NOT NULL,claimed_at_ms BIGINT NOT NULL DEFAULT 0,UNIQUE(domain_uuid,sequence),UNIQUE(domain_uuid,idempotency_key))`,
`CREATE TABLE activity_outbox_heads(domain_uuid TEXT NOT NULL,event_type TEXT NOT NULL,last_sequence BIGINT NOT NULL,PRIMARY KEY(domain_uuid,event_type))`,
`CREATE INDEX idx_metadata_outbox_pending ON activity_outbox(status,next_attempt_ms,domain_uuid,sequence)`,
}
currentAssertions := append(append([]string(nil), assertions...),
`SELECT revision_uuid,document_hash FROM revision_document_refs WHERE 1=0`,
`SELECT uuid,domain_uuid,sequence,event_type,actor_uuid,target_kind,target_uuid,payload,idempotency_key,status,attempts,next_attempt_ms,last_error,created_at_ms,claimed_at_ms FROM activity_outbox WHERE 1=0`,
`SELECT domain_uuid,event_type,last_sequence FROM activity_outbox_heads WHERE 1=0`)
if r.backend == PostgreSQL {
return nil, []db.PostgreSQLMigration{
{Version: 1, Name: "initial portable core", Statements: statements, Assertions: assertions},
{Version: 2, Name: "revision references and outbox", Statements: referenceStatements, Assertions: currentAssertions},
}
}
return []db.SQLMigration{
{Version: 1, Name: "initial portable core", Statements: statements, Assertions: assertions},
{Version: 2, Name: "revision references and outbox", Statements: referenceStatements, Assertions: currentAssertions},
}, nil
}
+64
View File
@@ -0,0 +1,64 @@
package metadata
import (
"context"
"testing"
)
func TestReferenceMigrationPreservesV1AndRetriesAtomically(t *testing.T) {
for _, backend := range []Backend{SQLite, PostgreSQL} {
t.Run(string(backend), func(t *testing.T) {
r := testRepository(t, backend)
ctx := context.Background()
id, err := r.CreatePage(ctx, "test", "/existing")
if err != nil {
t.Fatal(err)
}
// Reconstruct the preceding portable schema using its unchanged v1
// ledger. None of this targets legacy or production application data.
for _, q := range []string{`DROP TABLE revision_document_refs`, `DROP TABLE activity_outbox`, `DROP TABLE activity_outbox_heads`, `DELETE FROM schema_migration_steps WHERE component='core-metadata' AND version=2`} {
if _, err := r.database.ExecContext(ctx, q); err != nil {
t.Fatal(err)
}
}
_, err = r.database.ExecContext(ctx, `INSERT INTO revisions(uuid,object_uuid,document_hash,lang,content_type,created_at_ms,created_at) VALUES ('existing-revision',`+r.p(1)+`,`+r.p(2)+`,'und','text/plain',1000,1)`, id, hash("old"))
if err != nil {
t.Fatal(err)
}
// An unrelated existing table must stop adoption. The earlier DDL in
// the same migration must roll back and permit an explicit retry.
if _, err := r.database.ExecContext(ctx, `CREATE TABLE activity_outbox(unrelated INTEGER)`); err != nil {
t.Fatal(err)
}
if err := r.InitializeFresh(ctx); err == nil {
t.Fatal("unmanaged outbox table adopted")
}
var count int
if err := r.database.QueryRowContext(ctx, `SELECT count(*) FROM revision_document_refs`).Scan(&count); err == nil {
t.Fatal("partial v2 DDL remained")
}
if err := r.database.QueryRowContext(ctx, `SELECT count(*) FROM schema_migration_steps WHERE component='core-metadata' AND version=2`).Scan(&count); err != nil || count != 0 {
t.Fatal("failed migration recorded", err)
}
if _, err := r.database.ExecContext(ctx, `DROP TABLE activity_outbox`); err != nil {
t.Fatal(err)
}
if err := r.InitializeFresh(ctx); err != nil {
t.Fatal("migration retry failed", err)
}
old, err := r.Head(ctx, "test", id, "und")
if err != nil || old.UUID != "existing-revision" || old.DocumentHash != hash("old") {
t.Fatal("v1 revision altered", err)
}
if got, err := r.ResolvePath(ctx, "test", "/existing"); err != nil || got != id {
t.Fatal("v1 binding altered", err)
}
if _, err := r.AppendRevision(ctx, "test", Revision{ObjectUUID: id, DocumentHash: hash("new"), ContentType: "text/plain"}, old.UUID); err != nil {
t.Fatal("post-migration save failed", err)
}
if err := r.database.QueryRowContext(ctx, `SELECT count(*) FROM activity_outbox`).Scan(&count); err != nil || count != 1 {
t.Fatal("historical revisions spuriously notified", err, count)
}
})
}
}
+7
View File
@@ -202,6 +202,9 @@ func (s *Server) adapterActionsForPath(r *http.Request, semanticPath string) ([]
return plugins[i].DefaultEditor && !plugins[j].DefaultEditor
})
for _, plugin := range plugins {
if plugin.Mode == "editor" && !s.store.SupportsHostedEditors() {
continue
}
if pluginMatches(plugin, strings.ToLower(mediaType), filename) {
actions = append(actions, adapterAction{
ID: plugin.ID, Name: plugin.Name, Mode: plugin.Mode,
@@ -341,6 +344,10 @@ func (s *Server) handleOpenWith(w http.ResponseWriter, r *http.Request) {
http.NotFound(w, r)
return
}
if selected.Mode == "editor" && !s.store.SupportsHostedEditors() {
http.Error(w, "hosted editors are unavailable on this database backend; use the built-in editor", http.StatusServiceUnavailable)
return
}
actions, err := s.adapterActionsForPath(r, semanticPath)
if err != nil {
http.Error(w, err.Error(), 404)
+4
View File
@@ -100,6 +100,10 @@ func (s *Server) authorizeAdapterSession(r *http.Request, session *store.Adapter
}
func (s *Server) handleAdapterSessionAPI(w http.ResponseWriter, r *http.Request) {
if !s.store.SupportsHostedEditors() {
writeEventJSON(w, http.StatusServiceUnavailable, map[string]string{"error": "hosted editors disabled for this database backend; use the built-in editor"})
return
}
action := strings.Trim(strings.TrimPrefix(r.URL.Path, "/_/api/v1/adapter/session"), "/")
if action == "exchange" && r.Method == http.MethodPost {
var input struct {
+9 -9
View File
@@ -89,6 +89,7 @@ func (s *Server) handleSaveRevisionAPI(
return
}
domainUUID := s.domainUUIDForRequest(r)
actorUUID := ""
if req.EditorPrincipal != nil {
principal, e := s.store.PrincipalForSession(domainUUID, s.authTokenFromRequest(r))
id := ""
@@ -106,10 +107,14 @@ func (s *Server) handleSaveRevisionAPI(
api.WriteError(w, http.StatusUnauthorized, "authentication_required", "authentication required")
return
}
var revisionCount int
_ = s.store.DB.QueryRow(`SELECT COUNT(*) FROM revisions WHERE object_uuid=?`, req.ObjectUUID).Scan(&revisionCount)
actorUUID = principal.UUID
hasRevision, revisionErr := s.store.ObjectHasRevision(r.Context(), req.ObjectUUID)
if revisionErr != nil {
api.WriteError(w, 500, "storage_unavailable", "revision state unavailable")
return
}
capability := "write"
if revisionCount == 0 {
if !hasRevision {
capability = "create"
}
allowed := false
@@ -129,12 +134,7 @@ func (s *Server) handleSaveRevisionAPI(
}
}
var revision *store.Revision
if req.BaseRevision != nil {
revision, err = s.store.SaveRevisionContentIfHead(req.ObjectUUID, []byte(req.Body), req.Message, req.Language, req.ContentType, req.Filename, *req.BaseRevision)
} else {
revision, err = s.store.SaveRevisionContent(req.ObjectUUID, []byte(req.Body), req.Message, req.Language, req.ContentType, req.Filename)
}
revision, err := s.store.SaveRevisionContentInDomain(r.Context(), domainUUID, actorUUID, req.ObjectUUID, []byte(req.Body), req.Message, req.Language, req.ContentType, req.Filename, req.BaseRevision)
if errors.Is(err, store.ErrRevisionConflict) {
api.WriteError(w, http.StatusConflict, "revision_conflict", "document changed; reload the language head before saving")
return
+1 -2
View File
@@ -285,8 +285,7 @@ func (s *Server) verifyMagicLink(w http.ResponseWriter, r *http.Request) {
return
}
config, configErr := s.store.AuthProviderConfig(domainUUID, "smtp")
var valid bool
stateErr := s.store.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=? WHERE p.uuid=? AND p.state IN ('active','readonly') AND m.state='active' AND p.email=?)`, domainUUID, principalUUID, payload.Email).Scan(&valid)
valid, stateErr := s.store.ValidateMagicLinkIdentity(r.Context(), domainUUID, principalUUID, payload.Email)
if configErr != nil || !config.Enabled || stateErr != nil || !valid || payload.Email == "" {
http.Error(w, "This sign-in link is invalid or expired", http.StatusBadRequest)
return
+4 -12
View File
@@ -1,11 +1,11 @@
package server
import (
"context"
"encoding/base64"
"encoding/json"
"errors"
"net/http"
"path/filepath"
"strings"
"time"
@@ -36,14 +36,7 @@ func (s *Server) calendars() (*calendar.Repository, error) {
s.calendarErr = errors.New("calendar storage unavailable")
return
}
s.calendarRepo, s.calendarErr = calendar.New(filepath.Join(s.store.DocumentRoot, "calendars"), s.store.DB)
if s.calendarErr == nil {
s.calendarRepo.PublicAllowed = func(domain string) bool {
var allowed bool
err := s.store.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM locality_publication_policies p JOIN domains d ON d.uuid=p.domain_uuid AND d.enabled=1 JOIN config c ON c.domain_uuid=p.domain_uuid AND c.key='authorization_mode' AND c.value='enforcing' WHERE p.domain_uuid=? AND p.node_kind='domain' AND p.node_uuid=p.domain_uuid AND p.policy='public')`, domain).Scan(&allowed)
return err == nil && allowed
}
}
s.calendarRepo, s.calendarErr = s.store.NewCalendarRepository(context.Background())
})
return s.calendarRepo, s.calendarErr
}
@@ -316,9 +309,8 @@ func (s *Server) handleCalendarAPI(w http.ResponseWriter, r *http.Request) {
}
id = p.UUID
}
var count int
e := s.store.DB.QueryRowContext(r.Context(), `SELECT COUNT(*) FROM domain_memberships WHERE domain_uuid=? AND principal_uuid=? AND state='active'`, domain, id).Scan(&count)
if e != nil || count != 1 {
active, e := s.store.ActiveDomainMember(r.Context(), domain, id)
if e != nil || !active {
http.Error(w, "unknown collaborator", 400)
return
}
+2 -10
View File
@@ -161,14 +161,7 @@ func fetchCalendarSource(ctx context.Context, client *http.Client, c calendar.Ca
return events, response.Header.Get("ETag"), response.Header.Get("Last-Modified"), false, e
}
func (s *Server) ensureCalendarSweep() error {
var exists bool
if e := s.store.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM event_definitions WHERE uuid=?)`, calendarSweepType).Scan(&exists); e != nil {
return e
}
if exists {
return nil
}
return s.store.SaveEventDefinition(&store.EventDefinition{UUID: calendarSweepType, Name: "Calendar source synchronization", EventType: calendarSweepType, EventKey: calendarSweepType, Payload: "{}", ScheduleKind: "interval", IntervalSeconds: 60, Enabled: true, Priority: -10, MaxAttempts: 1})
return s.store.EnsureBuiltinEventDefinition(store.EventDefinition{UUID: calendarSweepType, Name: "Calendar source synchronization", EventType: calendarSweepType, EventKey: calendarSweepType, Payload: "{}", ScheduleKind: "interval", IntervalSeconds: 60, Enabled: true, Priority: -10, MaxAttempts: 1})
}
func (s *Server) enqueueCalendarSource(domain, id string, force bool) (bool, error) {
b, _ := json.Marshal(calendarSyncPayload{Domain: domain, Calendar: id, Force: force})
@@ -220,8 +213,7 @@ func (s *Server) runCalendarSource(job *store.EventJob) error {
if !c.Source.Enabled || (!p.Force && c.Source.Next > time.Now().UnixMilli()) {
return nil
}
var active bool
e = s.store.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM domain_memberships m JOIN principals p ON p.uuid=m.principal_uuid JOIN domains d ON d.uuid=m.domain_uuid WHERE m.domain_uuid=? AND m.principal_uuid=? AND m.state='active' AND p.state='active' AND d.enabled=1)`, p.Domain, c.Owner).Scan(&active)
active, e := s.store.ActiveDomainMember(context.Background(), p.Domain, c.Owner)
if e != nil {
return e
}
+31 -21
View File
@@ -9,6 +9,8 @@ import (
"net/url"
"path"
"strings"
"pageswiki/internal/store"
)
type cityAutoPlanItem struct {
@@ -46,15 +48,7 @@ func (s *Server) availableCityAutoName(domain, kind, parent, base, boundary stri
}
name = stem + "-" + hex.EncodeToString(sum[:8])
}
var exists bool
var err error
if kind == "spot" {
err = s.store.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM spots WHERE domain_uuid=? AND name=? AND state!='archived')`, domain, name).Scan(&exists)
} else if kind == "quartier" {
err = s.store.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM zones WHERE domain_uuid=? AND kind='quartier' AND name=? AND state!='archived')`, domain, name).Scan(&exists)
} else {
err = s.store.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM zones WHERE domain_uuid=? AND parent_uuid=? AND name=? AND state!='archived')`, domain, parent, name).Scan(&exists)
}
exists, err := s.store.CityNameExists(domain, kind, parent, name)
if err != nil {
return "", err
}
@@ -66,19 +60,29 @@ func (s *Server) availableCityAutoName(domain, kind, parent, base, boundary stri
}
func (s *Server) buildCityAutoPlan(domainUUID string) ([]cityAutoPlanItem, error) {
rows, err := s.store.DB.Query(`SELECT p.path,p.object_uuid FROM paths p WHERE p.domain_uuid=? AND p.path LIKE '/%' AND p.path!='/u' AND p.path NOT LIKE '/u/%'
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)
ORDER BY p.path`, domainUUID)
candidates, err := s.store.CityAutoCandidates(domainUUID)
if err != nil {
return nil, err
}
defer rows.Close()
var out []cityAutoPlanItem
for rows.Next() {
var semanticPath, pageUUID string
if err := rows.Scan(&semanticPath, &pageUUID); err != nil {
return nil, err
// Many Pages share one boundary. Resolve each boundary once, without
// retaining a database cursor while making nested repository calls.
type lookupResult struct {
node store.CityNodeDetail
err error
}
cache := map[string]lookupResult{}
lookup := func(kind, parent, boundary string) (store.CityNodeDetail, error) {
key := kind + "\x00" + parent + "\x00" + boundary
if r, ok := cache[key]; ok {
return r.node, r.err
}
node, err := s.store.CityNodeOverlappingPath(domainUUID, kind, parent, boundary)
cache[key] = lookupResult{node, err}
return node, err
}
for _, candidate := range candidates {
semanticPath, pageUUID := candidate.Path, candidate.ObjectUUID
parts := strings.Split(strings.Trim(semanticPath, "/"), "/")
if len(parts) < 3 || parts[0] == "system" {
continue
@@ -93,19 +97,25 @@ func (s *Server) buildCityAutoPlan(domainUUID string) ([]cityAutoPlanItem, error
item.SpotPath = item.StreetPath + "/_undefined"
}
item.Action = "create"
if q, e := s.store.CityNodeOverlappingPath(domainUUID, "quartier", "", item.QuartierPath); e == nil {
if q, e := lookup("quartier", "", item.QuartierPath); e == nil {
item.Quartier = q.Name
item.Action = "merge"
if st, e := s.store.CityNodeOverlappingPath(domainUUID, "street", q.UUID, item.StreetPath); e == nil {
if st, e := lookup("street", q.UUID, item.StreetPath); e == nil {
item.Street = st.Name
if spot, e := s.store.CityNodeOverlappingPath(domainUUID, "spot", st.UUID, item.SpotPath); e == nil {
if spot, e := lookup("spot", st.UUID, item.SpotPath); e == nil {
item.Spot = spot.Name
} else if !errors.Is(e, sql.ErrNoRows) {
return nil, e
}
} else if !errors.Is(e, sql.ErrNoRows) {
return nil, e
}
} else if !errors.Is(e, sql.ErrNoRows) {
return nil, e
}
out = append(out, item)
}
return out, rows.Err()
return out, nil
}
func (s *Server) applyCityAutoPlan(domainUUID, actor string) (int, error) {
+1 -1
View File
@@ -40,7 +40,7 @@ func (s *Server) handleCityGovernance(w http.ResponseWriter, r *http.Request) {
kind := map[string]string{"spots": "spot", "domains": "domain"}[p[0]]
var err error
if p[0] == "zones" {
err = s.store.DB.QueryRowContext(r.Context(), `SELECT kind FROM zones WHERE uuid=? AND domain_uuid=?`, p[1], domain).Scan(&kind)
kind, err = s.store.CityZoneKind(r.Context(), domain, p[1])
}
var result any
if err == nil && automatic {
+11 -4
View File
@@ -131,14 +131,17 @@ func (s *Server) handleConfig(
campusAdminRequired := strings.HasPrefix(section, "campus-") || strings.HasPrefix(section, "domain-") || section == "instance-status"
if campusAdminRequired {
targetCampusUUID := currentDomain.CampusUUID
var targetErr error
if section == "domain-create" {
targetCampusUUID = r.FormValue("domain_campus_uuid")
} else if section == "domain-update" || section == "domain-delete" || section == "domain-entry" || section == "domain-projection" {
_ = s.store.DB.QueryRow(`SELECT campus_uuid FROM domains WHERE id=?`, r.FormValue("domain_id")).Scan(&targetCampusUUID)
id, _ := strconv.ParseInt(r.FormValue("domain_id"), 10, 64)
targetCampusUUID, targetErr = s.store.ConfigTargetCampus(r.Context(), true, id)
} else if section != "campus-create" && r.FormValue("campus_id") != "" {
_ = s.store.DB.QueryRow(`SELECT uuid FROM campuses WHERE id=?`, r.FormValue("campus_id")).Scan(&targetCampusUUID)
id, _ := strconv.ParseInt(r.FormValue("campus_id"), 10, 64)
targetCampusUUID, targetErr = s.store.ConfigTargetCampus(r.Context(), false, id)
}
if !s.store.IsCampusAdmin(targetCampusUUID, principal.UUID) {
if targetErr != nil || !s.store.IsCampusAdmin(targetCampusUUID, principal.UUID) {
http.Error(w, "campus admin required", http.StatusForbidden)
return
}
@@ -824,6 +827,10 @@ func (s *Server) handleConfig(
}
case "zombie-purge":
if !s.store.SupportsZombieGC() {
http.Error(w, store.ErrBackendFeatureUnavailable.Error(), http.StatusServiceUnavailable)
return
}
_, err = s.store.PurgeZombieObjectsInDomain(
r.Context(), domainUUID,
@@ -918,7 +925,7 @@ func (s *Server) handleConfig(
s.getZombieGraceHours(s.domainUUIDForRequest(r))
var zombies []store.ZombieObject
if r.URL.Query().Get("panel") == "objects" {
if r.URL.Query().Get("panel") == "objects" && s.store.SupportsZombieGC() {
zombies, err =
s.store.ListZombieObjectsInDomain(
r.Context(), s.domainUUIDForRequest(r),
+3 -2
View File
@@ -88,12 +88,13 @@ func (s *Server) domainForRequestWithError(
return s.currentDomain(), nil
}
if cached, ok := r.Context().Value(requestDomainKey{}).(*requestDomainLookup); ok && cached.host == r.Host {
cached.once.Do(func() { cached.domain, cached.err = s.store.GetDomainByHost(r.Host) })
cached.once.Do(func() { cached.domain, cached.err = s.store.GetDomainByHostContext(r.Context(), r.Host) })
return cached.domain, cached.err
}
sp, err :=
s.store.GetDomainByHost(
s.store.GetDomainByHostContext(
r.Context(),
r.Host,
)
+4 -1
View File
@@ -39,7 +39,7 @@ func (q schedulerQueue) Started(ctx context.Context, job *dregarnuhr.Job) error
return q.store.AddEventLogContext(ctx, job.UUID, job.EventUUID, "info", "execution started")
}
func (q schedulerQueue) Finish(ctx context.Context, job *dregarnuhr.Job, err error, now time.Time) error {
return q.store.FinishEventAt(ctx, job.UUID, err, now)
return q.store.FinishClaimedEventAt(ctx, job, err, now)
}
func (s *Server) eventRunner() *dregarnuhr.Runner {
@@ -112,6 +112,9 @@ func (s *Server) schedulerLoop() dregarnuhr.Loop {
{Name: "initial-preview-sweep", After: 5 * time.Second, Run: func(context.Context, time.Time) error { s.enqueueAllPreviewEvents(); return nil }},
{Name: "preview-sweep", Every: 15 * time.Minute, Run: func(context.Context, time.Time) error { s.enqueueAllPreviewEvents(); return nil }},
{Name: "history-cleanup", Every: time.Hour, Run: func(context.Context, time.Time) error {
if !s.store.SupportsEventHistoryMaintenance() {
return nil
}
settings, err := s.store.GetQueueSettings()
if err != nil {
return err
+29 -12
View File
@@ -54,39 +54,56 @@ func (s *Server) initializePreviewScheduler() {
}
}
func (s *Server) startEventScheduler() {
func (s *Server) startEventScheduler() error {
if s.store == nil {
return
return nil
}
release, err := s.store.AcquireEventWorker(s.backgroundCtx)
if err != nil {
return err
}
ready := false
defer func() {
if !ready {
_ = release()
}
}()
if err := s.store.EnsureFeedEvent(); err != nil {
log.Printf("feed scheduler initialization failed")
return fmt.Errorf("feed scheduler initialization: %w", err)
}
if err := s.store.EnsureBuiltinResourceEvent(); err != nil {
log.Printf("resource monitor initialization failed: %v", err)
return fmt.Errorf("resource monitor initialization: %w", err)
}
if err := s.ensureCalendarSweep(); err != nil {
log.Printf("calendar scheduler initialization failed: %v", err)
return fmt.Errorf("calendar scheduler initialization: %w", err)
}
if err := s.store.EnsureTaskActivityBridgeEvent(); err != nil {
log.Printf("task journal bridge initialization failed: %v", err)
return fmt.Errorf("task journal bridge initialization: %w", err)
}
if err := s.store.EnsureTaskReminderEvent(); err != nil {
log.Printf("task reminder initialization failed: %v", err)
return fmt.Errorf("task reminder initialization: %w", err)
}
if err := s.store.EnsureTaskFocusEvent(); err != nil {
log.Printf("focus timer initialization failed: %v", err)
return fmt.Errorf("focus timer initialization: %w", err)
}
if err := s.store.EnsureTaskDigestEvent(); err != nil {
log.Printf("task digest initialization failed: %v", err)
return fmt.Errorf("task digest initialization: %w", err)
}
if err := s.store.EnsureNotificationPushEvent(); err != nil {
log.Printf("notification push initialization failed: %v", err)
if s.store.SupportsNotificationPush() {
if err := s.store.EnsureNotificationPushEvent(); err != nil {
return fmt.Errorf("notification push initialization: %w", err)
}
}
s.workerRelease = release
ready = true
s.backgroundWG.Add(1)
go func() {
if err := s.schedulerLoop().Run(context.Background()); err != nil {
defer s.backgroundWG.Done()
if err := s.schedulerLoop().Run(s.backgroundCtx); err != nil && !errors.Is(err, context.Canceled) {
log.Printf("event scheduler loop stopped: %v", err)
}
}()
return nil
}
func (s *Server) wakeEventScheduler() {
+8
View File
@@ -29,6 +29,10 @@ func zombieAPIOptions(r *http.Request) (int64, int, error) {
}
func (s *Server) handleZombieListAPI(w http.ResponseWriter, r *http.Request) {
if !s.store.SupportsZombieGC() {
http.Error(w, store.ErrBackendFeatureUnavailable.Error(), http.StatusServiceUnavailable)
return
}
if r.Method != http.MethodGet {
w.Header().Set("Allow", http.MethodGet)
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
@@ -50,6 +54,10 @@ func (s *Server) handleZombieListAPI(w http.ResponseWriter, r *http.Request) {
}
func (s *Server) handleZombiePurgeAPI(w http.ResponseWriter, r *http.Request) {
if !s.store.SupportsZombieGC() {
http.Error(w, store.ErrBackendFeatureUnavailable.Error(), http.StatusServiceUnavailable)
return
}
if r.Method != http.MethodPost {
w.Header().Set("Allow", http.MethodPost)
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+10 -1
View File
@@ -41,13 +41,18 @@ func (s *Server) zombieMaintenanceGrace() (int64, error) {
}
func (s *Server) startGCWorker() {
if !s.store.SupportsZombieGC() {
return
}
grace, err := s.zombieMaintenanceGrace()
if err != nil {
log.Printf("zombie GC maintenance disabled: %v", err)
return
}
s.backgroundWG.Add(1)
go func() {
defer s.backgroundWG.Done()
ticker :=
time.NewTicker(
@@ -57,7 +62,11 @@ func (s *Server) startGCWorker() {
defer ticker.Stop()
for {
<-ticker.C
select {
case <-s.backgroundCtx.Done():
return
case <-ticker.C:
}
deleted, err :=
s.store.PurgeZombieObjects(
+6 -21
View File
@@ -4,6 +4,7 @@ import (
"archive/tar"
"archive/zip"
"compress/gzip"
"database/sql"
"encoding/json"
"errors"
"fmt"
@@ -597,10 +598,6 @@ func (s *Server) rollbackImport(domainUUID, sessionUUID string) error {
if session.Status != "completed" && session.Status != "failed" {
return errors.New("only a completed or failed import can be rolled back")
}
entries, err := s.store.ImportJournal(sessionUUID)
if err != nil {
return err
}
actor := session.ActorUUID
if actor == "" {
actor = "system:import"
@@ -610,32 +607,20 @@ func (s *Server) rollbackImport(domainUUID, sessionUUID string) error {
return err
}
for _, edge := range edges {
_ = s.store.RemoveSpotPage(domainUUID, actor, edge.SpotUUID, edge.PageUUID, "primary")
if err := s.store.RemoveSpotPage(domainUUID, actor, edge.SpotUUID, edge.PageUUID, "primary"); err != nil && !errors.Is(err, sql.ErrNoRows) {
return err
}
}
nodes, err := s.store.ImportCityJournal(sessionUUID)
if err != nil {
return err
}
for _, node := range nodes {
_ = s.store.DeleteCityNode(domainUUID, actor, node.Kind, node.UUID)
}
tx, err := s.store.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
for _, x := range entries {
if _, err = tx.Exec(`DELETE FROM paths WHERE domain_uuid=? AND path=? AND object_uuid=?`, domainUUID, x.Path, x.ObjectUUID); err != nil {
if err := s.store.DeleteCityNode(domainUUID, actor, node.Kind, node.UUID); err != nil && !errors.Is(err, sql.ErrNoRows) {
return err
}
}
if _, err = tx.Exec(`UPDATE import_sessions SET status='rolled_back',updated_at_ms=? WHERE uuid=?`, time.Now().UnixMilli(), sessionUUID); err != nil {
return err
}
if err = tx.Commit(); err == nil {
s.store.InvalidatePathCaches()
}
return err
return s.store.RollbackImportPaths(domainUUID, sessionUUID)
}
func readImportArchive(filename, name string, wanted map[string]bool) (map[string][]byte, error) {
+57
View File
@@ -0,0 +1,57 @@
package server
import (
"context"
"errors"
"net/http"
"time"
)
// Close waits for the scheduler loop, maintenance and all running handlers
// before releasing database worker ownership. Deadline expiry leaves ownership
// held until the in-flight work actually exits; callers must not close the DB.
func (s *Server) Close(ctx context.Context) error {
s.closeOnce.Do(func() {
s.backgroundCancel()
go func() {
_ = s.eventRunner().Stop(context.Background())
s.backgroundWG.Wait()
if s.workerRelease != nil {
s.closeErr = s.workerRelease()
}
close(s.closeDone)
}()
})
select {
case <-s.closeDone:
return s.closeErr
case <-ctx.Done():
return ctx.Err()
}
}
// RunContext drains HTTP before releasing worker ownership. If a request or
// worker cannot stop in time, return an error without pretending it has exited.
func (s *Server) RunContext(ctx context.Context, addr string) error {
server := &http.Server{Addr: addr, Handler: s.handler(), ReadHeaderTimeout: 10 * time.Second}
done := make(chan error, 1)
go func() { done <- server.ListenAndServe() }()
var serveErr error
select {
case serveErr = <-done:
case <-ctx.Done():
shutdown, cancel := context.WithTimeout(context.Background(), 30*time.Second)
serveErr = server.Shutdown(shutdown)
cancel()
if serveErr != nil {
_ = server.Close()
}
}
closeCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
closeErr := s.Close(closeCtx)
if errors.Is(serveErr, http.ErrServerClosed) {
serveErr = nil
}
return errors.Join(serveErr, closeErr)
}
+100
View File
@@ -0,0 +1,100 @@
package server
import (
"context"
"errors"
"pageswiki/internal/db"
"pageswiki/internal/dregarnuhr"
"pageswiki/internal/store"
"testing"
"time"
)
func lifecycleFixture(t *testing.T) *store.Store {
t.Helper()
t.Chdir("../..")
database, err := db.Open(t.TempDir() + "/pages.db")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { database.Close() })
if err = db.Migrate(database); err != nil {
t.Fatal(err)
}
s := store.NewWithDocumentRoot(database, t.TempDir()+"/documents")
if err = s.EnsureConfigTable(); err != nil {
t.Fatal(err)
}
return s
}
func TestServerCloseRetainsOwnershipUntilHandlersExit(t *testing.T) {
st := lifecycleFixture(t)
st.BackgroundJobsDisabled = true
s, err := NewChecked(st)
if err != nil {
t.Fatal(err)
}
// Admission is driven manually: avoid unrelated timed triggers in this test.
st.BackgroundJobsDisabled = false
released := make(chan struct{})
s.workerRelease = func() error { close(released); return nil }
started := make(chan struct{})
cancelled := make(chan struct{})
exit := make(chan struct{})
if err = s.registeredEventHandlers().Register("synthetic.stop", func(ctx context.Context, _ *dregarnuhr.Job) error {
close(started)
<-ctx.Done()
close(cancelled)
<-exit
return ctx.Err()
}); err != nil {
t.Fatal(err)
}
if _, err = st.EnqueueEvent("synthetic.stop", "one", "", time.Now()); err != nil {
t.Fatal(err)
}
s.eventRunner().Dispatch(s.backgroundCtx)
select {
case <-started:
case <-time.After(time.Second):
t.Fatal("handler not started")
}
ctx, cancel := context.WithCancel(context.Background())
cancel()
if err = s.Close(ctx); !errors.Is(err, context.Canceled) {
t.Fatal(err)
}
select {
case <-cancelled:
case <-time.After(time.Second):
t.Fatal("handler not cancelled")
}
select {
case <-released:
t.Fatal("ownership released while handler lives")
default:
}
close(exit)
ctx, cancel = context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err = s.Close(ctx); err != nil {
t.Fatal(err)
}
select {
case <-released:
default:
t.Fatal("ownership retained after stop")
}
}
func TestServerRefusesSchedulerInitializationFailure(t *testing.T) {
st := lifecycleFixture(t)
if _, err := st.DB.Exec(`DROP TABLE event_definitions`); err != nil {
t.Fatal(err)
}
s, err := NewChecked(st)
if err == nil || s != nil {
t.Fatal("partial server accepted", err)
}
}
+3 -3
View File
@@ -1,9 +1,9 @@
package server
import "pageswiki/internal/mestionora"
import "pageswiki/internal/store"
// Construction is read-only: schema/index maintenance remains an explicit
// application startup operation, never a search request side effect.
func (s *Server) searchEngine() *mestionora.SQLite {
return mestionora.NewSQLite(s.store.DB)
func (s *Server) searchEngine() *store.Store {
return s.store
}
+7
View File
@@ -25,6 +25,9 @@ func validPushSubscription(sub webpush.Subscription) bool {
}
func (s *Server) notificationPushKeys(ctx context.Context) (private, public string, err error) {
if !s.store.SupportsNotificationPush() {
return "", "", store.ErrBackendFeatureUnavailable
}
err = s.store.DB.QueryRowContext(ctx, `SELECT private_key,public_key FROM notification_push_keys WHERE id=1`).Scan(&private, &public)
if !errors.Is(err, sql.ErrNoRows) {
return
@@ -42,6 +45,10 @@ func (s *Server) notificationPushKeys(ctx context.Context) (private, public stri
}
func (s *Server) handleNotificationPush(w http.ResponseWriter, r *http.Request, domain, owner string) {
if !s.store.SupportsNotificationPush() {
writeEventJSON(w, http.StatusServiceUnavailable, map[string]string{"error": "push disabled for this database backend"})
return
}
ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
defer cancel()
switch r.Method {
+6
View File
@@ -34,6 +34,12 @@ func notificationDeliveryClient() *http.Client {
}
func (s *Server) deliverNotificationPushContext(ctx context.Context, job *store.EventJob) error {
if err := ctx.Err(); err != nil {
return err
}
if !s.store.SupportsNotificationPush() {
return store.ErrBackendFeatureUnavailable
}
dispatcher := ordoschnellic.Dispatcher{
Queue: notificationDeliveryQueue{s.store},
Sender: ordoschnellic.WebPush{Keys: s.notificationPushKeys, Client: notificationDeliveryClient()},
+2 -13
View File
@@ -19,22 +19,11 @@ func (s *Server) periodicalShareTargets(r *http.Request, kind, path string) []pe
defer cancel()
r = r.WithContext(ctx)
source := s.domainUUIDForRequest(r)
rows, err := s.store.DB.QueryContext(r.Context(), `SELECT domain_uuid FROM periodical_projections WHERE source_uuid=? AND kind=? ORDER BY domain_uuid LIMIT 65`, source, kind)
ids, err := s.store.PeriodicalProjectionTargets(r.Context(), source, kind)
if err != nil {
return nil
}
ids := []string{}
for rows.Next() {
var id string
if err = rows.Scan(&id); err != nil {
rows.Close()
return nil
}
ids = append(ids, id)
}
err = rows.Err()
rows.Close()
if err != nil || len(ids) > 64 {
if len(ids) > 64 {
return nil
}
out := []periodicalShareTarget{}
+2 -17
View File
@@ -26,9 +26,7 @@ func (s *Server) appearanceForRequest(r *http.Request) personalAppearance {
if principal == nil {
return p
}
var raw string
var version int64
if s.store.DB.QueryRowContext(r.Context(), `SELECT version,data FROM personal_appearance WHERE domain_uuid=? AND owner_uuid=?`, domain, principal.UUID).Scan(&version, &raw) == nil {
if version, raw, err := s.store.PersonalAppearance(r.Context(), domain, principal.UUID); err == nil {
var saved personalAppearance
if json.Unmarshal([]byte(raw), &saved) == nil {
saved.Version = version
@@ -93,20 +91,7 @@ func (s *Server) savePersonalAppearance(w http.ResponseWriter, r *http.Request,
}
p.Version = version + 1
raw, _ := json.Marshal(p)
result, err := s.store.DB.ExecContext(r.Context(), `INSERT INTO personal_appearance(domain_uuid,owner_uuid,version,data) SELECT ?,?,?,? WHERE ?=0 ON CONFLICT(domain_uuid,owner_uuid) DO NOTHING`, domain, actor, p.Version, string(raw), version)
if err == nil {
var n int64
n, err = result.RowsAffected()
if err == nil && n == 0 {
result, err = s.store.DB.ExecContext(r.Context(), `UPDATE personal_appearance SET version=?,data=? WHERE domain_uuid=? AND owner_uuid=? AND version=?`, p.Version, string(raw), domain, actor, version)
if err == nil {
n, err = result.RowsAffected()
if n == 0 {
err = sql.ErrNoRows
}
}
}
}
err = s.store.SavePersonalAppearance(r.Context(), domain, actor, version, string(raw))
if errors.Is(err, sql.ErrNoRows) {
http.Error(w, "Settings changed elsewhere; reload before saving.", 409)
return
+223
View File
@@ -0,0 +1,223 @@
package server
import (
"bytes"
"context"
"encoding/json"
"io"
"net/http"
"net/http/httptest"
"net/url"
"os"
"path/filepath"
"strings"
"testing"
"time"
"github.com/google/uuid"
"pageswiki/internal/db"
"pageswiki/internal/store"
)
const nativeTestDomain = "35ff2304-a401-49ba-b21a-6129d4be2af2"
func nativeRuntimeFixture(t *testing.T) *store.Store {
t.Helper()
dsn := os.Getenv("PAGESWIKI_TEST_POSTGRES_DSN")
if dsn == "" {
t.Skip("set PAGESWIKI_TEST_POSTGRES_DSN to a disposable PostgreSQL URL")
}
u, err := url.Parse(dsn)
if err != nil {
t.Fatal("invalid test DSN")
}
ctx := context.Background()
admin, err := db.OpenPostgreSQL(ctx, db.PostgreSQLOptions{DSN: dsn, AllowInsecure: true})
if err != nil {
t.Fatal(err)
}
schema := "pageswiki_http_test_" + strings.ReplaceAll(uuid.NewString(), "-", "")
if _, err = admin.Exec(`CREATE SCHEMA "` + schema + `"`); err != nil {
admin.Close()
t.Fatal(err)
}
t.Cleanup(func() {
defer admin.Close()
if _, err := admin.Exec(`DROP SCHEMA "` + schema + `" CASCADE`); err != nil {
t.Error(err)
}
})
q := u.Query()
q.Set("search_path", schema)
u.RawQuery = q.Encode()
database, err := db.OpenPostgreSQL(ctx, db.PostgreSQLOptions{DSN: u.String(), AllowInsecure: true})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { database.Close() })
root := filepath.Join(t.TempDir(), "documents")
if err = os.Mkdir(root, 0700); err != nil {
t.Fatal(err)
}
t.Setenv("PAGESWIKI_AUTH_KEY", "synthetic runtime key")
// Initial bootstrap creates schema but refuses to invent namespace IDs.
if _, err = store.NewPostgreSQLWithDocumentRoot(ctx, database, root); err == nil {
t.Fatal("unprovisioned namespace accepted")
}
if _, err = database.Exec(`INSERT INTO campuses(uuid,name,title,created_at) VALUES('campus','default','Test Campus',1);
INSERT INTO domains(uuid,name,title,created_at,campus_uuid) VALUES('35ff2304-a401-49ba-b21a-6129d4be2af2','default','Test Domain',1,'campus')`); err != nil {
t.Fatal(err)
}
s, err := store.NewPostgreSQLWithDocumentRoot(ctx, database, root)
if err != nil {
t.Fatal(err)
}
t.Chdir("../..")
return s
}
func TestPostgreSQLRuntimeHTTPAndRestart(t *testing.T) {
st := nativeRuntimeFixture(t)
ctx := context.Background()
owner, err := st.BootstrapOwner(nativeTestDomain, "owner", "synthetic runtime password", "Owner", "")
if err != nil {
t.Fatal(err)
}
token, err := st.CreateAuthSession(nativeTestDomain, owner.UUID)
if err != nil {
t.Fatal(err)
}
if err = st.SetConfigInDomain(nativeTestDomain, "authorization_mode", "enforcing"); err != nil {
t.Fatal(err)
}
obj, err := st.CreatePageAtPathInDomain(nativeTestDomain, "/native-startup")
if err != nil {
t.Fatal(err)
}
if _, err = st.SaveRevisionContentInDomain(ctx, nativeTestDomain, owner.UUID, obj, []byte("<h1>Native startup page</h1><p>Canonical document</p>"), "initial", "en", "text/html", "", nil); err != nil {
t.Fatal(err)
}
for iteration := 0; iteration < 2; iteration++ {
if iteration > 0 {
st, err = store.NewPostgreSQLWithDocumentRoot(ctx, st.DB, st.DocumentRoot)
if err != nil {
t.Fatal(err)
}
}
s, err := NewChecked(st)
if err != nil {
t.Fatal(err)
}
closeServer := func() {
closeCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
defer cancel()
if err := s.Close(closeCtx); err != nil {
t.Error(err)
}
}
t.Cleanup(closeServer)
listener := httptest.NewServer(s.handler())
request, _ := http.NewRequest(http.MethodGet, listener.URL+"/native-startup", nil)
request.Host = "localhost"
request.Header.Set("Authorization", "Bearer "+token)
response, err := listener.Client().Do(request)
if err != nil {
listener.Close()
t.Fatal(err)
}
body, err := io.ReadAll(response.Body)
response.Body.Close()
listener.Close()
if err != nil || response.StatusCode != 200 || !bytes.Contains(body, []byte("Canonical document")) {
t.Fatalf("listener roundtrip: %d %v", response.StatusCode, err)
}
job := &store.EventJob{UUID: "synthetic-runtime-resource", Type: store.ResourceEventType}
for range 2 {
if err := s.runEvent(job); err != nil {
t.Fatal("resource worker", err)
}
}
var samples int
if err := st.DB.QueryRow(`SELECT count(*) FROM resource_samples WHERE job_uuid='synthetic-runtime-resource'`).Scan(&samples); err != nil || samples != 1 {
t.Fatal("resource deduplication", samples, err)
}
for _, target := range []string{"/health", "/", "/native-startup", "/e/-/native-startup", "/v/search?q=native-startup", "/_/api/v1/search/suggest?q=native", "/-/sys/config?panel=auth", "/v/tree", "/v/browser", "/v/plan/tasks", "/v/plan/cal/2026/11", "/v/plan/contacts", "/v/plan/dashboard", "/v/feeds"} {
r := httptest.NewRequest(http.MethodGet, "http://localhost"+target, nil)
r.Header.Set("Authorization", "Bearer "+token)
w := httptest.NewRecorder()
s.handler().ServeHTTP(w, r)
if w.Code != http.StatusOK {
t.Errorf("iteration %d %s: HTTP %d %.400s", iteration, target, w.Code, w.Body.String())
}
if strings.HasPrefix(target, "/v/search") && w.Header().Get("X-PagesWiki-Search-Profile") != "metadata-only" {
t.Error("SQLite search selected")
}
if target == "/native-startup" && !strings.Contains(w.Body.String(), "Canonical document") {
t.Error("page body missing")
}
}
base, err := st.GetRevisionForExactLanguage(obj, "en")
if err != nil {
t.Fatal(err)
}
payload, _ := json.Marshal(map[string]any{"object_uuid": obj, "body": "<h1>Native startup page</h1><p>Canonical document updated</p>", "lang": "en", "content_type": "text/html", "base_revision_uuid": base.UUID, "editor_principal_uuid": owner.UUID})
save := func(auth string) *httptest.ResponseRecorder {
r := httptest.NewRequest(http.MethodPost, "http://localhost/_/api/v1/revisions/save", bytes.NewReader(payload))
r.Header.Set("Authorization", "Bearer "+auth)
r.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
s.handler().ServeHTTP(w, r)
return w
}
if w := save(token); w.Code != 200 {
t.Fatalf("save: %d %s", w.Code, w.Body)
}
if w := save(token); w.Code != 409 {
t.Fatalf("stale save: %d %s", w.Code, w.Body)
}
if w := save("expired"); w.Code != 401 {
t.Fatalf("expired save: %d %s", w.Code, w.Body)
}
for _, target := range []string{calendarDAV, taskDAVCollection, contactDAV} {
r := httptest.NewRequest("PROPFIND", "http://localhost"+target, strings.NewReader(`<d:propfind xmlns:d="DAV:"><d:allprop/></d:propfind>`))
r.Header.Set("Authorization", "Bearer "+token)
r.Header.Set("Depth", "1")
r.Header.Set("Content-Type", "application/xml")
w := httptest.NewRecorder()
s.handler().ServeHTTP(w, r)
if w.Code != 207 {
t.Errorf("DAV %s: %d %.300s", target, w.Code, w.Body.String())
}
}
for _, panel := range []string{"objects", "assets", "auth-providers", "auth-sessions", "groups", "campuses", "domains", "scheduler", "logs", "queue", "organizer"} {
r := httptest.NewRequest("GET", "http://localhost/-/sys/config?panel="+panel, nil)
r.Header.Set("Authorization", "Bearer "+token)
w := httptest.NewRecorder()
s.handler().ServeHTTP(w, r)
if w.Code != 200 {
t.Errorf("panel %s: %d %.300s", panel, w.Code, w.Body.String())
}
}
// Another Server must not take ownership while this worker is alive.
if peer, e := NewChecked(st); e == nil {
peer.Close(ctx)
t.Error("duplicate worker accepted")
}
if iteration == 1 {
if err := st.RevokeAuthSession(token); err != nil {
t.Fatal(err)
}
if w := save(token); w.Code != 401 {
t.Errorf("revoked session accepted: %d", w.Code)
}
r := httptest.NewRequest("GET", "http://localhost/native-startup", nil)
r.Header.Set("Authorization", "Bearer "+token)
w := httptest.NewRecorder()
s.handler().ServeHTTP(w, r)
if w.Code == 200 || strings.Contains(w.Body.String(), "Canonical document") {
t.Error("revoked session exposed private page")
}
}
closeServer()
}
}
+3 -8
View File
@@ -38,16 +38,11 @@ func (s *Server) handleRestoreRevisionAPI(w http.ResponseWriter, r *http.Request
http.Error(w, "forbidden", 403)
return
}
revision, err := s.store.GetRevision(input.Revision)
if err != nil {
http.Error(w, "revision unavailable", 500)
return
}
message := strings.TrimSpace(input.Message)
if message == "" {
message = "Restore revision " + revision.UUID
message = "Restore revision " + metadata.UUID
}
saved, err := s.store.SaveRevisionContentIfHead(revision.ObjectUUID, []byte(revision.Body), message, revision.Language, revision.ContentType, revision.Filename, input.Expected)
saved, err := s.store.RestoreRevisionInDomain(r.Context(), s.domainUUIDForRequest(r), "", input.Revision, input.Expected, message)
if errors.Is(err, store.ErrRevisionConflict) {
http.Error(w, "revision changed; reload history", 412)
return
@@ -57,5 +52,5 @@ func (s *Server) handleRestoreRevisionAPI(w http.ResponseWriter, r *http.Request
return
}
w.Header().Set("Cache-Control", "no-store")
writeEventJSON(w, 200, map[string]string{"revision_uuid": saved.UUID, "object_uuid": revision.ObjectUUID})
writeEventJSON(w, 200, map[string]string{"revision_uuid": saved.UUID, "object_uuid": saved.ObjectUUID})
}
+1
View File
@@ -121,6 +121,7 @@ func searchExcerpt(raw, contentType, query string) string {
}
func (s *Server) handleSearch(w http.ResponseWriter, r *http.Request) {
w.Header().Set("X-PagesWiki-Search-Profile", s.store.SearchProfile())
if r.Method != http.MethodGet && r.Method != http.MethodHead {
w.Header().Set("Allow", "GET, HEAD")
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+1
View File
@@ -86,6 +86,7 @@ func citySuggestion(result store.CitySearchResult, query string) searchSuggestio
}
func (s *Server) handleSearchSuggestAPI(w http.ResponseWriter, r *http.Request) {
w.Header().Set("X-PagesWiki-Search-Profile", s.store.SearchProfile())
if r.Method != http.MethodGet {
w.Header().Set("Allow", http.MethodGet)
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+26 -6
View File
@@ -1,6 +1,7 @@
package server
import (
"context"
"database/sql"
"errors"
"fmt"
@@ -44,13 +45,32 @@ type Server struct {
schedulerRunner *dregarnuhr.Runner
eventHandlersOnce sync.Once
eventHandlers *dregarnuhr.Registry
backgroundCtx context.Context
backgroundCancel context.CancelFunc
backgroundWG sync.WaitGroup
workerRelease func() error
closeOnce sync.Once
closeDone chan struct{}
closeErr error
}
func New(
st *store.Store,
) *Server {
s, err := NewChecked(st)
if err != nil {
panic(err)
}
return s
}
// NewChecked refuses to serve when mandatory scheduler initialization fails.
// New remains a compatibility wrapper for existing constructors and tests.
func NewChecked(st *store.Store) (*Server, error) {
ctx, cancel := context.WithCancel(context.Background())
s := &Server{
backgroundCtx: ctx, backgroundCancel: cancel, closeDone: make(chan struct{}),
mux: http.NewServeMux(),
store: st,
previewSlots: make(chan struct{}, 1),
@@ -111,11 +131,14 @@ func New(
s.registerRoutes()
if !st.ReadOnly && !st.BackgroundJobsDisabled {
if err := s.startEventScheduler(); err != nil {
cancel()
return nil, err
}
s.startGCWorker()
s.startEventScheduler()
}
return s
return s, nil
}
func (s *Server) registerStaticRoutes() {
@@ -378,8 +401,5 @@ func (s *Server) Run(addr string) error {
addr,
)
return http.ListenAndServe(
addr,
s.handler(),
)
return s.RunContext(context.Background(), addr)
}
+1 -9
View File
@@ -193,18 +193,10 @@ func (s *Server) taskPagePath(r *http.Request, id string) string {
if id == "" {
return ""
}
rows, err := s.store.DB.QueryContext(r.Context(), `SELECT path FROM paths WHERE domain_uuid=? AND object_uuid=? ORDER BY length(path),path LIMIT 100`, s.domainUUIDForRequest(r), id)
paths, err := s.store.ObjectAliasPaths(r.Context(), s.domainUUIDForRequest(r), id)
if err != nil {
return ""
}
paths := []string{}
for rows.Next() {
var p string
if rows.Scan(&p) == nil {
paths = append(paths, p)
}
}
rows.Close()
allows := s.pathReadFilter(r)
for _, p := range paths {
if allows(p) {
@@ -0,0 +1,134 @@
package store
import (
"context"
"errors"
"fmt"
"sync"
"testing"
)
func TestActivityConsumersBackend(t *testing.T) {
for _, backend := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(backend), func(t *testing.T) {
s := testNamespaceStore(t, backend)
ctx := context.Background()
for range 2 {
if err := s.EnsureActivityOutboxSchema(); err != nil {
t.Fatal(err)
}
}
// Source and its envelope share one transaction, including rollback.
appendEvents := func(commit bool) {
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
t.Fatal(err)
}
defer tx.Rollback()
if err = s.lockTaskWriter(ctx, tx); err != nil {
t.Fatal(err)
}
for _, domain := range []string{"synthetic-a", "synthetic-b"} {
for i, typ := range []string{"task.changed", "noise", "page.changed", "task.changed"} {
e := ActivityOutboxEvent{DomainUUID: domain, EventType: typ, IdempotencyKey: fmt.Sprint(i)}
out, created, err := s.AppendActivityOutboxTx(tx, e)
if err != nil || !created || out.Sequence != int64(i+1) {
t.Fatal(out, created, err)
}
again, created, err := s.AppendActivityOutboxTx(tx, e)
if err != nil || created || again.UUID != out.UUID {
t.Fatal(again, created, err)
}
}
}
if commit {
if err = tx.Commit(); err != nil {
t.Fatal(err)
}
}
}
appendEvents(false)
sub := ActivitySubscription{ConsumerID: "consumer-a", EventTypes: []string{"task.changed", "page.changed"}}
if domains, err := s.PendingActivityConsumerDomains(ctx, sub, 100); err != nil || len(domains) != 0 {
t.Fatal(domains, err)
}
appendEvents(true)
if domains, err := s.PendingActivityConsumerDomains(ctx, sub, 100); err != nil || len(domains) != 2 {
t.Fatal(domains, err)
}
items, err := s.ActivityOutboxForConsumer(ctx, sub, "synthetic-a", 2)
if err != nil || len(items) != 2 || items[0].Sequence != 1 || items[1].Sequence != 3 {
t.Fatal(items, err)
}
if err = s.CompleteActivityOutboxThrough(sub.ConsumerID, "synthetic-a", 3); err != nil {
t.Fatal(err)
}
before, err := s.ActivityOutboxCheckpoint(sub.ConsumerID, "synthetic-a")
if err != nil {
t.Fatal(err)
}
if err = s.CompleteActivityOutboxThrough(sub.ConsumerID, "synthetic-a", 1); err != nil {
t.Fatal(err)
}
after, err := s.ActivityOutboxCheckpoint(sub.ConsumerID, "synthetic-a")
if err != nil || before != after {
t.Fatal(before, after, err)
}
items, err = s.ActivityOutboxForConsumer(ctx, sub, "synthetic-a", 10)
if err != nil || len(items) != 1 || items[0].Sequence != 4 {
t.Fatal(items, err)
}
// Another subscriber still sees the complete history.
sub.ConsumerID = "consumer-b"
items, err = s.ActivityOutboxForConsumer(ctx, sub, "synthetic-a", 10)
if err != nil || len(items) != 3 {
t.Fatal(items, err)
}
items, err = s.ActivityOutboxAfter(ctx, "synthetic-b", 2, 10)
if err != nil || len(items) != 2 {
t.Fatal(items, err)
}
items, err = s.PendingActivityOutbox(ctx, "synthetic-a", 10)
if err != nil || len(items) != 4 {
t.Fatal(items, err)
}
// Consumer action and checkpoint rollback together.
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
t.Fatal(err)
}
if err = s.AdvanceActivityOutboxCheckpointTx(tx, "consumer-b", "synthetic-a", 4); err != nil {
tx.Rollback()
t.Fatal(err)
}
tx.Rollback()
checkpoint, err := s.ActivityOutboxCheckpoint("consumer-b", "synthetic-a")
if err != nil || checkpoint.LastSequence != 0 {
t.Fatal(checkpoint, err)
}
// Simultaneous acknowledgments must not lose the larger watermark.
var wg sync.WaitGroup
for _, seq := range []int64{4, 2, 3, 1} {
wg.Add(1)
go func() {
defer wg.Done()
if err := s.CompleteActivityOutboxThrough("consumer-b", "synthetic-a", seq); err != nil {
t.Error(err)
}
}()
}
wg.Wait()
checkpoint, err = s.ActivityOutboxCheckpoint("consumer-b", "synthetic-a")
if err != nil || checkpoint.LastSequence != 4 {
t.Fatal(checkpoint, err)
}
if domains, err := s.PendingActivityConsumerDomains(ctx, sub, 100); err != nil || len(domains) != 1 || domains[0] != "synthetic-b" {
t.Fatal(domains, err)
}
s.ReadOnly = true
if err = s.CompleteActivityOutboxThrough("consumer-b", "synthetic-b", 4); !errors.Is(err, ErrReadOnly) {
t.Fatal("readonly", err)
}
})
}
}
@@ -0,0 +1,24 @@
package store
import (
"context"
"pageswiki/internal/db"
)
// The immutable journal and typed heads belong to core-metadata. Native
// writers advance heads in the source transaction; no SQLite trigger/backfill
// is run here. Consumer cursors are an independent schema component.
func (s *Store) ensurePostgreSQLActivityConsumers(ctx context.Context) error {
return db.ApplyPostgreSQLMigrations(ctx, s.DB, "store-activity-consumers", []db.PostgreSQLMigration{{Version: 1, Name: "independent activity consumer checkpoints", Statements: []string{
`CREATE TABLE activity_outbox_checkpoints(consumer_id TEXT COLLATE "C" NOT NULL,domain_uuid TEXT COLLATE "C" NOT NULL,last_sequence BIGINT NOT NULL DEFAULT 0 CHECK(last_sequence>=0),updated_at_ms BIGINT NOT NULL,PRIMARY KEY(consumer_id,domain_uuid))`,
`CREATE INDEX idx_activity_heads_type ON activity_outbox_heads(event_type,domain_uuid,last_sequence)`,
`CREATE INDEX idx_activity_outbox_subscription ON activity_outbox(domain_uuid,event_type,sequence)`,
`CREATE INDEX idx_activity_outbox_pending ON activity_outbox(status,next_attempt_ms,domain_uuid,sequence)`,
`CREATE INDEX idx_activity_outbox_target ON activity_outbox(domain_uuid,target_uuid,sequence)`,
}, Assertions: []string{
`SELECT consumer_id,domain_uuid,last_sequence,updated_at_ms FROM activity_outbox_checkpoints WHERE 1=0`,
`SELECT ` + activityOutboxColumns + ` FROM activity_outbox WHERE 1=0`,
`SELECT domain_uuid,event_type,last_sequence FROM activity_outbox_heads WHERE 1=0`,
}}})
}
+100 -17
View File
@@ -5,6 +5,7 @@ import (
"database/sql"
"encoding/json"
"errors"
"math"
"strings"
"time"
@@ -53,6 +54,14 @@ type ActivityOutboxCheckpoint struct {
var ErrActivityOutboxInput = errors.New("invalid activity outbox event")
func (s *Store) EnsureActivityOutboxSchema() error {
if s.ReadOnly {
return ErrReadOnly
}
if s.sqlBackend == storePostgreSQL {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
return s.ensurePostgreSQLActivityConsumers(ctx)
}
statements := []string{
`CREATE TABLE IF NOT EXISTS activity_outbox (
uuid TEXT PRIMARY KEY,
@@ -97,6 +106,9 @@ func (s *Store) EnsureActivityOutboxSchema() error {
// source mutation. Repeated idempotency keys return the original envelope and
// never create a second Domain sequence number.
func (s *Store) AppendActivityOutboxTx(tx *sql.Tx, event ActivityOutboxEvent) (ActivityOutboxRecord, bool, error) {
if s.ReadOnly {
return ActivityOutboxRecord{}, false, ErrReadOnly
}
event.DomainUUID = strings.TrimSpace(event.DomainUUID)
event.EventType = strings.TrimSpace(event.EventType)
event.IdempotencyKey = strings.TrimSpace(event.IdempotencyKey)
@@ -106,6 +118,9 @@ func (s *Store) AppendActivityOutboxTx(tx *sql.Tx, event ActivityOutboxEvent) (A
if event.UUID == "" {
event.UUID = uuid.NewString()
}
if s.sqlBackend == storePostgreSQL {
return s.appendNativeActivityOutboxTx(tx, event)
}
var existing ActivityOutboxRecord
err := scanActivityOutbox(tx.QueryRow(`SELECT `+activityOutboxColumns+`
FROM activity_outbox WHERE domain_uuid=? AND idempotency_key=?`, event.DomainUUID, event.IdempotencyKey), &existing)
@@ -137,6 +152,11 @@ func (s *Store) AppendActivityOutboxTx(tx *sql.Tx, event ActivityOutboxEvent) (A
// intentionally construct only a subset of the schema) usable while every
// normal Store created through New has the outbox table.
func (s *Store) appendActivityOutboxIfAvailable(tx *sql.Tx, event ActivityOutboxEvent) error {
if s.sqlBackend == storePostgreSQL {
// Native schemas are mandatory: absence is an error, not a lost event.
_, _, err := s.AppendActivityOutboxTx(tx, event)
return err
}
var present int
if err := tx.QueryRow(`SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='activity_outbox'`).Scan(&present); err != nil {
return err
@@ -148,15 +168,55 @@ func (s *Store) appendActivityOutboxIfAvailable(tx *sql.Tx, event ActivityOutbox
return err
}
// Native application writers hold the namespace advisory lock before any
// mutation. This shares sequence allocation with metadata.NewApplication.
func (s *Store) appendNativeActivityOutboxTx(tx *sql.Tx, e ActivityOutboxEvent) (ActivityOutboxRecord, bool, error) {
var result ActivityOutboxRecord
err := scanActivityOutbox(tx.QueryRow(`SELECT `+activityOutboxColumns+` FROM activity_outbox WHERE domain_uuid=$1 AND idempotency_key=$2`, e.DomainUUID, e.IdempotencyKey), &result)
if err == nil {
return result, false, nil
}
if !errors.Is(err, sql.ErrNoRows) {
return result, false, err
}
var last int64
if err = tx.QueryRow(`SELECT COALESCE(MAX(last_sequence),0) FROM activity_outbox_heads WHERE domain_uuid=$1`, e.DomainUUID).Scan(&last); err != nil {
return result, false, err
}
if last == math.MaxInt64 {
return result, false, ErrActivityOutboxInput
}
now := time.Now().UnixMilli()
_, err = tx.Exec(`INSERT INTO activity_outbox(uuid,domain_uuid,sequence,event_type,actor_uuid,target_kind,target_uuid,payload,idempotency_key,next_attempt_ms,created_at_ms) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11)`, e.UUID, e.DomainUUID, last+1, e.EventType, e.ActorUUID, e.TargetKind, e.TargetUUID, e.Payload, e.IdempotencyKey, now, now)
if err != nil {
return result, false, err
}
_, err = tx.Exec(`INSERT INTO activity_outbox_heads(domain_uuid,event_type,last_sequence) VALUES($1,$2,$3) ON CONFLICT(domain_uuid,event_type) DO UPDATE SET last_sequence=excluded.last_sequence`, e.DomainUUID, e.EventType, last+1)
if err != nil {
return result, false, err
}
err = scanActivityOutbox(tx.QueryRow(`SELECT `+activityOutboxColumns+` FROM activity_outbox WHERE uuid=$1`, e.UUID), &result)
return result, err == nil, err
}
func (s *Store) appendRevisionActivityOutboxIfAvailable(tx *sql.Tx, revision *Revision) error {
// Legacy unit fixtures may omit the entire outbox. Check that explicitly;
// once it exists, an unexpected source lookup error must abort the save,
// not silently commit a revision with no event.
var present int
if err := tx.QueryRow(`SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='activity_outbox'`).Scan(&present); err != nil {
return err
}
if present == 0 {
return nil
}
var domainUUID string
err := tx.QueryRow(`SELECT domain_uuid FROM paths WHERE object_uuid=? ORDER BY is_primary DESC, path LIMIT 1`, revision.ObjectUUID).Scan(&domainUUID)
if errors.Is(err, sql.ErrNoRows) {
return nil
}
if err != nil {
// Asset-only or legacy fixtures may not have a path for the object.
return nil
return err
}
payload, err := json.Marshal(map[string]any{
"revision_uuid": revision.UUID, "object_uuid": revision.ObjectUUID,
@@ -166,10 +226,11 @@ func (s *Store) appendRevisionActivityOutboxIfAvailable(tx *sql.Tx, revision *Re
if err != nil {
return err
}
return s.appendActivityOutboxIfAvailable(tx, ActivityOutboxEvent{
_, _, err = s.AppendActivityOutboxTx(tx, ActivityOutboxEvent{
DomainUUID: domainUUID, EventType: "revision.created", TargetKind: "revision", TargetUUID: revision.UUID,
Payload: string(payload), IdempotencyKey: "revision.created:" + revision.UUID,
})
return err
}
const activityOutboxColumns = `uuid,domain_uuid,sequence,event_type,actor_uuid,target_kind,target_uuid,payload,idempotency_key,status,attempts,next_attempt_ms,last_error,created_at_ms,claimed_at_ms`
@@ -185,13 +246,16 @@ func scanActivityOutbox(scanner interface{ Scan(...any) error }, out *ActivityOu
// authorization policy without making reads of the source object implicit.
// Deprecated: this is a legacy-status inspection, not consumer pending work.
// New workers must use ActivityOutboxForConsumer and their own checkpoint.
func (s *Store) PendingActivityOutbox(ctx context.Context, domainUUID string, limit int) ([]ActivityOutboxRecord, error) {
func (s *Store) PendingActivityOutbox(ctx context.Context, domainUUID string, limit int) (_ []ActivityOutboxRecord, resultErr error) {
defer func() { resultErr = s.sqlError("pending activity", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
if limit < 1 || limit > 500 {
limit = 100
}
rows, err := s.DB.QueryContext(ctx, `SELECT `+activityOutboxColumns+` FROM activity_outbox
WHERE status='pending' AND next_attempt_ms<=? AND (?='' OR domain_uuid=?)
ORDER BY domain_uuid,sequence LIMIT ?`, time.Now().UnixMilli(), domainUUID, domainUUID, limit)
WHERE status='pending' AND next_attempt_ms<=`+s.sqlParam(1)+` AND (`+s.sqlParam(2)+`='' OR domain_uuid=`+s.sqlParam(3)+`)
ORDER BY domain_uuid,sequence LIMIT `+s.sqlParam(4), time.Now().UnixMilli(), domainUUID, domainUUID, limit)
if err != nil {
return nil, err
}
@@ -210,7 +274,10 @@ func (s *Store) PendingActivityOutbox(ctx context.Context, domainUUID string, li
// ActivityOutboxAfter reads the immutable Domain sequence independently for
// each consumer. It intentionally includes every status: a consumer's
// checkpoint, rather than a shared job status, is the delivery contract.
func (s *Store) ActivityOutboxAfter(ctx context.Context, domainUUID string, afterSequence int64, limit int) ([]ActivityOutboxRecord, error) {
func (s *Store) ActivityOutboxAfter(ctx context.Context, domainUUID string, afterSequence int64, limit int) (_ []ActivityOutboxRecord, resultErr error) {
defer func() { resultErr = s.sqlError("activity history", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
if strings.TrimSpace(domainUUID) == "" || afterSequence < 0 {
return nil, ErrActivityOutboxInput
}
@@ -218,7 +285,7 @@ func (s *Store) ActivityOutboxAfter(ctx context.Context, domainUUID string, afte
limit = 100
}
rows, err := s.DB.QueryContext(ctx, `SELECT `+activityOutboxColumns+` FROM activity_outbox
WHERE domain_uuid=? AND sequence>? ORDER BY sequence LIMIT ?`, domainUUID, afterSequence, limit)
WHERE domain_uuid=`+s.sqlParam(1)+` AND sequence>`+s.sqlParam(2)+` ORDER BY sequence LIMIT `+s.sqlParam(3), domainUUID, afterSequence, limit)
if err != nil {
return nil, err
}
@@ -234,13 +301,16 @@ func (s *Store) ActivityOutboxAfter(ctx context.Context, domainUUID string, afte
return items, rows.Err()
}
func (s *Store) ActivityOutboxCheckpoint(consumerID, domainUUID string) (ActivityOutboxCheckpoint, error) {
func (s *Store) ActivityOutboxCheckpoint(consumerID, domainUUID string) (_ ActivityOutboxCheckpoint, resultErr error) {
defer func() { resultErr = s.sqlError("activity checkpoint", resultErr) }()
consumerID, domainUUID = strings.TrimSpace(consumerID), strings.TrimSpace(domainUUID)
if consumerID == "" || domainUUID == "" {
return ActivityOutboxCheckpoint{}, ErrActivityOutboxInput
}
var checkpoint ActivityOutboxCheckpoint
err := s.DB.QueryRow(`SELECT consumer_id,domain_uuid,last_sequence,updated_at_ms FROM activity_outbox_checkpoints WHERE consumer_id=? AND domain_uuid=?`, consumerID, domainUUID).
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
err := s.DB.QueryRowContext(ctx, `SELECT consumer_id,domain_uuid,last_sequence,updated_at_ms FROM activity_outbox_checkpoints WHERE consumer_id=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2), consumerID, domainUUID).
Scan(&checkpoint.ConsumerID, &checkpoint.DomainUUID, &checkpoint.LastSequence, &checkpoint.UpdatedAtMS)
if errors.Is(err, sql.ErrNoRows) {
return ActivityOutboxCheckpoint{ConsumerID: consumerID, DomainUUID: domainUUID}, nil
@@ -251,25 +321,35 @@ func (s *Store) ActivityOutboxCheckpoint(consumerID, domainUUID string) (Activit
// AdvanceActivityOutboxCheckpointTx is monotonic and safe to call after an
// idempotently completed consumer action. A stale retry can never move the
// checkpoint backwards.
func (s *Store) AdvanceActivityOutboxCheckpointTx(tx *sql.Tx, consumerID, domainUUID string, sequence int64) error {
func (s *Store) AdvanceActivityOutboxCheckpointTx(tx *sql.Tx, consumerID, domainUUID string, sequence int64) (resultErr error) {
defer func() { resultErr = s.sqlError("activity checkpoint", resultErr) }()
if s.ReadOnly {
return ErrReadOnly
}
consumerID, domainUUID = strings.TrimSpace(consumerID), strings.TrimSpace(domainUUID)
if consumerID == "" || domainUUID == "" || sequence < 0 {
return ErrActivityOutboxInput
}
now := time.Now().UnixMilli()
_, err := tx.Exec(`INSERT INTO activity_outbox_checkpoints(consumer_id,domain_uuid,last_sequence,updated_at_ms)
VALUES(?,?,?,?) ON CONFLICT(consumer_id,domain_uuid) DO UPDATE SET
last_sequence=CASE WHEN excluded.last_sequence>last_sequence THEN excluded.last_sequence ELSE last_sequence END,
updated_at_ms=CASE WHEN excluded.last_sequence>last_sequence THEN excluded.updated_at_ms ELSE updated_at_ms END`, consumerID, domainUUID, sequence, now)
VALUES(`+s.sqlValues(4)+`) ON CONFLICT(consumer_id,domain_uuid) DO UPDATE SET
last_sequence=CASE WHEN excluded.last_sequence>activity_outbox_checkpoints.last_sequence THEN excluded.last_sequence ELSE activity_outbox_checkpoints.last_sequence END,
updated_at_ms=CASE WHEN excluded.last_sequence>activity_outbox_checkpoints.last_sequence THEN excluded.updated_at_ms ELSE activity_outbox_checkpoints.updated_at_ms END`, consumerID, domainUUID, sequence, now)
return err
}
func (s *Store) AdvanceActivityOutboxCheckpoint(consumerID, domainUUID string, sequence int64) error {
tx, err := s.DB.Begin()
func (s *Store) AdvanceActivityOutboxCheckpoint(consumerID, domainUUID string, sequence int64) (err error) {
defer func() { err = s.sqlError("activity checkpoint", err) }()
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
if err = s.lockTaskWriter(ctx, tx); err != nil {
return err
}
if err := s.AdvanceActivityOutboxCheckpointTx(tx, consumerID, domainUUID, sequence); err != nil {
return err
}
@@ -278,7 +358,10 @@ func (s *Store) AdvanceActivityOutboxCheckpoint(consumerID, domainUUID string, s
// Deprecated: use PendingActivityConsumerDomains; a shared status cannot
// represent delivery to independent subscribers.
func (s *Store) PendingActivityOutboxDomains(ctx context.Context) ([]string, error) {
func (s *Store) PendingActivityOutboxDomains(ctx context.Context) (_ []string, resultErr error) {
defer func() { resultErr = s.sqlError("pending activity domains", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
rows, err := s.DB.QueryContext(ctx, `SELECT DISTINCT domain_uuid FROM activity_outbox WHERE status='pending' ORDER BY domain_uuid LIMIT 100`)
if err != nil {
return nil, err
+37
View File
@@ -9,6 +9,43 @@ import (
"pageswiki/internal/db"
)
func TestRevisionOutboxLookupFailureRollsBackSource(t *testing.T) {
database, err := db.Open(t.TempDir() + "/outbox.db")
if err != nil {
t.Fatal(err)
}
defer database.Close()
if err := db.Migrate(database); err != nil {
t.Fatal(err)
}
s := New(database)
id, err := s.CreatePageAtPath("/guide")
if err != nil {
t.Fatal(err)
}
if _, err := s.SaveRevision(id, "<p>original</p>", "first"); err != nil {
t.Fatal(err)
}
var before int
if err := database.QueryRow(`SELECT count(*) FROM activity_outbox`).Scan(&before); err != nil {
t.Fatal(err)
}
// Keep object/revision storage valid but break only the event source lookup.
if _, err := database.Exec(`ALTER TABLE paths RENAME COLUMN domain_uuid TO misplaced_domain_uuid`); err != nil {
t.Fatal(err)
}
if _, err := s.SaveRevision(id, "<p>must roll back</p>", "second"); err == nil {
t.Fatal("source lookup error was swallowed")
}
var revisions, events int
if err := database.QueryRow(`SELECT count(*) FROM revisions WHERE object_uuid=?`, id).Scan(&revisions); err != nil || revisions != 1 {
t.Fatal("revision committed without outbox", err, revisions)
}
if err := database.QueryRow(`SELECT count(*) FROM activity_outbox`).Scan(&events); err != nil || events != before {
t.Fatal("partial outbox commit", err, events)
}
}
func TestActivityOutboxIdempotencyAndDomainSequence(t *testing.T) {
db, err := sql.Open("sqlite", ":memory:")
if err != nil {
+20 -5
View File
@@ -3,6 +3,7 @@ package store
import (
"context"
"strings"
"time"
)
// Subscriptions are trusted worker configuration, never request parameters.
@@ -67,7 +68,10 @@ func (s *Store) ensureActivitySubscriptions() error {
// PendingActivityConsumerDomains does not scan event history or rely on the
// legacy shared status. Acknowledgment by another consumer cannot hide work.
func (s *Store) PendingActivityConsumerDomains(ctx context.Context, sub ActivitySubscription, limit int) ([]string, error) {
func (s *Store) PendingActivityConsumerDomains(ctx context.Context, sub ActivitySubscription, limit int) (_ []string, resultErr error) {
defer func() { resultErr = s.sqlError("activity subscriber domains", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
marks, args, err := sub.filter()
if err != nil {
return nil, err
@@ -77,7 +81,14 @@ func (s *Store) PendingActivityConsumerDomains(ctx context.Context, sub Activity
}
args = append([]any{sub.ConsumerID}, args...)
args = append(args, limit)
rows, err := s.DB.QueryContext(ctx, `SELECT h.domain_uuid FROM activity_outbox_heads h LEFT JOIN activity_outbox_checkpoints c ON c.domain_uuid=h.domain_uuid AND c.consumer_id=? WHERE h.event_type IN (`+marks+`) AND h.last_sequence>COALESCE(c.last_sequence,0) GROUP BY h.domain_uuid ORDER BY COALESCE(c.updated_at_ms,0),h.domain_uuid LIMIT ?`, args...)
if s.sqlBackend == storePostgreSQL {
params := make([]string, len(sub.EventTypes))
for i := range params {
params[i] = s.sqlParam(i + 2)
}
marks = strings.Join(params, ",")
}
rows, err := s.DB.QueryContext(ctx, `SELECT h.domain_uuid FROM activity_outbox_heads h LEFT JOIN activity_outbox_checkpoints c ON c.domain_uuid=h.domain_uuid AND c.consumer_id=`+s.sqlParam(1)+` WHERE h.event_type IN (`+marks+`) AND h.last_sequence>COALESCE(c.last_sequence,0) GROUP BY h.domain_uuid ORDER BY MIN(COALESCE(c.updated_at_ms,0)),h.domain_uuid LIMIT `+s.sqlParam(len(args)), args...)
if err != nil {
return nil, err
}
@@ -95,7 +106,10 @@ func (s *Store) PendingActivityConsumerDomains(ctx context.Context, sub Activity
// The SQL limit is applied per type first, so unrelated floods and SQLite's
// final multi-type ordering cannot materialize an unbounded pending backlog.
func (s *Store) ActivityOutboxForConsumer(ctx context.Context, sub ActivitySubscription, domain string, limit int) ([]ActivityOutboxRecord, error) {
func (s *Store) ActivityOutboxForConsumer(ctx context.Context, sub ActivitySubscription, domain string, limit int) (_ []ActivityOutboxRecord, resultErr error) {
defer func() { resultErr = s.sqlError("activity subscriber history", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
_, _, err := sub.filter()
if err != nil || domain == "" {
return nil, ErrActivityOutboxInput
@@ -106,11 +120,12 @@ func (s *Store) ActivityOutboxForConsumer(ctx context.Context, sub ActivitySubsc
queries := []string{}
args := []any{}
for _, typ := range sub.EventTypes {
queries = append(queries, `SELECT * FROM (SELECT `+activityOutboxColumns+` FROM activity_outbox WHERE domain_uuid=? AND event_type=? AND sequence>COALESCE((SELECT last_sequence FROM activity_outbox_checkpoints WHERE consumer_id=? AND domain_uuid=?),0) ORDER BY sequence LIMIT ?)`)
i := len(args)
queries = append(queries, `SELECT * FROM (SELECT `+activityOutboxColumns+` FROM activity_outbox WHERE domain_uuid=`+s.sqlParam(i+1)+` AND event_type=`+s.sqlParam(i+2)+` AND sequence>COALESCE((SELECT last_sequence FROM activity_outbox_checkpoints WHERE consumer_id=`+s.sqlParam(i+3)+` AND domain_uuid=`+s.sqlParam(i+4)+`),0) ORDER BY sequence LIMIT `+s.sqlParam(i+5)+`) AS typed_events`)
args = append(args, domain, typ, sub.ConsumerID, domain, limit)
}
args = append(args, limit)
rows, err := s.DB.QueryContext(ctx, strings.Join(queries, " UNION ")+` ORDER BY sequence LIMIT ?`, args...)
rows, err := s.DB.QueryContext(ctx, strings.Join(queries, " UNION ")+` ORDER BY sequence LIMIT `+s.sqlParam(len(args)), args...)
if err != nil {
return nil, err
}
+15
View File
@@ -50,6 +50,9 @@ func (s *Store) IssueAdapterTicketForPrincipal(principalUUID, domainUUID, plugin
}
func (s *Store) issueAdapterTicket(principalUUID, domainUUID, pluginID, objectUUID, revisionUUID, rootPath string) (string, error) {
if !s.SupportsHostedEditors() {
return "", ErrBackendFeatureUnavailable
}
token, hash, err := adapterSecret("pwa_t_")
if err != nil {
return "", err
@@ -70,6 +73,9 @@ func secretHash(token string) string {
}
func (s *Store) ExchangeAdapterTicket(ticket string) (string, *AdapterSession, error) {
if !s.SupportsHostedEditors() {
return "", nil, ErrBackendFeatureUnavailable
}
tx, err := s.DB.Begin()
if err != nil {
return "", nil, err
@@ -111,6 +117,9 @@ func (s *Store) ExchangeAdapterTicket(ticket string) (string, *AdapterSession, e
}
func (s *Store) GetAdapterSession(token string) (*AdapterSession, error) {
if !s.SupportsHostedEditors() {
return nil, ErrBackendFeatureUnavailable
}
var session AdapterSession
err := s.DB.QueryRow(`SELECT principal_uuid,domain_uuid,plugin_id,object_uuid,base_revision_uuid,root_path,
session_hash,session_expires_at_ms FROM adapter_sessions WHERE session_hash=?`,
@@ -123,10 +132,16 @@ func (s *Store) GetAdapterSession(token string) (*AdapterSession, error) {
}
func (s *Store) SaveHostedRevision(session *AdapterSession, payload []byte, message string) (*Revision, error) {
if !s.SupportsHostedEditors() {
return nil, ErrBackendFeatureUnavailable
}
return s.SaveHostedRevisionAt(session, session.ObjectUUID, session.BaseRevisionUUID, payload, message)
}
func (s *Store) SaveHostedRevisionAt(session *AdapterSession, objectUUID, baseRevisionUUID string, payload []byte, message string) (*Revision, error) {
if !s.SupportsHostedEditors() {
return nil, ErrBackendFeatureUnavailable
}
s.revisionWriteMu.Lock()
defer s.revisionWriteMu.Unlock()
base, err := s.GetRevision(baseRevisionUUID)
+825
View File
@@ -0,0 +1,825 @@
package store
import (
"context"
"crypto/sha256"
"database/sql"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"os"
"path/filepath"
"sort"
"strings"
"time"
"pageswiki/internal/calendar"
"pageswiki/internal/metadata"
)
type ImportedTable struct {
Name string `json:"name"`
Rows int64 `json:"rows"`
SHA256 string `json:"sha256"`
}
type applicationImportRefusal struct{ reason string }
func (e *applicationImportRefusal) Error() string { return e.reason }
func importRefuse(reason string) error { return &applicationImportRefusal{reason} }
func importRefusef(format string, args ...any) error {
return importRefuse(fmt.Sprintf(format, args...))
}
type ApplicationImportReport struct {
Tables []ImportedTable `json:"tables"`
Omitted []string `json:"omitted"`
Documents int64 `json:"documents"`
Fingerprint string `json:"fingerprint"`
Sequences map[string]int64 `json:"sequences"`
Transforms []string `json:"transforms"`
}
// ImportSQLiteApplication imports into an EMPTY, already prepared PostgreSQL
// schema. The caller holds an exclusive data-directory lock and stops all
// writers. Files stay at documentRoot; no source rows or canonical files are
// changed. This is not a merge or an online migration.
func ImportSQLiteApplication(ctx context.Context, source, target *sql.DB, documentRoot string) (report ApplicationImportReport, err error) {
key, err := existingAuthKey(documentRoot)
if err != nil {
return report, err
}
root, err := filepath.Abs(documentRoot)
if err != nil {
return report, err
}
if info, e := os.Stat(root); e != nil || !info.IsDir() {
return report, ErrDocumentStoreRequired
}
s := &Store{DB: target, sqlBackend: storePostgreSQL, DocumentRoot: root}
defer func() {
if err != nil {
var refused *applicationImportRefusal
if errors.As(err, &refused) {
return
}
err = s.sqlError("application import", err)
}
}()
from, err := source.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
if err != nil {
return report, err
}
defer from.Rollback()
tables, err := inspectApplicationImportSource(ctx, from)
if err != nil {
return report, err
}
to, err := target.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelSerializable})
if err != nil {
return report, err
}
defer to.Rollback()
if err = inspectApplicationImportTarget(ctx, to); err != nil {
return report, err
}
if _, err = to.ExecContext(ctx, `SELECT pg_advisory_xact_lock(1885431653,1853058931)`); err != nil {
return report, err
}
var completed bool
if err = to.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM application_import_receipts)`).Scan(&completed); err != nil {
return report, err
}
if completed {
return report, importRefuse("application import already completed; overwrite is forbidden")
}
names := make([]string, 0, len(applicationImportColumns))
for name := range applicationImportColumns {
names = append(names, name)
}
sort.Strings(names)
// Validate all destination columns and take table locks before emptiness
// checks. Only exact schema-provided seed rows may be removed.
for _, name := range names {
if _, err = to.ExecContext(ctx, `LOCK TABLE `+importIdent(name)+` IN ACCESS EXCLUSIVE MODE`); err != nil {
return report, err
}
var n int64
if err = to.QueryRowContext(ctx, `SELECT count(*) FROM `+importIdent(name)).Scan(&n); err != nil {
return report, err
}
if n > 0 {
predicate, ok := importSeedPredicates[name]
if !ok {
return report, importRefusef("import destination is not empty: %s", name)
}
var valid bool
if err = to.QueryRowContext(ctx, `SELECT count(*)=1 AND bool_and(`+predicate+`) FROM `+importIdent(name)).Scan(&valid); err != nil {
return report, err
}
if !valid {
return report, importRefusef("import destination seed has changed: %s", name)
}
}
// User triggers derive state or revoke publication on normal writes.
// Suspend them only inside this transaction while restoring exact state.
// Foreign keys and CHECK/UNIQUE constraints stay enabled throughout.
if _, err = to.ExecContext(ctx, `ALTER TABLE `+importIdent(name)+` DISABLE TRIGGER USER`); err != nil {
return report, err
}
}
for name := range importSeedPredicates {
if _, err = to.ExecContext(ctx, `DELETE FROM `+importIdent(name)); err != nil {
return report, err
}
}
order, err := importTableOrder(ctx, to, names)
if err != nil {
return report, err
}
for _, name := range order {
columns := applicationImportColumns[name]
if !tables[name] {
if !strings.HasPrefix(name, "calendar_") {
return report, importRefusef("missing source table: %s", name)
}
continue
}
fingerprint, err := copyImportTable(ctx, from, to, name, strings.Split(columns, ","))
if err != nil {
return report, err
}
report.Tables = append(report.Tables, fingerprint)
}
// Source-only structures are explicitly classified, not inferred by prefix.
for name := range tables {
if _, ok := applicationImportOmissions[name]; ok {
report.Omitted = append(report.Omitted, name)
}
}
sort.Strings(report.Omitted)
report.Transforms = []string{"task DAV index keys: SQLite NUL-separated to native v1 base64url (resources and deletion tombstones)"}
// Verify every retained Document reference before committing metadata.
docs, err := s.documentStorage()
if err != nil {
return report, err
}
refs, err := to.QueryContext(ctx, `SELECT document_hash FROM revisions UNION SELECT head_document_hash FROM assets UNION SELECT document_hash FROM revision_document_refs UNION SELECT document_hash FROM asset_head_history`)
if err != nil {
return report, err
}
for refs.Next() {
var hash string
if err = refs.Scan(&hash); err != nil {
refs.Close()
return report, err
}
if err = docs.Verify(ctx, hash); err != nil {
refs.Close()
return report, importRefuse("canonical Document missing or hash mismatch; import rolled back")
}
report.Documents++
}
err = refs.Err()
refs.Close()
if err != nil {
return report, err
}
if err = validateImportedBindings(ctx, to); err != nil {
return report, err
}
for _, name := range names {
if _, err = to.ExecContext(ctx, `ALTER TABLE `+importIdent(name)+` ENABLE TRIGGER USER`); err != nil {
return report, err
}
}
// Sequence reset uses transactional ALTER, not non-transactional setval.
report.Sequences, err = sourceImportSequences(ctx, from)
if err != nil {
return report, err
}
if err = resetImportIdentities(ctx, to, report.Sequences); err != nil {
return report, err
}
sort.Slice(report.Tables, func(i, j int) bool { return report.Tables[i].Name < report.Tables[j].Name })
b, _ := json.Marshal(report)
sum := sha256.Sum256(b)
report.Fingerprint = hex.EncodeToString(sum[:])
b, _ = json.Marshal(report)
ks := sha256.Sum256(key)
if _, err = to.ExecContext(ctx, `INSERT INTO application_import_receipts VALUES(1,$1,$2,$3,$4,$5)`, report.Fingerprint, root, hex.EncodeToString(ks[:]), string(b), time.Now().UnixMilli()); err != nil {
return report, err
}
if err = ctx.Err(); err != nil {
return report, err
}
err = to.Commit()
return report, err
}
var importSeedPredicates = map[string]string{
"organizer_contact_epoch": `id=1 AND value ~ '^[a-f0-9]{64}$'`,
"organizer_activity_bridge": `id=1 AND last_sequence=0`,
"navigation_generation": `id=1 AND version=1`,
"event_queue_settings": `id=1 AND concurrency=1 AND max_depth=10000 AND paused=0 AND retry_base_seconds=30 AND retention_hours=168`,
"event_log_policies": `event_type='*' AND retention_hours=168 AND aggregate_after_hours=24 AND bucket_seconds=60 AND max_rows=5000`,
}
func importIdent(s string) string { return `"` + strings.ReplaceAll(s, `"`, `""`) + `"` }
func inspectApplicationImportSource(ctx context.Context, tx *sql.Tx) (map[string]bool, error) {
rows, err := tx.QueryContext(ctx, `SELECT name FROM sqlite_master WHERE type='table' AND substr(name,1,7)!='sqlite_' ORDER BY name`)
if err != nil {
return nil, err
}
names := map[string]bool{}
for rows.Next() {
var n string
if err = rows.Scan(&n); err != nil {
rows.Close()
return nil, err
}
names[n] = true
}
err = rows.Err()
rows.Close()
if err != nil {
return nil, err
}
for name := range names {
expected, ok := applicationImportColumns[name]
if !ok {
expected, ok = applicationImportOmissions[name]
}
if !ok {
return nil, importRefusef("unclassified source table: %s", name)
}
cols, err := tx.QueryContext(ctx, `SELECT name FROM pragma_table_info(?) ORDER BY name`, name)
if err != nil {
return nil, err
}
var got []string
for cols.Next() {
var n string
if err = cols.Scan(&n); err != nil {
cols.Close()
return nil, err
}
got = append(got, n)
}
err = cols.Err()
cols.Close()
if err != nil {
return nil, err
}
if strings.Join(got, ",") != expected {
return nil, importRefusef("source columns differ: %s", name)
}
}
for name := range applicationImportColumns {
if !names[name] && !strings.HasPrefix(name, "calendar_") {
return nil, importRefusef("missing source table: %s", name)
}
}
objects, err := tx.QueryContext(ctx, `SELECT type,name,sql FROM sqlite_master WHERE type IN ('trigger','view') ORDER BY name`)
if err != nil {
return nil, err
}
for objects.Next() {
var kind, name, ddl string
if err = objects.Scan(&kind, &name, &ddl); err != nil {
objects.Close()
return nil, err
}
sum := sha256.Sum256([]byte(ddl))
if applicationImportSourceObjects[name] != kind+":"+hex.EncodeToString(sum[:]) {
objects.Close()
return nil, importRefusef("unclassified or modified source %s: %s", kind, name)
}
}
err = objects.Err()
objects.Close()
if err != nil {
return nil, err
}
return names, nil
}
func inspectApplicationImportTarget(ctx context.Context, tx *sql.Tx) error {
rows, err := tx.QueryContext(ctx, `SELECT table_name,column_name FROM information_schema.columns WHERE table_schema=current_schema() ORDER BY table_name,column_name`)
if err != nil {
return err
}
got := map[string][]string{}
for rows.Next() {
var t, c string
if err = rows.Scan(&t, &c); err != nil {
rows.Close()
return err
}
got[t] = append(got[t], c)
}
err = rows.Err()
rows.Close()
if err != nil {
return err
}
for name, cols := range got {
if name == "schema_migration_steps" || name == "application_import_receipts" {
continue
}
expected, ok := applicationImportColumns[name]
if !ok {
return importRefusef("unclassified destination table: %s", name)
}
if name == "event_jobs" {
expected += ",claim_token"
p := strings.Split(expected, ",")
sort.Strings(p)
expected = strings.Join(p, ",")
}
if strings.Join(cols, ",") != expected {
return importRefusef("destination columns differ: %s", name)
}
}
for name := range applicationImportColumns {
if _, ok := got[name]; !ok {
return importRefusef("missing destination table: %s", name)
}
}
return nil
}
func importTableOrder(ctx context.Context, tx *sql.Tx, names []string) ([]string, error) {
deps := map[string][]string{}
rows, err := tx.QueryContext(ctx, `SELECT a.relname,b.relname FROM pg_constraint f JOIN pg_class a ON a.oid=f.conrelid JOIN pg_class b ON b.oid=f.confrelid JOIN pg_namespace n ON n.oid=a.relnamespace WHERE f.contype='f' AND n.nspname=current_schema()`)
if err != nil {
return nil, err
}
for rows.Next() {
var a, b string
if err = rows.Scan(&a, &b); err != nil {
rows.Close()
return nil, err
}
if a != b {
deps[a] = append(deps[a], b)
}
}
err = rows.Err()
rows.Close()
if err != nil {
return nil, err
}
var order []string
seen := map[string]bool{}
for len(order) < len(names) {
changed := false
for _, name := range names {
if seen[name] {
continue
}
ready := true
for _, dep := range deps[name] {
ready = ready && seen[dep]
}
if ready {
order = append(order, name)
seen[name] = true
changed = true
}
}
if !changed {
return nil, importRefuse("unsupported import foreign key dependency")
}
}
return order, nil
}
func importSelect(name string, columns []string, pg bool) string {
quoted := make([]string, len(columns))
for i, c := range columns {
quoted[i] = importIdent(c)
}
// All columns participate, including duplicate legacy tags. SQL collation
// is kept bytewise to produce the same deterministic row stream.
order := make([]string, len(columns))
for i, q := range quoted {
if pg {
order[i] = q + ` NULLS FIRST`
} else {
order[i] = q + ` COLLATE BINARY NULLS FIRST`
}
}
if name == "organizer_task_deletions" {
order = []string{`"domain_uuid" COLLATE BINARY`, `"item_uuid" COLLATE BINARY`}
if pg {
order = []string{`"domain_uuid" COLLATE "C"`, `"item_uuid" COLLATE "C"`}
}
}
return `SELECT ` + strings.Join(quoted, ",") + ` FROM ` + importIdent(name) + ` ORDER BY ` + strings.Join(order, ",")
}
func copyImportTable(ctx context.Context, from, to *sql.Tx, name string, columns []string) (ImportedTable, error) {
result := ImportedTable{Name: name}
hash := sha256.New()
rows, err := from.QueryContext(ctx, importSelect(name, columns, false))
if err != nil {
return result, err
}
defer rows.Close()
quoted := make([]string, len(columns))
for i, c := range columns {
quoted[i] = importIdent(c)
}
var batch [][]any
bytes := 0
flush := func() error {
if len(batch) == 0 {
return nil
}
args := make([]any, 0, len(batch)*len(columns))
values := make([]string, 0, len(batch))
for _, row := range batch {
p := make([]string, len(columns))
for i, v := range row {
args = append(args, v)
p[i] = fmt.Sprintf("$%d", len(args))
}
values = append(values, "("+strings.Join(p, ",")+")")
}
_, err := to.ExecContext(ctx, `INSERT INTO `+importIdent(name)+` (`+strings.Join(quoted, ",")+`) OVERRIDING SYSTEM VALUE VALUES `+strings.Join(values, ","), args...)
batch = nil
bytes = 0
return err
}
for rows.Next() {
v := make([]any, len(columns))
dest := make([]any, len(v))
for i := range v {
dest[i] = &v[i]
}
if err = rows.Scan(dest...); err != nil {
return result, err
}
if err = normalizeImportRow(name, columns, v); err != nil {
return result, err
}
b, err := importRowBytes(v)
if err != nil {
return result, err
}
if len(b) > 64<<20 {
return result, importRefuse("import row exceeds 64 MiB safety limit")
}
hash.Write(b)
hash.Write([]byte{'\n'})
result.Rows++
batch = append(batch, v)
bytes += len(b)
if len(batch) >= 100 || bytes >= 2<<20 {
if err = flush(); err != nil {
return result, err
}
}
}
if err = rows.Err(); err != nil {
return result, err
}
rows.Close()
if err = flush(); err != nil {
return result, err
}
result.SHA256 = hex.EncodeToString(hash.Sum(nil))
// Re-read retained values, not only row counts. Bytea/NULL/integer/text
// retain their JSON type tags, so conversion or loss fails the transaction.
selectSQL := importSelect(name, columns, true)
// Force bytewise ordering for TEXT regardless of the database default.
meta, err := to.QueryContext(ctx, `SELECT column_name FROM information_schema.columns WHERE table_schema=current_schema() AND table_name=$1 AND data_type IN ('text','character varying','character')`, name)
if err != nil {
return result, err
}
textCols := map[string]bool{}
for meta.Next() {
var c string
if err = meta.Scan(&c); err != nil {
meta.Close()
return result, err
}
textCols[c] = true
}
err = meta.Err()
meta.Close()
if err != nil {
return result, err
}
ordering := make([]string, len(columns))
for i, c := range columns {
ordering[i] = importIdent(c)
if textCols[c] {
ordering[i] += ` COLLATE "C"`
}
ordering[i] += " NULLS FIRST"
}
if name == "organizer_task_deletions" {
ordering = []string{`"domain_uuid" COLLATE "C"`, `"item_uuid" COLLATE "C"`}
}
selectSQL = selectSQL[:strings.Index(selectSQL, " ORDER BY ")] + " ORDER BY " + strings.Join(ordering, ",")
check, err := to.QueryContext(ctx, selectSQL)
if err != nil {
return result, err
}
defer check.Close()
h := sha256.New()
var count int64
for check.Next() {
v := make([]any, len(columns))
dest := make([]any, len(v))
for i := range v {
dest[i] = &v[i]
}
if err = check.Scan(dest...); err != nil {
return result, err
}
b, err := importRowBytes(v)
if err != nil {
return result, err
}
h.Write(b)
h.Write([]byte{'\n'})
count++
}
if err = check.Err(); err != nil {
return result, err
}
if count != result.Rows || hex.EncodeToString(h.Sum(nil)) != result.SHA256 {
return result, importRefusef("import content fingerprint differs: %s", name)
}
return result, nil
}
func normalizeImportRow(table string, columns []string, values []any) error {
for i, column := range columns {
// SQLite may scan a non-NULL zero-length BLOB as []byte(nil).
// pgx binds that slice as SQL NULL unless made explicitly non-nil.
if b, ok := values[i].([]byte); ok && b == nil {
values[i] = []byte{}
}
if !(table == "organizer_dav_resources" && (column == "name" || column == "uid")) &&
!(table == "organizer_task_deletions" && (column == "dav_name" || column == "dav_uid")) {
continue
}
value, ok := values[i].(string)
if !ok {
return importRefuse("invalid task DAV index scalar")
}
project := ""
if strings.HasPrefix(value, "\x00") {
parts := strings.Split(value, "\x00")
if len(parts) != 3 || parts[1] == "" || parts[2] == "" {
return importRefuse("invalid legacy task DAV index key")
}
project, value = parts[1], parts[2]
} else if strings.ContainsRune(value, 0) {
return importRefuse("invalid legacy task DAV index key")
}
values[i] = nativeTaskDAVIndexKey(project, value)
}
return nil
}
func resetImportIdentities(ctx context.Context, tx *sql.Tx, sourceSequences map[string]int64) error {
rows, err := tx.QueryContext(ctx, `SELECT table_name,column_name FROM information_schema.columns WHERE table_schema=current_schema() AND is_identity='YES'`)
if err != nil {
return err
}
var ids [][2]string
for rows.Next() {
var t, c string
if err = rows.Scan(&t, &c); err != nil {
rows.Close()
return err
}
ids = append(ids, [2]string{t, c})
}
err = rows.Err()
rows.Close()
if err != nil {
return err
}
for _, id := range ids {
if _, ok := applicationImportColumns[id[0]]; !ok {
return importRefuse("unclassified identity")
}
var next int64
if err = tx.QueryRowContext(ctx, `SELECT COALESCE(max(`+importIdent(id[1])+`),0)+1 FROM `+importIdent(id[0])).Scan(&next); err != nil {
return err
}
if next < 1 {
return importRefuse("identity overflow")
}
if previous := sourceSequences[id[0]]; previous >= next {
if previous == int64(^uint64(0)>>1) {
return importRefuse("identity exhausted")
}
next = previous + 1
}
if _, err = tx.ExecContext(ctx, `ALTER TABLE `+importIdent(id[0])+` ALTER COLUMN `+importIdent(id[1])+` RESTART WITH `+fmt.Sprint(next)); err != nil {
return err
}
}
return nil
}
func sourceImportSequences(ctx context.Context, tx *sql.Tx) (map[string]int64, error) {
out := map[string]int64{}
var exists bool
if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE name='sqlite_sequence')`).Scan(&exists); err != nil {
return nil, err
}
if !exists {
return out, nil
}
rows, err := tx.QueryContext(ctx, `SELECT name,seq FROM sqlite_sequence`)
if err != nil {
return nil, err
}
defer rows.Close()
for rows.Next() {
var name string
var seq int64
if err = rows.Scan(&name, &seq); err != nil {
return nil, err
}
if _, ok := applicationImportColumns[name]; ok {
out[name] = seq
} else if _, ok := applicationImportOmissions[name]; !ok {
return nil, importRefusef("unclassified sequence: %s", name)
}
}
return out, rows.Err()
}
func validateImportedBindings(ctx context.Context, tx *sql.Tx) error {
var bad bool
err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM domains d LEFT JOIN campuses c ON c.uuid=d.campus_uuid WHERE c.uuid IS NULL) OR EXISTS(SELECT 1 FROM paths p LEFT JOIN domains d ON d.uuid=p.domain_uuid WHERE d.uuid IS NULL) OR EXISTS(SELECT 1 FROM domain_memberships m LEFT JOIN domains d ON d.uuid=m.domain_uuid LEFT JOIN principals p ON p.uuid=m.principal_uuid WHERE d.uuid IS NULL OR p.uuid IS NULL)`).Scan(&bad)
if err != nil {
return err
}
if bad {
return importRefuse("imported namespace or membership integrity failed")
}
return nil
}
// PreparePostgreSQLImport creates only schema in a dedicated empty database.
// It must not be used to adopt a populated or unversioned PostgreSQL schema.
func PreparePostgreSQLImport(ctx context.Context, target *sql.DB, root string) error {
if err := refusePopulatedImportTarget(ctx, target); err != nil {
return err
}
s := &Store{DB: target, sqlBackend: storePostgreSQL, DocumentRoot: root}
if err := s.ensurePostgreSQLNamespaces(ctx); err != nil {
return err
}
core, err := metadata.New(target, metadata.PostgreSQL)
if err != nil {
return err
}
if err = core.InitializeFresh(ctx); err != nil {
return err
}
if err = s.prepareNativeApplicationSchemas(ctx); err != nil {
return err
}
_, err = calendar.NewPostgreSQL(ctx, filepath.Join(root, "calendars"), target)
return err
}
// Preparation must not run migrations against an existing application. Failed
// attempts may leave versioned schema and exact default seeds, but no user rows.
func refusePopulatedImportTarget(ctx context.Context, target *sql.DB) error {
rows, err := target.QueryContext(ctx, `SELECT table_name FROM information_schema.tables WHERE table_schema=current_schema() AND table_type='BASE TABLE'`)
if err != nil {
return err
}
var names []string
for rows.Next() {
var name string
if err = rows.Scan(&name); err != nil {
rows.Close()
return err
}
names = append(names, name)
}
err = rows.Err()
rows.Close()
if err != nil {
return err
}
for _, name := range names {
if name == "schema_migration_steps" {
continue
}
if _, ok := applicationImportColumns[name]; !ok && name != "application_import_receipts" {
return importRefuse("import destination contains an unmanaged table")
}
var n int64
if err = target.QueryRowContext(ctx, `SELECT count(*) FROM `+importIdent(name)).Scan(&n); err != nil {
return err
}
if n == 0 {
continue
}
predicate, ok := importSeedPredicates[name]
if !ok {
return importRefusef("import destination is not empty: %s", name)
}
var valid bool
if err = target.QueryRowContext(ctx, `SELECT count(*)=1 AND bool_and(`+predicate+`) FROM `+importIdent(name)).Scan(&valid); err != nil {
return err
}
if !valid {
return importRefusef("import destination seed has changed: %s", name)
}
}
return nil
}
// JSON alone cannot distinguish a byte slice from its base64 text, nor an
// integer from an integral float. Explicit tags make conversion detectable.
func importRowBytes(values []any) ([]byte, error) {
type cell struct {
Type string
Value any
}
row := make([]cell, len(values))
for i, value := range values {
var kind string
switch value.(type) {
case nil:
kind = "null"
case string:
kind = "text"
case []byte:
kind = "bytes"
if value.([]byte) == nil {
value = []byte{}
}
case int64:
kind = "integer"
case float64:
kind = "float"
case bool:
kind = "boolean"
default:
return nil, importRefuse("unsupported import scalar type")
}
row[i] = cell{kind, value}
}
return json.Marshal(row)
}
// InspectSQLiteApplicationImport never writes or hydrates user content.
func InspectSQLiteApplicationImport(ctx context.Context, source *sql.DB) ([]string, error) {
tx, err := source.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
if err != nil {
return nil, err
}
defer tx.Rollback()
tables, err := inspectApplicationImportSource(ctx, tx)
if err != nil {
return nil, err
}
names := make([]string, 0, len(tables))
for name := range tables {
names = append(names, name)
}
sort.Strings(names)
return names, nil
}
// VerifyPostgreSQLImport gates the production selector. A successful core-only
// rehearsal is insufficient. The original key and the same canonical root are
// required; relocation/restore must preserve the configured mount path.
func VerifyPostgreSQLImport(ctx context.Context, target *sql.DB, root string) error {
key, err := existingAuthKey(root)
if err != nil {
return err
}
root, err = filepath.Abs(root)
if err != nil {
return err
}
var path, keyHash, fingerprint string
var completed int64
if err = target.QueryRowContext(ctx, `SELECT document_root,key_fingerprint,source_fingerprint,completed_at_ms FROM application_import_receipts WHERE id=1`).Scan(&path, &keyHash, &fingerprint, &completed); err != nil {
return importRefuse("PostgreSQL startup requires a completed full application import")
}
sum := sha256.Sum256(key)
if root != path || keyHash != hex.EncodeToString(sum[:]) || len(fingerprint) != 64 || completed <= 0 {
return importRefuse("PostgreSQL import root/key receipt mismatch")
}
return nil
}
@@ -0,0 +1,158 @@
package store
// Frozen source column inventory for the current SQLite application schema.
// Unknown tables/columns block copying. Changes require an explicit review.
var applicationImportColumns = map[string]string{
"activity_outbox": "actor_uuid,attempts,claimed_at_ms,created_at_ms,domain_uuid,event_type,idempotency_key,last_error,next_attempt_ms,payload,sequence,status,target_kind,target_uuid,uuid",
"activity_outbox_checkpoints": "consumer_id,domain_uuid,last_sequence,updated_at_ms",
"activity_outbox_heads": "domain_uuid,event_type,last_sequence",
"activity_outbox_migrations": "name",
"adapter_sessions": "base_revision_uuid,created_at_ms,domain_uuid,exchanged_at_ms,object_uuid,plugin_id,principal_uuid,root_path,session_expires_at_ms,session_hash,ticket_expires_at_ms,ticket_hash",
"asset_head_history": "action,actor_uuid,address,content_type,created_at_ms,document_hash,domain_uuid,filename,id,size_bytes",
"assets": "address,content_type,created_at_ms,domain_uuid,filename,head_document_hash,object_uuid,size_bytes,updated_at_ms",
"auth_audit_log": "created_at_ms,detail_json,domain_uuid,event,id,outcome,principal_uuid,request_id,target_id,target_type",
"auth_capability_grants": "capability,created_at_ms,role_uuid,target_id,target_type,uuid",
"auth_challenges": "attempt_count,consumed_at_ms,created_at_ms,domain_uuid,expires_at_ms,kind,payload_json,principal_uuid,token_hash,uuid",
"auth_cli_requests": "attempts,browser_hash,challenge,code_hash,created_ms,device_hash,domain_uuid,expires_ms,id,mfa_level,next_poll_ms,oidc_attempts,origin,principal_uuid,remember,state",
"auth_credentials": "created_at_ms,enabled,identifier,kind,parameters_json,principal_uuid,secret_hash,updated_at_ms,uuid",
"auth_group_mappings": "domain_uuid,enabled,external_group,group_uuid,mode,provider_type,provider_uuid,uuid",
"auth_group_role_bindings": "created_at_ms,group_uuid,role_uuid",
"auth_providers": "config_json,created_at_ms,domain_uuid,enabled,kind,secret_encrypted,updated_at_ms,uuid",
"auth_role_bindings": "created_at_ms,membership_uuid,role_uuid",
"auth_roles": "created_at_ms,description,domain_uuid,name,uuid",
"auth_sessions": "auth_time_ms,domain_uuid,expires_at_ms,last_seen_at_ms,mfa_level,principal_uuid,revoked_at_ms,token_hash,uuid",
"broadcasts": "body,created_at_ms,domain_uuid,ends_at_ms,severity,starts_at_ms,title,updated_at_ms,uuid",
"browser_navigation_links": "created_at_ms,domain_uuid,is_directory,label,path,position,principal_uuid,updated_at_ms,uuid",
"calendar_event_cache": "calendar,data,domain,end,etag,month,start,uid",
"calendar_index_state": "calendar,domain,version",
"calendar_month_cache": "calendar,domain,hash,month",
"campus_admin_grants": "created_at_ms,group_uuid,member_role,membership_uuid,source",
"campus_admin_membership_origins": "domain_uuid,membership_uuid,principal_uuid",
"campus_admin_migrations": "key",
"campus_tokens": "campus_uuid,created_at,id,label,last_used_at,revoked,token_hash",
"campuses": "authority_mode,controller_transport,created_at,default_lang,enabled,fqdn,id,last_contact_at,last_contact_error,name,title,uuid",
"city_governance_epochs": "domain_uuid,version",
"city_governance_events": "actor_uuid,after_json,before_json,created_at_ms,domain_uuid,epoch,id,node_kind,node_uuid",
"city_owner_bindings": "actor_uuid,created_at_ms,domain_uuid,membership_uuid,node_kind,node_uuid",
"city_page_overrides": "domain_uuid,page_uuid,spot_uuid",
"config": "domain_uuid,key,updated_at,value",
"document_backfills": "completed,last_uuid,processed,store_id,updated_at_ms",
"domain_entry_settings": "domain_uuid,settings_json",
"domain_memberships": "created_at_ms,domain_uuid,principal_uuid,state,uuid",
"domain_topology_versions": "domain_uuid,updated_at_ms,version",
"domains": "campus_uuid,created_at,domain,enabled,id,instance_fingerprint,instance_fqdn,name,placement,title,uuid",
"event_definitions": "created_at_ms,enabled,event_key,event_type,interval_seconds,max_attempts,name,next_run_at_ms,payload,priority,schedule_kind,updated_at_ms,uuid",
"event_jobs": "attempts,cancel_requested,created_at_ms,error,event_key,event_type,event_uuid,finished_at_ms,max_attempts,payload,priority,run_at_ms,started_at_ms,status,updated_at_ms,uuid",
"event_log_buckets": "bucket_start_ms,count,event_type,first_at_ms,last_at_ms,level,sample_message",
"event_log_policies": "aggregate_after_hours,bucket_seconds,event_type,max_rows,retention_hours",
"event_logs": "created_at_ms,event_uuid,id,job_uuid,level,message",
"event_queue_settings": "concurrency,id,max_depth,paused,retention_hours,retry_base_seconds",
"federation_instance_capabilities": "instance_uuid,manifest_version",
"federation_instances": "campus_uuid,created_at,fingerprint,fqdn,id,last_seen_at,status,uuid",
"federation_manifest_state": "applied_at,applied_revision,campus_uuid,controller_fingerprint,controller_public_key,manifest_json",
"federation_manifest_versions": "campus_uuid,manifest_hash,revision,updated_at",
"feed_actions": "claim,created_ms,desired,domain_uuid,error,field,item_id,owner_uuid,request_id,source_uuid,source_version,status,until_ms",
"feed_import_receipts": "domain_uuid,input_hash,owner_uuid,request_id,result",
"feed_items": "body,body_html,feed,folder,id,is_read,published_ms,remote_categories,remote_feed,source_uuid,starred,title,url",
"feed_note_receipts": "domain_uuid,input_hash,owner_uuid,page_uuid,request_id",
"feed_sources": "credential,domain_uuid,enabled,error,etag,folder,interval_seconds,last_ms,lease,lease_until,modified,next_ms,owner_uuid,provider,remote_catalog,remote_folders,title,url,uuid,version,write_enabled",
"feed_states": "id,is_read,source_uuid,starred,version",
"group_members": "created_at_ms,group_uuid,member_role,membership_uuid,source",
"group_permissions": "created_at_ms,group_uuid,permission,scope_path,uuid",
"groups": "builtin_key,created_at_ms,description,display_name,domain_uuid,inherit_members,name,state,updated_at_ms,uuid,visibility",
"import_city_edges": "created_at_ms,page_uuid,session_uuid,spot_uuid",
"import_city_journal": "created_at_ms,kind,node_uuid,session_uuid",
"import_items": "confidence,content_type,selected,sequence,session_uuid,size,source_path,suggested_quartier,suggested_spot,suggested_street,target_path,title",
"import_journal": "completed,created_at_ms,object_uuid,path,sequence,session_uuid",
"import_sessions": "actor_uuid,archive_name,archive_path,created_at_ms,domain_uuid,error,markdown_files,status,target_prefix,total_files,updated_at_ms,uuid",
"locality_access_entries": "domain_uuid,node_kind,node_uuid,permission,subject_kind,subject_name,subject_uuid",
"locality_access_policies": "actor_uuid,authority_rank,domain_uuid,grants_access,node_kind,node_uuid,scope_path",
"locality_auto_publication": "actor_uuid,domain_uuid,mode,node_kind,node_uuid,scope_path,version",
"locality_publication_entries": "document_hash,domain_uuid,lang,node_kind,node_uuid,object_uuid,path,revision_uuid",
"locality_publication_manifests": "actor_uuid,created_at_ms,domain_uuid,epoch,node_kind,node_uuid,topology_version",
"locality_publication_policies": "actor_uuid,domain_uuid,node_kind,node_uuid,policy,updated_at_ms",
"locality_publication_versions": "domain_uuid,node_kind,node_uuid,version",
"navigation_generation": "id,version",
"notification_inbox": "created_at_ms,domain_uuid,event_uuid,href,kind,message,read_at_ms,recipient_uuid,request_uuid,status,uuid",
"notification_push_keys": "id,private_key,public_key",
"notification_push_queue": "attempts,created_at_ms,lease_until_ms,next_at_ms,notification_uuid,subscription_id",
"notification_push_subscriptions": "domain_uuid,expires_at_ms,foreground_until_ms,id,owner_uuid,session_hash,subscription",
"object_origins": "created_at,domain_uuid,object_uuid",
"objects": "created_at,kind,uuid",
"organizer_activity_bridge": "id,last_sequence",
"organizer_capture_receipts": "domain_uuid,item_uuid,owner_uuid,request_hash,request_uuid",
"organizer_changes": "actor_uuid,created_at_ms,domain_uuid,item_uuid,sequence,version",
"organizer_contact_changes": "domain_uuid,owner_uuid,sequence,uuid",
"organizer_contact_credentials": "credential_id",
"organizer_contact_epoch": "id,value",
"organizer_contact_names": "domain_uuid,name,owner_uuid,uuid",
"organizer_contact_revisions": "created_ms,deleted,domain_uuid,hash,owner_uuid,uuid,version",
"organizer_contacts": "data,deleted,domain_uuid,hash,name,owner_uuid,search,uid,uuid,version",
"organizer_dashboard_layouts": "data,domain_uuid,owner_uuid,version",
"organizer_dav_collections": "domain_uuid,owner_uuid,path,project_uuid",
"organizer_dav_compat": "credential_id",
"organizer_dav_credentials": "created_ms,domain_uuid,expires_ms,id,label,owner_uuid,secret_hash,write_access",
"organizer_dav_default_lists": "domain_uuid,owner_uuid,title,updated_at_ms",
"organizer_dav_legacy_hrefs": "domain_uuid,item_uuid,name,owner_uuid",
"organizer_dav_resources": "domain_uuid,item_uuid,name,owner_uuid,uid",
"organizer_dav_scopes": "credential_id,scope",
"organizer_digest_attempts": "created_ms,day,domain_uuid,kind,owner_uuid,preference_version,reason,state,timezone,updated_ms,uuid",
"organizer_digest_deliveries": "attempt_uuid,day,domain_uuid,owner_uuid,state,updated_ms",
"organizer_digest_requests": "created_ms,day,domain_uuid,duplicate_ack,expected_attempt,owner_uuid,uuid",
"organizer_focus": "created_at_ms,deadline_ms,domain_uuid,duration_ms,owner_uuid,phase,remaining_ms,state,task_uuid,updated_at_ms,uuid,version",
"organizer_focus_changes": "action,created_at_ms,data,session_uuid,version",
"organizer_focus_spans": "closed,domain_uuid,end_ms,owner_uuid,phase,session_uuid,start_ms,task_uuid,version",
"organizer_items": "archived,bucket,created_at_ms,data,document_hash,domain_uuid,due_on,end_on,kind,owner_uuid,parent_uuid,planned_on,project_uuid,review_on,start_on,status,title,updated_at_ms,uuid,version",
"organizer_reminders": "civil_date,domain_uuid,fire_at_ms,item_uuid,kind,notification_key,owner_uuid,source_version,state,timezone",
"organizer_revisions": "actor_uuid,created_at_ms,document_hash,domain_uuid,item_uuid,version",
"organizer_task_deletions": "dav_name,dav_uid,deleted_at_ms,domain_uuid,item_uuid,owner_uuid,version",
"organizer_task_metrics": "completed_ms,complexity,domain_uuid,estimate,owner_uuid,task_uuid",
"organizer_task_preferences": "data,domain_uuid,next_digest_ms,owner_uuid,version",
"organizer_time_blocks": "calendar_uuid,created_at_ms,domain_uuid,end,event_uid,owner_uuid,start,state,task_uuid,title,uuid",
"organizer_work_revisions": "action,changed_ms,data,domain_uuid,owner_uuid,reason,version,work_uuid",
"organizer_work_sessions": "cancelled_ms,domain_uuid,end_ms,owner_uuid,start_ms,task_uuid,uuid,version",
"paths": "created_at,domain_uuid,is_primary,object_uuid,path",
"periodical_entries": "category,domain_uuid,kind,local_date,owner_uuid,page_uuid,timezone,title,version",
"periodical_events": "actor_uuid,created_at_ms,domain_uuid,id,kind,operation,page_uuid,version",
"periodical_posts": "actor_uuid,digest,domain_uuid,kind,page_uuid,request_id",
"periodical_prefixes": "domain_uuid,kind,prefix",
"periodical_projections": "domain_uuid,kind,prefix,source_uuid",
"periodical_settings": "domain_uuid,enabled,kind",
"personal_appearance": "data,domain_uuid,owner_uuid,version",
"principal_identities": "attributes_json,created_at_ms,issuer,principal_uuid,provider_type,provider_uuid,subject,uuid",
"principals": "avatar,avatar_content_type,created_at_ms,display_name,email,state,updated_at_ms,uuid",
"profile_contacts": "domain_uuid,phone_display,phone_number,principal_uuid,updated_at_ms,version,visibility",
"projection_metadata": "document_hash,error,kind,payload,retry_at_ms,updated_at_ms,version",
"publication_decisions": "created_at_ms,decision,generation,justification,request_uuid,reviewer_uuid,uuid",
"publication_requests": "created_at_ms,domain_uuid,expires_at_ms,generation,idempotency_key,policy_version,requester_uuid,scope_kind,scope_uuid,state,subject_hash,subject_json,updated_at_ms,uuid",
"resource_samples": "id,job_uuid,payload,timestamp_ms",
"revision_document_refs": "document_hash,revision_uuid",
"revisions": "body,content_type,created_at,created_at_ms,document_hash,filename,lang,message,object_uuid,uuid",
"search_schema_state": "name",
"spot_pages": "created_at_ms,edge_type,featured,label,page_uuid,sort_key,source,spot_uuid",
"spot_relations": "created_at_ms,relation_type,source_spot_uuid,target_spot_uuid,weight",
"spots": "charter_json,created_at_ms,domain_uuid,landing_json,name,path_prefix,schema_json,state,summary,title,updated_at_ms,uuid,version",
"street_inbox_pages": "created_at_ms,page_uuid,street_uuid",
"street_spots": "created_at_ms,section,sort_key,spot_uuid,street_uuid",
"tags": "created_at,object_uuid,tag",
"topology_events": "actor_principal_uuid,after_json,before_json,created_at_ms,domain_uuid,id,operation,request_id,target_type,target_uuid,topology_version",
"user_space_path_policies": "actor_uuid,domain_uuid,path,principal_uuid,updated_at_ms,visibility",
"user_space_policies": "actor_uuid,avatar_visibility,descendant_visibility,domain_uuid,principal_uuid,profile_visibility,root_visibility,updated_at_ms,version",
"user_space_policy_events": "actor_uuid,after_json,before_json,created_at_ms,domain_uuid,id,principal_uuid",
"zombie_gc_maintenance": "grace_seconds,singleton",
"zones": "charter_json,created_at_ms,description,domain_uuid,kind,name,parent_uuid,path_prefix,policy_json,sort_key,state,title,updated_at_ms,uuid,version",
}
// Only backend migration ledgers and rebuildable SQLite FTS projections are omitted.
var applicationImportOmissions = map[string]string{
"latest_revision_index": "content_type,created_at_ms,document_hash,filename,object_uuid,revision_uuid",
"revision_search": "body,filename,object_uuid,revision_uuid",
"revision_search_config": "k,v",
"revision_search_content": "c0,c1,c2,c3,id",
"revision_search_data": "block,id",
"revision_search_docsize": "id,sz",
"revision_search_idx": "pgno,segid,term",
"revision_search_state": "revision_uuid",
"schema_migration_steps": "applied_at_ms,checksum,component,name,version",
"schema_migrations": "applied_at,name",
}
@@ -0,0 +1,110 @@
package store
// Exact app-owned SQLite trigger/view definitions. Custom changes require review.
var applicationImportSourceObjects = map[string]string{
"activity_outbox_advance_head": "trigger:3058a7506ff2d387fc7eb0a9440f75595c97bb1ce652b35f8b6a9dd382c91a66",
"feed_actions_source_change": "trigger:84ccd4016b85c465aa79d0757bf1219d36719cf4fea7aceb3745b214aa1e982d",
"feed_actions_source_delete": "trigger:72e0375d92e19683ef72e1af961eb0682f2354c82efb6be5511780852634d91f",
"feed_source_delete": "trigger:624615a48b0116e16efe8f59a4e087589f17327a420e3fbca6d90f156b0d2d35",
"navigation_auth_capability_grants_DELETE": "trigger:9e3a4389d57054cb80c84bfb474a1cd8bbc6f51ea9ee34660692c36ca8e69a25",
"navigation_auth_capability_grants_INSERT": "trigger:a069846cfaed283798e2aaad60e23dedb21a7bc2593e18d200619c4f8018a185",
"navigation_auth_capability_grants_UPDATE": "trigger:bb864ba4dfa1bb7f3b1733921d375fcba95493c2e4e0e95b7d32c60072361275",
"navigation_auth_role_bindings_DELETE": "trigger:0c7890e438562e3fadfccf864e5d63a3a4963d9a5f9d05010f673dc9ff17e777",
"navigation_auth_role_bindings_INSERT": "trigger:a55f66a37f04085d766ddb89ef5c3ae91692e2c937c38d81f870a58d913d727b",
"navigation_auth_role_bindings_UPDATE": "trigger:100095820afdc2ea2cb31825a2484a93f292c3fa86eae1762dd3e21db5168073",
"navigation_auth_roles_DELETE": "trigger:a879c0bb47cd2280e965373b648af00d80dd4da47e8da6286daadd596d86fcbd",
"navigation_auth_roles_INSERT": "trigger:d102dd62d08af05e7fcf56ebbfe07812bbd74c1fc3731bd5513c2f924193b3bd",
"navigation_auth_roles_UPDATE": "trigger:a0984b20376c376fac9a5785da863dc34ca49498138c166261c782843540d071",
"navigation_campuses_DELETE": "trigger:8fb85a6937f692dd3c03875af27dac60da7cce09f3a6501b0c6d185ad40726c7",
"navigation_campuses_INSERT": "trigger:0657d8a8294e4d782b9e1287112a2f391805d3ba93d69539b9d634a6483cdace",
"navigation_campuses_UPDATE": "trigger:88fc863aae99ab5e78916a194bfd95c71a27191e1bfcf4ec93cd2d843551b6a4",
"navigation_city_governance_epochs_DELETE": "trigger:e0500d0b84809cf695fa41ee2781ebc285e8a9d273d3235fff4f75ea9a34288e",
"navigation_city_governance_epochs_INSERT": "trigger:fcab809d5a9038dcf64c1880ce937c3ab1a7fa92367fb97bec86f4c154c2ac2c",
"navigation_city_governance_epochs_UPDATE": "trigger:19449b43b8db827d1b3118ccbebb9b56e4c0017bd2b49e98725196202edbbd2b",
"navigation_city_owner_bindings_DELETE": "trigger:1d6776e9c3b8d289604d05b1ed3adebb0322cfd7299266ddc74d26cea0f0f0f9",
"navigation_city_owner_bindings_INSERT": "trigger:66fd2522d2a89cb1a6c58f412c28952f2e7ec357c493074a3806ad45bf028b26",
"navigation_city_owner_bindings_UPDATE": "trigger:0755ad5e7a325edda7e050f392a8628ec68a31b34fa89aab44293e35c6e6f4e8",
"navigation_city_page_overrides_DELETE": "trigger:5464f4bf8b9839c447deec70b71a8ee345033a46ab55d71a2852ac2adcebc38a",
"navigation_city_page_overrides_INSERT": "trigger:c154d7be988ca67b8eefd4715b2972d53e731b516a847db302db5edb6d03676b",
"navigation_city_page_overrides_UPDATE": "trigger:a62ea9270f83204ede125e48b5be7a9e0bae3be4097a793c7515a0123d67df08",
"navigation_domain_memberships_DELETE": "trigger:ad0f4d3f1f6f90cc740ee55d1038a9770d6795725a9a5cf6ba5078eb2dea4d1c",
"navigation_domain_memberships_INSERT": "trigger:2b25f34b22c69dddfa972561c62ece61777555e8fa1a9c83fb5eb561d4680aed",
"navigation_domain_memberships_UPDATE": "trigger:1cf891af8e22c12c7ad67d1bfe5694319a97923c13b2c1603128216d4954e8f2",
"navigation_domain_topology_versions_DELETE": "trigger:c8a39f592225412784d6ea851425c9e172d48bea7213e49d034a42a18836c7aa",
"navigation_domain_topology_versions_INSERT": "trigger:e13c715defc21167dfa60762c925c8b9ab7abde161d821d2a292be63a3356946",
"navigation_domain_topology_versions_UPDATE": "trigger:2142ff3636a1e61e590d9740cb3b61c247f955e451354d710225ac6ebbf3ebfc",
"navigation_domains_DELETE": "trigger:8ee87712265ae840a4d94874ebaf3ab79deb69706a9fcb17afe3aae5b3cab699",
"navigation_domains_INSERT": "trigger:fb3cefdcea591416a6d46a7c1bfed99d51e3aa383792a717a69203871f8e25b7",
"navigation_domains_UPDATE": "trigger:f5104dff7f370a7f531886af9f4a884b2ddc30509689c26975749b7c6bc46716",
"navigation_group_members_DELETE": "trigger:5e351d5e06f46f545f5e19f12a997156038a446af54d495cbff397f505cdaf3c",
"navigation_group_members_INSERT": "trigger:8b25c1b04980291cce53c85fd3c8c4a0c2b13499ce15af12699a58cc81bf3769",
"navigation_group_members_UPDATE": "trigger:348b2cce776333d54d54d24c941c408742f80285593e8cf5132502941c50bfdb",
"navigation_group_permissions_DELETE": "trigger:32aab8c788c491a6aabe288c6eb27df323f5bcfa92e33bfd5e94fa3d0a799624",
"navigation_group_permissions_INSERT": "trigger:7f2638908b391bf9dabfabd6ef0d9218510995df21b9a610ffc8fbf76b09f760",
"navigation_group_permissions_UPDATE": "trigger:4669026703d8aade79bbee5c9f56ca8123c0fa1c0cc393ea0d731f9b3548d636",
"navigation_groups_DELETE": "trigger:29af285057e26f2a1b1db7dc76fcb87a9a407ead289fbf908ef69c44d5d1e947",
"navigation_groups_INSERT": "trigger:ecbc10a3d8d1b099ec671af2bda61dc8d5a0ec06e00d18d2855c35fedf6e5542",
"navigation_groups_UPDATE": "trigger:ec274be8dfadb4297d9cbbbeff7cf9ff984fe2fb335b479f5d746aea902c6dfd",
"navigation_locality_access_entries_DELETE": "trigger:8f261aa7a88b75d3861d5fdb486ed973dd08dd882b62e3af45904e569b7767d9",
"navigation_locality_access_entries_INSERT": "trigger:8d963f3cd940d51c4614e168917cbf165c9a8f519865db2d5d272f12607af25a",
"navigation_locality_access_entries_UPDATE": "trigger:7780ac847469992cd6d222b3b5faeaa24031ae152252ea45a4251f5ac8104eb1",
"navigation_locality_access_policies_DELETE": "trigger:79ffcae086bd29bce3569f5d4bae2eccf0e7c436efcf90e38a02ea28a0b53a42",
"navigation_locality_access_policies_INSERT": "trigger:e6eb2ce999b658dfff3788c7657884bc1f6b2545cdbf1bb164ddc0072b39d046",
"navigation_locality_access_policies_UPDATE": "trigger:55edd795c4c54bb1596806a012f162e82c1526580a48892a54a0a53b19733335",
"navigation_locality_auto_publication_DELETE": "trigger:25ef213c6a2f72fdcd92ff78caf1c6ba1a7c6d449754af55fdf975e95f005af0",
"navigation_locality_auto_publication_INSERT": "trigger:b27b6312dac392c9ed98fe5916702ae1e03c2ef985c498d5a96107e6431cc2e2",
"navigation_locality_auto_publication_UPDATE": "trigger:6f8fcf1e33e4ee1eb75b3e1ed694076a76d34f8b3c3c1517e8e0246c0c2443fa",
"navigation_locality_publication_entries_DELETE": "trigger:340aa39b018f65eeb8caf844375b90759cc7cae12ed0ae5f1943020910cb9c5f",
"navigation_locality_publication_entries_INSERT": "trigger:6084380e04cf1f98600a1d86893f2e3474153541590d5106d8943c1632b134c2",
"navigation_locality_publication_entries_UPDATE": "trigger:3b332ffd9d4905fcd1aede89547decb06427886e9f954527067fd4cf4f2662d3",
"navigation_locality_publication_manifests_DELETE": "trigger:a2e0e39cfd27c419f3d597c55218ebab6ab51849570879eb45ac842d62222c38",
"navigation_locality_publication_manifests_INSERT": "trigger:fc7191e6f5c1c63116cabd1095767d22078e3e3bf61ac9cf32913db5a89889e1",
"navigation_locality_publication_manifests_UPDATE": "trigger:fbcea4d67a696062e6f9e1aea99d07a5ab6d6980e39adff715e67fd53fbd0630",
"navigation_locality_publication_policies_DELETE": "trigger:1243967d9cc72083c04790d2d7f7e348889fe0375279fc52286c2efc449b1745",
"navigation_locality_publication_policies_INSERT": "trigger:4d00a5b374aecc48075396e4a51ea51c1ddb99ee54cbbe362847b883dfb96856",
"navigation_locality_publication_policies_UPDATE": "trigger:ed03cf19aa341f95d2f43772554ea7a3e9df8ce48ed57468dcdb75fecba3070f",
"navigation_paths_DELETE": "trigger:4c359ac88380127cbdfeb004b0ec5336927ac3c7063827181985c8d84b4800ad",
"navigation_paths_INSERT": "trigger:80c5bb14e8f7d68c48270f3685461a43f1b42bbaa6b26c17cc4c0640cec17f97",
"navigation_paths_UPDATE": "trigger:70a812a7cd9a9e64fd4b51ff7339d65cec7e115de7840b7eb1bb2c6f548f42ee",
"navigation_principals_DELETE": "trigger:6658328e4049be3a7d1dbc223d19b369bd5884007ebcf192886f49025fd2766a",
"navigation_principals_INSERT": "trigger:1d1fe9ff6cc466b2238787c1436e427dc15cf807a1485e62fb8ec8a045668662",
"navigation_principals_UPDATE": "trigger:72faf544e6a984508fb0f7e2fb200d2c73bd5c55874d2bbedfc05314f18c5f75",
"navigation_revisions_DELETE": "trigger:03a821a70b405afcdd62ef21a84545d82bda28775a4f0c0e3eb2ae7f36933f66",
"navigation_revisions_INSERT": "trigger:3ba614f28fb3794a09ccdd3c248bbdc026225ae68a027afc0be1cf0ad73c9cda",
"navigation_revisions_UPDATE": "trigger:41f6a3d5d80aba84a9a65287e79e2323f51a2cd474021d7fe71d48168e6946e2",
"navigation_spot_pages_DELETE": "trigger:d601a473eafcfaf43221983b6990da3a313877a6554d5ed8e69a3f33b13ae62b",
"navigation_spot_pages_INSERT": "trigger:ec4e790c698efd8f8aa5739a21fb1c53f80fec79759e7dfcda807d374aa88507",
"navigation_spot_pages_UPDATE": "trigger:e6e8068aa97ddb395edf779970c4c516724194048ce195ffebca104dadf344ff",
"navigation_spot_relations_DELETE": "trigger:96871413826e8e9667f8ece6fc89c21a955099d945cea560173689369f7c7da3",
"navigation_spot_relations_INSERT": "trigger:1ad96b83bb291c0ac2c329f2a86497858418c172c977e9c1bbb3740ceffd9b15",
"navigation_spot_relations_UPDATE": "trigger:90f9dec821d3a671b88a9d837305f1d6157a6ea34588f1947fc73c18d37fcd63",
"navigation_spots_DELETE": "trigger:932721d8d3e803f93635fd19b0a041cd006bb77e1a4901ed7f1c096b9510e426",
"navigation_spots_INSERT": "trigger:3d295775e12bc78d561ec1b39e3d637a60dab853dbbdeb3deceefb9e5937f134",
"navigation_spots_UPDATE": "trigger:3af090d07d3008930664583893af50038cc7ef37aedf4b79368d1282365f7e9a",
"navigation_street_inbox_pages_DELETE": "trigger:bd8ee4f3ce651b71403024fb50b32e88c0cd1565b869f35d4e20a53abc31ec19",
"navigation_street_inbox_pages_INSERT": "trigger:8d5d6ed6b8450e2ee80ee8eba52c7ba42e664bb5dcf64925424640e604be4582",
"navigation_street_inbox_pages_UPDATE": "trigger:453d77bfa398726051d3688b6228ab1c0613003f9cab372e2262453b894aa60e",
"navigation_street_spots_DELETE": "trigger:1ba9ade99be0bdfad31c5ca47772e4b640a6f3395a6ea469e4439bb71daec28b",
"navigation_street_spots_INSERT": "trigger:852e6203572d50b13fee39872060acf8e64498ae51d6f757e900b66e7b9b781a",
"navigation_street_spots_UPDATE": "trigger:dff679b3f8c4a5eba6a0641b56faa3229b8c55eb3126fac7f04b72c432bb9b3a",
"navigation_user_space_path_policies_DELETE": "trigger:c3aa3758d9cac900298538b0aebbded9db58674319d3685b755127a38d82a5a5",
"navigation_user_space_path_policies_INSERT": "trigger:b31187de87a56d3b2f22f1ee0b635da00aa6eac64c81aa80286bef63495da8fc",
"navigation_user_space_path_policies_UPDATE": "trigger:3e2a7575623cbe3f8d2dfb1837b5492c7a3e61e0b8a339a6a21021d9d5820138",
"navigation_user_space_policies_DELETE": "trigger:0163223816f3eeb396bd2322d5d6e90e2c6d222a5b4fc434676c80978c38de45",
"navigation_user_space_policies_INSERT": "trigger:8001600fa9d8e6c487a77291251e5a3ffd2257375d38dc9262951891e6395ce7",
"navigation_user_space_policies_UPDATE": "trigger:14578732717e3708cb07c426de84f913ac99a6a6df2451437594bc0ce9f24a8d",
"navigation_zones_DELETE": "trigger:8078540c0d455786c925ee79158ee870b749a1aacfa2d798267e31e2e2928eab",
"navigation_zones_INSERT": "trigger:96e9867bac8f83340c53008ebe7b6da60ee94c285efd511b3becceba2de1687b",
"navigation_zones_UPDATE": "trigger:87ded915d38c4f4b5102b5b655dea5b3ba7b314fc02f740baf648a41e57f5857",
"notification_push_enqueue": "trigger:898b87d9c96ba4cd0157f95a76fa9f2cd692ae0a5178c7496177ad39ece60923",
"organizer_contact_credential_delete": "trigger:a106930d17e9af95527f7f1ae12975c4e98ff9e84478030c97ad8153a310b6de",
"organizer_contact_insert": "trigger:227fce8ed11726fbf5dfd98be662da16de2cfba4f13ea70c775a4508cac397f5",
"organizer_contact_update": "trigger:2ff643fe4aad770e65c021f143ff3d8940edac6bfb77322322c0a995057a0071",
"organizer_dav_compat_delete": "trigger:644447a76a1db36d598b86f4cd4b3ae3e23655f2709428e79909d53175965762",
"organizer_dav_scopes_delete": "trigger:1241f67ec0b744e331c7056bac44bf82fa4afc3bf6fd7d6fd5e018f4f3d1a203",
"revision_search_delete": "trigger:c5ae0b0c31fe048c46de47ea001737e8aec3b38ea4c67cdd7e12073e20e9df58",
"revision_search_insert": "trigger:e866fe23f1fe2732e3229c63a33bf48d28448c122fcfa03840de71354d1f5ba1",
"user_space_path_policy_delete": "trigger:83e40e2aaf9575c2e63cb4c20da1ba1c142c88a2a10c26694ee01b8455ea16da",
"user_space_path_policy_move": "trigger:919d2ff986131f5fc09b08115f741a429c9becf5477c4e36037bd8d9fef7ed62",
"user_space_path_policy_rename": "trigger:a581329d9436cf12f9cf08a74e8cd3a1aa96694fd4d9cc326dc81ad78c611fe8",
}
@@ -0,0 +1,19 @@
package store
import (
"context"
"pageswiki/internal/db"
)
// Legacy operational state is retained even where its native worker is gated.
func (s *Store) ensureNativeImportRetention(ctx context.Context) error {
return db.ApplyPostgreSQLMigrations(ctx, s.DB, "store-import-retention", []db.PostgreSQLMigration{{Version: 1, Name: "preserve tags and legacy maintenance state", Statements: []string{
`CREATE TABLE tags(object_uuid TEXT,tag TEXT,created_at BIGINT DEFAULT (extract(epoch from now())::bigint))`,
`CREATE INDEX tags_object_uuid ON tags(object_uuid)`,
`CREATE TABLE document_backfills(store_id TEXT PRIMARY KEY,last_uuid TEXT NOT NULL DEFAULT '',processed BIGINT NOT NULL DEFAULT 0,completed INTEGER NOT NULL DEFAULT 0,updated_at_ms BIGINT NOT NULL)`,
`CREATE TABLE zombie_gc_maintenance(singleton INTEGER PRIMARY KEY CHECK(singleton=1),grace_seconds BIGINT NOT NULL CHECK(grace_seconds>=86400))`,
`CREATE TABLE activity_outbox_migrations(name TEXT PRIMARY KEY)`,
`CREATE TABLE search_schema_state(name TEXT PRIMARY KEY)`,
`CREATE TABLE application_import_receipts(id INTEGER PRIMARY KEY CHECK(id=1),source_fingerprint TEXT NOT NULL,document_root TEXT NOT NULL,key_fingerprint TEXT NOT NULL,report_json TEXT NOT NULL,completed_at_ms BIGINT NOT NULL)`,
}, Assertions: []string{`SELECT object_uuid,tag,created_at FROM tags WHERE 1=0`, `SELECT store_id,last_uuid,processed,completed,updated_at_ms FROM document_backfills WHERE 1=0`, `SELECT singleton,grace_seconds FROM zombie_gc_maintenance WHERE 1=0`, `SELECT name FROM activity_outbox_migrations WHERE 1=0`, `SELECT name FROM search_schema_state WHERE 1=0`, `SELECT id,source_fingerprint,document_root,key_fingerprint,report_json,completed_at_ms FROM application_import_receipts WHERE 1=0`}}})
}
+348
View File
@@ -0,0 +1,348 @@
package store
import (
"bytes"
"context"
"crypto/sha256"
"database/sql"
"encoding/json"
"net/url"
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"github.com/google/uuid"
"pageswiki/internal/db"
)
func TestApplicationImportRoundTrip(t *testing.T) {
ctx := context.Background()
source := testNamespaceStore(t, storeSQLite)
if _, err := source.NewCalendarRepository(ctx); err != nil {
t.Fatal(err)
}
domain, err := source.GetDefaultDomain()
if err != nil {
t.Fatal(err)
}
owner, err := source.BootstrapOwner(domain.UUID, "owner", "synthetic import password", "日本語 owner", "")
if err != nil {
t.Fatal(err)
}
if err = source.SetConfigInDomain(domain.UUID, "authorization_mode", "enforcing"); err != nil {
t.Fatal(err)
}
obj, err := source.CreatePageAtPathInDomain(domain.UUID, "/日本語/roundtrip")
if err != nil {
t.Fatal(err)
}
rev, err := source.SaveRevisionContent(obj, []byte("<h1>Imported page</h1>"), "commit message", "en", "text/html", "")
if err != nil {
t.Fatal(err)
}
if err = source.AddTag(obj, "日本語 tag"); err != nil {
t.Fatal(err)
}
token, err := source.CreateAuthSession(domain.UUID, owner.UUID)
if err != nil {
t.Fatal(err)
}
if _, err = source.DB.Exec(`UPDATE principals SET avatar=? WHERE uuid=?`, []byte{0, 1, 2, 255}, owner.UUID); err != nil {
t.Fatal(err)
}
task, err := source.SaveTaskDAV(ctx, domain.UUID, owner.UUID, TaskRecord{UUID: uuid.NewString(), Kind: "task", Title: "移行タスク", Status: "todo", Bucket: "inbox"}, 0, &TaskDAVData{Name: "import.ics", UID: "import-task", Data: "synthetic VTODO"}, "", "")
if err != nil {
t.Fatal(err)
}
contact, err := source.SaveContact(ctx, domain.UUID, owner.UUID, Contact{UUID: uuid.NewString(), VCard: syntheticContact("import-contact")}, true)
if err != nil {
t.Fatal(err)
}
project, err := source.SaveTask(ctx, domain.UUID, owner.UUID, TaskRecord{UUID: uuid.NewString(), Kind: "project", Title: "移行 Project", Status: "todo", Bucket: "inbox"}, 0)
if err != nil {
t.Fatal(err)
}
projectTask, err := source.SaveTaskDAV(ctx, domain.UUID, owner.UUID, TaskRecord{UUID: uuid.NewString(), Kind: "task", Title: "Project task", Status: "todo", Bucket: "inbox", ProjectUUID: project.UUID}, 0, &TaskDAVData{Name: "import.ics", UID: "import-task", Data: "synthetic VTODO"}, "", project.UUID)
if err != nil {
t.Fatal(err)
}
deleted, err := source.SaveTask(ctx, domain.UUID, owner.UUID, TaskRecord{UUID: uuid.NewString(), Kind: "task", Title: "Deleted task", Status: "todo", Bucket: "inbox", ProjectUUID: project.UUID}, 0)
if err != nil {
t.Fatal(err)
}
if err = source.DeleteTask(ctx, domain.UUID, owner.UUID, deleted.UUID, deleted.Version); err != nil {
t.Fatal(err)
}
snapshot, err := source.ContactDAVSnapshot(ctx, domain.UUID, owner.UUID, "", 200)
if err != nil {
t.Fatal(err)
}
// Deleted highest sequence must not be reused after transfer.
if _, err = source.DB.Exec(`UPDATE sqlite_sequence SET seq=100000 WHERE name='organizer_contact_changes'`); err != nil {
t.Fatal(err)
}
target := testNamespaceStore(t, storePostgreSQL)
// Only synthetic bootstrap rows in this test's private schema are removed.
if _, err = target.DB.Exec(`DELETE FROM domains;DELETE FROM campuses;DELETE FROM config`); err != nil {
t.Fatal(err)
}
if err = PreparePostgreSQLImport(ctx, target.DB, source.DocumentRoot); err != nil {
t.Fatal(err)
}
if err = VerifyPostgreSQLImport(ctx, target.DB, source.DocumentRoot); err == nil {
t.Fatal("unimported target accepted")
}
// Force a late failure after row copying, without altering canonical files.
if _, err = source.DB.Exec(`INSERT INTO tags(object_uuid,tag,created_at) VALUES(?,?,?)`, obj, "rollback", "invalid bigint"); err != nil {
t.Fatal(err)
}
if _, err = ImportSQLiteApplication(ctx, source.DB, target.DB, source.DocumentRoot); err == nil {
t.Fatal("invalid row accepted")
}
var count int
if err = target.DB.QueryRow(`SELECT count(*) FROM domains`).Scan(&count); err != nil || count != 0 {
t.Fatal("partial import", count, err)
}
if err = target.DB.QueryRow(`SELECT count(*) FROM pg_trigger t JOIN pg_class c ON c.oid=t.tgrelid JOIN pg_namespace n ON n.oid=c.relnamespace WHERE n.nspname=current_schema() AND NOT t.tgisinternal AND t.tgenabled='D'`).Scan(&count); err != nil || count != 0 {
t.Fatal("disabled triggers retained", count, err)
}
if _, err = source.DB.Exec(`DELETE FROM tags WHERE tag='rollback'`); err != nil {
t.Fatal(err)
}
if err = PreparePostgreSQLImport(ctx, target.DB, source.DocumentRoot); err != nil {
t.Fatal("retry preparation", err)
}
report, err := ImportSQLiteApplication(ctx, source.DB, target.DB, source.DocumentRoot)
if err != nil {
t.Fatal(err)
}
if report.Documents != 1 || len(report.Tables) < 130 || report.Fingerprint == "" {
t.Fatal(report)
}
if err = VerifyPostgreSQLImport(ctx, target.DB, source.DocumentRoot); err != nil {
t.Fatal(err)
}
st, err := NewPostgreSQLWithDocumentRoot(ctx, target.DB, source.DocumentRoot)
if err != nil {
t.Fatal(err)
}
got, err := st.GetRevision(rev.UUID)
if err != nil || got.Body != rev.Body {
t.Fatal(got, err)
}
p, err := st.PrincipalForSession(domain.UUID, token)
if err != nil || p.UUID != owner.UUID {
t.Fatal(p, err)
}
var avatar []byte
if err = target.DB.QueryRow(`SELECT avatar FROM principals WHERE uuid=$1`, owner.UUID).Scan(&avatar); err != nil || !bytes.Equal(avatar, []byte{0, 1, 2, 255}) {
t.Fatal(avatar, err)
}
tags, err := st.ListTags(obj)
if err != nil || len(tags) != 1 || tags[0] != "日本語 tag" {
t.Fatal(tags, err)
}
if got, err := st.TaskDAVByName(ctx, domain.UUID, owner.UUID, "import.ics"); err != nil || got.UUID != task.UUID || got.Title != task.Title {
t.Fatal(got, err)
}
if got, err := st.TaskDAVByName(ctx, domain.UUID, owner.UUID, "import.ics", project.UUID); err != nil || got.UUID != projectTask.UUID {
t.Fatal("project DAV identity", got, err)
}
if err = st.DeleteTask(ctx, domain.UUID, owner.UUID, deleted.UUID, deleted.Version); err != nil {
t.Fatal("delete idempotency", err)
}
if got, err := st.Contact(ctx, domain.UUID, owner.UUID, contact.UUID); err != nil || got.VCard != contact.VCard {
t.Fatal(got, err)
}
if got, err := st.ContactDAVSnapshot(ctx, domain.UUID, owner.UUID, snapshot.Token, 200); err != nil || len(got.Items) != 0 {
t.Fatal("sync continuity", got, err)
}
contact.Name = "After import"
if _, err = st.SaveContact(ctx, domain.UUID, owner.UUID, contact, false); err != nil {
t.Fatal(err)
}
var sequence int64
if err = target.DB.QueryRow(`SELECT max(sequence) FROM organizer_contact_changes`).Scan(&sequence); err != nil || sequence <= 100000 {
t.Fatal("sequence reused", sequence, err)
}
if err = PreparePostgreSQLImport(ctx, target.DB, source.DocumentRoot); err == nil {
t.Fatal("populated target preparation accepted")
}
if os.Getenv("PAGESWIKI_TEST_POSTGRES_CONTAINER") != "" {
restored := restoreImportTestSchema(t, target)
if err = VerifyPostgreSQLImport(ctx, restored, source.DocumentRoot); err != nil {
t.Fatal(err)
}
r, err := NewPostgreSQLWithDocumentRoot(ctx, restored, source.DocumentRoot)
if err != nil {
t.Fatal(err)
}
if got, err := r.GetRevision(rev.UUID); err != nil || got.Body != rev.Body {
t.Fatal("restored revision", err)
}
if got, err := r.PrincipalForSession(domain.UUID, token); err != nil || got.UUID != owner.UUID {
t.Fatal("restored session", err)
}
if got, err := r.TaskDAVByName(ctx, domain.UUID, owner.UUID, "import.ics", project.UUID); err != nil || got.UUID != projectTask.UUID {
t.Fatal("restored task DAV", err)
}
if _, err = r.ContactDAVSnapshot(ctx, domain.UUID, owner.UUID, snapshot.Token, 200); err != nil {
t.Fatal("restored contact sync", err)
}
t.Log("schema-scoped pg_dump/pg_restore and canonical-file reuse verified")
}
if _, err = ImportSQLiteApplication(ctx, source.DB, target.DB, source.DocumentRoot); err == nil {
t.Fatal("overwrite accepted")
}
}
// Opt-in restore rehearsal: only the random schema created by this test is
// dumped and restored, inside the explicitly selected disposable container.
func restoreImportTestSchema(t *testing.T, source *Store) *sql.DB {
t.Helper()
container := os.Getenv("PAGESWIKI_TEST_POSTGRES_CONTAINER")
u, err := url.Parse(os.Getenv("PAGESWIKI_TEST_POSTGRES_DSN"))
if err != nil {
t.Fatal(err)
}
var schema string
if err = source.DB.QueryRow(`SELECT current_schema()`).Scan(&schema); err != nil {
t.Fatal(err)
}
if !strings.HasPrefix(schema, "pageswiki_namespace_test_") {
t.Fatal("restore requires a private test schema")
}
database := strings.TrimPrefix(u.Path, "/")
dump, err := exec.Command("docker", "exec", container, "pg_dump", "-U", u.User.Username(), "-d", database, "-n", schema, "--no-owner", "--no-acl", "-Fc").Output()
if err != nil {
t.Fatal("synthetic schema pg_dump failed")
}
old := schema + "_old"
if _, err = source.DB.Exec(`ALTER SCHEMA ` + importIdent(schema) + ` RENAME TO ` + importIdent(old)); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _, _ = source.DB.Exec(`DROP SCHEMA IF EXISTS ` + importIdent(old) + ` CASCADE`) })
cmd := exec.Command("docker", "exec", "-i", container, "pg_restore", "-U", u.User.Username(), "-d", database, "--exit-on-error", "--no-owner", "--no-acl")
cmd.Stdin = bytes.NewReader(dump)
if err = cmd.Run(); err != nil {
t.Fatal("synthetic schema pg_restore failed")
}
q := u.Query()
q.Set("search_path", schema)
u.RawQuery = q.Encode()
restored, err := db.OpenPostgreSQL(context.Background(), db.PostgreSQLOptions{DSN: u.String(), AllowInsecure: true})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { restored.Close() })
return restored
}
func TestApplicationImportScalarFingerprint(t *testing.T) {
seen := map[string]bool{}
for _, v := range []any{nil, "", []byte{}, "YQ==", []byte("a"), int64(1), float64(1), true} {
b, err := importRowBytes([]any{v})
if err != nil || seen[string(b)] {
t.Fatal("scalar collision", err)
}
seen[string(b)] = true
}
}
func TestApplicationImportRejectsSourceDrift(t *testing.T) {
for _, ddl := range []string{`CREATE TABLE unexpected(secret TEXT)`, `ALTER TABLE tags ADD COLUMN unexpected TEXT`, `CREATE TRIGGER unexpected AFTER INSERT ON tags BEGIN SELECT 1; END`} {
t.Run(strings.Fields(ddl)[1], func(t *testing.T) {
s := testNamespaceStore(t, storeSQLite)
if _, err := InspectSQLiteApplicationImport(context.Background(), s.DB); err != nil {
t.Fatal(err)
}
if _, err := s.DB.Exec(ddl); err != nil {
t.Fatal(err)
}
if _, err := InspectSQLiteApplicationImport(context.Background(), s.DB); err == nil {
t.Fatal("schema drift accepted")
}
})
}
}
// Opt-in schema inventory contains table/column metadata only, never user rows.
func TestApplicationImportCatalogInventory(t *testing.T) {
if os.Getenv("PAGESWIKI_IMPORT_CATALOG") != "1" {
t.Skip("schema inventory")
}
ctx := context.Background()
for _, backend := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
s := testNamespaceStore(t, backend)
if backend == storePostgreSQL {
root := filepath.Join(t.TempDir(), "documents")
if err := os.Mkdir(root, 0700); err != nil {
t.Fatal(err)
}
t.Setenv("PAGESWIKI_AUTH_KEY", "synthetic catalog key")
var err error
s, err = NewPostgreSQLWithDocumentRoot(ctx, s.DB, root)
if err != nil {
t.Fatal(err)
}
}
if _, err := s.NewCalendarRepository(ctx); err != nil {
t.Fatal(err)
}
query := `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name`
if backend == storePostgreSQL {
query = `SELECT table_name FROM information_schema.tables WHERE table_schema=current_schema() AND table_type='BASE TABLE' ORDER BY table_name`
}
rows, err := s.DB.Query(query)
if err != nil {
t.Fatal(err)
}
var tables []string
for rows.Next() {
var n string
if err = rows.Scan(&n); err != nil {
t.Fatal(err)
}
tables = append(tables, n)
}
rows.Close()
if backend == storeSQLite {
objects, err := s.DB.Query(`SELECT type,name,sql FROM sqlite_master WHERE type IN ('trigger','view') ORDER BY name`)
if err != nil {
t.Fatal(err)
}
for objects.Next() {
var kind, name, ddl string
if err = objects.Scan(&kind, &name, &ddl); err != nil {
t.Fatal(err)
}
t.Logf("SOURCEOBJECT %s %s %x", kind, name, sha256.Sum256([]byte(ddl)))
}
objects.Close()
}
for _, table := range tables {
var cols *sql.Rows
if backend == storeSQLite {
cols, err = s.DB.Query(`SELECT name,type FROM pragma_table_info(?) ORDER BY name`, table)
} else {
cols, err = s.DB.Query(`SELECT column_name,data_type FROM information_schema.columns WHERE table_schema=current_schema() AND table_name=$1 ORDER BY column_name`, table)
}
if err != nil {
t.Fatal(err)
}
columns := map[string]string{}
for cols.Next() {
var name, kind string
if err = cols.Scan(&name, &kind); err != nil {
t.Fatal(err)
}
columns[name] = kind
}
cols.Close()
b, _ := json.Marshal(columns)
t.Logf("CATALOG %d %s %s", backend, table, b)
}
}
}
+8 -105
View File
@@ -1,124 +1,27 @@
package store
import (
"bytes"
"context"
"database/sql"
"errors"
"fmt"
"io"
"strings"
"golang.org/x/net/html"
"pageswiki/internal/documentrefs"
)
var ErrEmbeddedAssetUnavailable = errors.New("embedded asset is unavailable")
var ErrEmbeddedAssetUnavailable = documentrefs.ErrUnavailable
// freezeEmbeddedAssets resolves mutable asset: HEADs only in HTML embedding
// attributes. Plain text and code examples containing asset: remain unchanged.
func (s *Store) freezeEmbeddedAssets(objectUUID string, payload []byte, contentType string) ([]byte, []string, error) {
return freezeEmbeddedAssetsFrom(s.DB, objectUUID, payload, contentType)
}
func freezeEmbeddedAssetsFrom(q interface{ QueryRow(string, ...any) *sql.Row }, objectUUID string, payload []byte, contentType string) ([]byte, []string, error) {
if !strings.HasPrefix(strings.ToLower(strings.TrimSpace(contentType)), "text/html") {
return payload, nil, nil
}
z := html.NewTokenizer(bytes.NewReader(payload))
var output bytes.Buffer
seen := map[string]bool{}
resolved := map[string]string{}
var hashes []string
resolve := func(address string) (string, error) {
if hash := resolved[address]; hash != "" {
return hash, nil
}
return documentrefs.Freeze(context.Background(), payload, contentType, func(_ context.Context, address string) (string, error) {
var hash string
err := q.QueryRow(`SELECT COALESCE(a.head_document_hash,'') FROM assets a JOIN paths p ON p.domain_uuid=a.domain_uuid WHERE p.object_uuid=? AND a.address=? ORDER BY COALESCE(p.is_primary,0) DESC LIMIT 1`, objectUUID, address).Scan(&hash)
if err != nil || !validDocumentHash(hash) {
if errors.Is(err, sql.ErrNoRows) || err == nil {
return "", fmt.Errorf("%w: %s", ErrEmbeddedAssetUnavailable, address)
}
return "", err
if errors.Is(err, sql.ErrNoRows) || err == nil && !validDocumentHash(hash) {
return "", fmt.Errorf("%w: %s", ErrEmbeddedAssetUnavailable, address)
}
resolved[address] = hash
if !seen[hash] {
seen[hash] = true
hashes = append(hashes, hash)
}
return hash, nil
}
for {
typeOfToken := z.Next()
if typeOfToken == html.ErrorToken {
if errors.Is(z.Err(), io.EOF) {
return output.Bytes(), hashes, nil
}
return nil, nil, z.Err()
}
if typeOfToken != html.StartTagToken && typeOfToken != html.SelfClosingTagToken {
output.Write(z.Raw())
continue
}
token := z.Token()
changed := false
assetRef := tokenAttribute(token.Attr, "asset-ref")
legacyImmutableRef := tokenAttribute(token.Attr, "immutable-ref")
if assetRef == "" && strings.HasPrefix(legacyImmutableRef, "asset:") {
assetRef = legacyImmutableRef
}
if strings.HasPrefix(assetRef, "asset:") {
hash, err := resolve(assetRef)
if err != nil {
return nil, nil, err
}
setTokenAttribute(&token, "asset-ref", assetRef)
setTokenAttribute(&token, "immutable-ref", "sha256:"+hash)
changed = true
}
for _, name := range []string{"src", "href", "poster", "data"} {
provenanceName := "data-pageswiki-asset-" + name
address := tokenAttribute(token.Attr, provenanceName)
if address == "" {
candidate := tokenAttribute(token.Attr, name)
if strings.HasPrefix(candidate, "asset:") {
address = candidate
}
}
if !strings.HasPrefix(address, "asset:") {
continue
}
hash, err := resolve(address)
if err != nil {
return nil, nil, err
}
setTokenAttribute(&token, provenanceName, address)
setTokenAttribute(&token, name, "/_/obj/sha256:"+hash)
changed = true
}
if changed {
output.WriteString(token.String())
} else {
output.Write(z.Raw())
}
}
}
func tokenAttribute(attributes []html.Attribute, name string) string {
for _, attribute := range attributes {
if strings.EqualFold(attribute.Key, name) {
return strings.TrimSpace(attribute.Val)
}
}
return ""
}
func setTokenAttribute(token *html.Token, name, value string) {
for index := range token.Attr {
if strings.EqualFold(token.Attr[index].Key, name) {
token.Attr[index].Key = name
token.Attr[index].Val = value
return
}
}
token.Attr = append(token.Attr, html.Attribute{Key: name, Val: value})
return hash, err
})
}
+105 -17
View File
@@ -1,12 +1,16 @@
package store
import (
"bytes"
"context"
"database/sql"
"errors"
"fmt"
"strings"
"time"
"pageswiki/internal/metadata"
"github.com/google/uuid"
)
@@ -48,6 +52,14 @@ type AssetDependency struct {
}
func (s *Store) EnsureAssetsSchema() error {
if s.sqlBackend == storePostgreSQL {
// Native core migrations own these tables; never run SQLite adoption.
rows, err := s.DB.Query(`SELECT a.domain_uuid,a.address,a.object_uuid,a.head_document_hash,a.content_type,a.filename,a.size_bytes,a.created_at_ms,a.updated_at_ms,h.id,h.action,h.document_hash,h.actor_uuid FROM assets a JOIN asset_head_history h ON h.domain_uuid=a.domain_uuid AND h.address=a.address WHERE 1=0`)
if err != nil {
return s.sqlError("asset schema", err)
}
return rows.Close()
}
columns, err := assetTableColumns(s.DB, "assets")
if err != nil {
return err
@@ -129,8 +141,9 @@ func assetTableColumns(db *sql.DB, table string) (map[string]bool, error) {
return out, rows.Err()
}
func (s *Store) ListAssets(domainUUID string) ([]Asset, error) {
rows, err := s.DB.Query(`SELECT a.domain_uuid,a.address,a.object_uuid,COALESCE(a.head_document_hash,''),a.content_type,a.filename,a.size_bytes,a.created_at_ms,a.updated_at_ms,(SELECT COUNT(DISTINCT x.revision_uuid) FROM revision_document_refs x JOIN revisions r ON r.uuid=x.revision_uuid WHERE x.document_hash IN (SELECT document_hash FROM asset_head_history h WHERE h.domain_uuid=a.domain_uuid AND h.address=a.address UNION SELECT a.head_document_hash) AND EXISTS(SELECT 1 FROM paths p WHERE p.domain_uuid=a.domain_uuid AND p.object_uuid=r.object_uuid)) FROM assets a WHERE a.domain_uuid=? ORDER BY a.updated_at_ms DESC,a.address`, domainUUID)
func (s *Store) ListAssets(domainUUID string) (_ []Asset, resultErr error) {
defer func() { resultErr = s.sqlError("list assets", resultErr) }()
rows, err := s.DB.Query(`SELECT a.domain_uuid,a.address,a.object_uuid,COALESCE(a.head_document_hash,''),a.content_type,a.filename,a.size_bytes,a.created_at_ms,a.updated_at_ms,(SELECT COUNT(DISTINCT x.revision_uuid) FROM revision_document_refs x JOIN revisions r ON r.uuid=x.revision_uuid WHERE x.document_hash IN (SELECT document_hash FROM asset_head_history h WHERE h.domain_uuid=a.domain_uuid AND h.address=a.address UNION SELECT a.head_document_hash) AND EXISTS(SELECT 1 FROM paths p WHERE p.domain_uuid=a.domain_uuid AND p.object_uuid=r.object_uuid)) FROM assets a WHERE a.domain_uuid=`+s.sqlParam(1)+` ORDER BY a.updated_at_ms DESC,a.address`, domainUUID)
if err != nil {
return nil, err
}
@@ -146,22 +159,24 @@ func (s *Store) ListAssets(domainUUID string) ([]Asset, error) {
return assets, rows.Err()
}
func (s *Store) GetAsset(domainUUID, address string) (*Asset, error) {
func (s *Store) GetAsset(domainUUID, address string) (_ *Asset, resultErr error) {
defer func() { resultErr = s.sqlError("get asset", resultErr) }()
var a Asset
err := s.DB.QueryRow(`SELECT a.domain_uuid,a.address,a.object_uuid,COALESCE(a.head_document_hash,''),a.content_type,a.filename,a.size_bytes,a.created_at_ms,a.updated_at_ms,(SELECT COUNT(DISTINCT x.revision_uuid) FROM revision_document_refs x JOIN revisions r ON r.uuid=x.revision_uuid WHERE x.document_hash IN (SELECT document_hash FROM asset_head_history h WHERE h.domain_uuid=a.domain_uuid AND h.address=a.address UNION SELECT a.head_document_hash) AND EXISTS(SELECT 1 FROM paths p WHERE p.domain_uuid=a.domain_uuid AND p.object_uuid=r.object_uuid)) FROM assets a WHERE a.domain_uuid=? AND a.address=?`, domainUUID, address).Scan(&a.DomainUUID, &a.Address, &a.ObjectUUID, &a.HeadDocumentHash, &a.ContentType, &a.Filename, &a.SizeBytes, &a.CreatedAtMS, &a.UpdatedAtMS, &a.ReferenceCount)
err := s.DB.QueryRow(`SELECT a.domain_uuid,a.address,a.object_uuid,COALESCE(a.head_document_hash,''),a.content_type,a.filename,a.size_bytes,a.created_at_ms,a.updated_at_ms,(SELECT COUNT(DISTINCT x.revision_uuid) FROM revision_document_refs x JOIN revisions r ON r.uuid=x.revision_uuid WHERE x.document_hash IN (SELECT document_hash FROM asset_head_history h WHERE h.domain_uuid=a.domain_uuid AND h.address=a.address UNION SELECT a.head_document_hash) AND EXISTS(SELECT 1 FROM paths p WHERE p.domain_uuid=a.domain_uuid AND p.object_uuid=r.object_uuid)) FROM assets a WHERE a.domain_uuid=`+s.sqlParam(1)+` AND a.address=`+s.sqlParam(2), domainUUID, address).Scan(&a.DomainUUID, &a.Address, &a.ObjectUUID, &a.HeadDocumentHash, &a.ContentType, &a.Filename, &a.SizeBytes, &a.CreatedAtMS, &a.UpdatedAtMS, &a.ReferenceCount)
if errors.Is(err, sql.ErrNoRows) {
return nil, ErrAssetNotFound
}
return &a, err
}
func (s *Store) GetAssetByHeadHash(domainUUID, hash string) (*Asset, error) {
func (s *Store) GetAssetByHeadHash(domainUUID, hash string) (_ *Asset, resultErr error) {
defer func() { resultErr = s.sqlError("get asset hash", resultErr) }()
hash = strings.ToLower(strings.TrimSpace(hash))
if !validDocumentHash(hash) {
return nil, ErrAssetNotFound
}
var a Asset
err := s.DB.QueryRow(`SELECT a.domain_uuid,a.address,a.object_uuid,COALESCE(a.head_document_hash,''),a.content_type,a.filename,a.size_bytes,a.created_at_ms,a.updated_at_ms,(SELECT COUNT(DISTINCT x.revision_uuid) FROM revision_document_refs x JOIN revisions r ON r.uuid=x.revision_uuid WHERE x.document_hash IN (SELECT document_hash FROM asset_head_history h WHERE h.domain_uuid=a.domain_uuid AND h.address=a.address UNION SELECT a.head_document_hash) AND EXISTS(SELECT 1 FROM paths p WHERE p.domain_uuid=a.domain_uuid AND p.object_uuid=r.object_uuid)) FROM assets a WHERE a.domain_uuid=? AND a.head_document_hash=? LIMIT 1`, domainUUID, hash).Scan(&a.DomainUUID, &a.Address, &a.ObjectUUID, &a.HeadDocumentHash, &a.ContentType, &a.Filename, &a.SizeBytes, &a.CreatedAtMS, &a.UpdatedAtMS, &a.ReferenceCount)
err := s.DB.QueryRow(`SELECT a.domain_uuid,a.address,a.object_uuid,COALESCE(a.head_document_hash,''),a.content_type,a.filename,a.size_bytes,a.created_at_ms,a.updated_at_ms,(SELECT COUNT(DISTINCT x.revision_uuid) FROM revision_document_refs x JOIN revisions r ON r.uuid=x.revision_uuid WHERE x.document_hash IN (SELECT document_hash FROM asset_head_history h WHERE h.domain_uuid=a.domain_uuid AND h.address=a.address UNION SELECT a.head_document_hash) AND EXISTS(SELECT 1 FROM paths p WHERE p.domain_uuid=a.domain_uuid AND p.object_uuid=r.object_uuid)) FROM assets a WHERE a.domain_uuid=`+s.sqlParam(1)+` AND a.head_document_hash=`+s.sqlParam(2)+` LIMIT 1`, domainUUID, hash).Scan(&a.DomainUUID, &a.Address, &a.ObjectUUID, &a.HeadDocumentHash, &a.ContentType, &a.Filename, &a.SizeBytes, &a.CreatedAtMS, &a.UpdatedAtMS, &a.ReferenceCount)
if errors.Is(err, sql.ErrNoRows) {
return nil, ErrAssetNotFound
}
@@ -178,6 +193,12 @@ func normalizeAssetAddress(address string) (string, error) {
}
func (s *Store) PutAsset(domainUUID, address string, payload []byte, contentType, filename, expectedHash, actorUUID string) (*Asset, bool, error) {
if s.ReadOnly {
return nil, false, ErrReadOnly
}
if s.sqlBackend == storePostgreSQL {
return s.putNativeAsset(domainUUID, address, payload, contentType, filename, expectedHash, actorUUID)
}
if s.DocumentRoot == "" {
return nil, false, errors.New("Asset writes require a configured Document Store")
}
@@ -244,8 +265,9 @@ func (s *Store) PutAsset(domainUUID, address string, payload []byte, contentType
return a, true, err
}
func (s *Store) ListAssetHistory(domainUUID, address string) ([]AssetHistory, error) {
rows, err := s.DB.Query(`SELECT id,action,document_hash,content_type,filename,size_bytes,actor_uuid,created_at_ms FROM asset_head_history WHERE domain_uuid=? AND address=? ORDER BY id DESC LIMIT 100`, domainUUID, address)
func (s *Store) ListAssetHistory(domainUUID, address string) (_ []AssetHistory, resultErr error) {
defer func() { resultErr = s.sqlError("asset history", resultErr) }()
rows, err := s.DB.Query(`SELECT id,action,document_hash,content_type,filename,size_bytes,actor_uuid,created_at_ms FROM asset_head_history WHERE domain_uuid=`+s.sqlParam(1)+` AND address=`+s.sqlParam(2)+` ORDER BY id DESC LIMIT 100`, domainUUID, address)
if err != nil {
return nil, err
}
@@ -261,7 +283,8 @@ func (s *Store) ListAssetHistory(domainUUID, address string) ([]AssetHistory, er
return out, rows.Err()
}
func (s *Store) ListAssetDependencies(domainUUID, address string) ([]AssetDependency, error) {
func (s *Store) ListAssetDependencies(domainUUID, address string) (_ []AssetDependency, resultErr error) {
defer func() { resultErr = s.sqlError("asset dependencies", resultErr) }()
rows, err := s.DB.Query(`
SELECT DISTINCT x.document_hash,r.uuid,r.object_uuid,p.path,
COALESCE(r.created_at_ms,COALESCE(r.created_at,0)*1000)
@@ -270,7 +293,7 @@ func (s *Store) ListAssetDependencies(domainUUID, address string) ([]AssetDepend
JOIN revision_document_refs x ON x.document_hash=h.document_hash
JOIN revisions r ON r.uuid=x.revision_uuid
JOIN paths p ON p.domain_uuid=h.domain_uuid AND p.object_uuid=r.object_uuid
WHERE h.domain_uuid=? AND h.address=?
WHERE h.domain_uuid=`+s.sqlParam(1)+` AND h.address=`+s.sqlParam(2)+`
ORDER BY COALESCE(r.created_at_ms,COALESCE(r.created_at,0)*1000) DESC,p.path
LIMIT 500
`, domainUUID, address)
@@ -290,6 +313,9 @@ func (s *Store) ListAssetDependencies(domainUUID, address string) ([]AssetDepend
}
func (s *Store) RestoreAssetHead(domainUUID, address string, historyID int64, expectedHash, actorUUID string) (*Asset, error) {
if s.ReadOnly {
return nil, ErrReadOnly
}
current, err := s.GetAsset(domainUUID, address)
if err != nil {
return nil, err
@@ -298,25 +324,40 @@ func (s *Store) RestoreAssetHead(domainUUID, address string, historyID int64, ex
return nil, ErrAssetConflict
}
var historical AssetHistory
err = s.DB.QueryRow(`SELECT id,action,document_hash,content_type,filename,size_bytes,actor_uuid,created_at_ms FROM asset_head_history WHERE domain_uuid=? AND address=? AND id=?`, domainUUID, address, historyID).Scan(&historical.ID, &historical.Action, &historical.DocumentHash, &historical.ContentType, &historical.Filename, &historical.SizeBytes, &historical.ActorUUID, &historical.CreatedAtMS)
err = s.DB.QueryRow(`SELECT id,action,document_hash,content_type,filename,size_bytes,actor_uuid,created_at_ms FROM asset_head_history WHERE domain_uuid=`+s.sqlParam(1)+` AND address=`+s.sqlParam(2)+` AND id=`+s.sqlParam(3), domainUUID, address, historyID).Scan(&historical.ID, &historical.Action, &historical.DocumentHash, &historical.ContentType, &historical.Filename, &historical.SizeBytes, &historical.ActorUUID, &historical.CreatedAtMS)
if errors.Is(err, sql.ErrNoRows) {
return nil, ErrAssetNotFound
}
if err != nil {
return nil, err
}
if s.sqlBackend == storePostgreSQL {
if s.DocumentRoot == "" {
return nil, ErrDocumentStoreRequired
}
docs, err := s.documentStorage()
if err != nil {
return nil, err
}
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
if err = docs.Verify(ctx, historical.DocumentHash); err != nil {
return nil, err
}
}
reader, err := s.OpenDocument(historical.DocumentHash)
if err != nil {
return nil, err
}
_ = reader.Close()
now := time.Now().UnixMilli()
tx, err := s.DB.Begin()
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
if err != nil {
return nil, err
}
defer tx.Rollback()
result, err := tx.Exec(`UPDATE assets SET head_document_hash=?,content_type=?,filename=?,size_bytes=?,updated_at_ms=? WHERE domain_uuid=? AND address=? AND head_document_hash=?`, historical.DocumentHash, historical.ContentType, historical.Filename, historical.SizeBytes, now, domainUUID, address, current.HeadDocumentHash)
result, err := tx.Exec(`UPDATE assets SET head_document_hash=`+s.sqlParam(1)+`,content_type=`+s.sqlParam(2)+`,filename=`+s.sqlParam(3)+`,size_bytes=`+s.sqlParam(4)+`,updated_at_ms=`+s.sqlParam(5)+` WHERE domain_uuid=`+s.sqlParam(6)+` AND address=`+s.sqlParam(7)+` AND head_document_hash=`+s.sqlParam(8), historical.DocumentHash, historical.ContentType, historical.Filename, historical.SizeBytes, now, domainUUID, address, current.HeadDocumentHash)
if err != nil {
return nil, err
}
@@ -324,7 +365,7 @@ func (s *Store) RestoreAssetHead(domainUUID, address string, historyID int64, ex
if affected != 1 {
return nil, ErrAssetConflict
}
if _, err = tx.Exec(`INSERT INTO asset_head_history(domain_uuid,address,action,document_hash,content_type,filename,size_bytes,actor_uuid,created_at_ms) VALUES(?,?,'restore',?,?,?,?,?,?)`, domainUUID, address, historical.DocumentHash, historical.ContentType, historical.Filename, historical.SizeBytes, actorUUID, now); err != nil {
if _, err = tx.Exec(`INSERT INTO asset_head_history(domain_uuid,address,action,document_hash,content_type,filename,size_bytes,actor_uuid,created_at_ms) VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,'restore',`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`,`+s.sqlParam(7)+`,`+s.sqlParam(8)+`)`, domainUUID, address, historical.DocumentHash, historical.ContentType, historical.Filename, historical.SizeBytes, actorUUID, now); err != nil {
return nil, err
}
if err = tx.Commit(); err != nil {
@@ -334,6 +375,9 @@ func (s *Store) RestoreAssetHead(domainUUID, address string, historyID int64, ex
}
func (s *Store) DeleteAsset(domainUUID, address, expectedHash, actorUUID string) error {
if s.ReadOnly {
return ErrReadOnly
}
a, err := s.GetAsset(domainUUID, address)
if err != nil {
return err
@@ -342,15 +386,16 @@ func (s *Store) DeleteAsset(domainUUID, address, expectedHash, actorUUID string)
return ErrAssetConflict
}
now := time.Now().UnixMilli()
tx, err := s.DB.Begin()
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
if err != nil {
return err
}
defer tx.Rollback()
if _, err = tx.Exec(`INSERT INTO asset_head_history(domain_uuid,address,action,document_hash,content_type,filename,size_bytes,actor_uuid,created_at_ms) VALUES(?,?,'delete',?,?,?,?,?,?)`, domainUUID, address, a.HeadDocumentHash, a.ContentType, a.Filename, a.SizeBytes, actorUUID, now); err != nil {
if _, err = tx.Exec(`INSERT INTO asset_head_history(domain_uuid,address,action,document_hash,content_type,filename,size_bytes,actor_uuid,created_at_ms) VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,'delete',`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`,`+s.sqlParam(7)+`,`+s.sqlParam(8)+`)`, domainUUID, address, a.HeadDocumentHash, a.ContentType, a.Filename, a.SizeBytes, actorUUID, now); err != nil {
return err
}
result, err := tx.Exec(`DELETE FROM assets WHERE domain_uuid=? AND address=? AND head_document_hash=?`, domainUUID, address, a.HeadDocumentHash)
result, err := tx.Exec(`DELETE FROM assets WHERE domain_uuid=`+s.sqlParam(1)+` AND address=`+s.sqlParam(2)+` AND head_document_hash=`+s.sqlParam(3), domainUUID, address, a.HeadDocumentHash)
if err != nil {
return err
}
@@ -359,3 +404,46 @@ func (s *Store) DeleteAsset(domainUUID, address, expectedHash, actorUUID string)
}
return tx.Commit()
}
func (s *Store) putNativeAsset(domain, address string, payload []byte, contentType, filename, expected, actor string) (*Asset, bool, error) {
if s.DocumentRoot == "" {
return nil, false, ErrDocumentStoreRequired
}
address, err := normalizeAssetAddress(address)
if err != nil {
return nil, false, err
}
if strings.TrimSpace(contentType) == "" {
contentType = "application/octet-stream"
}
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
repo, err := metadata.NewApplication(s.DB, metadata.PostgreSQL)
if err != nil {
return nil, false, err
}
docs, err := s.documentStorage()
if err != nil {
return nil, false, err
}
hash := revisionHash(string(payload))
previous, getErr := repo.GetAsset(ctx, domain, address)
if getErr != nil && !errors.Is(getErr, metadata.ErrNotFound) {
return nil, false, getErr
}
if previous.HeadDocumentHash != strings.Trim(expected, "\"") {
return nil, false, ErrAssetConflict
}
if err = docs.PutIfAbsent(ctx, hash, int64(len(payload)), bytes.NewReader(payload)); err != nil {
return nil, false, err
}
a, err := repo.PutAsset(ctx, metadata.Asset{DomainUUID: domain, Address: address, HeadDocumentHash: hash, ContentType: contentType, Filename: strings.TrimSpace(filename), SizeBytes: int64(len(payload))}, strings.Trim(expected, "\""), actor)
if errors.Is(err, metadata.ErrConflict) {
return nil, false, ErrAssetConflict
}
if err != nil {
return nil, false, err
}
result, err := s.GetAsset(domain, address)
return result, a.UpdatedAtMS != previous.UpdatedAtMS, err
}
+128
View File
@@ -0,0 +1,128 @@
package store
import (
"errors"
"fmt"
"os"
"path/filepath"
"testing"
"pageswiki/internal/geduldh"
)
func TestAssetsBackendLifecycle(t *testing.T) {
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(b), func(t *testing.T) {
f := newPublicationBackend(t, b)
s := f.s
s.DocumentRoot = t.TempDir()
if err := s.EnsureAssetsSchema(); err != nil {
t.Fatal(err)
}
a, changed, err := s.PutAsset(f.domain, "asset:image:logo", []byte("one"), "image/png", "logo.png", "", f.actor)
if err != nil || !changed {
t.Fatal(a, changed, err)
}
if _, changed, err = s.PutAsset(f.domain, a.Address, []byte("one"), a.ContentType, a.Filename, a.HeadDocumentHash, f.actor); err != nil || changed {
t.Fatal("no-op", changed, err)
}
obj, err := s.CreatePageAtPathInDomain(f.domain, "/asset-page")
if err != nil {
t.Fatal(err)
}
if _, err = s.SaveRevisionContent(obj, []byte(`<img src="asset:image:logo">`), "", "en", "text/html", ""); err != nil {
t.Fatal(err)
}
updated, _, err := s.PutAsset(f.domain, a.Address, []byte("two"), a.ContentType, a.Filename, a.HeadDocumentHash, f.actor)
if err != nil || updated.ReferenceCount != 1 {
t.Fatal(updated, err)
}
deps, err := s.ListAssetDependencies(f.domain, a.Address)
if err != nil || len(deps) != 1 || deps[0].Path != "/asset-page" {
t.Fatal(deps, err)
}
assets, err := s.ListAssets(f.domain)
if err != nil || len(assets) != 1 || assets[0].ReferenceCount != 1 {
t.Fatal(assets, err)
}
byHash, err := s.GetAssetByHeadHash(f.domain, updated.HeadDocumentHash)
if err != nil || byHash.ObjectUUID != a.ObjectUUID {
t.Fatal(byHash, err)
}
history, err := s.ListAssetHistory(f.domain, a.Address)
if err != nil || len(history) != 2 {
t.Fatal(history, err)
}
if _, err = s.RestoreAssetHead(f.domain, a.Address, history[1].ID, "wrong", f.actor); !errors.Is(err, ErrAssetConflict) {
t.Fatal(err)
}
restored, err := s.RestoreAssetHead(f.domain, a.Address, history[1].ID, updated.HeadDocumentHash, f.actor)
if err != nil || restored.HeadDocumentHash != a.HeadDocumentHash {
t.Fatal(restored, err)
}
f.exec(`ALTER TABLE asset_head_history RENAME COLUMN action TO unavailable_action`)
if err = s.DeleteAsset(f.domain, a.Address, restored.HeadDocumentHash, f.actor); err == nil {
t.Fatal("ignored audit failure")
}
if current, err := s.GetAsset(f.domain, a.Address); err != nil || current.HeadDocumentHash != restored.HeadDocumentHash {
t.Fatal(current, err)
}
f.exec(`ALTER TABLE asset_head_history RENAME COLUMN unavailable_action TO action`)
if err = s.DeleteAsset(f.domain, a.Address, restored.HeadDocumentHash, f.actor); err != nil {
t.Fatal(err)
}
if _, err = s.GetAsset(f.domain, a.Address); !errors.Is(err, ErrAssetNotFound) {
t.Fatal(err)
}
history, err = s.ListAssetHistory(f.domain, a.Address)
if err != nil || len(history) != 4 || history[0].Action != "delete" {
t.Fatal(history, err)
}
})
}
}
func TestPostgreSQLAssetMissingPayloadAndCAS(t *testing.T) {
f := newPublicationBackend(t, storePostgreSQL)
s := f.s
s.DocumentRoot = t.TempDir()
a, _, err := s.PutAsset(f.domain, "asset:image:test", []byte("original"), "image/png", "", "", f.actor)
if err != nil {
t.Fatal(err)
}
history, err := s.ListAssetHistory(f.domain, a.Address)
if err != nil {
t.Fatal(err)
}
peer := &Store{DB: s.DB, sqlBackend: storePostgreSQL, DocumentRoot: s.DocumentRoot}
results := make(chan error, 2)
for i, w := range []*Store{s, peer} {
go func(i int, w *Store) {
_, _, e := w.PutAsset(f.domain, a.Address, []byte(fmt.Sprint(i)), "image/png", "", a.HeadDocumentHash, f.actor)
results <- e
}(i, w)
}
wins := 0
for i := 0; i < 2; i++ {
e := <-results
if e == nil {
wins++
} else if !errors.Is(e, ErrAssetConflict) {
t.Fatal(e)
}
}
if wins != 1 {
t.Fatal(wins)
}
current, err := s.GetAsset(f.domain, a.Address)
if err != nil {
t.Fatal(err)
}
key, _ := geduldh.Key(a.HeadDocumentHash)
if err = os.Remove(filepath.Join(s.DocumentRoot, key)); err != nil {
t.Fatal(err)
}
if _, err = s.RestoreAssetHead(f.domain, a.Address, history[0].ID, current.HeadDocumentHash, f.actor); err == nil {
t.Fatal("missing payload restored")
}
}
+111 -170
View File
@@ -1,6 +1,7 @@
package store
import (
"context"
"crypto/rand"
"crypto/sha256"
"database/sql"
@@ -82,70 +83,18 @@ func VerifyPassword(encoded, password string) bool {
func (s *Store) PrincipalCount() (int, error) {
var count int
err := s.DB.QueryRow(`SELECT COUNT(*) FROM principals`).Scan(&count)
return count, err
return count, s.sqlError("principal count", err)
}
func (s *Store) BootstrapOwner(domainUUID, username, password, displayName, email string) (*Principal, error) {
username = strings.ToLower(strings.TrimSpace(username))
if !authUsernamePattern.MatchString(username) {
return nil, errors.New("username must be 2-64 lowercase letters, digits, underscores, or hyphens")
}
encoded, err := HashPassword(password)
if err != nil {
return nil, err
}
tx, err := s.DB.Begin()
if err != nil {
return nil, err
}
defer tx.Rollback()
var count int
if err = tx.QueryRow(`SELECT COUNT(*) FROM principals`).Scan(&count); err != nil || count != 0 {
if err == nil {
err = errors.New("owner already exists")
}
return nil, err
}
now := time.Now().UnixMilli()
principalID, membershipID, roleID := uuid.NewString(), uuid.NewString(), uuid.NewString()
if strings.TrimSpace(displayName) == "" {
displayName = username
}
queries := []struct {
q string
args []any
}{
{`INSERT INTO principals(uuid,display_name,email,state,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?)`, []any{principalID, displayName, strings.TrimSpace(email), "active", now, now}},
{`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,subject,created_at_ms) VALUES(?,?,?,?,?)`, []any{uuid.NewString(), principalID, "password", username, now}},
{`INSERT INTO auth_credentials(uuid,principal_uuid,kind,identifier,secret_hash,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?,?)`, []any{uuid.NewString(), principalID, "password", username, encoded, now, now}},
{`INSERT INTO domain_memberships(uuid,domain_uuid,principal_uuid,state,created_at_ms) VALUES(?,?,?,?,?)`, []any{membershipID, domainUUID, principalID, "active", now}},
{`INSERT INTO auth_roles(uuid,domain_uuid,name,description,created_at_ms) VALUES(?,?,?,?,?)`, []any{roleID, domainUUID, "owner", "Domain owner", now}},
{`INSERT INTO auth_role_bindings(membership_uuid,role_uuid,created_at_ms) VALUES(?,?,?)`, []any{membershipID, roleID, now}},
}
for _, item := range queries {
if _, err = tx.Exec(item.q, item.args...); err != nil {
return nil, err
}
}
for _, capability := range []string{"read", "write", "rename", "delete", "link", "manage", "delegate"} {
if _, err = tx.Exec(`INSERT INTO auth_capability_grants(uuid,role_uuid,capability,target_type,target_id,created_at_ms) VALUES(?,?,?,?,?,?)`, uuid.NewString(), roleID, capability, "domain", domainUUID, now); err != nil {
return nil, err
}
}
if err = tx.Commit(); err != nil {
return nil, err
}
if err = s.EnsureBuiltinAdminGroups(); err != nil {
return nil, err
}
return &Principal{UUID: principalID, DisplayName: displayName, Email: email, State: "active"}, nil
return s.BootstrapOwnerContext(context.Background(), domainUUID, username, password, displayName, email)
}
func (s *Store) AuthenticatePassword(identifier, password string) (*Principal, error) {
identifier = strings.ToLower(strings.TrimSpace(identifier))
var p Principal
var encoded string
err := s.DB.QueryRow(`SELECT p.uuid,p.display_name,p.email,p.state,c.secret_hash FROM auth_credentials c JOIN principals p ON p.uuid=c.principal_uuid WHERE c.kind='password' AND c.identifier=? AND c.enabled=1`, identifier).Scan(&p.UUID, &p.DisplayName, &p.Email, &p.State, &encoded)
err := s.DB.QueryRow(`SELECT p.uuid,p.display_name,p.email,p.state,c.secret_hash FROM auth_credentials c JOIN principals p ON p.uuid=c.principal_uuid WHERE c.kind='password' AND c.identifier=`+s.sqlParam(1)+` AND c.enabled=1`, identifier).Scan(&p.UUID, &p.DisplayName, &p.Email, &p.State, &encoded)
if err != nil || (p.State != "active" && p.State != "readonly") || !VerifyPassword(encoded, password) {
return nil, ErrAccessDenied
}
@@ -178,25 +127,33 @@ func (s *Store) createTypedAuthSessionForLifetime(domainUUID, principalUUID stri
sum := sha256.Sum256([]byte(token))
hash := base64.RawURLEncoding.EncodeToString(sum[:])
now := time.Now().UnixMilli()
result, err := s.DB.Exec(`INSERT INTO auth_sessions(uuid,token_hash,principal_uuid,domain_uuid,auth_time_ms,expires_at_ms,last_seen_at_ms,mfa_level)
SELECT ?,?,p.uuid,m.domain_uuid,?,?,?,? FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid
WHERE p.uuid=? AND p.state IN ('active','readonly') AND m.domain_uuid=? AND m.state='active'`,
uuid.NewString(), hash, now, now+lifetime.Milliseconds(), now, mfaLevel, principalUUID, domainUUID)
// Share the administration lock with suspension and inherited-membership
// revocation; an INSERT snapshot alone can race a concurrent suspension.
err = s.groupWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error {
result, err := tx.ExecContext(ctx, fmt.Sprintf(`INSERT INTO auth_sessions(uuid,token_hash,principal_uuid,domain_uuid,auth_time_ms,expires_at_ms,last_seen_at_ms,mfa_level)
SELECT %s,%s,p.uuid,m.domain_uuid,%s,%s,%s,%s FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid
WHERE p.uuid=%s AND p.state IN ('active','readonly') AND m.domain_uuid=%s AND m.state='active'`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3), s.sqlParam(4), s.sqlParam(5), s.sqlParam(6), s.sqlParam(7), s.sqlParam(8)),
uuid.NewString(), hash, now, now+lifetime.Milliseconds(), now, mfaLevel, principalUUID, domainUUID)
if err != nil {
return err
}
if count, err := result.RowsAffected(); err != nil || count != 1 {
return ErrAccessDenied
}
return nil
})
if err != nil {
return "", err
}
if count, err := result.RowsAffected(); err != nil || count != 1 {
return "", ErrAccessDenied
}
return token, nil
}
func (s *Store) PrincipalForSession(domainUUID, token string) (*Principal, error) {
sum := sha256.Sum256([]byte(token))
hash := base64.RawURLEncoding.EncodeToString(sum[:])
var p Principal
err := s.DB.QueryRow(`SELECT p.uuid,COALESCE((SELECT subject FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' LIMIT 1),p.uuid),p.display_name,p.email,p.state,length(p.avatar)>0 FROM auth_sessions s JOIN principals p ON p.uuid=s.principal_uuid
err := s.DB.QueryRow(fmt.Sprintf(`SELECT p.uuid,COALESCE((SELECT subject FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' ORDER BY i.subject,i.uuid LIMIT 1),p.uuid),p.display_name,p.email,p.state,length(p.avatar)>0 FROM auth_sessions s JOIN principals p ON p.uuid=s.principal_uuid
JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=s.domain_uuid AND m.state='active'
WHERE s.token_hash=? AND s.domain_uuid=? AND s.revoked_at_ms=0 AND s.expires_at_ms>?`, hash, domainUUID, time.Now().UnixMilli()).Scan(&p.UUID, &p.Username, &p.DisplayName, &p.Email, &p.State, &p.HasAvatar)
WHERE s.token_hash=%s AND s.domain_uuid=%s AND s.revoked_at_ms=0 AND s.expires_at_ms>%s`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3)), hash, domainUUID, time.Now().UnixMilli()).Scan(&p.UUID, &p.Username, &p.DisplayName, &p.Email, &p.State, &p.HasAvatar)
if err != nil || (p.State != "active" && p.State != "readonly") {
return nil, ErrAccessDenied
}
@@ -206,28 +163,32 @@ func (s *Store) PrincipalForSession(domainUUID, token string) (*Principal, error
func (s *Store) PrincipalByUsername(domainUUID, username string) (*Principal, error) {
username = strings.ToLower(strings.TrimSpace(username))
var p Principal
err := s.DB.QueryRow(`SELECT p.uuid,i.subject,p.display_name,p.email,p.state,length(p.avatar)>0 FROM principal_identities i JOIN principals p ON p.uuid=i.principal_uuid JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=? WHERE i.provider_type='password' AND i.subject=?`, domainUUID, username).Scan(&p.UUID, &p.Username, &p.DisplayName, &p.Email, &p.State, &p.HasAvatar)
return &p, err
err := s.DB.QueryRow(fmt.Sprintf(`SELECT p.uuid,i.subject,p.display_name,p.email,p.state,length(p.avatar)>0 FROM principal_identities i JOIN principals p ON p.uuid=i.principal_uuid JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=%s WHERE i.provider_type='password' AND i.subject=%s ORDER BY i.uuid LIMIT 1`, s.sqlParam(1), s.sqlParam(2)), domainUUID, username).Scan(&p.UUID, &p.Username, &p.DisplayName, &p.Email, &p.State, &p.HasAvatar)
return &p, s.sqlError("principal username", err)
}
func (s *Store) SetPrincipalAvatar(principalUUID, contentType string, data []byte) error {
_, err := s.DB.Exec(`UPDATE principals SET avatar=?,avatar_content_type=?,updated_at_ms=? WHERE uuid=?`, data, contentType, time.Now().UnixMilli(), principalUUID)
return err
// An empty avatar is stored as a zero-length BLOB/BYTEA, never SQL NULL.
if data == nil {
data = []byte{}
}
_, err := s.DB.Exec(fmt.Sprintf(`UPDATE principals SET avatar=%s,avatar_content_type=%s,updated_at_ms=%s WHERE uuid=%s`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3), s.sqlParam(4)), data, contentType, time.Now().UnixMilli(), principalUUID)
return s.sqlError("principal avatar update", err)
}
func (s *Store) PrincipalAvatar(principalUUID string) (string, []byte, error) {
var contentType string
var data []byte
err := s.DB.QueryRow(`SELECT avatar_content_type,avatar FROM principals WHERE uuid=?`, principalUUID).Scan(&contentType, &data)
return contentType, data, err
err := s.DB.QueryRow(`SELECT avatar_content_type,avatar FROM principals WHERE uuid=`+s.sqlParam(1), principalUUID).Scan(&contentType, &data)
return contentType, data, s.sqlError("principal avatar", err)
}
func (s *Store) RevokeAuthSession(token string) error {
sum := sha256.Sum256([]byte(token))
_, err := s.DB.Exec(`UPDATE auth_sessions SET revoked_at_ms=? WHERE token_hash=?`, time.Now().UnixMilli(), base64.RawURLEncoding.EncodeToString(sum[:]))
return err
_, err := s.DB.Exec(`UPDATE auth_sessions SET revoked_at_ms=`+s.sqlParam(1)+` WHERE token_hash=`+s.sqlParam(2)+` AND revoked_at_ms=0`, time.Now().UnixMilli(), base64.RawURLEncoding.EncodeToString(sum[:]))
return s.sqlError("revoke session", err)
}
func (s *Store) ListDomainPrincipals(domainUUID string) ([]Principal, error) {
rows, err := s.DB.Query(`SELECT p.uuid,p.display_name,p.email,p.state FROM domain_memberships m JOIN principals p ON p.uuid=m.principal_uuid WHERE m.domain_uuid=? ORDER BY lower(p.display_name),p.uuid`, domainUUID)
rows, err := s.DB.Query(`SELECT p.uuid,p.display_name,p.email,p.state FROM domain_memberships m JOIN principals p ON p.uuid=m.principal_uuid WHERE m.domain_uuid=`+s.sqlParam(1)+` ORDER BY lower(p.display_name),p.uuid`, domainUUID)
if err != nil {
return nil, err
}
@@ -243,7 +204,7 @@ func (s *Store) ListDomainPrincipals(domainUUID string) ([]Principal, error) {
return out, rows.Err()
}
func (s *Store) ListAuthSessions(domainUUID string) ([]AuthSessionInfo, error) {
rows, err := s.DB.Query(`SELECT s.uuid,s.principal_uuid,p.display_name,s.auth_time_ms,s.expires_at_ms,s.last_seen_at_ms,s.mfa_level FROM auth_sessions s JOIN principals p ON p.uuid=s.principal_uuid WHERE s.domain_uuid=? AND s.revoked_at_ms=0 AND s.expires_at_ms>? ORDER BY s.last_seen_at_ms DESC`, domainUUID, time.Now().UnixMilli())
rows, err := s.DB.Query(fmt.Sprintf(`SELECT s.uuid,s.principal_uuid,p.display_name,s.auth_time_ms,s.expires_at_ms,s.last_seen_at_ms,s.mfa_level FROM auth_sessions s JOIN principals p ON p.uuid=s.principal_uuid WHERE s.domain_uuid=%s AND s.revoked_at_ms=0 AND s.expires_at_ms>%s ORDER BY s.last_seen_at_ms DESC,s.uuid`, s.sqlParam(1), s.sqlParam(2)), domainUUID, time.Now().UnixMilli())
if err != nil {
return nil, err
}
@@ -259,9 +220,9 @@ func (s *Store) ListAuthSessions(domainUUID string) ([]AuthSessionInfo, error) {
return out, rows.Err()
}
func (s *Store) RevokeAuthSessionByID(domainUUID, sessionUUID string) error {
result, err := s.DB.Exec(`UPDATE auth_sessions SET revoked_at_ms=? WHERE domain_uuid=? AND uuid=? AND revoked_at_ms=0`, time.Now().UnixMilli(), domainUUID, sessionUUID)
result, err := s.DB.Exec(fmt.Sprintf(`UPDATE auth_sessions SET revoked_at_ms=%s WHERE domain_uuid=%s AND uuid=%s AND revoked_at_ms=0`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3)), time.Now().UnixMilli(), domainUUID, sessionUUID)
if err != nil {
return err
return s.sqlError("revoke session by ID", err)
}
count, _ := result.RowsAffected()
if count == 0 {
@@ -270,31 +231,32 @@ func (s *Store) RevokeAuthSessionByID(domainUUID, sessionUUID string) error {
return nil
}
func (s *Store) SetPrincipalState(domainUUID, principalUUID, state string) error {
return s.SetPrincipalStateContext(context.Background(), domainUUID, principalUUID, state)
}
func (s *Store) SetPrincipalStateContext(ctx context.Context, domainUUID, principalUUID, state string) error {
if state != "active" && state != "readonly" && state != "suspended" && state != "quarantined" {
return errors.New("invalid principal state")
}
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
result, err := tx.Exec(`UPDATE principals SET state=?,updated_at_ms=? WHERE uuid=? AND EXISTS(SELECT 1 FROM domain_memberships WHERE domain_uuid=? AND principal_uuid=?)`, state, time.Now().UnixMilli(), principalUUID, domainUUID, principalUUID)
if err != nil {
return err
}
count, _ := result.RowsAffected()
if count == 0 {
return sql.ErrNoRows
}
if state != "active" {
if _, err = tx.Exec(`UPDATE auth_sessions SET revoked_at_ms=? WHERE principal_uuid=?`, time.Now().UnixMilli(), principalUUID); err != nil {
return s.groupWrite(ctx, func(ctx context.Context, tx *sql.Tx) error {
result, err := tx.ExecContext(ctx, fmt.Sprintf(`UPDATE principals SET state=%s,updated_at_ms=%s WHERE uuid=%s AND EXISTS(SELECT 1 FROM domain_memberships WHERE domain_uuid=%s AND principal_uuid=%s)`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3), s.sqlParam(4), s.sqlParam(5)), state, time.Now().UnixMilli(), principalUUID, domainUUID, principalUUID)
if err != nil {
return err
}
}
if err = projectCampusAdminMembershipsTx(tx); err != nil {
return err
}
return tx.Commit()
count, err := result.RowsAffected()
if err != nil {
return err
}
if count == 0 {
return sql.ErrNoRows
}
if state != "active" {
if _, err := tx.ExecContext(ctx, fmt.Sprintf(`UPDATE auth_sessions SET revoked_at_ms=%s WHERE principal_uuid=%s AND revoked_at_ms=0`, s.sqlParam(1), s.sqlParam(2)), time.Now().UnixMilli(), principalUUID); err != nil {
return err
}
}
return s.projectCampusAdminMembershipsContext(ctx, tx)
})
}
func (s *Store) UpdatePrincipalProfile(principalUUID, displayName, email string) error {
@@ -303,59 +265,21 @@ func (s *Store) UpdatePrincipalProfile(principalUUID, displayName, email string)
if displayName == "" {
return errors.New("display name is required")
}
_, err := s.DB.Exec(`UPDATE principals SET display_name=?,email=?,updated_at_ms=? WHERE uuid=?`, displayName, email, time.Now().UnixMilli(), principalUUID)
return err
_, err := s.DB.Exec(fmt.Sprintf(`UPDATE principals SET display_name=%s,email=%s,updated_at_ms=%s WHERE uuid=%s`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3), s.sqlParam(4)), displayName, email, time.Now().UnixMilli(), principalUUID)
return s.sqlError("principal profile update", err)
}
func (s *Store) CreatePasswordAccount(domainUUID, username, password, displayName, email string) (*Principal, error) {
username = strings.ToLower(strings.TrimSpace(username))
if !authUsernamePattern.MatchString(username) {
return nil, errors.New("username must be 2-64 lowercase letters, digits, underscores, or hyphens")
}
encoded, err := HashPassword(password)
if err != nil {
return nil, err
}
tx, err := s.DB.Begin()
if err != nil {
return nil, err
}
defer tx.Rollback()
now := time.Now().UnixMilli()
p := &Principal{UUID: uuid.NewString(), DisplayName: strings.TrimSpace(displayName), Email: strings.TrimSpace(email), State: "active"}
if p.DisplayName == "" {
p.DisplayName = username
}
membershipID := uuid.NewString()
roleID := ""
err = tx.QueryRow(`SELECT uuid FROM auth_roles WHERE domain_uuid=? AND name='member'`, domainUUID).Scan(&roleID)
if errors.Is(err, sql.ErrNoRows) {
roleID = uuid.NewString()
if _, err = tx.Exec(`INSERT INTO auth_roles(uuid,domain_uuid,name,description,created_at_ms) VALUES(?,?,?,?,?)`, roleID, domainUUID, "member", "Domain member", now); err != nil {
return nil, err
}
if _, err = tx.Exec(`INSERT INTO auth_capability_grants(uuid,role_uuid,capability,target_type,target_id,created_at_ms) VALUES(?,?,?,?,?,?)`, uuid.NewString(), roleID, "read", "domain", domainUUID, now); err != nil {
return nil, err
}
} else if err != nil {
return nil, err
}
queries := []struct {
q string
args []any
}{{`INSERT INTO principals(uuid,display_name,email,state,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?)`, []any{p.UUID, p.DisplayName, p.Email, p.State, now, now}}, {`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,subject,created_at_ms) VALUES(?,?,?,?,?)`, []any{uuid.NewString(), p.UUID, "password", username, now}}, {`INSERT INTO auth_credentials(uuid,principal_uuid,kind,identifier,secret_hash,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?,?)`, []any{uuid.NewString(), p.UUID, "password", username, encoded, now, now}}, {`INSERT INTO domain_memberships(uuid,domain_uuid,principal_uuid,state,created_at_ms) VALUES(?,?,?,?,?)`, []any{membershipID, domainUUID, p.UUID, "active", now}}, {`INSERT INTO auth_role_bindings(membership_uuid,role_uuid,created_at_ms) VALUES(?,?,?)`, []any{membershipID, roleID, now}}}
for _, item := range queries {
if _, err = tx.Exec(item.q, item.args...); err != nil {
return nil, err
}
}
if err = tx.Commit(); err != nil {
return nil, err
}
return p, nil
return s.CreatePasswordAccountContext(context.Background(), domainUUID, username, password, displayName, email)
}
func (s *Store) EnsureAuthSchema() error {
if s.sqlBackend == storePostgreSQL {
if err := s.ensurePostgreSQLAuthFoundation(context.Background()); err != nil {
return err
}
return s.ensurePostgreSQLLocalityFoundation(context.Background())
}
statements := []string{
`CREATE TABLE IF NOT EXISTS principals (
uuid TEXT PRIMARY KEY, display_name TEXT NOT NULL DEFAULT '',
@@ -453,9 +377,19 @@ func (s *Store) EnsureAuthSchema() error {
}
func (s *Store) Authorize(request AuthorizationRequest) error {
return s.AuthorizeContext(context.Background(), request)
}
func (s *Store) AuthorizeContext(ctx context.Context, request AuthorizationRequest) error {
return s.policyRead(ctx, func(ctx context.Context, tx *sql.Tx) error {
return s.authorizeSnapshot(ctx, tx, request, false)
})
}
func (s *Store) authorizeSnapshot(ctx context.Context, tx *sql.Tx, request AuthorizationRequest, exactObject bool) error {
request.Capability = strings.ToLower(strings.TrimSpace(request.Capability))
request.TargetType = strings.ToLower(strings.TrimSpace(request.TargetType))
base := s.authorizeGrant(request, false)
base := s.authorizeGrantContext(ctx, tx, request, exactObject)
if base != nil && !errors.Is(base, ErrAccessDenied) {
return base
}
@@ -465,14 +399,14 @@ func (s *Store) Authorize(request AuthorizationRequest) error {
return base
}
if request.TargetType == "object" {
if err := s.CheckObjectLocalityAccessCaps(request.DomainUUID, request.PrincipalUUID, request.Capability, request.TargetID); err != nil {
if err := s.checkObjectLocalityAccessCaps(ctx, tx, request.DomainUUID, request.PrincipalUUID, request.Capability, request.TargetID); err != nil {
return err
}
}
if request.TargetType != "path" {
return base
}
p, err := loadLocalityAccess(s.DB, request.DomainUUID, request.PrincipalUUID)
p, err := s.loadLocalityAccess(cityReadQuery{ctx, tx}, request.DomainUUID, request.PrincipalUUID)
if err != nil {
return err
}
@@ -485,57 +419,64 @@ func (s *Store) Authorize(request AuthorizationRequest) error {
// AuthorizeExactObject excludes broad Domain/wildcard grants. Global identity
// alone must not extend a Domain administrator's authority to another Domain.
func (s *Store) AuthorizeExactObject(request AuthorizationRequest) error {
return s.AuthorizeExactObjectContext(context.Background(), request)
}
func (s *Store) AuthorizeExactObjectContext(ctx context.Context, request AuthorizationRequest) error {
if request.TargetType != "object" || request.TargetID == "" || request.TargetID == "*" {
return ErrAccessDenied
}
request.Capability = strings.ToLower(strings.TrimSpace(request.Capability))
switch request.Capability {
case "read", "write", "create", "upload", "rename", "link", "delete":
if err := s.CheckObjectLocalityAccessCaps(request.DomainUUID, request.PrincipalUUID, request.Capability, request.TargetID); err != nil {
return err
}
}
return s.authorizeGrant(request, true)
return s.policyRead(ctx, func(ctx context.Context, tx *sql.Tx) error {
return s.authorizeSnapshot(ctx, tx, request, true)
})
}
func (s *Store) authorizeGrant(request AuthorizationRequest, exactObject bool) error {
return authorizeGrantFrom(s.DB, request, exactObject)
return s.authorizeGrantContext(context.Background(), s.DB, request, exactObject)
}
type authQueryer interface {
pathQueryer
QueryRow(string, ...any) *sql.Row
groupPermissionQueryer
QueryRowContext(context.Context, string, ...any) *sql.Row
}
func authorizeGrantFrom(q authQueryer, request AuthorizationRequest, exactObject bool) error {
// Compatibility entry point for existing SQLite-only transactions.
return (&Store{}).authorizeGrantContext(context.Background(), q, request, exactObject)
}
// Evaluates direct role bindings and group grants only. Object locality,
// publication and protected namespace restrictions remain in Authorize and
// must not be bypassed by treating this component as complete authorization.
func (s *Store) authorizeGrantContext(ctx context.Context, q authQueryer, request AuthorizationRequest, exactObject bool) error {
request.Capability = strings.ToLower(strings.TrimSpace(request.Capability))
request.TargetType = strings.ToLower(strings.TrimSpace(request.TargetType))
if request.DomainUUID == "" || request.PrincipalUUID == "" || request.Capability == "" {
return ErrAccessDenied
}
target := `((g.target_type=? AND (g.target_id=? OR g.target_id='*')) OR (g.target_type='domain' AND g.target_id=?))`
target := fmt.Sprintf(`((g.target_type=%s AND (g.target_id=%s OR g.target_id='*')) OR (g.target_type='domain' AND g.target_id=%s))`, s.sqlParam(6), s.sqlParam(7), s.sqlParam(8))
args := []any{request.DomainUUID, request.PrincipalUUID, request.Capability, request.Capability, request.Capability, request.TargetType, request.TargetID}
if exactObject {
target = `(g.target_type=? AND g.target_id=?)`
target = fmt.Sprintf(`(g.target_type=%s AND g.target_id=%s)`, s.sqlParam(6), s.sqlParam(7))
} else {
args = append(args, request.DomainUUID)
}
var allowed int
err := q.QueryRow(`SELECT EXISTS(
var allowed bool
err := q.QueryRowContext(ctx, fmt.Sprintf(`SELECT EXISTS(
SELECT 1 FROM principals p
JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=?
JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=%s
JOIN auth_role_bindings b ON b.membership_uuid=m.uuid
JOIN auth_roles r ON r.uuid=b.role_uuid AND r.domain_uuid=m.domain_uuid
JOIN auth_capability_grants g ON g.role_uuid=r.uuid
WHERE p.uuid=? AND (p.state='active' OR (p.state='readonly' AND ?='read')) AND m.state='active'
AND (g.capability=? OR (? IN ('create','upload') AND g.capability='write'))
AND `+target+`)`, args...).Scan(&allowed)
WHERE p.uuid=%s AND (p.state='active' OR (p.state='readonly' AND %s='read')) AND m.state='active'
AND (g.capability=%s OR (%s IN ('create','upload') AND g.capability='write'))
AND `+target+`)`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3), s.sqlParam(4), s.sqlParam(5)), args...).Scan(&allowed)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return err
return s.sqlError("role grant evaluation", err)
}
if allowed == 0 {
if !allowed {
if request.TargetType == "path" {
groupAllowed, groupErr := groupPermissionAllowsFrom(q, request.DomainUUID, request.PrincipalUUID, request.Capability, request.TargetID)
groupAllowed, groupErr := s.groupPermissionAllowsContext(ctx, q, request.DomainUUID, request.PrincipalUUID, request.Capability, request.TargetID)
if groupErr != nil {
return groupErr
}
@@ -550,6 +491,6 @@ func authorizeGrantFrom(q authQueryer, request AuthorizationRequest, exactObject
func (s *Store) PurgeExpiredAuthArtifacts() error {
now := time.Now().UnixMilli()
_, err := s.DB.Exec(`DELETE FROM auth_challenges WHERE expires_at_ms<? OR consumed_at_ms>0`, now)
return err
_, err := s.DB.Exec(`DELETE FROM auth_challenges WHERE expires_at_ms<`+s.sqlParam(1)+` OR consumed_at_ms>0`, now)
return s.sqlError("expired auth artifacts", err)
}
+119
View File
@@ -0,0 +1,119 @@
package store
import (
"context"
"database/sql"
"errors"
"strings"
"time"
"github.com/google/uuid"
)
// Account identity, credential, membership and role bindings are committed
// together. Password hashing intentionally happens before acquiring DB locks.
func (s *Store) createPasswordAccountContext(ctx context.Context, domain, username, password, displayName, email string, bootstrap bool) (*Principal, error) {
username = strings.ToLower(strings.TrimSpace(username))
if !authUsernamePattern.MatchString(username) {
return nil, errors.New("username must be 2-64 lowercase letters, digits, underscores, or hyphens")
}
if err := ctx.Err(); err != nil {
return nil, err
}
encoded, err := HashPassword(password)
if err != nil {
return nil, err
}
p := &Principal{UUID: uuid.NewString(), DisplayName: strings.TrimSpace(displayName), Email: strings.TrimSpace(email), State: "active"}
if p.DisplayName == "" {
p.DisplayName = username
}
err = s.groupWrite(ctx, func(ctx context.Context, tx *sql.Tx) error {
if bootstrap {
var count int
if err := tx.QueryRowContext(ctx, `SELECT count(*) FROM principals`).Scan(&count); err != nil {
return err
}
if count != 0 {
return namespaceValidationError("owner already exists")
}
}
// PostgreSQL cannot bootstrap into a nonexistent or disabled namespace.
// SQLite retains its historical authentication-only fixture support.
if s.sqlBackend == storePostgreSQL {
var present bool
if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM domains WHERE uuid=$1 AND enabled=1 AND placement='local')`, domain).Scan(&present); err != nil {
return err
}
if !present {
return sql.ErrNoRows
}
}
now := time.Now().UnixMilli()
membership, role := uuid.NewString(), ""
roleName, description := "member", "Domain member"
if bootstrap {
roleName, description = "owner", "Domain owner"
}
err := tx.QueryRowContext(ctx, `SELECT uuid FROM auth_roles WHERE domain_uuid=`+s.sqlParam(1)+` AND name=`+s.sqlParam(2), domain, roleName).Scan(&role)
if bootstrap && err == nil {
return namespaceValidationError("owner role already exists")
}
if errors.Is(err, sql.ErrNoRows) {
role = uuid.NewString()
if _, err = tx.ExecContext(ctx, `INSERT INTO auth_roles(uuid,domain_uuid,name,description,created_at_ms) VALUES(`+s.sqlValues(5)+`)`, role, domain, roleName, description, now); err != nil {
return err
}
capabilities := []string{"read"}
if bootstrap {
capabilities = []string{"read", "write", "rename", "delete", "link", "manage", "delegate"}
}
for _, capability := range capabilities {
if _, err = tx.ExecContext(ctx, `INSERT INTO auth_capability_grants(uuid,role_uuid,capability,target_type,target_id,created_at_ms) VALUES(`+s.sqlValues(6)+`)`, uuid.NewString(), role, capability, "domain", domain, now); err != nil {
return err
}
}
} else if err != nil {
return err
}
queries := []struct {
q string
args []any
}{
{`INSERT INTO principals(uuid,display_name,email,state,created_at_ms,updated_at_ms) VALUES(` + s.sqlValues(6) + `)`, []any{p.UUID, p.DisplayName, p.Email, p.State, now, now}},
{`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,subject,created_at_ms) VALUES(` + s.sqlValues(5) + `)`, []any{uuid.NewString(), p.UUID, "password", username, now}},
{`INSERT INTO auth_credentials(uuid,principal_uuid,kind,identifier,secret_hash,created_at_ms,updated_at_ms) VALUES(` + s.sqlValues(7) + `)`, []any{uuid.NewString(), p.UUID, "password", username, encoded, now, now}},
{`INSERT INTO domain_memberships(uuid,domain_uuid,principal_uuid,state,created_at_ms) VALUES(` + s.sqlValues(5) + `)`, []any{membership, domain, p.UUID, "active", now}},
{`INSERT INTO auth_role_bindings(membership_uuid,role_uuid,created_at_ms) VALUES(` + s.sqlValues(3) + `)`, []any{membership, role, now}},
}
for _, q := range queries {
if _, err := tx.ExecContext(ctx, q.q, q.args...); err != nil {
return err
}
}
if bootstrap {
if s.sqlBackend == storeSQLite {
var present bool
if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE name='domains' AND type='table')`).Scan(&present); err != nil {
return err
}
if !present {
return nil
}
}
return s.ensureBuiltinAdminGroupsContext(ctx, tx)
}
return nil
})
if err != nil {
return nil, err
}
return p, nil
}
func (s *Store) BootstrapOwnerContext(ctx context.Context, domain, username, password, displayName, email string) (*Principal, error) {
return s.createPasswordAccountContext(ctx, domain, username, password, displayName, email, true)
}
func (s *Store) CreatePasswordAccountContext(ctx context.Context, domain, username, password, displayName, email string) (*Principal, error) {
return s.createPasswordAccountContext(ctx, domain, username, password, displayName, email, false)
}
@@ -0,0 +1,535 @@
package store
import (
"bytes"
"context"
"database/sql"
"errors"
"fmt"
"strings"
"sync"
"testing"
"time"
)
func TestAccountBackendCLIHandoff(t *testing.T) {
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(b), func(t *testing.T) {
s, d := accountBackendStore(t, b)
p, err := s.BootstrapOwner(d, "owner", "synthetic password for backend tests", "", "")
if err != nil {
t.Fatal(err)
}
browser, err := s.CreateBrowserAuthSession(d, p.UUID, 1)
if err != nil {
t.Fatal(err)
}
ctx := context.Background()
verifier := strings.Repeat("a", 43)
id, device, code, err := s.StartCLIAuthForLogin(ctx, d, cliTestOrigin, hashAuthToken(verifier), true)
if err != nil {
t.Fatal(err)
}
request, err := s.CLIAuthRequest(ctx, d, cliTestOrigin, id)
if err != nil || !request.Remember {
t.Fatal("trusted choice lost", err)
}
if _, _, _, err = s.ExchangeCLIAuth(ctx, d, cliTestOrigin, device, verifier); !errors.Is(err, ErrCLIPending) {
t.Fatal("pending state", err)
}
if _, _, _, err = s.ExchangeCLIAuth(ctx, d, cliTestOrigin, device, verifier); !errors.Is(err, ErrCLISlowDown) {
t.Fatal("poll limit", err)
}
if err = s.BeginCLIAuth(ctx, d, cliTestOrigin, id); err != nil {
t.Fatal(err)
}
if err = s.BindCLIAuth(ctx, d, cliTestOrigin, id, browser); err != nil {
t.Fatal(err)
}
if err = s.DecideCLIAuth(ctx, d, cliTestOrigin, id, browser, code, "", true); err != nil {
t.Fatal(err)
}
if _, err = s.DB.Exec(`UPDATE auth_cli_requests SET next_poll_ms=0`); err != nil {
t.Fatal(err)
}
// Failed issuance must not consume approval.
if _, err = s.DB.Exec(`ALTER TABLE auth_sessions RENAME COLUMN mfa_level TO missing_mfa`); err != nil {
t.Fatal(err)
}
if token, _, _, e := s.ExchangeCLIAuth(ctx, d, cliTestOrigin, device, verifier); e == nil || token != "" {
t.Fatal("partial session returned", e)
}
request, err = s.CLIAuthRequest(ctx, d, cliTestOrigin, id)
if err != nil || request.State != "approved" {
t.Fatal("grant consumed on failed issuance", err)
}
if _, err = s.DB.Exec(`ALTER TABLE auth_sessions RENAME COLUMN missing_mfa TO mfa_level`); err != nil {
t.Fatal(err)
}
type result struct {
token, name string
err error
}
results := make(chan result, 2)
for i := 0; i < 2; i++ {
go func() {
token, name, _, e := s.ExchangeCLIAuth(ctx, d, cliTestOrigin, device, verifier)
results <- result{token, name, e}
}()
}
success := 0
for i := 0; i < 2; i++ {
r := <-results
if r.err != nil {
if !errors.Is(r.err, ErrCLIExpired) {
t.Fatal(r.err)
}
continue
}
success++
if r.name != "owner" || !strings.HasPrefix(r.token, "pw_api_") {
t.Fatal("invalid exchange response")
}
if principal, e := s.PrincipalForSession(d, r.token); e != nil || principal.UUID != p.UUID {
t.Fatal("CLI session invalid", e)
}
}
if success != 1 {
t.Fatal("approval consumed more than once", success)
}
// Include concurrent admissions at the boundary, not only sequential caps.
for i := 0; i < 62; i++ {
if _, _, _, e := s.StartCLIAuth(ctx, d, cliTestOrigin, hashAuthToken(verifier)); e != nil {
t.Fatal(e)
}
}
limits := make(chan error, 2)
for i := 0; i < 2; i++ {
go func() { _, _, _, e := s.StartCLIAuth(ctx, d, cliTestOrigin, hashAuthToken(verifier)); limits <- e }()
}
success = 0
for i := 0; i < 2; i++ {
if e := <-limits; e == nil {
success++
} else if !errors.Is(e, ErrCLILimit) {
t.Fatal(e)
}
}
if success != 1 {
t.Fatal("concurrent admission bypassed limit", success)
}
})
}
}
func TestAccountBackendExternalIdentity(t *testing.T) {
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(b), func(t *testing.T) {
s, d := accountBackendStore(t, b)
s.authKey = make([]byte, 32)
config := validLDAPProviderConfig()
if err := s.SetAuthProviderConfig(d, config); err != nil {
t.Fatal(err)
}
provider, err := s.AuthProviderConfig(d, "ldap")
if err != nil || !provider.Enabled || provider.LDAPBindPassword != config.LDAPBindPassword {
t.Fatal("provider configuration mismatch", err)
}
config.LDAPBindPassword = ""
config.LDAPSearchFilter = "(mail={{username}})"
if err = s.SetAuthProviderConfig(d, config); err != nil {
t.Fatal(err)
}
kept, err := s.AuthProviderConfig(d, "ldap")
if err != nil || kept.UUID != provider.UUID || kept.LDAPBindPassword != provider.LDAPBindPassword {
t.Fatal("provider lost secret or identity", err)
}
p, err := s.ProvisionExternalAccount(d, "directory", "Directory User", "mail@example.test", "ldap", provider.UUID, "", "immutable-id", map[string]string{"display": "Directory User"})
if err != nil {
t.Fatal(err)
}
if _, err = s.AuthenticatePassword("directory", "anything with twelve characters"); !errors.Is(err, ErrAccessDenied) {
t.Fatal("external user has password", err)
}
for _, lookup := range []func() (*Principal, error){
func() (*Principal, error) { return s.PrincipalByExternalUsername(d, "DIRECTORY") },
func() (*Principal, error) { return s.PrincipalByVerifiedEmail(d, "MAIL@example.test") },
func() (*Principal, error) { return s.PrincipalByDisplayName(d, "Directory User") },
func() (*Principal, error) {
return s.PrincipalByExternalIdentity(d, "ldap", provider.UUID, "", "immutable-id")
},
} {
found, err := lookup()
if err != nil || found.UUID != p.UUID {
t.Fatal("external identity lookup", err)
}
}
if err = s.BindExternalIdentityIfProviderUnbound(d, p.UUID, "ldap", provider.UUID, "", "replacement-id", nil); !errors.Is(err, ErrAccessDenied) {
t.Fatal("provider identity replaced", err)
}
second, err := s.CreatePasswordAccount(d, "second", "synthetic password for backend tests", "Directory User", "mail@example.test")
if err != nil {
t.Fatal(err)
}
if _, err = s.PrincipalByVerifiedEmail(d, "mail@example.test"); !errors.Is(err, ErrAccessDenied) {
t.Fatal("ambiguous email accepted", err)
}
if _, err = s.PrincipalByDisplayName(d, "Directory User"); !errors.Is(err, ErrAccessDenied) {
t.Fatal("ambiguous display accepted", err)
}
if err = s.BindExternalIdentity(second.UUID, "ldap", provider.UUID, "", "immutable-id", nil); !errors.Is(err, ErrAccessDenied) {
t.Fatal("identity owner replaced", err)
}
if _, err = s.ProvisionExternalAccount(d, "rollback-ext", "", "", "ldap", provider.UUID, "", "immutable-id", nil); !errors.Is(err, ErrAccessDenied) {
t.Fatal("duplicate identity provisioned", err)
}
if _, err = s.PrincipalByUsername(d, "rollback-ext"); !errors.Is(err, sql.ErrNoRows) {
t.Fatal("partial external account remains", err)
}
if err = s.BindExternalIdentityIfProviderUnbound(d, second.UUID, "oidc", "oidc-provider", "https://issuer.example.test", "unique", nil); err != nil {
t.Fatal(err)
}
challenge, err := s.CreateAuthChallenge(d, p.UUID, "magic-link", map[string]string{"return": "/docs"}, time.Minute)
if err != nil {
t.Fatal(err)
}
if _, err = s.ConsumeAuthChallenge("outside", "magic-link", challenge, nil); !errors.Is(err, ErrAccessDenied) {
t.Fatal("cross-domain challenge accepted", err)
}
results := make(chan error, 2)
for i := 0; i < 2; i++ {
go func() {
var payload map[string]string
id, e := s.ConsumeAuthChallenge(d, "magic-link", challenge, &payload)
if e == nil && (id != p.UUID || payload["return"] != "/docs") {
e = fmt.Errorf("challenge payload mismatch")
}
results <- e
}()
}
success := 0
for i := 0; i < 2; i++ {
if e := <-results; e == nil {
success++
} else if !errors.Is(e, ErrAccessDenied) {
t.Fatal(e)
}
}
if success != 1 {
t.Fatal("challenge accepted more than once", success)
}
})
}
}
func TestAccountBackendTOTP(t *testing.T) {
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(b), func(t *testing.T) {
s, d := accountBackendStore(t, b)
s.authKey = make([]byte, 32) // Synthetic credential encryption key.
p, err := s.BootstrapOwner(d, "owner", "synthetic password for backend tests", "", "")
if err != nil {
t.Fatal(err)
}
secret, err := s.BeginTOTPEnrollment(p.UUID)
if err != nil {
t.Fatal(err)
}
if s.HasTOTP(p.UUID) || s.PendingTOTPSecret(p.UUID) != secret {
t.Fatal("pending enrollment mismatch")
}
code, err := totpCode(secret, time.Now().Unix()/30)
if err != nil {
t.Fatal(err)
}
if err = s.ConfirmTOTPEnrollment(p.UUID, code); err != nil {
t.Fatal(err)
}
if !s.HasTOTP(p.UUID) || s.PendingTOTPSecret(p.UUID) != "" {
t.Fatal("confirmed enrollment mismatch")
}
if err = s.VerifyTOTP(p.UUID, code); !errors.Is(err, ErrAccessDenied) {
t.Fatal("enrollment code replay", err)
}
// Reset only synthetic counters to exercise single-use concurrent login
// without wall-clock sleeps or a test-dependent production clock.
if _, err = s.DB.Exec(`UPDATE auth_credentials SET parameters_json='{}' WHERE kind='totp'`); err != nil {
t.Fatal(err)
}
code, _ = totpCode(secret, time.Now().Unix()/30)
challenge, err := s.CreateTOTPLoginChallengeForLogin(d, p.UUID, true)
if err != nil {
t.Fatal(err)
}
if _, _, err = s.CompleteTOTPLoginChallengeForLogin("outside", challenge, code); !errors.Is(err, ErrAccessDenied) {
t.Fatal("cross-domain TOTP challenge", err)
}
results := make(chan error, 2)
for i := 0; i < 2; i++ {
go func() {
id, remember, e := s.CompleteTOTPLoginChallengeForLogin(d, challenge, code)
if e == nil && (id != p.UUID || !remember) {
e = fmt.Errorf("challenge result mismatch")
}
results <- e
}()
}
success := 0
for i := 0; i < 2; i++ {
if e := <-results; e == nil {
success++
} else if !errors.Is(e, ErrAccessDenied) {
t.Fatal(e)
}
}
if success != 1 {
t.Fatal("concurrent code consumers", success)
}
challenge, err = s.CreateTOTPLoginChallenge(d, p.UUID)
if err != nil {
t.Fatal(err)
}
for i := 0; i < 6; i++ {
if _, e := s.CompleteTOTPLoginChallenge(d, challenge, "invalid"); !errors.Is(e, ErrAccessDenied) {
t.Fatal(e)
}
}
if err = s.PurgeExpiredAuthArtifacts(); err != nil {
t.Fatal(err)
}
var remaining int
if err = s.DB.QueryRow(`SELECT count(*) FROM auth_challenges`).Scan(&remaining); err != nil || remaining != 0 {
t.Fatal("consumed challenge cleanup", remaining, err)
}
if err = s.DisableTOTP(p.UUID); err != nil {
t.Fatal(err)
}
if s.HasTOTP(p.UUID) {
t.Fatal("TOTP still enabled")
}
})
}
}
func TestAccountBackendProfileAndSessionManagement(t *testing.T) {
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(b), func(t *testing.T) {
s, d := accountBackendStore(t, b)
p, err := s.BootstrapOwner(d, "owner", "synthetic password for backend tests", "Owner", "")
if err != nil {
t.Fatal(err)
}
if err = s.UpdatePrincipalProfile(p.UUID, " 日本語の名前 ", " user@example.test "); err != nil {
t.Fatal(err)
}
data := []byte{0, 255, 1, 0, 128}
if err = s.SetPrincipalAvatar(p.UUID, "image/png", data); err != nil {
t.Fatal(err)
}
kind, got, err := s.PrincipalAvatar(p.UUID)
if err != nil || kind != "image/png" || !bytes.Equal(got, data) {
t.Fatal("avatar round trip", kind, got, err)
}
found, err := s.PrincipalByUsername(d, " OWNER ")
if err != nil || found.DisplayName != "日本語の名前" || found.Email != "user@example.test" || !found.HasAvatar {
t.Fatal(found, err)
}
if _, err = s.PrincipalByUsername("other-domain", "owner"); !errors.Is(err, sql.ErrNoRows) {
t.Fatal("cross-domain profile lookup", err)
}
if err = s.SetPrincipalAvatar(p.UUID, "", nil); err != nil {
t.Fatal(err)
}
found, err = s.PrincipalByUsername(d, "owner")
if err != nil || found.HasAvatar {
t.Fatal("avatar removal", err)
}
principals, err := s.ListDomainPrincipals(d)
if err != nil || len(principals) != 1 || principals[0].UUID != p.UUID {
t.Fatal(principals, err)
}
principals, err = s.ListDomainPrincipals("other-domain")
if err != nil || len(principals) != 0 {
t.Fatal("cross-domain principal list", err)
}
token, err := s.CreateBrowserAuthSession(d, p.UUID, 2)
if err != nil {
t.Fatal(err)
}
sessions, err := s.ListAuthSessions(d)
if err != nil || len(sessions) != 1 || sessions[0].MFALevel != 2 {
t.Fatal(sessions, err)
}
id := sessions[0].UUID
if err = s.RevokeAuthSessionByID("other-domain", id); !errors.Is(err, sql.ErrNoRows) {
t.Fatal("cross-domain revocation", err)
}
if _, err = s.PrincipalForSession(d, token); err != nil {
t.Fatal(err)
}
if err = s.RevokeAuthSessionByID(d, id); err != nil {
t.Fatal(err)
}
if _, err = s.PrincipalForSession(d, token); !errors.Is(err, ErrAccessDenied) {
t.Fatal("revoked session accepted", err)
}
sessions, err = s.ListAuthSessions(d)
if err != nil || len(sessions) != 0 {
t.Fatal("revoked session listed", err)
}
})
}
}
func TestAccountBackendBootstrapProjectionFailureIsAtomic(t *testing.T) {
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(b), func(t *testing.T) {
s, d := accountBackendStore(t, b)
if _, err := s.DB.Exec(`ALTER TABLE campus_admin_grants RENAME COLUMN source TO missing_source`); err != nil {
t.Fatal(err)
}
if _, err := s.BootstrapOwner(d, "owner", "synthetic password for backend tests", "", ""); err == nil {
t.Fatal("bootstrap succeeded with broken projection")
}
for _, table := range []string{"principals", "principal_identities", "auth_credentials", "auth_roles", "auth_capability_grants", "auth_role_bindings", "domain_memberships"} {
var count int
if err := s.DB.QueryRow(`SELECT count(*) FROM ` + table).Scan(&count); err != nil || count != 0 {
t.Fatalf("%s has partial bootstrap data: %d %v", table, count, err)
}
}
})
}
}
func accountBackendStore(t *testing.T, b storeSQLBackend) (*Store, string) {
t.Helper()
s := testNamespaceStore(t, b)
if b == storePostgreSQL {
if err := s.ensurePostgreSQLAuthFoundation(context.Background()); err != nil {
t.Fatal(err)
}
}
d, err := s.GetDefaultDomain()
if err != nil {
t.Fatal(err)
}
return s, d.UUID
}
func TestAccountBackendLoginAndSession(t *testing.T) {
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(b), func(t *testing.T) {
s, d := accountBackendStore(t, b)
const password = "synthetic password for backend tests"
p, err := s.BootstrapOwner(d, " Owner ", password, "所有者", "owner@example.test")
if err != nil {
t.Fatal(err)
}
if !s.IsBuiltinGroupAdmin(d, p.UUID, "domain_admin") || !s.IsBuiltinGroupAdmin(d, p.UUID, "campus_admin") {
t.Fatal("bootstrap did not publish admin groups")
}
if _, err := s.BootstrapOwner(d, "second", password, "", ""); err == nil {
t.Fatal("second bootstrap accepted")
}
if _, err := s.AuthenticatePassword("owner", "incorrect password"); !errors.Is(err, ErrAccessDenied) {
t.Fatal("incorrect password accepted", err)
}
logged, err := s.AuthenticatePassword("OWNER", password)
if err != nil || logged.UUID != p.UUID {
t.Fatal("login mismatch", err)
}
member, err := s.CreatePasswordAccount(d, "member", password, "Member", "")
if err != nil {
t.Fatal(err)
}
if err := s.authorizeGrant(AuthorizationRequest{DomainUUID: d, PrincipalUUID: member.UUID, Capability: "read", TargetType: "domain", TargetID: d}, false); err != nil {
t.Fatal(err)
}
if err := s.authorizeGrant(AuthorizationRequest{DomainUUID: d, PrincipalUUID: member.UUID, Capability: "write", TargetType: "domain", TargetID: d}, false); !errors.Is(err, ErrAccessDenied) {
t.Fatal("member can write", err)
}
token, err := s.CreateBrowserAuthSession(d, p.UUID, 1)
if err != nil {
t.Fatal(err)
}
if _, err := s.PrincipalForSession(d, token); err != nil {
t.Fatal(err)
}
for _, invalid := range []string{strings.TrimPrefix(token, "pw_browser_"), strings.Replace(token, "pw_browser_", "pw_api_", 1)} {
if _, err := s.PrincipalForSession(d, invalid); !errors.Is(err, ErrAccessDenied) {
t.Fatal("token purpose changed", err)
}
}
if _, err := s.PrincipalForSession("outside", token); !errors.Is(err, ErrAccessDenied) {
t.Fatal("cross-domain session accepted", err)
}
if err := s.SetPrincipalState(d, p.UUID, "suspended"); err != nil {
t.Fatal(err)
}
if _, err := s.CreateAuthSession(d, p.UUID); !errors.Is(err, ErrAccessDenied) {
t.Fatal("suspended principal obtained session", err)
}
if err := s.SetPrincipalState(d, p.UUID, "active"); err != nil {
t.Fatal(err)
}
if _, err := s.PrincipalForSession(d, token); !errors.Is(err, ErrAccessDenied) {
t.Fatal("session resurrected", err)
}
token, err = s.CreateAuthSession(d, p.UUID)
if err != nil {
t.Fatal(err)
}
if err := s.RevokeAuthSession(token); err != nil {
t.Fatal(err)
}
if _, err := s.PrincipalForSession(d, token); !errors.Is(err, ErrAccessDenied) {
t.Fatal("revocation ignored", err)
}
if _, err := s.DB.Exec(`ALTER TABLE auth_role_bindings RENAME COLUMN role_uuid TO missing_role`); err != nil {
t.Fatal(err)
}
if _, err := s.CreatePasswordAccount(d, "rollback", password, "", ""); err == nil {
t.Fatal("partial account accepted")
}
var count int
if err := s.DB.QueryRow(`SELECT count(*) FROM principal_identities WHERE subject='rollback'`).Scan(&count); err != nil || count != 0 {
t.Fatal("partial identity remains", err)
}
})
}
}
func TestAccountBackendConcurrentBootstrap(t *testing.T) {
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(b), func(t *testing.T) {
s, d := accountBackendStore(t, b)
var wg sync.WaitGroup
results := make(chan error, 2)
for _, name := range []string{"owner-one", "owner-two"} {
wg.Add(1)
go func(name string) {
defer wg.Done()
_, err := s.BootstrapOwner(d, name, "synthetic password for bootstrap", "", "")
results <- err
}(name)
}
wg.Wait()
close(results)
success := 0
for err := range results {
if err == nil {
success++
} else if !strings.Contains(err.Error(), "owner already exists") {
t.Fatal(err)
}
}
if success != 1 {
t.Fatalf("bootstrap successes=%d", success)
}
count, err := s.PrincipalCount()
if err != nil || count != 1 {
t.Fatal("multiple bootstrap principals", err)
}
})
}
}
+132
View File
@@ -0,0 +1,132 @@
package store
import (
"context"
"errors"
"fmt"
"sync"
"testing"
)
func TestAdminAuthorizationBackendContract(t *testing.T) {
for _, backend := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(backend), func(t *testing.T) {
s := testNamespaceStore(t, backend)
ctx := context.Background()
if backend == storePostgreSQL {
if err := s.ensurePostgreSQLAuthFoundation(ctx); err != nil {
t.Fatal(err)
}
}
campus, err := s.GetDefaultCampus()
if err != nil {
t.Fatal(err)
}
domain, err := s.GetDefaultDomain()
if err != nil {
t.Fatal(err)
}
other := seedNamespaceDomain(t, s, campus.UUID, "other-admin-domain", "other-admin-domain")
exec := func(query string, args ...any) {
t.Helper()
if _, err := s.DB.ExecContext(ctx, query, args...); err != nil {
t.Fatal(err)
}
}
exec(`INSERT INTO principals(uuid,display_name,created_at_ms,updated_at_ms) VALUES('admin-test-principal','管理者',1,1)`)
exec(`INSERT INTO domain_memberships(uuid,domain_uuid,principal_uuid,created_at_ms) VALUES('admin-test-membership',`+s.sqlParam(1)+`,'admin-test-principal',1)`, domain.UUID)
exec(`INSERT INTO groups(uuid,domain_uuid,name,builtin_key,created_at_ms,updated_at_ms) VALUES('admin-test-group',`+s.sqlParam(1)+`,'admin-test-group','campus_admin',1,1)`, domain.UUID)
exec(`INSERT INTO group_members(group_uuid,membership_uuid,member_role,created_at_ms) VALUES('admin-test-group','admin-test-membership','owner',1)`)
check := func(want bool) {
t.Helper()
got, err := s.IsBuiltinGroupAdminContext(ctx, domain.UUID, "admin-test-principal", "campus_admin")
if err != nil || got != want {
t.Fatalf("group allowed=%v want=%v error=%v", got, want, err)
}
got, err = s.IsCampusAdminContext(ctx, campus.UUID, "admin-test-principal")
if err != nil || got != want {
t.Fatalf("campus allowed=%v want=%v error=%v", got, want, err)
}
}
check(true)
for _, field := range []string{"principals", "domain_memberships", "groups"} {
exec(`UPDATE ` + field + ` SET state='suspended'`)
check(false)
exec(`UPDATE ` + field + ` SET state='active'`)
}
exec(`UPDATE domains SET enabled=0 WHERE uuid=`+s.sqlParam(1), domain.UUID)
check(false)
exec(`UPDATE domains SET enabled=1 WHERE uuid=`+s.sqlParam(1), domain.UUID)
for _, role := range []string{"member", "manager", "owner"} {
exec(`UPDATE group_members SET member_role=`+s.sqlParam(1)+` WHERE group_uuid='admin-test-group'`, role)
check(role != "member")
}
// A forged cross-domain group membership must not confer authority.
exec(`UPDATE groups SET domain_uuid=`+s.sqlParam(1)+` WHERE uuid='admin-test-group'`, other.UUID)
check(false)
exec(`UPDATE groups SET domain_uuid=`+s.sqlParam(1)+` WHERE uuid='admin-test-group'`, domain.UUID)
check(true)
for _, key := range []string{"domain_admin", "made-up", "campus_admin' OR 1=1--"} {
if s.IsBuiltinGroupAdmin(domain.UUID, "admin-test-principal", key) {
t.Fatal("unexpected administrative grant")
}
}
if s.IsBuiltinGroupAdmin(other.UUID, "admin-test-principal", "campus_admin") || s.IsCampusAdmin("other-campus", "admin-test-principal") {
t.Fatal("cross namespace grant")
}
cancelled, cancel := context.WithCancel(ctx)
cancel()
if allowed, err := s.IsCampusAdminContext(cancelled, campus.UUID, "admin-test-principal"); allowed || !errors.Is(err, context.Canceled) {
t.Fatalf("cancellation: allowed=%v error=%v", allowed, err)
}
if allowed, err := s.IsBuiltinGroupAdminContext(cancelled, domain.UUID, "admin-test-principal", "campus_admin"); allowed || !errors.Is(err, context.Canceled) {
t.Fatalf("cancellation: allowed=%v error=%v", allowed, err)
}
exec(`ALTER TABLE group_members RENAME COLUMN member_role TO unavailable_role`)
if s.IsCampusAdmin(campus.UUID, "admin-test-principal") || s.IsBuiltinGroupAdmin(domain.UUID, "admin-test-principal", "campus_admin") {
t.Fatal("database error must fail closed")
}
if allowed, err := s.IsCampusAdminContext(ctx, campus.UUID, "admin-test-principal"); allowed || err == nil {
t.Fatal("context API must report database error")
}
})
}
}
func TestPostgreSQLAuthFoundationMigration(t *testing.T) {
s := testNamespaceStore(t, storePostgreSQL)
ctx := context.Background()
if err := s.EnsureAuthSchema(); err != nil {
t.Fatalf("native authentication schema: %v", err)
}
var wg sync.WaitGroup
errorsCh := make(chan error, 4)
for i := 0; i < 4; i++ {
wg.Add(1)
go func() { defer wg.Done(); errorsCh <- s.ensurePostgreSQLAuthFoundation(ctx) }()
}
wg.Wait()
close(errorsCh)
for err := range errorsCh {
if err != nil {
t.Fatal(err)
}
}
if _, err := s.DB.Exec(`INSERT INTO principals(uuid,created_at_ms,updated_at_ms) VALUES('retained',1,1)`); err != nil {
t.Fatal(err)
}
var avatar []byte
if err := s.DB.QueryRow(`SELECT avatar FROM principals WHERE uuid='retained'`).Scan(&avatar); err != nil || len(avatar) != 0 {
t.Fatalf("avatar default: %v", err)
}
if _, err := s.DB.Exec(`ALTER TABLE principals RENAME COLUMN avatar TO missing_avatar`); err != nil {
t.Fatal(err)
}
if err := s.ensurePostgreSQLAuthFoundation(ctx); err == nil {
t.Fatal("schema drift accepted")
}
var count int
if err := s.DB.QueryRow(`SELECT count(*) FROM principals WHERE uuid='retained'`).Scan(&count); err != nil || count != 1 {
t.Fatal("existing identity lost")
}
}
+60 -34
View File
@@ -44,8 +44,8 @@ type CLIAuthRequest struct {
Remember bool
}
// Admission is one write statement; concurrent unauthenticated requests cannot
// race the caps. Requests are retained for ten minutes for issuance accounting.
// Admission is serialized on both backends so concurrent unauthenticated
// requests cannot race the caps. Retain requests for issuance accounting.
func (s *Store) StartCLIAuth(ctx context.Context, domain, origin, challenge string) (id, device, code string, err error) {
return s.StartCLIAuthForLogin(ctx, domain, origin, challenge, false)
}
@@ -68,40 +68,48 @@ func (s *Store) StartCLIAuthForLogin(ctx context.Context, domain, origin, challe
}
code = strings.ToUpper(hex.EncodeToString(raw[:]))
now := time.Now().UnixMilli()
_, err = s.DB.ExecContext(ctx, `DELETE FROM auth_cli_requests WHERE expires_ms<?`, now-5*60*1000)
if err != nil {
return
rememberValue := 0
if remember {
rememberValue = 1
}
var result sql.Result
result, err = s.DB.ExecContext(ctx, `INSERT INTO auth_cli_requests(id,domain_uuid,origin,device_hash,challenge,code_hash,created_ms,expires_ms,remember)
SELECT ?,?,?,?,?,?,?,?,? WHERE (SELECT count(*) FROM auth_cli_requests)<4096
AND (SELECT count(*) FROM auth_cli_requests WHERE domain_uuid=? AND created_ms>?)<64`,
id, domain, origin, hashAuthToken(device), challenge, hashAuthToken(code), now, now+300000, remember, domain, now-300000)
if err == nil {
if n, e := result.RowsAffected(); e != nil {
err = e
} else if n != 1 {
err = ErrCLILimit
err = s.groupWrite(ctx, func(ctx context.Context, tx *sql.Tx) error {
if _, err := tx.ExecContext(ctx, `DELETE FROM auth_cli_requests WHERE expires_ms<`+s.sqlParam(1), now-5*60*1000); err != nil {
return err
}
result, err := tx.ExecContext(ctx, `INSERT INTO auth_cli_requests(id,domain_uuid,origin,device_hash,challenge,code_hash,created_ms,expires_ms,remember)
SELECT `+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`,`+s.sqlParam(7)+`,`+s.sqlParam(8)+`,`+s.sqlParam(9)+` WHERE (SELECT count(*) FROM auth_cli_requests)<4096
AND (SELECT count(*) FROM auth_cli_requests WHERE domain_uuid=`+s.sqlParam(10)+` AND created_ms>`+s.sqlParam(11)+`)<64`,
id, domain, origin, hashAuthToken(device), challenge, hashAuthToken(code), now, now+300000, rememberValue, domain, now-300000)
if err == nil {
if n, e := result.RowsAffected(); e != nil {
err = e
} else if n != 1 {
err = ErrCLILimit
}
}
return err
})
if err != nil {
id, device, code = "", "", ""
}
return
}
func (s *Store) CLIAuthRequest(ctx context.Context, domain, origin, id string) (*CLIAuthRequest, error) {
var grant CLIAuthRequest
err := s.DB.QueryRowContext(ctx, `SELECT id,origin,state,browser_hash,principal_uuid,expires_ms,remember FROM auth_cli_requests WHERE id=? AND domain_uuid=? AND origin=? AND expires_ms>?`, id, domain, origin, time.Now().UnixMilli()).Scan(&grant.ID, &grant.Origin, &grant.State, &grant.BrowserHash, &grant.PrincipalUUID, &grant.ExpiresMS, &grant.Remember)
err := s.DB.QueryRowContext(ctx, `SELECT id,origin,state,browser_hash,principal_uuid,expires_ms,remember FROM auth_cli_requests WHERE id=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+` AND origin=`+s.sqlParam(3)+` AND expires_ms>`+s.sqlParam(4)+``, id, domain, origin, time.Now().UnixMilli()).Scan(&grant.ID, &grant.Origin, &grant.State, &grant.BrowserHash, &grant.PrincipalUUID, &grant.ExpiresMS, &grant.Remember)
if errors.Is(err, sql.ErrNoRows) {
return nil, ErrCLIExpired
}
return &grant, err
return &grant, s.sqlError("CLI auth lookup", err)
}
func (s *Store) BeginCLIAuth(ctx context.Context, domain, origin, id string) error {
if s.ReadOnly {
return ErrReadOnly
}
result, err := s.DB.ExecContext(ctx, `UPDATE auth_cli_requests SET oidc_attempts=oidc_attempts+1 WHERE id=? AND domain_uuid=? AND origin=? AND state='pending' AND browser_hash='' AND expires_ms>? AND oidc_attempts<3`, id, domain, origin, time.Now().UnixMilli())
return cliChanged(result, err)
result, err := s.DB.ExecContext(ctx, `UPDATE auth_cli_requests SET oidc_attempts=oidc_attempts+1 WHERE id=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+` AND origin=`+s.sqlParam(3)+` AND state='pending' AND browser_hash='' AND expires_ms>`+s.sqlParam(4)+` AND oidc_attempts<3`, id, domain, origin, time.Now().UnixMilli())
return s.sqlError("CLI auth begin", cliChanged(result, err))
}
// Only the verified OIDC callback calls this method. The first successful
@@ -111,10 +119,10 @@ func (s *Store) BindCLIAuth(ctx context.Context, domain, origin, id, browser str
return ErrAccessDenied
}
now := time.Now().UnixMilli()
result, err := s.DB.ExecContext(ctx, `UPDATE auth_cli_requests SET browser_hash=?,principal_uuid=(SELECT principal_uuid FROM auth_sessions WHERE token_hash=?)
WHERE id=? AND domain_uuid=? AND origin=? AND state='pending' AND browser_hash='' AND expires_ms>?
AND EXISTS(SELECT 1 FROM auth_sessions WHERE token_hash=? AND domain_uuid=? AND revoked_at_ms=0 AND expires_at_ms>?)`, hashAuthToken(browser), hashAuthToken(browser), id, domain, origin, now, hashAuthToken(browser), domain, now)
return cliChanged(result, err)
result, err := s.DB.ExecContext(ctx, `UPDATE auth_cli_requests SET browser_hash=`+s.sqlParam(1)+`,principal_uuid=(SELECT principal_uuid FROM auth_sessions WHERE token_hash=`+s.sqlParam(2)+`)
WHERE id=`+s.sqlParam(3)+` AND domain_uuid=`+s.sqlParam(4)+` AND origin=`+s.sqlParam(5)+` AND state='pending' AND browser_hash='' AND expires_ms>`+s.sqlParam(6)+`
AND EXISTS(SELECT 1 FROM auth_sessions WHERE token_hash=`+s.sqlParam(7)+` AND domain_uuid=`+s.sqlParam(8)+` AND revoked_at_ms=0 AND expires_at_ms>`+s.sqlParam(9)+`)`, hashAuthToken(browser), hashAuthToken(browser), id, domain, origin, now, hashAuthToken(browser), domain, now)
return s.sqlError("CLI auth bind", cliChanged(result, err))
}
func cliChanged(result sql.Result, err error) error {
@@ -141,7 +149,7 @@ func (s *Store) DecideCLIAuth(ctx context.Context, domain, origin, id, browser,
now := time.Now().UnixMilli()
var expectedCode string
err := s.DB.QueryRowContext(ctx, `UPDATE auth_cli_requests SET attempts=attempts+1
WHERE id=? AND domain_uuid=? AND origin=? AND state='pending' AND browser_hash=? AND attempts<5 AND expires_ms>?
WHERE id=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+` AND origin=`+s.sqlParam(3)+` AND state='pending' AND browser_hash=`+s.sqlParam(4)+` AND attempts<5 AND expires_ms>`+s.sqlParam(5)+`
RETURNING code_hash`, id, domain, origin, hashAuthToken(browser), now).Scan(&expectedCode)
if err != nil {
return ErrAccessDenied
@@ -156,11 +164,11 @@ func (s *Store) DecideCLIAuth(ctx context.Context, domain, origin, id, browser,
if approve {
state = "approved"
}
result, err := s.DB.ExecContext(ctx, `UPDATE auth_cli_requests SET state=?,mfa_level=? WHERE id=? AND domain_uuid=? AND state='pending' AND browser_hash=? AND expires_ms>?
result, err := s.DB.ExecContext(ctx, `UPDATE auth_cli_requests SET state=`+s.sqlParam(1)+`,mfa_level=`+s.sqlParam(2)+` WHERE id=`+s.sqlParam(3)+` AND domain_uuid=`+s.sqlParam(4)+` AND state='pending' AND browser_hash=`+s.sqlParam(5)+` AND expires_ms>`+s.sqlParam(6)+`
AND EXISTS(SELECT 1 FROM auth_sessions a JOIN principals p ON p.uuid=a.principal_uuid JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=a.domain_uuid
WHERE a.token_hash=? AND a.domain_uuid=? AND a.revoked_at_ms=0 AND a.expires_at_ms>? AND p.state IN ('active','readonly') AND m.state='active')`, state, level, id, domain, hashAuthToken(browser), now, hashAuthToken(browser), domain, now)
WHERE a.token_hash=`+s.sqlParam(7)+` AND a.domain_uuid=`+s.sqlParam(8)+` AND a.revoked_at_ms=0 AND a.expires_at_ms>`+s.sqlParam(9)+` AND p.state IN ('active','readonly') AND m.state='active')`, state, level, id, domain, hashAuthToken(browser), now, hashAuthToken(browser), domain, now)
if err = cliChanged(result, err); err != nil {
return err
return s.sqlError("CLI auth decision", err)
}
return err
}
@@ -169,6 +177,14 @@ func (s *Store) DecideCLIAuth(ctx context.Context, domain, origin, id, browser,
// Grant consumption and API-session creation commit together. No replay on a
// lost HTTP response: a new login is required (no credential stored in grant).
func (s *Store) ExchangeCLIAuth(ctx context.Context, domain, origin, device, verifier string) (token, username string, expires int64, err error) {
defer func() {
if err != nil {
token, username, expires = "", "", 0
err = s.sqlError("CLI auth exchange", err)
}
}()
ctx, cancel := context.WithTimeout(ctx, 15*time.Second)
defer cancel()
if s.ReadOnly {
err = ErrReadOnly
return
@@ -181,14 +197,20 @@ func (s *Store) ExchangeCLIAuth(ctx context.Context, domain, origin, device, ver
return
}
defer tx.Rollback()
if s.sqlBackend == storePostgreSQL {
// Match account suspension and membership revocation lock ordering.
if _, err = tx.ExecContext(ctx, `SELECT pg_advisory_xact_lock(1885431653, 1853058931)`); err != nil {
return
}
}
var id, state, browser string
var remember bool
err = tx.QueryRowContext(ctx, `UPDATE auth_cli_requests SET next_poll_ms=?,state=CASE WHEN state='approved' THEN 'consumed' ELSE state END
WHERE device_hash=? AND challenge=? AND domain_uuid=? AND origin=? AND expires_ms>? AND next_poll_ms<=? AND state IN ('pending','approved','denied')
err = tx.QueryRowContext(ctx, `UPDATE auth_cli_requests SET next_poll_ms=`+s.sqlParam(1)+`,state=CASE WHEN state='approved' THEN 'consumed' ELSE state END
WHERE device_hash=`+s.sqlParam(2)+` AND challenge=`+s.sqlParam(3)+` AND domain_uuid=`+s.sqlParam(4)+` AND origin=`+s.sqlParam(5)+` AND expires_ms>`+s.sqlParam(6)+` AND next_poll_ms<=`+s.sqlParam(7)+` AND state IN ('pending','approved','denied')
RETURNING id,state,browser_hash,remember`, now+5000, hashAuthToken(device), hashAuthToken(verifier), domain, origin, now, now).Scan(&id, &state, &browser, &remember)
if errors.Is(err, sql.ErrNoRows) {
var exists int
e := tx.QueryRowContext(ctx, `SELECT count(*) FROM auth_cli_requests WHERE device_hash=? AND challenge=? AND domain_uuid=? AND origin=? AND expires_ms>? AND state IN ('pending','approved','denied')`, hashAuthToken(device), hashAuthToken(verifier), domain, origin, now).Scan(&exists)
e := tx.QueryRowContext(ctx, `SELECT count(*) FROM auth_cli_requests WHERE device_hash=`+s.sqlParam(1)+` AND challenge=`+s.sqlParam(2)+` AND domain_uuid=`+s.sqlParam(3)+` AND origin=`+s.sqlParam(4)+` AND expires_ms>`+s.sqlParam(5)+` AND state IN ('pending','approved','denied')`, hashAuthToken(device), hashAuthToken(verifier), domain, origin, now).Scan(&exists)
if e != nil {
err = e
} else if exists > 0 {
@@ -221,12 +243,16 @@ func (s *Store) ExchangeCLIAuth(ctx context.Context, domain, origin, device, ver
return
}
token = "pw_api_" + raw
minimum, maximum := "min", "max"
if s.sqlBackend == storePostgreSQL {
minimum, maximum = "LEAST", "GREATEST"
}
// A disabled user, removed membership or revoked browser cannot delegate.
err = tx.QueryRowContext(ctx, `INSERT INTO auth_sessions(uuid,token_hash,principal_uuid,domain_uuid,auth_time_ms,expires_at_ms,last_seen_at_ms,mfa_level)
SELECT ?,?,p.uuid,a.domain_uuid,a.auth_time_ms,min(?,a.expires_at_ms),?,max(a.mfa_level,g.mfa_level)
SELECT `+s.sqlParam(1)+`,`+s.sqlParam(2)+`,p.uuid,a.domain_uuid,a.auth_time_ms,`+minimum+`(`+s.sqlParam(3)+`,a.expires_at_ms),`+s.sqlParam(4)+`,`+maximum+`(a.mfa_level,g.mfa_level)
FROM auth_cli_requests g JOIN auth_sessions a ON a.token_hash=g.browser_hash JOIN principals p ON p.uuid=a.principal_uuid JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=a.domain_uuid
WHERE a.token_hash=? AND a.domain_uuid=? AND a.revoked_at_ms=0 AND a.expires_at_ms>? AND p.state IN ('active','readonly') AND m.state='active'
AND g.id=?
WHERE a.token_hash=`+s.sqlParam(5)+` AND a.domain_uuid=`+s.sqlParam(6)+` AND a.revoked_at_ms=0 AND a.expires_at_ms>`+s.sqlParam(7)+` AND p.state IN ('active','readonly') AND m.state='active'
AND g.id=`+s.sqlParam(8)+`
RETURNING principal_uuid,expires_at_ms`, uuid.NewString(), hashAuthToken(token), now+lifetime, now, browser, domain, now, id).Scan(&username, &expires)
if errors.Is(err, sql.ErrNoRows) {
err = ErrAccessDenied
@@ -236,7 +262,7 @@ func (s *Store) ExchangeCLIAuth(ctx context.Context, domain, origin, device, ver
return
}
var name string
err = tx.QueryRowContext(ctx, `SELECT COALESCE((SELECT subject FROM principal_identities WHERE principal_uuid=? AND provider_type='password' LIMIT 1),?)`, username, username).Scan(&name)
err = tx.QueryRowContext(ctx, `SELECT COALESCE((SELECT subject FROM principal_identities WHERE principal_uuid=`+s.sqlParam(1)+` AND provider_type='password' ORDER BY subject,uuid LIMIT 1),`+s.sqlParam(2)+`)`, username, username).Scan(&name)
if err != nil {
token = ""
return
+94 -72
View File
@@ -1,6 +1,7 @@
package store
import (
"context"
"crypto/sha256"
"database/sql"
"encoding/base64"
@@ -134,25 +135,19 @@ func (s *Store) BindExternalIdentityIfProviderUnbound(domainUUID, principalUUID,
if err != nil {
return err
}
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
if _, err = tx.Exec(`UPDATE principals SET updated_at_ms=updated_at_ms WHERE uuid=?`, principalUUID); err != nil {
return err
}
var eligible, alreadyBound bool
if err = tx.QueryRow(`SELECT EXISTS(SELECT 1 FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=? AND m.state='active' WHERE p.uuid=? AND p.state IN ('active','readonly'))`, domainUUID, principalUUID).Scan(&eligible); err != nil || !eligible {
return ErrAccessDenied
}
if err = tx.QueryRow(`SELECT EXISTS(SELECT 1 FROM principal_identities WHERE principal_uuid=? AND provider_type=? AND provider_uuid=?)`, principalUUID, providerType, providerUUID).Scan(&alreadyBound); err != nil || alreadyBound {
return ErrAccessDenied
}
if _, err = tx.Exec(`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,provider_uuid,issuer,subject,attributes_json,created_at_ms) VALUES(?,?,?,?,?,?,?,?)`, uuid.NewString(), principalUUID, providerType, providerUUID, issuer, subject, payload, time.Now().UnixMilli()); err != nil {
return ErrAccessDenied
}
return tx.Commit()
return s.groupWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error {
var eligible, alreadyBound bool
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=`+s.sqlParam(1)+` AND m.state='active' WHERE p.uuid=`+s.sqlParam(2)+` AND p.state IN ('active','readonly'))`, domainUUID, principalUUID).Scan(&eligible); err != nil || !eligible {
return ErrAccessDenied
}
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM principal_identities WHERE principal_uuid=`+s.sqlParam(1)+` AND provider_type=`+s.sqlParam(2)+` AND provider_uuid=`+s.sqlParam(3)+`)`, principalUUID, providerType, providerUUID).Scan(&alreadyBound); err != nil || alreadyBound {
return ErrAccessDenied
}
if _, err = tx.ExecContext(ctx, `INSERT INTO principal_identities(uuid,principal_uuid,provider_type,provider_uuid,issuer,subject,attributes_json,created_at_ms) VALUES(`+s.sqlValues(8)+`)`, uuid.NewString(), principalUUID, providerType, providerUUID, issuer, subject, payload, time.Now().UnixMilli()); err != nil {
return ErrAccessDenied
}
return nil
})
}
// ProvisionExternalAccount creates a normal Domain member with a local
@@ -172,42 +167,49 @@ func (s *Store) ProvisionExternalAccount(domainUUID, username, displayName, emai
if p.DisplayName == "" {
p.DisplayName = username
}
tx, err := s.DB.Begin()
err = s.groupWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error {
if s.sqlBackend == storePostgreSQL {
var present bool
if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM domains WHERE uuid=$1 AND enabled=1 AND placement='local')`, domainUUID).Scan(&present); err != nil {
return err
}
if !present {
return sql.ErrNoRows
}
}
roleID := ""
err = tx.QueryRowContext(ctx, `SELECT uuid FROM auth_roles WHERE domain_uuid=`+s.sqlParam(1)+` AND name='member'`, domainUUID).Scan(&roleID)
if errors.Is(err, sql.ErrNoRows) {
roleID = uuid.NewString()
if _, err = tx.ExecContext(ctx, `INSERT INTO auth_roles(uuid,domain_uuid,name,description,created_at_ms) VALUES(`+s.sqlValues(5)+`)`, roleID, domainUUID, "member", "Domain member", now); err != nil {
return err
}
if _, err = tx.ExecContext(ctx, `INSERT INTO auth_capability_grants(uuid,role_uuid,capability,target_type,target_id,created_at_ms) VALUES(`+s.sqlValues(6)+`)`, uuid.NewString(), roleID, "read", "domain", domainUUID, now); err != nil {
return err
}
} else if err != nil {
return err
}
membershipID := uuid.NewString()
for _, item := range []struct {
query string
args []any
}{
{`INSERT INTO principals(uuid,display_name,email,state,created_at_ms,updated_at_ms) VALUES(` + s.sqlValues(6) + `)`, []any{p.UUID, p.DisplayName, p.Email, p.State, now, now}},
{`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,subject,created_at_ms) VALUES(` + s.sqlValues(5) + `)`, []any{uuid.NewString(), p.UUID, "password", username, now}},
{`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,provider_uuid,issuer,subject,attributes_json,created_at_ms) VALUES(` + s.sqlValues(8) + `)`, []any{uuid.NewString(), p.UUID, providerType, providerUUID, issuer, subject, payload, now}},
{`INSERT INTO domain_memberships(uuid,domain_uuid,principal_uuid,state,created_at_ms) VALUES(` + s.sqlValues(5) + `)`, []any{membershipID, domainUUID, p.UUID, "active", now}},
{`INSERT INTO auth_role_bindings(membership_uuid,role_uuid,created_at_ms) VALUES(` + s.sqlValues(3) + `)`, []any{membershipID, roleID, now}},
} {
if _, err = tx.ExecContext(ctx, item.query, item.args...); err != nil {
return ErrAccessDenied
}
}
return nil
})
if err != nil {
return nil, err
}
defer tx.Rollback()
roleID := ""
err = tx.QueryRow(`SELECT uuid FROM auth_roles WHERE domain_uuid=? AND name='member'`, domainUUID).Scan(&roleID)
if errors.Is(err, sql.ErrNoRows) {
roleID = uuid.NewString()
if _, err = tx.Exec(`INSERT INTO auth_roles(uuid,domain_uuid,name,description,created_at_ms) VALUES(?,?,?,?,?)`, roleID, domainUUID, "member", "Domain member", now); err != nil {
return nil, err
}
if _, err = tx.Exec(`INSERT INTO auth_capability_grants(uuid,role_uuid,capability,target_type,target_id,created_at_ms) VALUES(?,?,?,?,?,?)`, uuid.NewString(), roleID, "read", "domain", domainUUID, now); err != nil {
return nil, err
}
} else if err != nil {
return nil, err
}
membershipID := uuid.NewString()
for _, item := range []struct {
query string
args []any
}{
{`INSERT INTO principals(uuid,display_name,email,state,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?)`, []any{p.UUID, p.DisplayName, p.Email, p.State, now, now}},
{`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,subject,created_at_ms) VALUES(?,?,?,?,?)`, []any{uuid.NewString(), p.UUID, "password", username, now}},
{`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,provider_uuid,issuer,subject,attributes_json,created_at_ms) VALUES(?,?,?,?,?,?,?,?)`, []any{uuid.NewString(), p.UUID, providerType, providerUUID, issuer, subject, payload, now}},
{`INSERT INTO domain_memberships(uuid,domain_uuid,principal_uuid,state,created_at_ms) VALUES(?,?,?,?,?)`, []any{membershipID, domainUUID, p.UUID, "active", now}},
{`INSERT INTO auth_role_bindings(membership_uuid,role_uuid,created_at_ms) VALUES(?,?,?)`, []any{membershipID, roleID, now}},
} {
if _, err = tx.Exec(item.query, item.args...); err != nil {
return nil, ErrAccessDenied
}
}
if err = tx.Commit(); err != nil {
return nil, err
}
return p, nil
}
@@ -248,20 +250,23 @@ func (s *Store) SetAuthProviderConfig(domainUUID string, config AuthProviderConf
if err != nil {
return err
}
} else {
_ = s.DB.QueryRow(`SELECT secret_encrypted FROM auth_providers WHERE domain_uuid=? AND kind=?`, domainUUID, config.Kind).Scan(&encrypted)
}
_, err = s.DB.Exec(`INSERT INTO auth_providers(uuid,domain_uuid,kind,config_json,secret_encrypted,enabled,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?,?,?) ON CONFLICT(domain_uuid,kind) DO UPDATE SET config_json=excluded.config_json,secret_encrypted=excluded.secret_encrypted,enabled=excluded.enabled,updated_at_ms=excluded.updated_at_ms`, uuid.NewString(), domainUUID, config.Kind, string(payload), encrypted, config.Enabled, time.Now().UnixMilli(), time.Now().UnixMilli())
return err
enabled := 0
if config.Enabled {
enabled = 1
}
// Preserve the current secret inside the UPSERT, not via a stale pre-read.
_, err = s.DB.Exec(`INSERT INTO auth_providers(uuid,domain_uuid,kind,config_json,secret_encrypted,enabled,created_at_ms,updated_at_ms) VALUES(`+s.sqlValues(8)+`) ON CONFLICT(domain_uuid,kind) DO UPDATE SET config_json=excluded.config_json,secret_encrypted=CASE WHEN excluded.secret_encrypted='' THEN auth_providers.secret_encrypted ELSE excluded.secret_encrypted END,enabled=excluded.enabled,updated_at_ms=excluded.updated_at_ms`, uuid.NewString(), domainUUID, config.Kind, string(payload), encrypted, enabled, time.Now().UnixMilli(), time.Now().UnixMilli())
return s.sqlError("auth provider update", err)
}
func (s *Store) AuthProviderConfig(domainUUID, kind string) (AuthProviderConfig, error) {
var config AuthProviderConfig
var payload, encrypted string
var enabled bool
err := s.DB.QueryRow(`SELECT uuid,config_json,secret_encrypted,enabled FROM auth_providers WHERE domain_uuid=? AND kind=?`, domainUUID, kind).Scan(&config.UUID, &payload, &encrypted, &enabled)
err := s.DB.QueryRow(`SELECT uuid,config_json,secret_encrypted,enabled FROM auth_providers WHERE domain_uuid=`+s.sqlParam(1)+` AND kind=`+s.sqlParam(2)+``, domainUUID, kind).Scan(&config.UUID, &payload, &encrypted, &enabled)
if err != nil {
return config, err
return config, s.sqlError("auth provider lookup", err)
}
if err := json.Unmarshal([]byte(payload), &config); err != nil {
return config, err
@@ -304,8 +309,8 @@ func (s *Store) PrincipalByExternalUsername(domainUUID, username string) (*Princ
}
rows, err := s.DB.Query(`SELECT p.uuid,i.subject,p.display_name,p.email,p.state,length(p.avatar)>0
FROM principal_identities i JOIN principals p ON p.uuid=i.principal_uuid
JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=? AND m.state='active'
WHERE i.provider_type='password' AND i.subject=? AND p.state IN ('active','readonly') LIMIT 2`, domainUUID, username)
JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=`+s.sqlParam(1)+` AND m.state='active'
WHERE i.provider_type='password' AND i.subject=`+s.sqlParam(2)+` AND p.state IN ('active','readonly') LIMIT 2`, domainUUID, username)
if err != nil {
return nil, err
}
@@ -335,7 +340,7 @@ func (s *Store) PrincipalByVerifiedEmail(domainUUID, email string) (*Principal,
if email == "" || domainUUID == "" {
return nil, ErrAccessDenied
}
rows, err := s.DB.Query(`SELECT p.uuid,COALESCE((SELECT subject FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' LIMIT 1),p.uuid),p.display_name,p.email,p.state,length(p.avatar)>0 FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=? AND m.state='active' WHERE lower(p.email)=? AND p.state IN ('active','readonly') LIMIT 2`, domainUUID, email)
rows, err := s.DB.Query(`SELECT p.uuid,COALESCE((SELECT subject FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' ORDER BY subject,uuid LIMIT 1),p.uuid),p.display_name,p.email,p.state,length(p.avatar)>0 FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=`+s.sqlParam(1)+` AND m.state='active' WHERE lower(p.email)=`+s.sqlParam(2)+` AND p.state IN ('active','readonly') LIMIT 2`, domainUUID, email)
if err != nil {
return nil, err
}
@@ -370,11 +375,11 @@ func (s *Store) PrincipalByDisplayName(domainUUID, displayName string) (*Princip
return nil, ErrAccessDenied
}
rows, err := s.DB.Query(`SELECT p.uuid,
COALESCE((SELECT subject FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' LIMIT 1),p.uuid),
COALESCE((SELECT subject FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' ORDER BY subject,uuid LIMIT 1),p.uuid),
p.display_name,p.email,p.state,length(p.avatar)>0
FROM principals p JOIN domain_memberships m
ON m.principal_uuid=p.uuid AND m.domain_uuid=? AND m.state='active'
WHERE p.display_name=? AND p.state IN ('active','readonly') LIMIT 2`, domainUUID, displayName)
ON m.principal_uuid=p.uuid AND m.domain_uuid=`+s.sqlParam(1)+` AND m.state='active'
WHERE p.display_name=`+s.sqlParam(2)+` AND p.state IN ('active','readonly') LIMIT 2`, domainUUID, displayName)
if err != nil {
return nil, err
}
@@ -408,7 +413,7 @@ func (s *Store) BindExternalIdentity(principalUUID, providerType, providerUUID,
return err
}
now := time.Now().UnixMilli()
result, err := s.DB.Exec(`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,provider_uuid,issuer,subject,attributes_json,created_at_ms) VALUES(?,?,?,?,?,?,?,?) ON CONFLICT(provider_type,provider_uuid,issuer,subject) DO UPDATE SET attributes_json=excluded.attributes_json WHERE principal_identities.principal_uuid=excluded.principal_uuid`, uuid.NewString(), principalUUID, providerType, providerUUID, issuer, subject, string(payload), now)
result, err := s.DB.Exec(`INSERT INTO principal_identities(uuid,principal_uuid,provider_type,provider_uuid,issuer,subject,attributes_json,created_at_ms) VALUES(`+s.sqlValues(8)+`) ON CONFLICT(provider_type,provider_uuid,issuer,subject) DO UPDATE SET attributes_json=excluded.attributes_json WHERE principal_identities.principal_uuid=excluded.principal_uuid`, uuid.NewString(), principalUUID, providerType, providerUUID, issuer, subject, string(payload), now)
if err != nil {
return err
}
@@ -424,7 +429,7 @@ func (s *Store) BindExternalIdentity(principalUUID, providerType, providerUUID,
func (s *Store) PrincipalByExternalIdentity(domainUUID, providerType, providerUUID, issuer, subject string) (*Principal, error) {
var p Principal
err := s.DB.QueryRow(`SELECT p.uuid,COALESCE((SELECT subject FROM principal_identities x WHERE x.principal_uuid=p.uuid AND x.provider_type='password' LIMIT 1),p.uuid),p.display_name,p.email,p.state,length(p.avatar)>0 FROM principal_identities i JOIN principals p ON p.uuid=i.principal_uuid JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=? AND m.state='active' WHERE i.provider_type=? AND i.provider_uuid=? AND i.issuer=? AND i.subject=? AND p.state IN ('active','readonly')`, domainUUID, providerType, providerUUID, issuer, subject).Scan(&p.UUID, &p.Username, &p.DisplayName, &p.Email, &p.State, &p.HasAvatar)
err := s.DB.QueryRow(`SELECT p.uuid,COALESCE((SELECT subject FROM principal_identities x WHERE x.principal_uuid=p.uuid AND x.provider_type='password' ORDER BY subject,uuid LIMIT 1),p.uuid),p.display_name,p.email,p.state,length(p.avatar)>0 FROM principal_identities i JOIN principals p ON p.uuid=i.principal_uuid JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=`+s.sqlParam(1)+` AND m.state='active' WHERE i.provider_type=`+s.sqlParam(2)+` AND i.provider_uuid=`+s.sqlParam(3)+` AND i.issuer=`+s.sqlParam(4)+` AND i.subject=`+s.sqlParam(5)+` AND p.state IN ('active','readonly')`, domainUUID, providerType, providerUUID, issuer, subject).Scan(&p.UUID, &p.Username, &p.DisplayName, &p.Email, &p.State, &p.HasAvatar)
return &p, err
}
@@ -433,23 +438,29 @@ func (s *Store) CreateAuthChallenge(domainUUID, principalUUID, kind string, payl
if err != nil {
return "", err
}
encoded, _ := json.Marshal(payload)
encoded, err := json.Marshal(payload)
if err != nil {
return "", err
}
now := time.Now().UnixMilli()
_, err = s.DB.Exec(`INSERT INTO auth_challenges(uuid,domain_uuid,principal_uuid,kind,token_hash,payload_json,expires_at_ms,created_at_ms) VALUES(?,?,?,?,?,?,?,?)`, uuid.NewString(), domainUUID, principalUUID, kind, hash, string(encoded), now+lifetime.Milliseconds(), now)
return token, err
_, err = s.DB.Exec(`INSERT INTO auth_challenges(uuid,domain_uuid,principal_uuid,kind,token_hash,payload_json,expires_at_ms,created_at_ms) VALUES(`+s.sqlValues(8)+`)`, uuid.NewString(), domainUUID, principalUUID, kind, hash, string(encoded), now+lifetime.Milliseconds(), now)
if err != nil {
return "", s.sqlError("auth challenge creation", err)
}
return token, nil
}
func (s *Store) ConsumeAuthChallenge(domainUUID, kind, token string, payload any) (string, error) {
hash := hashAuthToken(token)
var id, principalUUID, encoded string
var expires int64
err := s.DB.QueryRow(`SELECT uuid,principal_uuid,payload_json,expires_at_ms FROM auth_challenges WHERE domain_uuid=? AND kind=? AND token_hash=? AND consumed_at_ms=0`, domainUUID, kind, hash).Scan(&id, &principalUUID, &encoded, &expires)
err := s.DB.QueryRow(`SELECT uuid,principal_uuid,payload_json,expires_at_ms FROM auth_challenges WHERE domain_uuid=`+s.sqlParam(1)+` AND kind=`+s.sqlParam(2)+` AND token_hash=`+s.sqlParam(3)+` AND consumed_at_ms=0`, domainUUID, kind, hash).Scan(&id, &principalUUID, &encoded, &expires)
if err != nil || expires < time.Now().UnixMilli() {
return "", ErrAccessDenied
}
result, err := s.DB.Exec(`UPDATE auth_challenges SET consumed_at_ms=? WHERE uuid=? AND consumed_at_ms=0`, time.Now().UnixMilli(), id)
result, err := s.DB.Exec(`UPDATE auth_challenges SET consumed_at_ms=`+s.sqlParam(1)+` WHERE uuid=`+s.sqlParam(2)+` AND consumed_at_ms=0 AND expires_at_ms>`+s.sqlParam(3), time.Now().UnixMilli(), id, time.Now().UnixMilli())
if err != nil {
return "", err
return "", s.sqlError("auth challenge consumption", err)
}
changed, _ := result.RowsAffected()
if changed != 1 {
@@ -461,6 +472,17 @@ func (s *Store) ConsumeAuthChallenge(domainUUID, kind, token string, payload any
return principalUUID, nil
}
// A consumed link does not authorize a changed email address or a disabled
// membership. Keep the HTTP layer independent of the SQL placeholder dialect.
func (s *Store) ValidateMagicLinkIdentity(ctx context.Context, domain, principal, email string) (bool, error) {
if email == "" {
return false, nil
}
var valid bool
err := s.DB.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=`+s.sqlParam(1)+` WHERE p.uuid=`+s.sqlParam(2)+` AND p.state IN ('active','readonly') AND m.state='active' AND p.email=`+s.sqlParam(3)+`)`, domain, principal, email).Scan(&valid)
return err == nil && valid, s.sqlError("magic link identity", err)
}
func hashAuthToken(token string) string {
sum := sha256.Sum256([]byte(token))
return base64.RawURLEncoding.EncodeToString(sum[:])
+88
View File
@@ -0,0 +1,88 @@
package store
import (
"context"
"pageswiki/internal/db"
)
// This foundation is deliberately separate from EnsureAuthSchema: full
// authorization, audit and locality policies are required before serving auth.
// Existing tables are never adopted or repaired implicitly.
func (s *Store) ensurePostgreSQLAuthFoundation(ctx context.Context) error {
steps := []db.PostgreSQLMigration{{
Version: 1, Name: "identities memberships and administrative groups",
Statements: []string{
`CREATE TABLE principals(uuid TEXT COLLATE "C" PRIMARY KEY,display_name TEXT NOT NULL DEFAULT '',email TEXT NOT NULL DEFAULT '',state TEXT NOT NULL DEFAULT 'active',avatar BYTEA NOT NULL DEFAULT ''::bytea,avatar_content_type TEXT NOT NULL DEFAULT '',created_at_ms BIGINT NOT NULL,updated_at_ms BIGINT NOT NULL)`,
`CREATE TABLE principal_identities(uuid TEXT COLLATE "C" PRIMARY KEY,principal_uuid TEXT COLLATE "C" NOT NULL,provider_type TEXT COLLATE "C" NOT NULL,provider_uuid TEXT COLLATE "C" NOT NULL DEFAULT '',issuer TEXT COLLATE "C" NOT NULL DEFAULT '',subject TEXT COLLATE "C" NOT NULL,attributes_json TEXT NOT NULL DEFAULT '{}',created_at_ms BIGINT NOT NULL,UNIQUE(provider_type,provider_uuid,issuer,subject))`,
`CREATE TABLE domain_memberships(uuid TEXT COLLATE "C" PRIMARY KEY,domain_uuid TEXT COLLATE "C" NOT NULL,principal_uuid TEXT COLLATE "C" NOT NULL,state TEXT NOT NULL DEFAULT 'active',created_at_ms BIGINT NOT NULL,UNIQUE(domain_uuid,principal_uuid))`,
`CREATE TABLE auth_roles(uuid TEXT COLLATE "C" PRIMARY KEY,domain_uuid TEXT COLLATE "C" NOT NULL,name TEXT COLLATE "C" NOT NULL,description TEXT NOT NULL DEFAULT '',created_at_ms BIGINT NOT NULL,UNIQUE(domain_uuid,name))`,
`CREATE TABLE auth_role_bindings(membership_uuid TEXT COLLATE "C" NOT NULL,role_uuid TEXT COLLATE "C" NOT NULL,created_at_ms BIGINT NOT NULL,PRIMARY KEY(membership_uuid,role_uuid))`,
`CREATE TABLE auth_capability_grants(uuid TEXT COLLATE "C" PRIMARY KEY,role_uuid TEXT COLLATE "C" NOT NULL,capability TEXT COLLATE "C" NOT NULL,target_type TEXT COLLATE "C" NOT NULL,target_id TEXT COLLATE "C" NOT NULL DEFAULT '*',created_at_ms BIGINT NOT NULL,UNIQUE(role_uuid,capability,target_type,target_id))`,
`CREATE TABLE groups(uuid TEXT COLLATE "C" PRIMARY KEY,domain_uuid TEXT COLLATE "C" NOT NULL,name TEXT COLLATE "C" NOT NULL,display_name TEXT NOT NULL DEFAULT '',description TEXT NOT NULL DEFAULT '',visibility TEXT NOT NULL DEFAULT 'members',state TEXT NOT NULL DEFAULT 'active',builtin_key TEXT NOT NULL DEFAULT '',inherit_members INTEGER NOT NULL DEFAULT 0,created_at_ms BIGINT NOT NULL,updated_at_ms BIGINT NOT NULL,UNIQUE(domain_uuid,name))`,
`CREATE TABLE group_members(group_uuid TEXT COLLATE "C" NOT NULL,membership_uuid TEXT COLLATE "C" NOT NULL,member_role TEXT NOT NULL DEFAULT 'member',source TEXT NOT NULL DEFAULT 'local',created_at_ms BIGINT NOT NULL,PRIMARY KEY(group_uuid,membership_uuid))`,
`CREATE TABLE campus_admin_grants(group_uuid TEXT COLLATE "C" NOT NULL,membership_uuid TEXT COLLATE "C" NOT NULL,source TEXT COLLATE "C" NOT NULL,member_role TEXT NOT NULL,created_at_ms BIGINT NOT NULL,PRIMARY KEY(group_uuid,membership_uuid,source))`,
`CREATE INDEX campus_admin_grants_membership ON campus_admin_grants(membership_uuid)`,
`CREATE TABLE campus_admin_membership_origins(membership_uuid TEXT COLLATE "C" PRIMARY KEY,domain_uuid TEXT COLLATE "C" NOT NULL,principal_uuid TEXT COLLATE "C" NOT NULL,UNIQUE(domain_uuid,principal_uuid))`,
`CREATE TABLE campus_admin_migrations(key TEXT COLLATE "C" PRIMARY KEY)`,
`CREATE INDEX domain_memberships_principal ON domain_memberships(principal_uuid,domain_uuid)`,
`CREATE INDEX group_members_membership ON group_members(membership_uuid,group_uuid)`,
},
Assertions: []string{
`SELECT uuid,display_name,email,state,avatar,avatar_content_type,created_at_ms,updated_at_ms FROM principals WHERE 1=0`,
`SELECT uuid,principal_uuid,provider_type,provider_uuid,issuer,subject,attributes_json,created_at_ms FROM principal_identities WHERE 1=0`,
`SELECT uuid,domain_uuid,principal_uuid,state,created_at_ms FROM domain_memberships WHERE 1=0`,
`SELECT uuid,domain_uuid,name,description,created_at_ms FROM auth_roles WHERE 1=0`,
`SELECT membership_uuid,role_uuid,created_at_ms FROM auth_role_bindings WHERE 1=0`,
`SELECT uuid,role_uuid,capability,target_type,target_id,created_at_ms FROM auth_capability_grants WHERE 1=0`,
`SELECT uuid,domain_uuid,name,display_name,description,visibility,state,builtin_key,inherit_members,created_at_ms,updated_at_ms FROM groups WHERE 1=0`,
`SELECT group_uuid,membership_uuid,member_role,source,created_at_ms FROM group_members WHERE 1=0`,
`SELECT group_uuid,membership_uuid,source,member_role,created_at_ms FROM campus_admin_grants WHERE 1=0`,
`SELECT membership_uuid,domain_uuid,principal_uuid FROM campus_admin_membership_origins WHERE 1=0`,
`SELECT key FROM campus_admin_migrations WHERE 1=0`,
},
}}
// Session storage is required for atomic revocation of derived membership.
// Account/session APIs are added in later component ports; this step's DDL
// and checksum remain unchanged as those APIs become available.
steps = append(steps, db.PostgreSQLMigration{
Version: 2, Name: "session storage for administrative revocation",
Statements: []string{
`CREATE TABLE auth_sessions(uuid TEXT COLLATE "C" PRIMARY KEY,token_hash TEXT COLLATE "C" NOT NULL UNIQUE,principal_uuid TEXT COLLATE "C" NOT NULL,domain_uuid TEXT COLLATE "C" NOT NULL,auth_time_ms BIGINT NOT NULL,expires_at_ms BIGINT NOT NULL,last_seen_at_ms BIGINT NOT NULL,mfa_level INTEGER NOT NULL DEFAULT 0,revoked_at_ms BIGINT NOT NULL DEFAULT 0)`,
`CREATE INDEX auth_sessions_membership ON auth_sessions(domain_uuid,principal_uuid) WHERE revoked_at_ms=0`,
},
Assertions: append(append([]string{}, steps[0].Assertions...), `SELECT uuid,token_hash,principal_uuid,domain_uuid,auth_time_ms,expires_at_ms,last_seen_at_ms,mfa_level,revoked_at_ms FROM auth_sessions WHERE 1=0`),
})
steps = append(steps, db.PostgreSQLMigration{
Version: 3, Name: "scoped group permissions",
Statements: []string{
`CREATE TABLE group_permissions(uuid TEXT COLLATE "C" PRIMARY KEY,group_uuid TEXT COLLATE "C" NOT NULL,scope_path TEXT COLLATE "C" NOT NULL,permission TEXT NOT NULL,created_at_ms BIGINT NOT NULL,UNIQUE(group_uuid,scope_path))`,
`CREATE INDEX principal_identities_principal_provider ON principal_identities(principal_uuid,provider_type,subject,uuid)`,
},
Assertions: append(append([]string{}, steps[1].Assertions...), `SELECT uuid,group_uuid,scope_path,permission,created_at_ms FROM group_permissions WHERE 1=0`),
})
steps = append(steps, db.PostgreSQLMigration{Version: 4, Name: "account credentials", Statements: []string{
`CREATE TABLE auth_credentials(uuid TEXT COLLATE "C" PRIMARY KEY,principal_uuid TEXT COLLATE "C" NOT NULL,kind TEXT COLLATE "C" NOT NULL,identifier TEXT COLLATE "C" NOT NULL DEFAULT '',secret_hash TEXT NOT NULL,parameters_json TEXT NOT NULL DEFAULT '{}',enabled INTEGER NOT NULL DEFAULT 1,created_at_ms BIGINT NOT NULL,updated_at_ms BIGINT NOT NULL,UNIQUE(kind,identifier))`,
}, Assertions: append(append([]string{}, steps[2].Assertions...), `SELECT uuid,principal_uuid,kind,identifier,secret_hash,parameters_json,enabled,created_at_ms,updated_at_ms FROM auth_credentials WHERE 1=0`)})
steps = append(steps, db.PostgreSQLMigration{Version: 5, Name: "authentication challenges", Statements: []string{
`CREATE TABLE auth_challenges(uuid TEXT COLLATE "C" PRIMARY KEY,domain_uuid TEXT COLLATE "C" NOT NULL,principal_uuid TEXT COLLATE "C" NOT NULL DEFAULT '',kind TEXT COLLATE "C" NOT NULL,token_hash TEXT COLLATE "C" NOT NULL UNIQUE,payload_json TEXT NOT NULL DEFAULT '{}',expires_at_ms BIGINT NOT NULL,consumed_at_ms BIGINT NOT NULL DEFAULT 0,attempt_count INTEGER NOT NULL DEFAULT 0,created_at_ms BIGINT NOT NULL)`,
`CREATE INDEX auth_challenges_expiry ON auth_challenges(expires_at_ms)`,
}, Assertions: append(append([]string{}, steps[3].Assertions...), `SELECT uuid,domain_uuid,principal_uuid,kind,token_hash,payload_json,expires_at_ms,consumed_at_ms,attempt_count,created_at_ms FROM auth_challenges WHERE 1=0`)})
steps = append(steps, db.PostgreSQLMigration{Version: 6, Name: "authentication provider configuration", Statements: []string{
`CREATE TABLE auth_providers(uuid TEXT COLLATE "C" PRIMARY KEY,domain_uuid TEXT COLLATE "C" NOT NULL,kind TEXT COLLATE "C" NOT NULL,config_json TEXT NOT NULL DEFAULT '{}',secret_encrypted TEXT NOT NULL DEFAULT '',enabled INTEGER NOT NULL DEFAULT 0,created_at_ms BIGINT NOT NULL,updated_at_ms BIGINT NOT NULL,UNIQUE(domain_uuid,kind))`,
}, Assertions: append(append([]string{}, steps[4].Assertions...), `SELECT uuid,domain_uuid,kind,config_json,secret_encrypted,enabled,created_at_ms,updated_at_ms FROM auth_providers WHERE 1=0`)})
steps = append(steps, db.PostgreSQLMigration{Version: 7, Name: "CLI authorization handoff", Statements: []string{
`CREATE TABLE auth_cli_requests(id TEXT COLLATE "C" PRIMARY KEY,domain_uuid TEXT COLLATE "C" NOT NULL,origin TEXT COLLATE "C" NOT NULL,device_hash TEXT COLLATE "C" NOT NULL UNIQUE,challenge TEXT COLLATE "C" NOT NULL,code_hash TEXT COLLATE "C" NOT NULL,state TEXT NOT NULL DEFAULT 'pending',browser_hash TEXT COLLATE "C" NOT NULL DEFAULT '',principal_uuid TEXT COLLATE "C" NOT NULL DEFAULT '',mfa_level INTEGER NOT NULL DEFAULT 0,attempts INTEGER NOT NULL DEFAULT 0,oidc_attempts INTEGER NOT NULL DEFAULT 0,created_ms BIGINT NOT NULL,expires_ms BIGINT NOT NULL,next_poll_ms BIGINT NOT NULL DEFAULT 0,remember INTEGER NOT NULL DEFAULT 0 CHECK(remember IN (0,1)))`,
`CREATE INDEX auth_cli_domain_created ON auth_cli_requests(domain_uuid,created_ms)`,
`CREATE INDEX auth_cli_expiry ON auth_cli_requests(expires_ms)`,
}, Assertions: append(append([]string{}, steps[5].Assertions...), `SELECT id,domain_uuid,origin,device_hash,challenge,code_hash,state,browser_hash,principal_uuid,mfa_level,attempts,oidc_attempts,created_ms,expires_ms,next_poll_ms,remember FROM auth_cli_requests WHERE 1=0`)})
steps = append(steps, db.PostgreSQLMigration{Version: 8, Name: "authorization mapping and audit storage", Statements: []string{
`CREATE TABLE auth_group_role_bindings(group_uuid TEXT COLLATE "C" NOT NULL,role_uuid TEXT COLLATE "C" NOT NULL,created_at_ms BIGINT NOT NULL,PRIMARY KEY(group_uuid,role_uuid))`,
`CREATE TABLE auth_group_mappings(uuid TEXT COLLATE "C" PRIMARY KEY,domain_uuid TEXT COLLATE "C" NOT NULL,provider_type TEXT NOT NULL,provider_uuid TEXT COLLATE "C" NOT NULL,external_group TEXT COLLATE "C" NOT NULL,group_uuid TEXT COLLATE "C" NOT NULL,mode TEXT NOT NULL DEFAULT 'additive',enabled INTEGER NOT NULL DEFAULT 1,UNIQUE(domain_uuid,provider_type,provider_uuid,external_group))`,
`CREATE TABLE auth_audit_log(id BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,domain_uuid TEXT COLLATE "C" NOT NULL DEFAULT '',principal_uuid TEXT COLLATE "C" NOT NULL DEFAULT '',event TEXT NOT NULL,outcome TEXT NOT NULL,target_type TEXT NOT NULL DEFAULT '',target_id TEXT NOT NULL DEFAULT '',request_id TEXT NOT NULL DEFAULT '',detail_json TEXT NOT NULL DEFAULT '{}',created_at_ms BIGINT NOT NULL)`,
}, Assertions: append(append([]string{}, steps[6].Assertions...),
`SELECT group_uuid,role_uuid,created_at_ms FROM auth_group_role_bindings WHERE 1=0`,
`SELECT uuid,domain_uuid,provider_type,provider_uuid,external_group,group_uuid,mode,enabled FROM auth_group_mappings WHERE 1=0`,
`SELECT id,domain_uuid,principal_uuid,event,outcome,target_type,target_id,request_id,detail_json,created_at_ms FROM auth_audit_log WHERE 1=0`)})
return db.ApplyPostgreSQLMigrations(ctx, s.DB, "store-auth-foundation", steps)
}
+64 -46
View File
@@ -1,12 +1,14 @@
package store
import (
"context"
"crypto/aes"
"crypto/cipher"
"crypto/hmac"
"crypto/rand"
"crypto/sha1"
"crypto/sha256"
"database/sql"
"encoding/base32"
"encoding/base64"
"encoding/binary"
@@ -63,8 +65,14 @@ func (s *Store) BeginTOTPEnrollment(principalUUID string) (string, error) {
return "", err
}
now := time.Now().UnixMilli()
_, err = s.DB.Exec(`INSERT INTO auth_credentials(uuid,principal_uuid,kind,identifier,secret_hash,parameters_json,enabled,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,'{}',0,?,?) ON CONFLICT(kind,identifier) DO UPDATE SET secret_hash=excluded.secret_hash,parameters_json='{}',enabled=0,updated_at_ms=excluded.updated_at_ms`, uuid.NewString(), principalUUID, "totp-pending", principalUUID, encrypted, now, now)
return secret, err
err = s.groupWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error {
_, err := tx.ExecContext(ctx, `INSERT INTO auth_credentials(uuid,principal_uuid,kind,identifier,secret_hash,parameters_json,enabled,created_at_ms,updated_at_ms) VALUES(`+s.sqlValues(9)+`) ON CONFLICT(kind,identifier) DO UPDATE SET secret_hash=excluded.secret_hash,parameters_json='{}',enabled=0,updated_at_ms=excluded.updated_at_ms`, uuid.NewString(), principalUUID, "totp-pending", principalUUID, encrypted, "{}", 0, now, now)
return err
})
if err != nil {
return "", err
}
return secret, nil
}
func totpCode(secret string, counter int64) (string, error) {
key, err := base32.StdEncoding.WithPadding(base32.NoPadding).DecodeString(strings.ToUpper(secret))
@@ -95,9 +103,9 @@ func verifyTOTPCode(secret, code string, last int64) (int64, bool) {
}
return 0, false
}
func (s *Store) confirmTOTP(principalUUID, kind, code string) (int64, error) {
func (s *Store) confirmTOTP(ctx context.Context, tx *sql.Tx, principalUUID, kind, code string) (int64, error) {
var encrypted, params string
err := s.DB.QueryRow(`SELECT secret_hash,parameters_json FROM auth_credentials WHERE principal_uuid=? AND kind=? AND identifier=?`, principalUUID, kind, principalUUID).Scan(&encrypted, &params)
err := tx.QueryRowContext(ctx, fmt.Sprintf(`SELECT secret_hash,parameters_json FROM auth_credentials WHERE principal_uuid=%s AND kind=%s AND identifier=%s AND (kind='totp-pending' OR enabled=1)`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3)), principalUUID, kind, principalUUID).Scan(&encrypted, &params)
if err != nil {
return 0, err
}
@@ -108,7 +116,9 @@ func (s *Store) confirmTOTP(principalUUID, kind, code string) (int64, error) {
var state struct {
LastCounter int64 `json:"last_counter"`
}
_ = json.Unmarshal([]byte(params), &state)
if json.Unmarshal([]byte(params), &state) != nil {
return 0, ErrAccessDenied
}
counter, ok := verifyTOTPCode(string(plain), code, state.LastCounter)
if !ok {
return 0, ErrAccessDenied
@@ -116,31 +126,37 @@ func (s *Store) confirmTOTP(principalUUID, kind, code string) (int64, error) {
return counter, nil
}
func (s *Store) ConfirmTOTPEnrollment(principalUUID, code string) error {
counter, err := s.confirmTOTP(principalUUID, "totp-pending", code)
if err != nil {
return err
}
params, _ := json.Marshal(map[string]int64{"last_counter": counter})
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
_, _ = tx.Exec(`DELETE FROM auth_credentials WHERE principal_uuid=? AND kind='totp'`, principalUUID)
_, err = tx.Exec(`UPDATE auth_credentials SET kind='totp',enabled=1,parameters_json=?,updated_at_ms=? WHERE principal_uuid=? AND kind='totp-pending'`, string(params), time.Now().UnixMilli(), principalUUID)
if err != nil {
return err
}
return tx.Commit()
return s.groupWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error {
counter, err := s.confirmTOTP(ctx, tx, principalUUID, "totp-pending", code)
if err != nil {
return err
}
params, _ := json.Marshal(map[string]int64{"last_counter": counter})
if _, err = tx.ExecContext(ctx, `DELETE FROM auth_credentials WHERE principal_uuid=`+s.sqlParam(1)+` AND kind='totp'`, principalUUID); err != nil {
return err
}
result, err := tx.ExecContext(ctx, fmt.Sprintf(`UPDATE auth_credentials SET kind='totp',enabled=1,parameters_json=%s,updated_at_ms=%s WHERE principal_uuid=%s AND kind='totp-pending'`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3)), string(params), time.Now().UnixMilli(), principalUUID)
if err != nil {
return err
}
n, err := result.RowsAffected()
if err != nil {
return err
}
if n != 1 {
return ErrAccessDenied
}
return nil
})
}
func (s *Store) HasTOTP(principalUUID string) bool {
var exists int
_ = s.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM auth_credentials WHERE principal_uuid=? AND kind='totp' AND enabled=1)`, principalUUID).Scan(&exists)
return exists != 0
var exists bool
_ = s.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM auth_credentials WHERE principal_uuid=`+s.sqlParam(1)+` AND kind='totp' AND enabled=1)`, principalUUID).Scan(&exists)
return exists
}
func (s *Store) PendingTOTPSecret(principalUUID string) string {
var encrypted string
if s.DB.QueryRow(`SELECT secret_hash FROM auth_credentials WHERE principal_uuid=? AND kind='totp-pending'`, principalUUID).Scan(&encrypted) != nil {
if s.DB.QueryRow(`SELECT secret_hash FROM auth_credentials WHERE principal_uuid=`+s.sqlParam(1)+` AND kind='totp-pending'`, principalUUID).Scan(&encrypted) != nil {
return ""
}
plain, err := s.decryptAuthSecret(encrypted)
@@ -150,24 +166,23 @@ func (s *Store) PendingTOTPSecret(principalUUID string) string {
return string(plain)
}
func (s *Store) VerifyTOTP(principalUUID, code string) error {
counter, err := s.confirmTOTP(principalUUID, "totp", code)
if err != nil {
return s.groupWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error {
// Validation and counter advancement share the same lock on both DBs.
// No JSON SQL dialect is needed, and enrollment cannot race verification.
counter, err := s.confirmTOTP(ctx, tx, principalUUID, "totp", code)
if err != nil {
return err
}
params, _ := json.Marshal(map[string]int64{"last_counter": counter})
_, err = tx.ExecContext(ctx, fmt.Sprintf(`UPDATE auth_credentials SET parameters_json=%s,updated_at_ms=%s WHERE principal_uuid=%s AND kind='totp' AND enabled=1`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3)), string(params), time.Now().UnixMilli(), principalUUID)
return err
}
params, _ := json.Marshal(map[string]int64{"last_counter": counter})
result, err := s.DB.Exec(`UPDATE auth_credentials SET parameters_json=?,updated_at_ms=? WHERE principal_uuid=? AND kind='totp' AND CAST(COALESCE(json_extract(parameters_json,'$.last_counter'),0) AS INTEGER)<?`, string(params), time.Now().UnixMilli(), principalUUID, counter)
if err != nil {
return err
}
changed, _ := result.RowsAffected()
if changed != 1 {
return ErrAccessDenied
}
return nil
})
}
func (s *Store) DisableTOTP(principalUUID string) error {
_, err := s.DB.Exec(`DELETE FROM auth_credentials WHERE principal_uuid=? AND kind IN ('totp','totp-pending')`, principalUUID)
return err
return s.groupWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error {
_, err := tx.ExecContext(ctx, `DELETE FROM auth_credentials WHERE principal_uuid=`+s.sqlParam(1)+` AND kind IN ('totp','totp-pending')`, principalUUID)
return err
})
}
func TOTPURI(secret, account, issuer string) string {
@@ -186,8 +201,11 @@ func (s *Store) CreateTOTPLoginChallengeForLogin(domainUUID, principalUUID strin
}
now := time.Now().UnixMilli()
payload, _ := json.Marshal(map[string]any{"principal_uuid": principalUUID, "remember": remember})
_, err = s.DB.Exec(`INSERT INTO auth_challenges(uuid,domain_uuid,principal_uuid,kind,token_hash,payload_json,expires_at_ms,created_at_ms) VALUES(?,?,?,?,?,?,?,?)`, uuid.NewString(), domainUUID, principalUUID, "totp-login", hash, string(payload), now+5*60*1000, now)
return token, err
_, err = s.DB.Exec(`INSERT INTO auth_challenges(uuid,domain_uuid,principal_uuid,kind,token_hash,payload_json,expires_at_ms,created_at_ms) VALUES(`+s.sqlValues(8)+`)`, uuid.NewString(), domainUUID, principalUUID, "totp-login", hash, string(payload), now+5*60*1000, now)
if err != nil {
return "", s.sqlError("TOTP login challenge", err)
}
return token, nil
}
func (s *Store) CompleteTOTPLoginChallenge(domainUUID, token, code string) (string, error) {
id, _, err := s.CompleteTOTPLoginChallengeForLogin(domainUUID, token, code)
@@ -200,7 +218,7 @@ func (s *Store) CompleteTOTPLoginChallengeForLogin(domainUUID, token, code strin
var challengeUUID, principalUUID, payload string
var expires int64
var attempts int
err := s.DB.QueryRow(`SELECT uuid,principal_uuid,expires_at_ms,attempt_count,payload_json FROM auth_challenges WHERE domain_uuid=? AND kind='totp-login' AND token_hash=? AND consumed_at_ms=0`, domainUUID, hash).Scan(&challengeUUID, &principalUUID, &expires, &attempts, &payload)
err := s.DB.QueryRow(fmt.Sprintf(`SELECT uuid,principal_uuid,expires_at_ms,attempt_count,payload_json FROM auth_challenges WHERE domain_uuid=%s AND kind='totp-login' AND token_hash=%s AND consumed_at_ms=0`, s.sqlParam(1), s.sqlParam(2)), domainUUID, hash).Scan(&challengeUUID, &principalUUID, &expires, &attempts, &payload)
if err != nil || expires < time.Now().UnixMilli() || attempts >= 5 {
return "", false, ErrAccessDenied
}
@@ -211,12 +229,12 @@ func (s *Store) CompleteTOTPLoginChallengeForLogin(domainUUID, token, code strin
return "", false, ErrAccessDenied
}
if err = s.VerifyTOTP(principalUUID, code); err != nil {
_, _ = s.DB.Exec(`UPDATE auth_challenges SET attempt_count=attempt_count+1,consumed_at_ms=CASE WHEN attempt_count+1>=5 THEN ? ELSE consumed_at_ms END WHERE uuid=? AND consumed_at_ms=0`, time.Now().UnixMilli(), challengeUUID)
_, _ = s.DB.Exec(fmt.Sprintf(`UPDATE auth_challenges SET attempt_count=attempt_count+1,consumed_at_ms=CASE WHEN attempt_count+1>=5 THEN %s ELSE consumed_at_ms END WHERE uuid=%s AND consumed_at_ms=0`, s.sqlParam(1), s.sqlParam(2)), time.Now().UnixMilli(), challengeUUID)
return "", false, err
}
result, err := s.DB.Exec(`UPDATE auth_challenges SET consumed_at_ms=? WHERE uuid=? AND consumed_at_ms=0`, time.Now().UnixMilli(), challengeUUID)
result, err := s.DB.Exec(fmt.Sprintf(`UPDATE auth_challenges SET consumed_at_ms=%s WHERE uuid=%s AND consumed_at_ms=0 AND attempt_count<5 AND expires_at_ms>%s`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3)), time.Now().UnixMilli(), challengeUUID, time.Now().UnixMilli())
if err != nil {
return "", false, err
return "", false, s.sqlError("TOTP challenge consumption", err)
}
changed, _ := result.RowsAffected()
if changed != 1 {
+40 -28
View File
@@ -7,7 +7,6 @@ import (
"encoding/hex"
"encoding/json"
"errors"
"strings"
"time"
)
@@ -37,7 +36,7 @@ type AutoPublicationChange struct {
ImpactToken string `json:"impact_token"`
}
func autoScope(ctx context.Context, tx *sql.Tx, domain, kind, id string) (string, error) {
func (s *Store) autoScope(ctx context.Context, tx *sql.Tx, domain, kind, id string) (string, error) {
if kind == "domain" {
if id != domain {
return "", ErrGovernanceInvalid
@@ -49,11 +48,11 @@ func autoScope(ctx context.Context, tx *sql.Tx, domain, kind, id string) (string
table = "spots"
}
var scope string
err := tx.QueryRowContext(ctx, `SELECT path_prefix FROM `+table+` WHERE domain_uuid=? AND uuid=? AND state!='archived'`, domain, id).Scan(&scope)
err := tx.QueryRowContext(ctx, `SELECT path_prefix FROM `+table+` WHERE domain_uuid=`+s.sqlParam(1)+` AND uuid=`+s.sqlParam(2)+` AND state!='archived'`, domain, id).Scan(&scope)
return scope, err
}
func autoRules(ctx context.Context, tx *sql.Tx, domain string) ([]autoPublicationRule, error) {
rows, err := tx.QueryContext(ctx, `SELECT node_kind,node_uuid,mode,scope_path,actor_uuid,version FROM locality_auto_publication WHERE domain_uuid=? ORDER BY node_kind,node_uuid LIMIT 129`, domain)
func (s *Store) autoRules(ctx context.Context, tx *sql.Tx, domain string) ([]autoPublicationRule, error) {
rows, err := tx.QueryContext(ctx, `SELECT node_kind,node_uuid,mode,scope_path,actor_uuid,version FROM locality_auto_publication WHERE domain_uuid=`+s.sqlParam(1)+` ORDER BY node_kind,node_uuid LIMIT 129`, domain)
if err != nil {
return nil, err
}
@@ -71,37 +70,45 @@ func autoRules(ctx context.Context, tx *sql.Tx, domain string) ([]autoPublicatio
}
return out, rows.Err()
}
func requireManualPublication(ctx context.Context, tx *sql.Tx, domain, actor, kind, id string) error {
scope, err := autoScope(ctx, tx, domain, kind, id)
func (s *Store) requireManualPublication(ctx context.Context, tx *sql.Tx, domain, actor, kind, id string) error {
scope, err := s.autoScope(ctx, tx, domain, kind, id)
if err != nil {
return err
}
_, err = tx.ExecContext(ctx, `INSERT INTO locality_auto_publication VALUES(?,?,?,'required',?,?,1) ON CONFLICT(domain_uuid,node_kind,node_uuid) DO UPDATE SET mode='required',scope_path=excluded.scope_path,actor_uuid=excluded.actor_uuid,version=version+1`, domain, kind, id, scope, actor)
_, err = tx.ExecContext(ctx, `INSERT INTO locality_auto_publication VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,'required',`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,1) ON CONFLICT(domain_uuid,node_kind,node_uuid) DO UPDATE SET mode='required',scope_path=excluded.scope_path,actor_uuid=excluded.actor_uuid,version=locality_auto_publication.version+1`, domain, kind, id, scope, actor)
return err
}
func (s *Store) AutoPublication(ctx context.Context, domain, actor, kind, id string, change *AutoPublicationChange) (AutoPublication, error) {
func (s *Store) AutoPublication(ctx context.Context, domain, actor, kind, id string, change *AutoPublicationChange) (_ AutoPublication, resultErr error) {
defer func() { resultErr = s.sqlError("AutoPublication", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
state := AutoPublication{Mode: "inherit"}
tx, err := s.DB.BeginTx(ctx, nil)
options := s.policyReadOptions()
if change != nil {
options = &sql.TxOptions{Isolation: sql.LevelReadCommitted}
}
tx, err := s.DB.BeginTx(ctx, options)
if err != nil {
return state, err
}
defer tx.Rollback()
if change != nil {
if _, err = tx.ExecContext(ctx, `INSERT INTO city_governance_epochs VALUES(?,0) ON CONFLICT(domain_uuid) DO UPDATE SET version=version`, domain); err != nil {
if err = s.lockPolicyWrite(ctx, tx); err != nil {
return state, err
}
if _, err = tx.ExecContext(ctx, `INSERT INTO city_governance_epochs VALUES(`+s.sqlParam(1)+`,0) ON CONFLICT(domain_uuid) DO UPDATE SET version=city_governance_epochs.version`, domain); err != nil {
return state, err
}
}
g, err := governanceSnapshot(ctx, tx, domain, actor, kind, id)
g, err := s.governanceSnapshot(ctx, tx, domain, actor, kind, id)
if err != nil {
return state, err
}
scope, err := autoScope(ctx, tx, domain, kind, id)
scope, err := s.autoScope(ctx, tx, domain, kind, id)
if err != nil {
return state, err
}
rules, err := autoRules(ctx, tx, domain)
rules, err := s.autoRules(ctx, tx, domain)
if err != nil {
return state, err
}
@@ -113,7 +120,7 @@ func (s *Store) AutoPublication(ctx context.Context, domain, actor, kind, id str
state.Mode, state.Version = rule.Mode, rule.Version
state.Active = rule.Mode == "automatic" && rule.Scope == scope
if state.Active && rule.Actor != actor {
_, e := governanceSnapshot(ctx, tx, domain, rule.Actor, kind, id)
_, e := s.governanceSnapshot(ctx, tx, domain, rule.Actor, kind, id)
if errors.Is(e, sql.ErrNoRows) || errors.Is(e, ErrAccessDenied) {
state.Active = false
} else if e != nil {
@@ -122,7 +129,7 @@ func (s *Store) AutoPublication(ctx context.Context, domain, actor, kind, id str
}
}
if rule.Mode == "required" && !(rule.Kind == kind && rule.ID == id) {
parent, e := autoScope(ctx, tx, domain, rule.Kind, rule.ID)
parent, e := s.autoScope(ctx, tx, domain, rule.Kind, rule.ID)
if e != nil && !errors.Is(e, sql.ErrNoRows) {
return state, e
}
@@ -139,7 +146,7 @@ func (s *Store) AutoPublication(ctx context.Context, domain, actor, kind, id str
return state, ErrGovernanceConflict
}
if change == nil || change.Mode != "required" {
state.Impact, err = publicationImpact(ctx, tx, domain, actor, kind, id, g)
state.Impact, err = s.publicationImpact(ctx, tx, domain, actor, kind, id, g)
if err != nil {
if change == nil && errors.Is(err, ErrPublicationImpact) {
state.CanAutomatic = false
@@ -184,7 +191,7 @@ func (s *Store) AutoPublication(ctx context.Context, domain, actor, kind, id str
if !change.Confirm || change.ImpactToken == "" || change.ImpactToken != state.Impact.ImpactToken {
return state, ErrPublicationImpact
}
if err = installPublicationGuards(ctx, tx); err != nil {
if err = s.installPublicationGuards(ctx, tx); err != nil {
return state, err
}
}
@@ -192,7 +199,7 @@ func (s *Store) AutoPublication(ctx context.Context, domain, actor, kind, id str
return state, ErrPublicationImpact
}
before, _ := json.Marshal(state)
_, err = tx.ExecContext(ctx, `INSERT INTO locality_auto_publication VALUES(?,?,?,?,?,?,1) ON CONFLICT(domain_uuid,node_kind,node_uuid) DO UPDATE SET mode=excluded.mode,scope_path=excluded.scope_path,actor_uuid=excluded.actor_uuid,version=version+1`, domain, kind, id, change.Mode, scope, actor)
_, err = tx.ExecContext(ctx, `INSERT INTO locality_auto_publication VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`,1) ON CONFLICT(domain_uuid,node_kind,node_uuid) DO UPDATE SET mode=excluded.mode,scope_path=excluded.scope_path,actor_uuid=excluded.actor_uuid,version=locality_auto_publication.version+1`, domain, kind, id, change.Mode, scope, actor)
if err != nil {
return state, err
}
@@ -201,7 +208,7 @@ func (s *Store) AutoPublication(ctx context.Context, domain, actor, kind, id str
state.Active = change.Mode == "automatic"
state.Impact.ImpactToken = ""
after, _ := json.Marshal(state)
_, err = tx.ExecContext(ctx, `INSERT INTO city_governance_events(domain_uuid,epoch,actor_uuid,node_kind,node_uuid,before_json,after_json,created_at_ms) VALUES(?,?,?,?,?,?,?,?)`, domain, g.Epoch, actor, kind, id, string(before), string(after), time.Now().UnixMilli())
_, err = tx.ExecContext(ctx, `INSERT INTO city_governance_events(domain_uuid,epoch,actor_uuid,node_kind,node_uuid,before_json,after_json,created_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)+`)`, domain, g.Epoch, actor, kind, id, string(before), string(after), time.Now().UnixMilli())
if err != nil {
return state, err
}
@@ -211,26 +218,31 @@ func (s *Store) AutoPublication(ctx context.Context, domain, actor, kind, id str
// Evaluate live heads, audience, publisher authority and literal Path boundaries
// in one read transaction. No request mutates approval manifests or source content.
func (s *Store) automaticPublicPages(ctx context.Context, domain, onlyPath string) ([]PublishedNavigationPage, error) {
tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
tx, err := s.DB.BeginTx(ctx, s.policyReadOptions())
if err != nil {
return nil, err
}
defer tx.Rollback()
return s.automaticPublicPagesTx(ctx, tx, domain, onlyPath)
}
func (s *Store) automaticPublicPagesTx(ctx context.Context, tx *sql.Tx, domain, onlyPath string) ([]PublishedNavigationPage, error) {
var err error
var live bool
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM domains d JOIN campuses c ON c.uuid=d.campus_uuid JOIN config cfg ON cfg.domain_uuid=d.uuid AND cfg.key='authorization_mode' AND cfg.value='enforcing' WHERE d.uuid=? AND d.enabled=1 AND c.enabled=1)`, domain).Scan(&live); err != nil {
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM domains d JOIN campuses c ON c.uuid=d.campus_uuid JOIN config cfg ON cfg.domain_uuid=d.uuid AND cfg.key='authorization_mode' AND cfg.value='enforcing' WHERE d.uuid=`+s.sqlParam(1)+` AND d.enabled=1 AND c.enabled=1)`, domain).Scan(&live); err != nil {
return nil, err
}
if !live {
return nil, nil
}
rules, err := autoRules(ctx, tx, domain)
rules, err := s.autoRules(ctx, tx, domain)
if err != nil {
return nil, err
}
blocked := []string{}
for _, rule := range rules {
if rule.Mode == "required" {
scope, e := autoScope(ctx, tx, domain, rule.Kind, rule.ID)
scope, e := s.autoScope(ctx, tx, domain, rule.Kind, rule.ID)
if errors.Is(e, sql.ErrNoRows) {
continue
}
@@ -259,21 +271,21 @@ func (s *Store) automaticPublicPages(ctx context.Context, domain, onlyPath strin
if onlyPath != "" && !autoContains(rule.Scope, onlyPath) {
continue
}
g, e := governanceSnapshot(ctx, tx, domain, rule.Actor, rule.Kind, rule.ID)
g, e := s.governanceSnapshot(ctx, tx, domain, rule.Actor, rule.Kind, rule.ID)
if errors.Is(e, sql.ErrNoRows) || errors.Is(e, ErrAccessDenied) || errors.Is(e, ErrGovernanceInvalid) {
continue
}
if e != nil {
return nil, e
}
current, e := autoScope(ctx, tx, domain, rule.Kind, rule.ID)
current, e := s.autoScope(ctx, tx, domain, rule.Kind, rule.ID)
if e != nil {
return nil, e
}
if current != rule.Scope || !g.DraftEffectivePublic || deny(current) {
continue
}
p, e := publicationImpactBounded(ctx, tx, domain, rule.Actor, rule.Kind, rule.ID, g, MaxNavigationEntries, onlyPath)
p, e := s.publicationImpactBounded(ctx, tx, domain, rule.Actor, rule.Kind, rule.ID, g, MaxNavigationEntries, onlyPath)
if errors.Is(e, ErrAccessDenied) {
continue
}
@@ -296,7 +308,7 @@ func (s *Store) automaticPublicPages(ctx context.Context, domain, onlyPath strin
for id := range entries {
args = append(args, id)
}
rows, err := tx.QueryContext(ctx, `SELECT uuid,object_uuid,document_hash,COALESCE(NULLIF(lang,''),'und'),COALESCE(NULLIF(content_type,''),'text/html; charset=utf-8'),COALESCE(filename,''),created_at_ms FROM revisions WHERE uuid IN (`+strings.TrimSuffix(strings.Repeat("?,", len(args)), ",")+`) ORDER BY created_at_ms DESC,uuid`, args...)
rows, err := tx.QueryContext(ctx, `SELECT uuid,object_uuid,document_hash,COALESCE(NULLIF(lang,''),'und'),COALESCE(NULLIF(content_type,''),'text/html; charset=utf-8'),COALESCE(filename,''),created_at_ms FROM revisions WHERE uuid IN (`+s.sqlValues(len(args))+`) ORDER BY created_at_ms DESC,uuid`, args...)
if err != nil {
return nil, err
}
+54 -14
View File
@@ -2,6 +2,7 @@ package store
import (
"context"
"database/sql"
"strings"
"time"
@@ -30,11 +31,14 @@ func scanBroadcast(scanner interface{ Scan(...any) error }, b *Broadcast) error
return scanner.Scan(&b.UUID, &b.DomainUUID, &b.Title, &b.Body, &b.Severity, &b.StartsAtMS, &b.EndsAtMS, &b.CreatedAtMS, &b.UpdatedAtMS)
}
func (s *Store) ListActiveBroadcasts(ctx context.Context, domain string, nowMS int64) ([]Broadcast, error) {
func (s *Store) ListActiveBroadcasts(ctx context.Context, domain string, nowMS int64) (_ []Broadcast, resultErr error) {
defer func() { resultErr = s.sqlError("active broadcasts", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
if nowMS == 0 {
nowMS = time.Now().UnixMilli()
}
rows, err := s.DB.QueryContext(ctx, `SELECT `+broadcastColumns+` FROM broadcasts WHERE domain_uuid=? AND (starts_at_ms=0 OR starts_at_ms<=?) AND (ends_at_ms=0 OR ends_at_ms>?) ORDER BY severity DESC,updated_at_ms DESC LIMIT 20`, domain, nowMS, nowMS)
rows, err := s.DB.QueryContext(ctx, `SELECT `+broadcastColumns+` FROM broadcasts WHERE domain_uuid=`+s.sqlParam(1)+` AND (starts_at_ms=0 OR starts_at_ms<=`+s.sqlParam(2)+`) AND (ends_at_ms=0 OR ends_at_ms>`+s.sqlParam(3)+`) ORDER BY severity DESC,updated_at_ms DESC LIMIT 20`, domain, nowMS, nowMS)
if err != nil {
return nil, err
}
@@ -49,8 +53,11 @@ func (s *Store) ListActiveBroadcasts(ctx context.Context, domain string, nowMS i
}
return out, rows.Err()
}
func (s *Store) ListBroadcasts(ctx context.Context, domain string) ([]Broadcast, error) {
rows, err := s.DB.QueryContext(ctx, `SELECT `+broadcastColumns+` FROM broadcasts WHERE domain_uuid=? ORDER BY updated_at_ms DESC LIMIT 100`, domain)
func (s *Store) ListBroadcasts(ctx context.Context, domain string) (_ []Broadcast, resultErr error) {
defer func() { resultErr = s.sqlError("broadcast listing", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
rows, err := s.DB.QueryContext(ctx, `SELECT `+broadcastColumns+` FROM broadcasts WHERE domain_uuid=`+s.sqlParam(1)+` ORDER BY updated_at_ms DESC LIMIT 100`, domain)
if err != nil {
return nil, err
}
@@ -65,7 +72,11 @@ func (s *Store) ListBroadcasts(ctx context.Context, domain string) ([]Broadcast,
}
return out, rows.Err()
}
func (s *Store) SaveBroadcast(b Broadcast) error {
func (s *Store) SaveBroadcast(b Broadcast) (resultErr error) {
defer func() { resultErr = s.sqlError("broadcast save", resultErr) }()
if s.ReadOnly {
return ErrReadOnly
}
b.DomainUUID = strings.TrimSpace(b.DomainUUID)
b.Title = strings.TrimSpace(b.Title)
b.Body = strings.TrimSpace(b.Body)
@@ -80,26 +91,55 @@ func (s *Store) SaveBroadcast(b Broadcast) error {
b.CreatedAtMS = now
}
b.UpdatedAtMS = now
_, err := s.DB.Exec(`INSERT INTO broadcasts(`+broadcastColumns+`) VALUES(?,?,?,?,?,?,?,?,?) ON CONFLICT(uuid) DO UPDATE SET title=excluded.title,body=excluded.body,severity=excluded.severity,starts_at_ms=excluded.starts_at_ms,ends_at_ms=excluded.ends_at_ms,updated_at_ms=excluded.updated_at_ms`, b.UUID, b.DomainUUID, b.Title, b.Body, b.Severity, b.StartsAtMS, b.EndsAtMS, b.CreatedAtMS, b.UpdatedAtMS)
return err
}
func (s *Store) DeleteBroadcast(domain, id string) error {
tx, err := s.DB.Begin()
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
if _, err = tx.Exec(`DELETE FROM notification_inbox WHERE domain_uuid=? AND event_uuid=? AND kind='broadcast'`, domain, id); err != nil {
if err = s.lockTaskWriter(ctx, tx); err != nil {
return err
}
if _, err = tx.Exec(`DELETE FROM broadcasts WHERE domain_uuid=? AND uuid=?`, domain, id); err != nil {
result, err := tx.ExecContext(ctx, `INSERT INTO broadcasts(`+broadcastColumns+`) VALUES(`+s.sqlValues(9)+`) ON CONFLICT(uuid) DO UPDATE SET title=excluded.title,body=excluded.body,severity=excluded.severity,starts_at_ms=excluded.starts_at_ms,ends_at_ms=excluded.ends_at_ms,updated_at_ms=excluded.updated_at_ms WHERE broadcasts.domain_uuid=excluded.domain_uuid`, b.UUID, b.DomainUUID, b.Title, b.Body, b.Severity, b.StartsAtMS, b.EndsAtMS, b.CreatedAtMS, b.UpdatedAtMS)
if err != nil {
return err
}
n, err := result.RowsAffected()
if err != nil {
return err
}
if n != 1 {
return sql.ErrNoRows
}
return tx.Commit()
}
func (s *Store) DeleteBroadcast(domain, id string) (resultErr error) {
defer func() { resultErr = s.sqlError("broadcast deletion", resultErr) }()
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
if err = s.lockTaskWriter(ctx, tx); err != nil {
return err
}
if _, err = tx.Exec(`DELETE FROM notification_inbox WHERE domain_uuid=`+s.sqlParam(1)+` AND event_uuid=`+s.sqlParam(2)+` AND kind='broadcast'`, domain, id); err != nil {
return err
}
if _, err = tx.Exec(`DELETE FROM broadcasts WHERE domain_uuid=`+s.sqlParam(1)+` AND uuid=`+s.sqlParam(2)+``, domain, id); err != nil {
return err
}
return tx.Commit()
}
func (s *Store) GetBroadcast(ctx context.Context, domain, id string) (Broadcast, error) {
func (s *Store) GetBroadcast(ctx context.Context, domain, id string) (_ Broadcast, resultErr error) {
defer func() { resultErr = s.sqlError("broadcast lookup", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
var b Broadcast
err := scanBroadcast(s.DB.QueryRowContext(ctx, `SELECT `+broadcastColumns+` FROM broadcasts WHERE domain_uuid=? AND uuid=?`, domain, id), &b)
err := scanBroadcast(s.DB.QueryRowContext(ctx, `SELECT `+broadcastColumns+` FROM broadcasts WHERE domain_uuid=`+s.sqlParam(1)+` AND uuid=`+s.sqlParam(2)+``, domain, id), &b)
return b, err
}
+61 -14
View File
@@ -1,11 +1,37 @@
package store
import (
"context"
"strings"
"pageswiki/internal/mestionora"
)
func (s *Store) fillNativeBrowserTitles(entries []BrowserEntry) error {
if s.sqlBackend != storePostgreSQL {
return nil
}
ctx, cancel := context.WithTimeout(context.Background(), cityReadTimeout)
defer cancel()
budget := int64(32 << 20)
for i := range entries {
e := &entries[i]
if e.IsDir || e.DocumentHash == "" || !strings.HasPrefix(strings.ToLower(e.ContentType), "text/html") {
continue
}
if budget < 65536 {
return ErrNavigationBudget
}
window, err := s.ReadDocumentWindowContext(ctx, e.DocumentHash, 0, 65536)
if err != nil {
return err
}
budget -= int64(len(window.Data))
e.Title = firstHTMLHeading(string(window.Data))
}
return nil
}
type BrowserEntry struct {
Name string
Path string
@@ -46,34 +72,43 @@ func (s *Store) ListBrowserEntries(parent string) ([]BrowserEntry, error) {
}
func (s *Store) ListBrowserEntriesInDomain(domainUUID, parent string) ([]BrowserEntry, error) {
ctx, cancel := context.WithTimeout(context.Background(), cityReadTimeout)
defer cancel()
parent = normalizeBrowserPath(parent)
prefix := strings.TrimRight(parent, "/") + "/"
// Collapse descendants before consulting revisions. A folder listing must
// not rank every revision of every document in the subtree. Binary ranges
// keep prefix matching literal (including %, _) and use the Path index.
rows, err := s.DB.Query(`
pos := s.sqlStringPosition("name", "/")
byteSize := "length(CAST(r.body AS BLOB))"
tie := "rowid"
if s.sqlBackend == storePostgreSQL {
byteSize = "octet_length(r.body)"
tie = "uuid"
}
rows, err := s.DB.QueryContext(ctx, `
WITH relative AS (
SELECT substr(path, length(?) + 1) AS name, object_uuid
FROM paths WHERE domain_uuid=? AND path >= ? AND path < ? AND path != ?
SELECT substr(path, length(`+s.sqlParam(1)+`) + 1) AS name, object_uuid
FROM paths WHERE domain_uuid=`+s.sqlParam(2)+` AND path >= `+s.sqlParam(3)+` AND path < `+s.sqlParam(4)+` AND path != `+s.sqlParam(5)+`
), children AS (
SELECT CASE WHEN instr(name,'/')=0 THEN name ELSE substr(name,1,instr(name,'/')-1) END AS name,
MAX(CASE WHEN instr(name,'/')=0 THEN object_uuid ELSE '' END) AS object_uuid,
MAX(instr(name,'/')>0) AS is_dir,
SUM(instr(name,'/')>0) AS child_count
SELECT CASE WHEN `+pos+`=0 THEN name ELSE substr(name,1,`+pos+`-1) END AS name,
MAX(CASE WHEN `+pos+`=0 THEN object_uuid ELSE '' END) AS object_uuid,
MAX(CASE WHEN `+pos+`>0 THEN 1 ELSE 0 END) AS is_dir,
SUM(CASE WHEN `+pos+`>0 THEN 1 ELSE 0 END) AS child_count
FROM relative WHERE name != '' GROUP BY 1
)
SELECT c.name,c.object_uuid,c.is_dir,c.child_count,
COALESCE(length(CAST(r.body AS BLOB)),0),COALESCE(r.created_at,0),
COALESCE(`+byteSize+`,0),COALESCE(r.created_at,0),
COALESCE(r.content_type,''),COALESCE(r.filename,''),
COALESCE(r.document_hash,''),COALESCE(r.uuid,''),
COALESCE(substr(CAST(r.body AS TEXT),1,65536),'')
FROM children c LEFT JOIN revisions r ON r.rowid=(
SELECT head.rowid FROM revisions head
FROM children c LEFT JOIN revisions r ON r.`+tie+`=(
SELECT head.`+tie+` FROM revisions head
WHERE c.is_dir=0 AND head.object_uuid=c.object_uuid
ORDER BY head.created_at_ms DESC, head.rowid DESC LIMIT 1
ORDER BY head.created_at_ms DESC, head.`+tie+` DESC LIMIT 1
)
ORDER BY c.is_dir DESC,c.name ASC
`, prefix, domainUUID, prefix, strings.TrimSuffix(prefix, "/")+"0", parent)
ORDER BY c.is_dir DESC,c.name ASC LIMIT `+s.sqlParam(6)+`
`, prefix, domainUUID, prefix, strings.TrimSuffix(prefix, "/")+"0", parent, MaxNavigationEntries+1)
if err != nil {
return nil, err
}
@@ -95,6 +130,18 @@ func (s *Store) ListBrowserEntriesInDomain(domainUUID, parent string) ([]Browser
}
}
out = append(out, entry)
if len(out) > MaxNavigationEntries {
return nil, ErrNavigationBudget
}
}
return out, rows.Err()
if err := rows.Err(); err != nil {
return nil, err
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := s.fillNativeBrowserTitles(out); err != nil {
return nil, err
}
return out, nil
}
+37 -15
View File
@@ -1,11 +1,14 @@
package store
import (
"context"
"database/sql"
"errors"
"strings"
"time"
"pageswiki/internal/db"
"github.com/google/uuid"
)
@@ -23,13 +26,18 @@ type BrowserNavigationLink struct {
}
func (s *Store) EnsureBrowserNavigationSchema() error {
if s.sqlBackend == storePostgreSQL {
return db.ApplyPostgreSQLMigrations(context.Background(), s.DB, "store-browser-navigation", []db.PostgreSQLMigration{{Version: 1, Name: "browser navigator links", Statements: []string{
`CREATE TABLE browser_navigation_links(uuid TEXT COLLATE "C" PRIMARY KEY,domain_uuid TEXT COLLATE "C" NOT NULL,principal_uuid TEXT COLLATE "C" NOT NULL,label TEXT NOT NULL,path TEXT COLLATE "C" NOT NULL,is_directory INTEGER NOT NULL DEFAULT 0,position BIGINT NOT NULL DEFAULT 0,created_at_ms BIGINT NOT NULL,updated_at_ms BIGINT NOT NULL,UNIQUE(domain_uuid,principal_uuid,path))`,
}, Assertions: []string{`SELECT uuid,domain_uuid,principal_uuid,label,path,is_directory,position,created_at_ms,updated_at_ms FROM browser_navigation_links WHERE 1=0`}}})
}
return s.ensureSchemaComponent("browser-navigation")
}
func (s *Store) ListBrowserNavigationLinks(domainUUID, principalUUID string) ([]BrowserNavigationLink, error) {
rows, err := s.DB.Query(`SELECT uuid,label,path,is_directory,position,updated_at_ms
FROM browser_navigation_links
WHERE domain_uuid=? AND principal_uuid=?
WHERE domain_uuid=`+s.sqlParam(1)+` AND principal_uuid=`+s.sqlParam(2)+`
ORDER BY position,created_at_ms,uuid`, domainUUID, principalUUID)
if err != nil {
return nil, err
@@ -52,7 +60,8 @@ func (s *Store) AddBrowserNavigationLink(domainUUID, principalUUID, label, path
if domainUUID == "" || principalUUID == "" || label == "" || len(label) > 120 || path == "/" || len(path) > 2048 {
return nil, errors.New("invalid browser navigator link")
}
tx, err := s.DB.Begin()
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
if err != nil {
return nil, err
}
@@ -60,7 +69,7 @@ func (s *Store) AddBrowserNavigationLink(domainUUID, principalUUID, label, path
var link BrowserNavigationLink
err = tx.QueryRow(`SELECT uuid,label,path,is_directory,position,updated_at_ms
FROM browser_navigation_links
WHERE domain_uuid=? AND principal_uuid=? AND path=?`, domainUUID, principalUUID, path).
WHERE domain_uuid=`+s.sqlParam(1)+` AND principal_uuid=`+s.sqlParam(2)+` AND path=`+s.sqlParam(3), domainUUID, principalUUID, path).
Scan(&link.UUID, &link.Label, &link.Path, &link.IsDir, &link.Position, &link.UpdatedAt)
if err == nil {
return &link, nil
@@ -70,7 +79,7 @@ func (s *Store) AddBrowserNavigationLink(domainUUID, principalUUID, label, path
}
var count, position int
if err := tx.QueryRow(`SELECT COUNT(*),COALESCE(MAX(position),-1)+1
FROM browser_navigation_links WHERE domain_uuid=? AND principal_uuid=?`, domainUUID, principalUUID).
FROM browser_navigation_links WHERE domain_uuid=`+s.sqlParam(1)+` AND principal_uuid=`+s.sqlParam(2), domainUUID, principalUUID).
Scan(&count, &position); err != nil {
return nil, err
}
@@ -81,7 +90,7 @@ func (s *Store) AddBrowserNavigationLink(domainUUID, principalUUID, label, path
link = BrowserNavigationLink{UUID: uuid.NewString(), Label: label, Path: path, IsDir: isDir, Position: position, UpdatedAt: now}
if _, err := tx.Exec(`INSERT INTO browser_navigation_links
(uuid,domain_uuid,principal_uuid,label,path,is_directory,position,created_at_ms,updated_at_ms)
VALUES(?,?,?,?,?,?,?,?,?)`, link.UUID, domainUUID, principalUUID, link.Label, link.Path, link.IsDir, link.Position, now, now); err != nil {
VALUES(`+s.sqlValues(9)+`)`, link.UUID, domainUUID, principalUUID, link.Label, link.Path, boolToInt(link.IsDir), link.Position, now, now); err != nil {
return nil, err
}
if err := tx.Commit(); err != nil {
@@ -95,8 +104,11 @@ func (s *Store) RenameBrowserNavigationLink(domainUUID, principalUUID, id, label
if label == "" || len(label) > 120 {
return errors.New("invalid browser navigator label")
}
result, err := s.DB.Exec(`UPDATE browser_navigation_links SET label=?,updated_at_ms=?
WHERE uuid=? AND domain_uuid=? AND principal_uuid=?`, label, time.Now().UnixMilli(), id, domainUUID, principalUUID)
if s.ReadOnly {
return ErrReadOnly
}
result, err := s.DB.Exec(`UPDATE browser_navigation_links SET label=`+s.sqlParam(1)+`,updated_at_ms=`+s.sqlParam(2)+`
WHERE uuid=`+s.sqlParam(3)+` AND domain_uuid=`+s.sqlParam(4)+` AND principal_uuid=`+s.sqlParam(5), label, time.Now().UnixMilli(), id, domainUUID, principalUUID)
if err != nil {
return err
}
@@ -108,8 +120,11 @@ func (s *Store) RenameBrowserNavigationLink(domainUUID, principalUUID, id, label
}
func (s *Store) DeleteBrowserNavigationLink(domainUUID, principalUUID, id string) error {
if s.ReadOnly {
return ErrReadOnly
}
result, err := s.DB.Exec(`DELETE FROM browser_navigation_links
WHERE uuid=? AND domain_uuid=? AND principal_uuid=?`, id, domainUUID, principalUUID)
WHERE uuid=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+` AND principal_uuid=`+s.sqlParam(3), id, domainUUID, principalUUID)
if err != nil {
return err
}
@@ -123,19 +138,26 @@ func (s *Store) DeleteBrowserNavigationLink(domainUUID, principalUUID, id string
// renameBrowserNavigationPathsTx keeps a user's saved navigator targets aligned
// with semantic Path mutations. If the destination was already saved, the
// existing destination link wins and the now-duplicate source link is removed.
func renameBrowserNavigationPathsTx(tx *sql.Tx, domainUUID, oldPath, newPath string, recursive bool) error {
func (s *Store) renameBrowserNavigationPathsTx(tx *sql.Tx, domainUUID, oldPath, newPath string, recursive bool) error {
var tableExists bool
if err := tx.QueryRow(`SELECT EXISTS(
existsSQL := `SELECT EXISTS(
SELECT 1 FROM sqlite_master WHERE type='table' AND name='browser_navigation_links'
)`).Scan(&tableExists); err != nil {
)`
if s.sqlBackend == storePostgreSQL {
existsSQL = `SELECT to_regclass('browser_navigation_links') IS NOT NULL`
}
if err := tx.QueryRow(existsSQL).Scan(&tableExists); err != nil {
return err
}
if !tableExists {
if s.sqlBackend == storePostgreSQL {
return ErrPostgreSQLComponentNotReady
}
return nil
}
rows, err := tx.Query(`SELECT uuid,principal_uuid,path
FROM browser_navigation_links
WHERE domain_uuid=? AND (path=? OR (? AND path>=? AND path<?))
WHERE domain_uuid=`+s.sqlParam(1)+` AND (path=`+s.sqlParam(2)+` OR (`+s.sqlParam(3)+` AND path>=`+s.sqlParam(4)+` AND path<`+s.sqlParam(5)+`))
ORDER BY length(path),path`, domainUUID, oldPath, recursive, oldPath+"/", oldPath+"0")
if err != nil {
return err
@@ -162,9 +184,9 @@ func renameBrowserNavigationPathsTx(tx *sql.Tx, domainUUID, oldPath, newPath str
for _, item := range targets {
var existing string
err := tx.QueryRow(`SELECT uuid FROM browser_navigation_links
WHERE domain_uuid=? AND principal_uuid=? AND path=?`, domainUUID, item.principal, item.next).Scan(&existing)
WHERE domain_uuid=`+s.sqlParam(1)+` AND principal_uuid=`+s.sqlParam(2)+` AND path=`+s.sqlParam(3), domainUUID, item.principal, item.next).Scan(&existing)
if err == nil && existing != item.id {
if _, err := tx.Exec(`DELETE FROM browser_navigation_links WHERE uuid=?`, item.id); err != nil {
if _, err := tx.Exec(`DELETE FROM browser_navigation_links WHERE uuid=`+s.sqlParam(1), item.id); err != nil {
return err
}
continue
@@ -172,7 +194,7 @@ func renameBrowserNavigationPathsTx(tx *sql.Tx, domainUUID, oldPath, newPath str
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return err
}
if _, err := tx.Exec(`UPDATE browser_navigation_links SET path=?,updated_at_ms=? WHERE uuid=?`, item.next, now, item.id); err != nil {
if _, err := tx.Exec(`UPDATE browser_navigation_links SET path=`+s.sqlParam(1)+`,updated_at_ms=`+s.sqlParam(2)+` WHERE uuid=`+s.sqlParam(3), item.next, now, item.id); err != nil {
return err
}
}
+36
View File
@@ -0,0 +1,36 @@
package store
import (
"context"
"path/filepath"
"time"
"pageswiki/internal/calendar"
)
// NewCalendarRepository selects the explicit index backend. Calendar files
// remain canonical; this does not enable native application bootstrap or HA.
func (s *Store) NewCalendarRepository(ctx context.Context) (*calendar.Repository, error) {
if s.DocumentRoot == "" {
return nil, ErrDocumentStoreRequired
}
root := filepath.Join(s.DocumentRoot, "calendars")
var r *calendar.Repository
var err error
if s.sqlBackend == storePostgreSQL {
r, err = calendar.NewPostgreSQL(ctx, root, s.DB)
} else {
r, err = calendar.New(root, s.DB)
}
if err != nil {
return nil, err
}
r.PublicAllowed = func(domain string) bool {
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
var allowed bool
err := s.DB.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM locality_publication_policies p JOIN domains d ON d.uuid=p.domain_uuid AND d.enabled=1 JOIN campuses campus ON campus.uuid=d.campus_uuid AND campus.enabled=1 JOIN config c ON c.domain_uuid=p.domain_uuid AND c.key='authorization_mode' AND c.value='enforcing' WHERE p.domain_uuid=`+s.sqlParam(1)+` AND p.node_kind='domain' AND p.node_uuid=p.domain_uuid AND p.policy='public')`, domain).Scan(&allowed)
return err == nil && allowed
}
return r, nil
}
+316
View File
@@ -0,0 +1,316 @@
package store
import (
"context"
"encoding/json"
"errors"
"fmt"
"os"
"path/filepath"
"strings"
"testing"
"time"
"github.com/google/uuid"
"pageswiki/internal/calendar"
)
func calendarEvent(t *testing.T, uid string, start time.Time) calendar.Event {
t.Helper()
e, err := calendar.Build("", calendar.Event{UID: uid, Summary: "日本語の予定", Start: start, End: start.Add(time.Hour)})
if err != nil {
t.Fatal(err)
}
return e
}
func TestCalendarBackendContract(t *testing.T) {
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(b), func(t *testing.T) {
s, d, a := productivityBackendFixture(t, b)
ctx := context.Background()
r, err := s.NewCalendarRepository(ctx)
if err != nil {
t.Fatal(err)
}
peer, err := s.NewCalendarRepository(ctx)
if err != nil {
t.Fatal("schema replay", err)
}
c, err := r.Create(ctx, d, a, "予定", "予定表")
if err != nil {
t.Fatal(err)
}
if _, err = r.Create(ctx, d, a, "duplicate", "予定表"); !errors.Is(err, calendar.ErrNameTaken) {
t.Fatal(err)
}
if err = r.SaveDefaults(ctx, d, a, []string{c.ID}); err != nil {
t.Fatal(err)
}
if ids, err := peer.Defaults(d, a); err != nil || len(ids) != 1 || ids[0] != c.ID {
t.Fatal(ids, err)
}
start := time.Date(2026, 11, 30, 12, 0, 0, 0, time.UTC)
e := calendarEvent(t, "test@example.invalid", start)
saved, created, err := r.ChangeDAV(ctx, d, c.ID, a, "client.ics", "*", &e, nil)
if err != nil || !created {
t.Fatal(saved, created, err)
}
if _, _, err = r.ChangeDAV(ctx, d, c.ID, a, "alias.ics", "*", &e, nil); !errors.Is(err, calendar.ErrConflict) {
t.Fatal(err)
}
meta, items, err := peer.DAVSnapshot(ctx, d, c.ID, a, false)
if err != nil || len(items) != 1 || items[0].Data != "" || calendar.DAVFilename(meta, e.UID) != "client.ics" {
t.Fatal(meta, items, err)
}
if tags, err := r.QueryETags(ctx, d, c.ID, a, start.Add(-time.Hour), start.Add(2*time.Hour)); err != nil || len(tags) != 1 || tags[0].ETag != saved.ETag {
t.Fatal(tags, err)
}
if upcoming, err := r.Upcoming(ctx, d, c.ID, a, start, start.Add(2*time.Hour)); err != nil || len(upcoming) != 1 || upcoming[0].Summary != e.Summary {
t.Fatal(upcoming, err)
}
if _, err = r.Event(ctx, d, c.ID, uuid.NewString(), e.UID); !errors.Is(err, calendar.ErrMissing) {
t.Fatal("private read", err)
}
if _, err = r.Event(ctx, uuid.NewString(), c.ID, a, e.UID); !errors.Is(err, calendar.ErrMissing) {
t.Fatal("domain isolation", err)
}
moved := calendarEvent(t, e.UID, start.Add(48*time.Hour))
if _, _, err = peer.ChangeDAV(ctx, d, c.ID, a, "client.ics", saved.ETag, &moved, nil); err != nil {
t.Fatal(err)
}
if _, _, err = r.ChangeDAV(ctx, d, c.ID, a, "client.ics", saved.ETag, &e, nil); !errors.Is(err, calendar.ErrConflict) {
t.Fatal("stale ETag", err)
}
for _, table := range []string{"calendar_event_cache", "calendar_month_cache", "calendar_index_state"} {
if _, err = s.DB.Exec(`DELETE FROM ` + table); err != nil {
t.Fatal(err)
}
}
got, err := r.Event(ctx, d, c.ID, a, e.UID)
if err != nil || !got.Start.Equal(moved.Start) {
t.Fatal("rebuild", got, err)
}
meta, err = r.Get(d, c.ID, a)
if err != nil || len(meta.Months) != 1 || meta.Months["2026-12"] == "" {
t.Fatal(meta, err)
}
meta, err = r.Settings(ctx, d, c.ID, a, meta.Version, "renamed", false, nil, "new-name")
if err != nil {
t.Fatal(err)
}
if _, items, err = peer.DAVSnapshot(ctx, d, c.ID, a, true); err != nil || len(items) != 1 || items[0].Data == "" {
t.Fatal(items, err)
}
reader := uuid.NewString()
meta, err = r.Settings(ctx, d, c.ID, a, meta.Version, meta.Name, false, map[string]string{reader: "read"})
if err != nil {
t.Fatal(err)
}
if _, err = r.Event(ctx, d, c.ID, reader, e.UID); err != nil {
t.Fatal(err)
}
if _, err = r.Change(ctx, d, c.ID, reader, e.UID, moved.ETag, nil); !errors.Is(err, calendar.ErrForbidden) {
t.Fatal("read collaborator wrote", err)
}
if _, err = r.Settings(ctx, d, c.ID, reader, meta.Version, "hijack", false, nil); !errors.Is(err, calendar.ErrForbidden) {
t.Fatal(err)
}
meta, err = r.Settings(ctx, d, c.ID, a, meta.Version, meta.Name, false, nil)
if err != nil {
t.Fatal(err)
}
if _, err = peer.Event(ctx, d, c.ID, reader, e.UID); !errors.Is(err, calendar.ErrMissing) {
t.Fatal("revoked member", err)
}
if err = r.Delete(ctx, d, c.ID, a, "stale"); !errors.Is(err, calendar.ErrConflict) {
t.Fatal(err)
}
if err = r.Delete(ctx, d, c.ID, a, meta.Version); err != nil {
t.Fatal(err)
}
if _, err = peer.Get(d, c.ID, a); !errors.Is(err, calendar.ErrMissing) {
t.Fatal(err)
}
if ids, err := r.Defaults(d, a); err != nil || len(ids) != 0 {
t.Fatal(ids, err)
}
var n int
if err = s.DB.QueryRow(`SELECT count(*) FROM calendar_event_cache`).Scan(&n); err != nil || n != 0 {
t.Fatal(n, err)
}
})
}
}
func TestCalendarTaskBlockBackend(t *testing.T) {
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(b), func(t *testing.T) {
s, d, a := productivityBackendFixture(t, b)
ctx := context.Background()
r, err := s.NewCalendarRepository(ctx)
if err != nil {
t.Fatal(err)
}
c, err := r.Create(ctx, d, a, "Personal")
if err != nil {
t.Fatal(err)
}
task, err := s.SaveTask(ctx, d, a, TaskRecord{UUID: uuid.NewString(), Kind: "task", Title: "作業", Status: "todo", Bucket: "inbox"}, 0)
if err != nil {
t.Fatal(err)
}
start := time.Date(2026, 11, 15, 9, 0, 0, 0, time.UTC)
block, err := s.ReserveTaskBlock(ctx, d, a, TaskBlock{UUID: uuid.NewString(), TaskUUID: task.UUID, CalendarUUID: c.ID, Start: start, End: start.Add(time.Hour)}, task.Version)
if err != nil {
t.Fatal(err)
}
e := calendarEvent(t, block.EventUID, start)
_, event, err := r.TaskBlock(ctx, d, c.ID, a, block.EventUID, &e)
if err != nil {
t.Fatal(err)
}
if err = s.SetTaskBlockState(ctx, d, a, block.UUID, "active"); err != nil {
t.Fatal(err)
}
moved := calendarEvent(t, block.EventUID, start.Add(2*time.Hour))
if _, err = r.Change(ctx, d, c.ID, a, block.EventUID, event.ETag, &moved); err != nil {
t.Fatal(err)
}
_, retried, err := r.TaskBlock(ctx, d, c.ID, a, block.EventUID, &e)
if err != nil || !retried.Start.Equal(moved.Start) {
t.Fatal("retry overwrote changed schedule", retried, err)
}
err = r.ReadPersonalLocalIndex(ctx, d, c.ID, a, func(calendar.Calendar) error {
blocks, more, e := s.TaskDayBlocks(ctx, d, a, c.ID, start.Add(-time.Hour), start.Add(24*time.Hour))
if e != nil || more || len(blocks) != 1 || blocks[0].Start != moved.Start.UnixMilli() || blocks[0].Title != task.Title {
t.Fatalf("blocks=%v more=%v error=%v", blocks, more, e)
}
return nil
})
if err != nil {
t.Fatal(err)
}
// Synthetic metadata only; a deliberately missing file proves that
// external-source contents are rejected BEFORE refresh/read occurs.
guard, err := r.Create(ctx, d, a, "External guard")
if err != nil {
t.Fatal(err)
}
guard.Source = &calendar.Source{Kind: "ics", URL: "https://example.invalid/never-fetch"}
guard.Months = map[string]string{"2026-11": strings.Repeat("a", 64)}
data, _ := json.Marshal(guard)
if err = os.WriteFile(filepath.Join(r.Root, d, guard.ID, "calendar.json"), data, 0600); err != nil {
t.Fatal(err)
}
if _, _, err = r.TaskBlock(ctx, d, guard.ID, a, "blocked", nil); !errors.Is(err, calendar.ErrForbidden) {
t.Fatal("external snapshot touched", err)
}
called := false
err = r.ReadPersonalLocalIndex(ctx, d, guard.ID, a, func(calendar.Calendar) error { called = true; return nil })
if called || !errors.Is(err, calendar.ErrForbidden) {
t.Fatal(called, err)
}
})
}
}
func TestPostgreSQLCalendarRecoveryAndConcurrency(t *testing.T) {
s, d, a := productivityBackendFixture(t, storePostgreSQL)
ctx := context.Background()
r, err := s.NewCalendarRepository(ctx)
if err != nil {
t.Fatal(err)
}
peer, err := s.NewCalendarRepository(ctx)
if err != nil {
t.Fatal(err)
}
c, err := r.Create(ctx, d, a, "recovery")
if err != nil {
t.Fatal(err)
}
start := time.Date(2026, 11, 15, 9, 0, 0, 0, time.UTC)
e := calendarEvent(t, "concurrent", start)
if _, err = r.Change(ctx, d, c.ID, a, e.UID, "*", &e); err != nil {
t.Fatal(err)
}
if _, err = r.Event(ctx, d, c.ID, a, e.UID); err != nil {
t.Fatal(err)
}
ch := make(chan error, 2)
for i, w := range []*calendar.Repository{r, peer} {
go func(i int, w *calendar.Repository) {
v, err := calendar.Build(e.Data, calendar.Event{UID: e.UID, Summary: fmt.Sprint(i), Start: start.Add(time.Duration(i+1) * time.Hour), End: start.Add(time.Duration(i+2) * time.Hour)})
if err == nil {
_, err = w.Change(ctx, d, c.ID, a, e.UID, e.ETag, &v)
}
ch <- err
}(i, w)
}
wins := 0
for i := 0; i < 2; i++ {
err := <-ch
if err == nil {
wins++
} else if !errors.Is(err, calendar.ErrConflict) {
t.Fatal(err)
}
}
if wins != 1 {
t.Fatal(wins)
}
current, err := r.Event(ctx, d, c.ID, a, e.UID)
if err != nil {
t.Fatal(err)
}
var version string
if err = s.DB.QueryRow(`SELECT version FROM calendar_index_state WHERE domain=$1 AND calendar=$2`, d, c.ID).Scan(&version); err != nil {
t.Fatal(err)
}
moved := calendarEvent(t, e.UID, start.AddDate(0, 1, 0))
if _, err = r.Change(ctx, d, c.ID, a, e.UID, current.ETag, &moved); err != nil {
t.Fatal(err)
}
// Canonical manifest is committed; fail rebuilding its new generation.
if _, err = s.DB.Exec(`ALTER TABLE calendar_event_cache ADD CONSTRAINT synthetic_calendar_failure CHECK(month <> '2026-12')`); err != nil {
t.Fatal(err)
}
if _, err = r.Event(ctx, d, c.ID, a, e.UID); err == nil || strings.Contains(err.Error(), "concurrent") {
t.Fatal("cache failure not sanitized", err)
}
var after string
if err = s.DB.QueryRow(`SELECT version FROM calendar_index_state WHERE domain=$1 AND calendar=$2`, d, c.ID).Scan(&after); err != nil || after != version {
t.Fatal("partial cache commit", after, err)
}
if _, err = s.DB.Exec(`ALTER TABLE calendar_event_cache DROP CONSTRAINT synthetic_calendar_failure`); err != nil {
t.Fatal(err)
}
got, err := peer.Event(ctx, d, c.ID, a, e.UID)
if err != nil || !got.Start.Equal(moved.Start) {
t.Fatal("recovery", got, err)
}
if _, err = r.Change(ctx, d, c.ID, a, e.UID, current.ETag, &e); !errors.Is(err, calendar.ErrConflict) {
t.Fatal("lost response retry", err)
}
meta, err := r.Get(d, c.ID, a)
if err != nil {
t.Fatal(err)
}
// Cache deletion failure must leave the canonical calendar visible.
if _, err = s.DB.Exec(`ALTER TABLE calendar_month_cache RENAME COLUMN calendar TO unavailable_calendar`); err != nil {
t.Fatal(err)
}
if err = r.Delete(ctx, d, c.ID, a, meta.Version); err == nil {
t.Fatal("delete fault ignored")
}
if _, err = peer.Get(d, c.ID, a); err != nil {
t.Fatal("canonical lost on failed delete", err)
}
if _, err = s.DB.Exec(`ALTER TABLE calendar_month_cache RENAME COLUMN unavailable_calendar TO calendar`); err != nil {
t.Fatal(err)
}
if err = r.Delete(ctx, d, c.ID, a, meta.Version); err != nil {
t.Fatal(err)
}
}
+170 -168
View File
@@ -1,8 +1,8 @@
package store
import (
"context"
"database/sql"
"errors"
"strings"
"time"
@@ -26,6 +26,9 @@ type Campus struct {
}
func (s *Store) EnsureCampusesSchema() error {
if s.sqlBackend == storePostgreSQL {
return s.ensurePostgreSQLCampusDefaults(context.Background())
}
_, err := s.DB.Exec(`
CREATE TABLE IF NOT EXISTS campuses (
id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -135,7 +138,11 @@ func (s *Store) EnsureCampusesSchema() error {
}
func (s *Store) GetDefaultCampus() (*Campus, error) {
row := s.DB.QueryRow(`
return s.GetDefaultCampusContext(context.Background())
}
func (s *Store) GetDefaultCampusContext(ctx context.Context) (*Campus, error) {
row := s.DB.QueryRowContext(ctx, `
SELECT
id,
uuid,
@@ -157,13 +164,18 @@ func (s *Store) GetDefaultCampus() (*Campus, error) {
LIMIT 1
`)
return scanCampus(row)
c, err := scanCampus(row)
return c, s.sqlError("read default campus", err)
}
func (s *Store) GetCampusByUUID(
campusUUID string,
) (*Campus, error) {
row := s.DB.QueryRow(`
return s.GetCampusByUUIDContext(context.Background(), campusUUID)
}
func (s *Store) GetCampusByUUIDContext(ctx context.Context, campusUUID string) (*Campus, error) {
row := s.DB.QueryRowContext(ctx, `
SELECT
id,
uuid,
@@ -178,16 +190,21 @@ func (s *Store) GetCampusByUUID(
enabled,
created_at
FROM campuses
WHERE uuid = ?
WHERE uuid = `+s.sqlParam(1)+`
AND enabled = 1
LIMIT 1
`, campusUUID)
return scanCampus(row)
c, err := scanCampus(row)
return c, s.sqlError("read campus", err)
}
func (s *Store) ListCampuses() ([]Campus, error) {
rows, err := s.DB.Query(`
return s.ListCampusesContext(context.Background())
}
func (s *Store) ListCampusesContext(ctx context.Context) ([]Campus, error) {
rows, err := s.DB.QueryContext(ctx, `
SELECT
id,
uuid,
@@ -208,7 +225,7 @@ func (s *Store) ListCampuses() ([]Campus, error) {
id
`)
if err != nil {
return nil, err
return nil, s.sqlError("list campuses", err)
}
defer rows.Close()
@@ -216,12 +233,12 @@ func (s *Store) ListCampuses() ([]Campus, error) {
for rows.Next() {
campus, err := scanCampus(rows)
if err != nil {
return nil, err
return nil, s.sqlError("decode campus list", err)
}
campuses = append(campuses, *campus)
}
return campuses, rows.Err()
return campuses, s.sqlError("list campuses", rows.Err())
}
func (s *Store) CreateCampus(
@@ -235,7 +252,7 @@ func (s *Store) CreateCampus(
name = normalizeCampusName(name)
title = strings.TrimSpace(title)
if name == "" {
return errors.New("campus name is required")
return namespaceValidationError("campus name is required")
}
if title == "" {
title = name
@@ -256,43 +273,22 @@ func (s *Store) CreateCampus(
return err
}
if authorityMode == "managed" {
return errors.New(
return namespaceValidationError(
"managed campus must be added through controller enrollment",
)
}
if err := s.ensureCampusFQDNAvailable(0, fqdn); err != nil {
return err
}
enabledValue := 0
if enabled {
enabledValue = 1
}
_, err = s.DB.Exec(`
INSERT INTO campuses (
uuid,
name,
title,
default_lang,
authority_mode,
fqdn,
enabled,
created_at
)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
`,
uuid.NewString(),
name,
title,
defaultLang,
authorityMode,
fqdn,
enabledValue,
time.Now().Unix(),
)
return err
return s.namespaceWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error {
if err := s.ensureCampusFQDNAvailableFrom(ctx, tx, 0, fqdn); err != nil {
return err
}
_, err := tx.ExecContext(ctx, `INSERT INTO campuses(uuid,name,title,default_lang,authority_mode,fqdn,enabled,created_at) VALUES (`+s.sqlValues(8)+`)`, uuid.NewString(), name, title, defaultLang, authorityMode, fqdn, enabledValue, time.Now().Unix())
return err
})
}
func (s *Store) UpdateCampus(
@@ -305,22 +301,24 @@ func (s *Store) UpdateCampus(
enabled bool,
) error {
if id <= 0 {
return errors.New("campus id is required")
return namespaceValidationError("campus id is required")
}
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
defer cancel()
var existingMode string
if err := s.DB.QueryRow(`
SELECT authority_mode FROM campuses WHERE id = ?
if err := s.DB.QueryRowContext(ctx, `
SELECT authority_mode FROM campuses WHERE id = `+s.sqlParam(1)+`
`, id).Scan(&existingMode); err != nil {
return err
return s.sqlError("read campus authority", err)
}
if existingMode == "managed" {
return errors.New("managed campus settings are inherited")
return namespaceValidationError("managed campus settings are inherited")
}
name = normalizeCampusName(name)
title = strings.TrimSpace(title)
if name == "" {
return errors.New("campus name is required")
return namespaceValidationError("campus name is required")
}
if title == "" {
title = name
@@ -340,163 +338,165 @@ func (s *Store) UpdateCampus(
if err != nil {
return err
}
if err := s.ensureCampusFQDNAvailable(id, fqdn); err != nil {
return err
}
if !enabled {
var domainCount int
if err := s.DB.QueryRow(`
return s.namespaceWrite(ctx, func(ctx context.Context, tx *sql.Tx) error {
// Re-read inherited status under the same lock as the mutation.
if err := tx.QueryRowContext(ctx, `SELECT authority_mode FROM campuses WHERE id=`+s.sqlParam(1), id).Scan(&existingMode); err != nil {
return err
}
if existingMode == "managed" {
return namespaceValidationError("managed campus settings are inherited")
}
if err := s.ensureCampusFQDNAvailableFrom(ctx, tx, id, fqdn); err != nil {
return err
}
if !enabled {
var domainCount int
if err := tx.QueryRowContext(ctx, `
SELECT count(*)
FROM domains
WHERE campus_uuid = (
SELECT uuid
FROM campuses
WHERE id = ?
WHERE id = `+s.sqlParam(1)+`
)
`, id).Scan(&domainCount); err != nil {
return err
}
if domainCount > 0 {
return errors.New("campus is referenced by domains")
}
return err
}
if domainCount > 0 {
return namespaceValidationError("campus is referenced by domains")
}
var enabledCount int
if err := s.DB.QueryRow(`
var enabledCount int
if err := tx.QueryRowContext(ctx, `
SELECT count(*)
FROM campuses
WHERE enabled = 1
AND id != ?
AND id != `+s.sqlParam(1)+`
`, id).Scan(&enabledCount); err != nil {
return err
return err
}
if enabledCount == 0 {
return namespaceValidationError("at least one enabled campus is required")
}
}
if enabledCount == 0 {
return errors.New("at least one enabled campus is required")
enabledValue := 0
if enabled {
enabledValue = 1
}
}
enabledValue := 0
if enabled {
enabledValue = 1
}
_, err = s.DB.Exec(`
_, err = tx.ExecContext(ctx, `
UPDATE campuses
SET
name = ?,
title = ?,
default_lang = ?,
authority_mode = ?,
fqdn = ?,
enabled = ?
WHERE id = ?
name = `+s.sqlParam(1)+`,
title = `+s.sqlParam(2)+`,
default_lang = `+s.sqlParam(3)+`,
authority_mode = `+s.sqlParam(4)+`,
fqdn = `+s.sqlParam(5)+`,
enabled = `+s.sqlParam(6)+`
WHERE id = `+s.sqlParam(7)+`
`,
name,
title,
defaultLang,
authorityMode,
fqdn,
enabledValue,
id,
)
name,
title,
defaultLang,
authorityMode,
fqdn,
enabledValue,
id,
)
return err
return err
})
}
func (s *Store) DeleteCampus(
id int64,
) error {
var targetEnabled int
var authorityMode string
if err := s.DB.QueryRow(`
if s.ReadOnly {
return ErrReadOnly
}
return s.namespaceWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error {
var err error
var targetEnabled int
var authorityMode string
if err := tx.QueryRowContext(ctx, `
SELECT enabled, authority_mode
FROM campuses
WHERE id = ?
WHERE id = `+s.sqlParam(1)+`
`, id).Scan(&targetEnabled, &authorityMode); err != nil {
return err
}
var count int
if err := s.DB.QueryRow(`
return err
}
var count int
if err := tx.QueryRowContext(ctx, `
SELECT count(*)
FROM campuses
`).Scan(&count); err != nil {
return err
}
if count <= 1 {
return errors.New("at least one campus is required")
}
return err
}
if count <= 1 {
return namespaceValidationError("at least one campus is required")
}
if targetEnabled != 0 {
var enabledCount int
if err := s.DB.QueryRow(`
if targetEnabled != 0 {
var enabledCount int
if err := tx.QueryRowContext(ctx, `
SELECT count(*)
FROM campuses
WHERE enabled = 1
AND id != ?
AND id != `+s.sqlParam(1)+`
`, id).Scan(&enabledCount); err != nil {
return err
return err
}
if enabledCount == 0 {
return namespaceValidationError("at least one enabled campus is required")
}
}
if enabledCount == 0 {
return errors.New("at least one enabled campus is required")
if authorityMode == "managed" {
return s.deleteManagedCampusTx(ctx, tx, id)
}
}
if authorityMode == "managed" {
return s.deleteManagedCampus(id)
}
var domainCount int
if err := s.DB.QueryRow(`
var domainCount int
if err := tx.QueryRowContext(ctx, `
SELECT count(*)
FROM domains
WHERE campus_uuid = (
SELECT uuid
FROM campuses
WHERE id = ?
WHERE id = `+s.sqlParam(1)+`
)
`, id).Scan(&domainCount); err != nil {
return err
}
if domainCount > 0 {
return errors.New("campus is referenced by domains")
}
return err
}
if domainCount > 0 {
return namespaceValidationError("campus is referenced by domains")
}
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
var campusUUID string
if err := tx.QueryRow(`
SELECT uuid FROM campuses WHERE id = ?
var campusUUID string
if err := tx.QueryRowContext(ctx, `
SELECT uuid FROM campuses WHERE id = `+s.sqlParam(1)+`
`, id).Scan(&campusUUID); err != nil {
return err
}
if _, err := tx.Exec(`
DELETE FROM federation_instances WHERE campus_uuid = ?
`, campusUUID); err != nil {
return err
}
if _, err := tx.Exec(`
DELETE FROM campus_tokens WHERE campus_uuid = ?
`, campusUUID); err != nil {
return err
}
result, err := tx.Exec(`
DELETE FROM campuses WHERE id = ?
return err
}
if err := s.deleteFederationCampusTx(ctx, tx, campusUUID); err != nil {
return err
}
result, err := tx.ExecContext(ctx, `
DELETE FROM campuses WHERE id = `+s.sqlParam(1)+`
`, id)
if err != nil {
return err
}
if err != nil {
return err
}
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return sql.ErrNoRows
}
return tx.Commit()
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return sql.ErrNoRows
}
return nil
})
}
func normalizeCampusName(name string) string {
@@ -511,7 +511,7 @@ func normalizeCampusLanguage(raw string) (string, error) {
}
tag, err := language.Parse(raw)
if err != nil {
return "", errors.New("invalid campus default language")
return "", namespaceValidationError("invalid campus default language")
}
return tag.String(), nil
}
@@ -526,38 +526,40 @@ func normalizeCampusAuthority(mode, fqdn string) (string, string, error) {
case "standalone", "controller":
case "managed":
default:
return "", "", errors.New("invalid campus authority mode")
return "", "", namespaceValidationError("invalid campus authority mode")
}
if fqdn == "" {
return "", "", errors.New("campus FQDN is required")
return "", "", namespaceValidationError("campus FQDN is required")
}
if !strings.Contains(fqdn, ".") && fqdn != "localhost" {
return "", "", errors.New("invalid campus FQDN")
return "", "", namespaceValidationError("invalid campus FQDN")
}
return mode, fqdn, nil
}
func (s *Store) ensureCampusFQDNAvailable(id int64, fqdn string) error {
func (s *Store) ensureCampusFQDNAvailableFrom(ctx context.Context, q interface {
QueryRowContext(context.Context, string, ...any) *sql.Row
}, id int64, fqdn string) error {
var count int
if err := s.DB.QueryRow(`
if err := q.QueryRowContext(ctx, `
SELECT count(*) FROM campuses
WHERE id != ? AND lower(fqdn) = lower(?)
WHERE id != `+s.sqlParam(1)+` AND lower(fqdn) = lower(`+s.sqlParam(2)+`)
`, id, fqdn).Scan(&count); err != nil {
return err
}
if count > 0 {
return errors.New("campus FQDN already exists")
return namespaceValidationError("campus FQDN already exists")
}
if err := s.DB.QueryRow(`
if err := q.QueryRowContext(ctx, `
WITH effective_hosts AS (
SELECT lower(
CASE
WHEN d.domain = '' THEN
CASE WHEN c.id = ? THEN ? ELSE c.fqdn END
WHEN instr(d.domain, '.') > 0 THEN d.domain
CASE WHEN c.id = `+s.sqlParam(1)+` THEN `+s.sqlParam(2)+` ELSE c.fqdn END
WHEN `+s.sqlHasDot("d.domain")+` THEN d.domain
ELSE d.domain || '.' ||
CASE WHEN c.id = ? THEN ? ELSE c.fqdn END
CASE WHEN c.id = `+s.sqlParam(3)+` THEN `+s.sqlParam(4)+` ELSE c.fqdn END
END
) AS host
FROM domains d
@@ -566,12 +568,12 @@ func (s *Store) ensureCampusFQDNAvailable(id int64, fqdn string) error {
SELECT count(*) FROM (
SELECT host FROM effective_hosts
GROUP BY host HAVING count(*) > 1
)
) AS duplicate_hosts
`, id, fqdn, id, fqdn).Scan(&count); err != nil {
return err
}
if count > 0 {
return errors.New("campus FQDN conflicts with a domain host")
return namespaceValidationError("campus FQDN conflicts with a domain host")
}
return nil
}
+182 -115
View File
@@ -1,8 +1,8 @@
package store
import (
"context"
"database/sql"
"errors"
"regexp"
"strings"
"time"
@@ -87,6 +87,12 @@ type CityNodeDetail struct {
}
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))`,
@@ -152,18 +158,22 @@ func cityPathContains(parent, child string) bool {
}
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 "", errors.New("only a Quartier may bind the Domain root")
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 ? AS candidate) input WHERE domain_uuid=? AND state!='archived' AND ` + cityPathOverlapSQL("path_prefix", "input.candidate")
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=?`
query += ` AND kind=` + s.sqlParam(3)
}
args := []any{pathPrefix, domainUUID}
if kind != "spot" {
@@ -173,7 +183,7 @@ func validateCityPathPrefix(tx *sql.Tx, domainUUID, kind, pathPrefix string) (st
return "", err
}
if conflicts > 0 {
return "", errors.New("City Path boundaries of the same level must not overlap")
return "", namespaceValidationError("City Path boundaries of the same level must not overlap")
}
return pathPrefix, nil
}
@@ -189,19 +199,19 @@ func validateCityBoundaryChanges(items []cityPathBoundary, changed map[string]bo
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")
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 errors.New("Street Path must be a strict descendant of its Quartier 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 errors.New("Spot Path must be a strict descendant of its Street Path")
return namespaceValidationError("Spot Path must be a strict descendant of its Street Path")
}
}
}
@@ -209,7 +219,11 @@ func validateCityBoundaryChanges(items []cityPathBoundary, changed map[string]bo
}
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)
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
}
@@ -222,12 +236,19 @@ func loadCityBoundaries(tx *sql.Tx, domainUUID string) ([]cityPathBoundary, erro
}
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) {
items, err := loadCityBoundaries(tx, domainUUID)
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
}
@@ -256,21 +277,23 @@ func renameCityPathPrefixesTx(tx *sql.Tx, domainUUID, oldPath, newPath string) (
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 {
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) error {
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, err := s.DB.Begin()
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
if err != nil {
return err
}
defer tx.Rollback()
items, err := loadCityBoundaries(tx, domainUUID)
items, err := s.loadCityBoundaries(tx, domainUUID)
if err != nil {
return err
}
@@ -291,14 +314,14 @@ func (s *Store) UpdateCityNodePath(domainUUID, actor, kind, id, pathPrefix strin
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)
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 := bumpTopologyVersion(tx, domainUUID, actor, "city.node.path_updated", kind, id); err != nil {
if err := s.bumpTopologyVersion(tx, domainUUID, actor, "city.node.path_updated", kind, id); err != nil {
return err
}
return tx.Commit()
@@ -307,22 +330,26 @@ func (s *Store) UpdateCityNodePath(domainUUID, actor, kind, id, pathPrefix strin
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 "", 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(?,2,?) ON CONFLICT(domain_uuid) DO UPDATE SET version=version+1,updated_at_ms=excluded.updated_at_ms`, domainUUID, now)
_, 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=?`, domainUUID).Scan(&version); err != nil {
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(?,?,?,?,?,?,?)`, domainUUID, version, actor, operation, targetType, targetUUID, now)
_, 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
}
@@ -330,26 +357,28 @@ func (s *Store) CreateZone(domainUUID, actor, kind, parentUUID, name, title, des
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 {
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) (string, error) {
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 "", errors.New("zone kind must be quartier or street")
return "", namespaceValidationError("zone kind must be quartier or street")
}
if strings.TrimSpace(title) == "" {
title = name
}
tx, err := s.DB.Begin()
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
if err != nil {
return "", err
}
@@ -357,7 +386,7 @@ func (s *Store) CreateZoneAtPath(domainUUID, actor, kind, parentUUID, name, titl
if strings.TrimSpace(pathPrefix) == "" {
pathPrefix = "/" + name
}
pathPrefix, err = validateCityPathPrefix(tx, domainUUID, kind, pathPrefix)
pathPrefix, err = s.validateCityPathPrefix(tx, domainUUID, kind, pathPrefix)
if err != nil {
return "", err
}
@@ -365,11 +394,11 @@ func (s *Store) CreateZoneAtPath(domainUUID, actor, kind, parentUUID, name, titl
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 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 "", errors.New("Street Path must be a strict descendant of its Quartier Path")
return "", namespaceValidationError("Street Path must be a strict descendant of its Quartier Path")
}
}
id, now := uuid.NewString(), time.Now().UnixMilli()
@@ -383,18 +412,18 @@ func (s *Store) CreateZoneAtPath(domainUUID, actor, kind, parentUUID, name, titl
// 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 {
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=? WHERE domain_uuid=? AND kind=? AND parent_uuid=? AND name=? AND state='archived'`, time.Now().UnixMilli(), domainUUID, kind, parentUUID, name); err != nil {
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(?,?,?,?,?,?,?,?,'draft',?,?)`, id, domainUUID, kind, parent, name, strings.TrimSpace(title), strings.TrimSpace(description), pathPrefix, now, now); err != nil {
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 := bumpTopologyVersion(tx, domainUUID, actor, "city.zone.created", kind, id); err != nil {
if err := s.bumpTopologyVersion(tx, domainUUID, actor, "city.zone.created", kind, id); err != nil {
return "", err
}
return id, tx.Commit()
@@ -403,13 +432,14 @@ func (s *Store) CreateZoneAtPath(domainUUID, actor, kind, parentUUID, name, titl
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 {
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) (string, error) {
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
@@ -417,7 +447,8 @@ func (s *Store) CreateSpotAtPath(domainUUID, actor, streetUUID, name, title, sum
if strings.TrimSpace(title) == "" {
title = name
}
tx, err := s.DB.Begin()
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
if err != nil {
return "", err
}
@@ -425,38 +456,39 @@ func (s *Store) CreateSpotAtPath(domainUUID, actor, streetUUID, name, title, sum
if strings.TrimSpace(pathPrefix) == "" {
pathPrefix = "/" + name
}
pathPrefix, err = validateCityPathPrefix(tx, domainUUID, "spot", pathPrefix)
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=? 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 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 "", errors.New("Spot Path must be a strict descendant of its Street Path")
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=? WHERE domain_uuid=? AND name=? AND state='archived'`, now, domainUUID, name); err != nil {
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(?,?,?,?,?,?,'draft',?,?)`, id, domainUUID, name, strings.TrimSpace(title), strings.TrimSpace(summary), pathPrefix, now, now); err != nil {
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(?,?,?)`, streetUUID, id, now); err != nil {
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 := bumpTopologyVersion(tx, domainUUID, actor, "city.spot.created", "spot", id); err != nil {
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) error {
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 errors.New("invalid SpotPage edge type")
return namespaceValidationError("invalid SpotPage edge type")
}
if pageUUID == "" {
var err error
@@ -465,32 +497,35 @@ func (s *Store) AddSpotPage(domainUUID, actor, spotUUID, pageUUID, path, edgeTyp
return err
}
}
tx, err := s.DB.Begin()
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
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")
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(?,?,?,?,?) ON CONFLICT(spot_uuid,page_uuid,edge_type) DO UPDATE SET label=excluded.label`, spotUUID, pageUUID, edgeType, strings.TrimSpace(label), time.Now().UnixMilli())
_, 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 := bumpTopologyVersion(tx, domainUUID, actor, "city.spot_page.added", "spot", spotUUID); err != nil {
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) error {
tx, err := s.DB.Begin()
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=? AND page_uuid=? AND edge_type=? AND EXISTS(SELECT 1 FROM spots WHERE uuid=? AND domain_uuid=?)`, spotUUID, pageUUID, edgeType, spotUUID, domainUUID)
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
}
@@ -498,14 +533,14 @@ func (s *Store) RemoveSpotPage(domainUUID, actor, spotUUID, pageUUID, edgeType s
if changed == 0 {
return sql.ErrNoRows
}
if err := bumpTopologyVersion(tx, domainUUID, actor, "city.spot_page.removed", "spot", spotUUID); err != nil {
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 listSpotPages(s.DB, domainUUID, spotUUID, -1)
return s.listSpotPages(s.DB, domainUUID, spotUUID, -1)
}
type cityQuerier interface {
@@ -513,17 +548,25 @@ type cityQuerier interface {
}
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=? 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=?
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=? AND s.domain_uuid=p.domain_uuid AND s.state!='archived'
WHERE p.domain_uuid=? AND `+cityPathScopeSQL("s.path_prefix", "p.path")+`
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
) ORDER BY featured DESC,sort_key,edge_type,path LIMIT ?`, domainUUID, domainUUID, spotUUID, spotUUID, domainUUID, limit)
) 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
}
@@ -541,13 +584,13 @@ func listSpotPages(db cityQuerier, domainUUID, spotUUID string, limit int) ([]Ci
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=?
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=? 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=?)
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=? AND st.kind='street' AND st.state!='archived'
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 {
@@ -567,37 +610,41 @@ func (s *Store) ListPageSpotAppearances(domainUUID, pageUUID string) ([]CitySpot
return out, rows.Err()
}
func (s *Store) AddSpotRelation(domainUUID, actor, sourceUUID, targetUUID, relationType string) error {
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 errors.New("invalid Spot relation")
return namespaceValidationError("invalid Spot relation")
}
tx, err := s.DB.Begin()
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=? 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.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(?,?,?,?) ON CONFLICT DO NOTHING`, sourceUUID, targetUUID, relationType, time.Now().UnixMilli()); err != nil {
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 := bumpTopologyVersion(tx, domainUUID, actor, "city.spot_relation.added", "spot", sourceUUID); err != nil {
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) error {
tx, err := s.DB.Begin()
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=? AND target_spot_uuid=? AND relation_type=? AND EXISTS(SELECT 1 FROM spots WHERE uuid=? AND domain_uuid=?)`, sourceUUID, targetUUID, relationType, sourceUUID, domainUUID)
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
}
@@ -605,29 +652,31 @@ func (s *Store) RemoveSpotRelation(domainUUID, actor, sourceUUID, targetUUID, re
if changed == 0 {
return sql.ErrNoRows
}
if err := bumpTopologyVersion(tx, domainUUID, actor, "city.spot_relation.removed", "spot", sourceUUID); err != nil {
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) error {
tx, err := s.DB.Begin()
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=? 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 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=? AND domain_uuid=? AND kind='street' AND state!='archived'`, streetUUID, domainUUID).Scan(&streetPath); err != nil {
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 errors.New("Street Path is outside the destination Quartier Path; change its boundary first")
return namespaceValidationError("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)
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
}
@@ -635,30 +684,32 @@ func (s *Store) MoveStreet(domainUUID, actor, streetUUID, quartierUUID string, s
if changed != 1 {
return sql.ErrNoRows
}
if err := bumpTopologyVersion(tx, domainUUID, actor, "city.street.moved", "street", streetUUID); err != nil {
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) error {
tx, err := s.DB.Begin()
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=? AND domain_uuid=? AND state!='archived'`, streetUUID, domainUUID).Scan(&kind, &streetPath); err != nil || kind != "street" {
return errors.New("destination must be an active Street")
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=? AND state!='archived'`, spotUUID).Scan(&spotDomain, &spotPath); err != nil || spotDomain != domainUUID {
return errors.New("Spot must belong to the current Domain")
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 errors.New("Spot Path is outside the destination Street Path; change its boundary first")
return namespaceValidationError("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)
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
}
@@ -666,10 +717,10 @@ func (s *Store) MoveSpot(domainUUID, actor, spotUUID, streetUUID string, sortKey
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 {
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 := bumpTopologyVersion(tx, domainUUID, actor, "city.spot.moved", "spot", spotUUID); err != nil {
if err := s.bumpTopologyVersion(tx, domainUUID, actor, "city.spot.moved", "spot", spotUUID); err != nil {
return err
}
return tx.Commit()
@@ -678,8 +729,10 @@ func (s *Store) MoveSpot(domainUUID, actor, spotUUID, streetUUID string, sortKey
// 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()
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
}
@@ -688,26 +741,32 @@ func (s *Store) DeleteCityNode(domainUUID, actor, kind, id string) error {
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)
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 {
_, _ = 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)
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=? AND domain_uuid=? AND state!='archived'`, id, domainUUID).Scan(&actual); err != nil || actual != kind {
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=? AND kind='street' AND parent_uuid=? AND state!='archived'`, domainUUID, id)
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
}
@@ -718,47 +777,55 @@ func (s *Store) DeleteCityNode(domainUUID, actor, kind, id string) error {
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=?)`, streetID)
_, 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=?) OR target_spot_uuid IN (SELECT spot_uuid FROM street_spots WHERE street_uuid=?)`, streetID, streetID)
_, 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=? WHERE uuid IN (SELECT spot_uuid FROM street_spots WHERE street_uuid=?) AND domain_uuid=?`, now, streetID, domainUUID)
_, 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=?`, streetID)
_, 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=? WHERE domain_uuid=? AND kind='street' AND parent_uuid=? AND state!='archived'`, now, domainUUID, id)
_, 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=? WHERE uuid=? AND domain_uuid=? AND kind=? AND state!='archived'`, now, id, domainUUID, kind)
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 errors.New("invalid City element kind")
return namespaceValidationError("invalid City element kind")
}
if changed == 0 {
return sql.ErrNoRows
}
if err := bumpTopologyVersion(tx, domainUUID, actor, "city.node.deleted", kind, id); err != nil {
if err := s.bumpTopologyVersion(tx, domainUUID, actor, "city.node.deleted", kind, id); err != nil {
return err
}
return tx.Commit()
@@ -773,18 +840,18 @@ func (s *Store) CityNodeOverlappingPath(domainUUID, kind, parentUUID, pathPrefix
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`
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 ? AS candidate) input WHERE domain_uuid=? AND kind=? AND state!='archived' AND ` + cityPathOverlapSQL("path_prefix", "input.candidate")
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=?`
query += ` AND parent_uuid=` + s.sqlParam(4)
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`
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
}
+47
View File
@@ -0,0 +1,47 @@
package store
import "context"
type CityAutoCandidate struct{ Path, ObjectUUID string }
// Close the source cursor before callers resolve or create locality nodes.
// Oversized plans fail explicitly rather than reconciling a truncated City.
func (s *Store) CityAutoCandidates(domain string) ([]CityAutoCandidate, error) {
ctx, cancel := context.WithTimeout(context.Background(), cityReadTimeout)
defer cancel()
rows, err := s.DB.QueryContext(ctx, `SELECT p.path,p.object_uuid FROM paths p WHERE p.domain_uuid=`+s.sqlParam(1)+` AND p.path>='/' AND p.path<'0' AND NOT `+s.pathScopeSQL("'/u'", "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)
ORDER BY p.path LIMIT `+s.sqlParam(2), domain, MaxNavigationEntries+1)
if err != nil {
return nil, s.sqlError("city auto candidates", err)
}
defer rows.Close()
var out []CityAutoCandidate
for rows.Next() {
var c CityAutoCandidate
if err := rows.Scan(&c.Path, &c.ObjectUUID); err != nil {
return nil, s.sqlError("city auto candidates", err)
}
out = append(out, c)
if len(out) > MaxNavigationEntries {
return nil, ErrCityMapBudget
}
}
return out, s.sqlError("city auto candidates", rows.Err())
}
func (s *Store) CityNameExists(domain, kind, parent, name string) (bool, error) {
var found bool
var err error
switch kind {
case "spot":
err = s.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM spots WHERE domain_uuid=`+s.sqlParam(1)+` AND name=`+s.sqlParam(2)+` AND state!='archived')`, domain, name).Scan(&found)
case "quartier":
err = s.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM zones WHERE domain_uuid=`+s.sqlParam(1)+` AND kind='quartier' AND name=`+s.sqlParam(2)+` AND state!='archived')`, domain, name).Scan(&found)
case "street":
err = s.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM zones WHERE domain_uuid=`+s.sqlParam(1)+` AND kind='street' AND parent_uuid=`+s.sqlParam(2)+` AND name=`+s.sqlParam(3)+` AND state!='archived')`, domain, parent, name).Scan(&found)
default:
return false, ErrGovernanceInvalid
}
return found, s.sqlError("city generated name", err)
}
+133
View File
@@ -0,0 +1,133 @@
package store
import (
"errors"
"fmt"
"testing"
)
func TestCityBackendReadAndOrganize(t *testing.T) {
for _, backend := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(backend), func(t *testing.T) {
f := newPublicationBackend(t, backend)
s := f.s
f.page("page", "/news_%/st/sp/entry", "rev", 1)
f.exec(`INSERT INTO spots(uuid,domain_uuid,name,path_prefix,created_at_ms,updated_at_ms) VALUES(`+s.sqlValues(6)+`)`, "dest", f.domain, "destination", "/news_%/st/destination", 1, 1)
f.exec(`INSERT INTO street_spots(street_uuid,spot_uuid,created_at_ms) VALUES('st','dest',1)`)
model, err := s.GetCityMap(f.domain)
if err != nil {
t.Fatal(err)
}
if len(model.Quartiers) != 1 || len(model.Quartiers[0].Streets) != 1 || len(model.Quartiers[0].Streets[0].Spots) != 2 {
t.Fatal(model)
}
pages, err := s.ListSpotPages(f.domain, "sp")
if err != nil || len(pages) != 1 || pages[0].PageUUID != "page" {
t.Fatal(pages, err)
}
context, err := s.ResolveCityPathContext(f.domain, "/news_%/st/sp/entry")
if err != nil || context.Spot == nil || context.Spot.UUID != "sp" {
t.Fatal(context, err)
}
node, err := s.CityNode(f.domain, "street", "q/st")
if err != nil || node.UUID != "st" {
t.Fatal(node, err)
}
if err = s.RenameCityTitle(f.domain, f.actor, "spot", "sp", "New title", model.Version); err != nil {
t.Fatal(err)
}
if err = s.RenameCityTitle(f.domain, f.actor, "spot", "sp", "stale", model.Version); !errors.Is(err, ErrCityChanged) {
t.Fatal(err)
}
model, err = s.GetCityMap(f.domain)
if err != nil {
t.Fatal(err)
}
// Transfer a single implicit Page; the old boundary must stop claiming it.
result, err := s.OrganizeCity(f.domain, f.actor, CityOrganizeRequest{BaseVersion: model.Version, Action: "merge", TargetSpotUUID: "dest", Pages: []CityPageSelection{{SpotUUID: "sp", PageUUID: "page"}}})
if err != nil || result.Pages != 1 {
t.Fatal(result, err)
}
pages, err = s.ListSpotPages(f.domain, "sp")
if err != nil || len(pages) != 0 {
t.Fatal(pages, err)
}
pages, err = s.ListSpotPages(f.domain, "dest")
if err != nil || len(pages) != 1 {
t.Fatal(pages, err)
}
model, err = s.GetCityMap(f.domain)
if err != nil {
t.Fatal(err)
}
f.exec(`INSERT INTO spot_relations(source_spot_uuid,target_spot_uuid,relation_type,weight,created_at_ms) VALUES('sp','dest','related',2,1)`)
// Merge whole Spots into a new one, retaining Page placements and URLs.
result, err = s.OrganizeCity(f.domain, f.actor, CityOrganizeRequest{BaseVersion: model.Version, Action: "merge", Spots: []string{"sp", "dest"}, NewSpot: &CityNewSpot{StreetUUID: "st", Name: "merged", Title: "Merged", PathPrefix: "/news_%/st/merged"}})
if err != nil || result.Pages != 1 {
t.Fatal(result, err)
}
if id, err := s.ResolvePathInDomain(f.domain, "/news_%/st/sp/entry"); err != nil || id != "page" {
t.Fatal(id, err)
}
health, err := s.GetCityHealth(f.domain)
if err != nil || health.Spots != 1 || health.BrokenRelations != 0 {
t.Fatal(health, err)
}
if err = s.UpdateCityNodePath(f.domain, f.actor, "spot", result.TargetSpotUUID, "/news_%/st/changed"); err != nil {
t.Fatal(err)
}
model, err = s.GetCityMap(f.domain)
if err != nil {
t.Fatal(err)
}
if _, err = s.OrganizeCity(f.domain, f.actor, CityOrganizeRequest{BaseVersion: model.Version, Action: "move", Spots: []string{result.TargetSpotUUID}, StreetUUID: "st", PathPrefix: "/news_%/st/moved"}); err != nil {
t.Fatal(err)
}
events, err := s.ListTopologyEvents(f.domain, 0, 100)
if err != nil || len(events) < 4 {
t.Fatal(events, err)
}
// Failure to persist the audit event must not commit the title change.
model, err = s.GetCityMap(f.domain)
if err != nil {
t.Fatal(err)
}
f.exec(`ALTER TABLE topology_events RENAME COLUMN operation TO unavailable_operation`)
if err = s.RenameCityTitle(f.domain, f.actor, "spot", result.TargetSpotUUID, "must roll back", model.Version); err == nil {
t.Fatal("missing audit accepted")
}
node, err = s.CityNode(f.domain, "spot", "uuid:"+result.TargetSpotUUID)
if err != nil || node.Title != "Merged" {
t.Fatal(node, err)
}
})
}
}
func TestPostgreSQLCityConcurrentVersion(t *testing.T) {
f := newPublicationBackend(t, storePostgreSQL)
s := f.s
model, err := s.GetCityMap(f.domain)
if err != nil {
t.Fatal(err)
}
peer := &Store{DB: s.DB, sqlBackend: storePostgreSQL}
results := make(chan error, 2)
for _, writer := range []*Store{s, peer} {
go func(w *Store) {
results <- w.RenameCityTitle(f.domain, f.actor, "spot", "sp", "changed", model.Version)
}(writer)
}
wins := 0
for i := 0; i < 2; i++ {
err := <-results
if err == nil {
wins++
} else if !errors.Is(err, ErrCityChanged) {
t.Fatal(err)
}
}
if wins != 1 {
t.Fatal("multiple version winners", wins)
}
}
+103
View File
@@ -0,0 +1,103 @@
package store
import (
"database/sql"
"errors"
"fmt"
"testing"
)
func TestCityBackendCRUDAndPlan(t *testing.T) {
for _, backend := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(backend), func(t *testing.T) {
f := newPublicationBackend(t, backend)
s := f.s
q, err := s.CreateZoneAtPath(f.domain, f.actor, "quartier", "", "work", "Work", "", "/work_%")
if err != nil {
t.Fatal(err)
}
st, err := s.CreateZoneAtPath(f.domain, f.actor, "street", q, "desk", "Desk", "", "/work_%/desk")
if err != nil {
t.Fatal(err)
}
sp, err := s.CreateSpotAtPath(f.domain, f.actor, st, "office", "Office", "", "/work_%/desk/office")
if err != nil {
t.Fatal(err)
}
other, err := s.CreateSpotAtPath(f.domain, f.actor, st, "books", "Books", "", "/work_%/desk/books")
if err != nil {
t.Fatal(err)
}
f.page("crud-page", "/outside/entry", "crud-rev", 1)
if err = s.AddSpotPage(f.domain, f.actor, sp, "crud-page", "", "reference", "Read"); err != nil {
t.Fatal(err)
}
appearances, err := s.ListPageSpotAppearances(f.domain, "crud-page")
if err != nil || len(appearances) != 1 {
t.Fatal(appearances, err)
}
if err = s.AddSpotRelation(f.domain, f.actor, sp, other, "related"); err != nil {
t.Fatal(err)
}
if err = s.RemoveSpotRelation(f.domain, f.actor, sp, other, "related"); err != nil {
t.Fatal(err)
}
if err = s.RemoveSpotPage(f.domain, f.actor, sp, "crud-page", "reference"); err != nil {
t.Fatal(err)
}
model, err := s.GetCityMap(f.domain)
if err != nil {
t.Fatal(err)
}
plan := CityPlan{BaseVersion: model.Version, Operations: []CityPlanOperation{{Action: "set_path", Kind: "spot", UUID: sp, PathPrefix: "/work_%/desk/office2"}}}
if _, err = s.PreviewCityPlan(f.domain, plan); err != nil {
t.Fatal(err)
}
if _, err = s.ApplyCityPlan(f.domain, f.actor, plan); err != nil {
t.Fatal(err)
}
if _, err = s.ApplyCityPlan(f.domain, f.actor, plan); err == nil {
t.Fatal("stale plan accepted")
}
node, err := s.CityNodeOverlappingPath(f.domain, "spot", st, "/work_%/desk/office2/page")
if err != nil || node.UUID != sp {
t.Fatal(node, err)
}
if err = s.MoveSpot(f.domain, f.actor, sp, st, 5); err != nil {
t.Fatal(err)
}
if err = s.MoveStreet(f.domain, f.actor, st, q, 7); err != nil {
t.Fatal(err)
}
found, err := s.CityNameExists(f.domain, "spot", "", "office")
if err != nil || !found {
t.Fatal(found, err)
}
candidates, err := s.CityAutoCandidates(f.domain)
if err != nil || len(candidates) != 1 {
t.Fatal(candidates, err)
}
// A failed audit must roll back the complete recursive deletion.
f.exec(`ALTER TABLE topology_events RENAME COLUMN operation TO unavailable_operation`)
if err = s.DeleteCityNode(f.domain, f.actor, "quartier", q); err == nil {
t.Fatal("deletion ignored audit failure")
}
if _, err = s.CityNode(f.domain, "spot", "uuid:"+sp); err != nil {
t.Fatal(err)
}
f.exec(`ALTER TABLE topology_events RENAME COLUMN unavailable_operation TO operation`)
if err = s.DeleteCityNode(f.domain, f.actor, "quartier", q); err != nil {
t.Fatal(err)
}
if _, err = s.CityNode(f.domain, "spot", "uuid:"+sp); !errors.Is(err, sql.ErrNoRows) {
t.Fatal(err)
}
if _, err = s.ResolvePathInDomain(f.domain, "/outside/entry"); err != nil {
t.Fatal("City delete removed document", err)
}
if _, err = s.CreateZoneAtPath(f.domain, f.actor, "quartier", "", "work", "Reused", "", "/work_%"); err != nil {
t.Fatal("archived name not reusable", err)
}
})
}
}
+42 -28
View File
@@ -76,9 +76,13 @@ func EvaluateLocalityPublication(chain []LocalityPolicy) (allows, published bool
// All authority, parentage and policy reads use this one snapshot. Mutation
// callers acquire SQLite's write reservation before entering this function.
func governanceSnapshot(ctx context.Context, tx *sql.Tx, domain, actor, kind, id string) (g CityGovernance, err error) {
return (&Store{}).governanceSnapshot(ctx, tx, domain, actor, kind, id)
}
func (s *Store) governanceSnapshot(ctx context.Context, tx *sql.Tx, domain, actor, kind, id string) (g CityGovernance, err error) {
g = CityGovernance{Kind: kind, UUID: id, Owners: []LocalityOwner{}}
var membership string
err = tx.QueryRowContext(ctx, `SELECT m.uuid FROM domain_memberships m JOIN principals p ON p.uuid=m.principal_uuid AND p.state='active' JOIN domains d ON d.uuid=m.domain_uuid AND d.enabled=1 WHERE m.domain_uuid=? AND m.principal_uuid=? AND m.state='active'`, domain, actor).Scan(&membership)
err = tx.QueryRowContext(ctx, `SELECT m.uuid FROM domain_memberships m JOIN principals p ON p.uuid=m.principal_uuid AND p.state='active' JOIN domains d ON d.uuid=m.domain_uuid AND d.enabled=1 WHERE m.domain_uuid=`+s.sqlParam(1)+` AND m.principal_uuid=`+s.sqlParam(2)+` AND m.state='active'`, domain, actor).Scan(&membership)
if err == sql.ErrNoRows {
return g, ErrAccessDenied
}
@@ -86,7 +90,7 @@ func governanceSnapshot(ctx context.Context, tx *sql.Tx, domain, actor, kind, id
return g, err
}
var admin bool
err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM groups g JOIN group_members gm ON gm.group_uuid=g.uuid WHERE g.domain_uuid=? AND g.builtin_key='domain_admin' AND g.state='active' AND gm.membership_uuid=? AND gm.member_role IN ('owner','manager'))`, domain, membership).Scan(&admin)
err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM groups g JOIN group_members gm ON gm.group_uuid=g.uuid WHERE g.domain_uuid=`+s.sqlParam(1)+` AND g.builtin_key='domain_admin' AND g.state='active' AND gm.membership_uuid=`+s.sqlParam(2)+` AND gm.member_role IN ('owner','manager'))`, domain, membership).Scan(&admin)
if err != nil {
return g, err
}
@@ -97,7 +101,7 @@ func governanceSnapshot(ctx context.Context, tx *sql.Tx, domain, actor, kind, id
return g, sql.ErrNoRows
}
case "quartier", "street":
err = tx.QueryRowContext(ctx, `SELECT COALESCE(parent_uuid,''),path_prefix FROM zones WHERE uuid=? AND domain_uuid=? AND kind=? AND state!='archived'`, id, domain, kind).Scan(&parent, &nodePath)
err = tx.QueryRowContext(ctx, `SELECT COALESCE(parent_uuid,''),path_prefix FROM zones WHERE uuid=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+` AND kind=`+s.sqlParam(3)+` AND state!='archived'`, id, domain, kind).Scan(&parent, &nodePath)
if kind == "quartier" {
q = id
if parent != "" {
@@ -109,7 +113,7 @@ func governanceSnapshot(ctx context.Context, tx *sql.Tx, domain, actor, kind, id
streetPath = nodePath
}
case "spot":
err = tx.QueryRowContext(ctx, `SELECT st.uuid,st.parent_uuid,s.path_prefix,st.path_prefix 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' WHERE s.uuid=? AND s.domain_uuid=? AND s.state!='archived'`, id, domain).Scan(&street, &q, &nodePath, &streetPath)
err = tx.QueryRowContext(ctx, `SELECT st.uuid,st.parent_uuid,s.path_prefix,st.path_prefix 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' WHERE s.uuid=`+s.sqlParam(1)+` AND s.domain_uuid=`+s.sqlParam(2)+` AND s.state!='archived'`, id, domain).Scan(&street, &q, &nodePath, &streetPath)
default:
return g, ErrGovernanceInvalid
}
@@ -117,7 +121,7 @@ func governanceSnapshot(ctx context.Context, tx *sql.Tx, domain, actor, kind, id
return g, err
}
if q != "" {
if err = tx.QueryRowContext(ctx, `SELECT path_prefix FROM zones WHERE uuid=? AND domain_uuid=? AND kind='quartier' AND state!='archived' AND COALESCE(parent_uuid,'')=''`, q, domain).Scan(&quartierPath); err != nil {
if err = tx.QueryRowContext(ctx, `SELECT path_prefix FROM zones WHERE uuid=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+` AND kind='quartier' AND state!='archived' AND COALESCE(parent_uuid,'')=''`, q, domain).Scan(&quartierPath); err != nil {
return g, err
}
}
@@ -125,7 +129,7 @@ func governanceSnapshot(ctx context.Context, tx *sql.Tx, domain, actor, kind, id
return g, ErrGovernanceInvalid
}
var qOwner, own bool
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM city_owner_bindings WHERE domain_uuid=? AND node_kind='quartier' AND node_uuid=? AND membership_uuid=?), EXISTS(SELECT 1 FROM city_owner_bindings WHERE domain_uuid=? AND node_kind=? AND node_uuid=? AND membership_uuid=?)`, domain, q, membership, domain, kind, id, membership).Scan(&qOwner, &own); err != nil {
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM city_owner_bindings WHERE domain_uuid=`+s.sqlParam(1)+` AND node_kind='quartier' AND node_uuid=`+s.sqlParam(2)+` AND membership_uuid=`+s.sqlParam(3)+`), EXISTS(SELECT 1 FROM city_owner_bindings WHERE domain_uuid=`+s.sqlParam(4)+` AND node_kind=`+s.sqlParam(5)+` AND node_uuid=`+s.sqlParam(6)+` AND membership_uuid=`+s.sqlParam(7)+`)`, domain, q, membership, domain, kind, id, membership).Scan(&qOwner, &own); err != nil {
return g, err
}
if !admin && !qOwner && !(kind == "spot" && own) {
@@ -144,7 +148,7 @@ func governanceSnapshot(ctx context.Context, tx *sql.Tx, domain, actor, kind, id
}
for i := range g.Chain {
p := &g.Chain[i]
err = tx.QueryRowContext(ctx, `SELECT policy FROM locality_publication_policies WHERE domain_uuid=? AND node_kind=? AND node_uuid=?`, domain, p.Kind, p.UUID).Scan(&p.Policy)
err = tx.QueryRowContext(ctx, `SELECT policy FROM locality_publication_policies WHERE domain_uuid=`+s.sqlParam(1)+` AND node_kind=`+s.sqlParam(2)+` AND node_uuid=`+s.sqlParam(3)+``, domain, p.Kind, p.UUID).Scan(&p.Policy)
if err != nil && err != sql.ErrNoRows {
return g, err
}
@@ -155,16 +159,16 @@ func governanceSnapshot(ctx context.Context, tx *sql.Tx, domain, actor, kind, id
g.Policy = g.Chain[len(g.Chain)-1].Policy
g.SuperiorAllowsPublic, _ = EvaluateLocalityPublication(g.Chain[:len(g.Chain)-1])
_, g.DraftEffectivePublic = EvaluateLocalityPublication(g.Chain)
if err = tx.QueryRowContext(ctx, `SELECT COALESCE((SELECT version FROM city_governance_epochs WHERE domain_uuid=?),0),COALESCE((SELECT version FROM domain_topology_versions WHERE domain_uuid=?),1)`, domain, domain).Scan(&g.Epoch, &g.TopologyVersion); err != nil {
if err = tx.QueryRowContext(ctx, `SELECT COALESCE((SELECT version FROM city_governance_epochs WHERE domain_uuid=`+s.sqlParam(1)+`),0),COALESCE((SELECT version FROM domain_topology_versions WHERE domain_uuid=`+s.sqlParam(2)+`),1)`, domain, domain).Scan(&g.Epoch, &g.TopologyVersion); err != nil {
return g, err
}
if err = tx.QueryRowContext(ctx, `SELECT COALESCE((SELECT version FROM locality_publication_versions WHERE domain_uuid=? AND node_kind=? AND node_uuid=?),0)`, domain, kind, id).Scan(&g.PublicationVersion); err != nil {
if err = tx.QueryRowContext(ctx, `SELECT COALESCE((SELECT version FROM locality_publication_versions WHERE domain_uuid=`+s.sqlParam(1)+` AND node_kind=`+s.sqlParam(2)+` AND node_uuid=`+s.sqlParam(3)+`),0)`, domain, kind, id).Scan(&g.PublicationVersion); err != nil {
return g, err
}
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM locality_publication_manifests m WHERE domain_uuid=? AND node_kind=? AND node_uuid=? AND epoch=? AND topology_version=? AND EXISTS(SELECT 1 FROM locality_publication_entries e WHERE e.domain_uuid=m.domain_uuid AND e.node_kind=m.node_kind AND e.node_uuid=m.node_uuid))`, domain, kind, id, g.Epoch, g.TopologyVersion).Scan(&g.PublicationEnabled); err != nil {
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM locality_publication_manifests m WHERE domain_uuid=`+s.sqlParam(1)+` AND node_kind=`+s.sqlParam(2)+` AND node_uuid=`+s.sqlParam(3)+` AND epoch=`+s.sqlParam(4)+` AND topology_version=`+s.sqlParam(5)+` AND EXISTS(SELECT 1 FROM locality_publication_entries e WHERE e.domain_uuid=m.domain_uuid AND e.node_kind=m.node_kind AND e.node_uuid=m.node_uuid))`, domain, kind, id, g.Epoch, g.TopologyVersion).Scan(&g.PublicationEnabled); err != nil {
return g, err
}
rows, err := tx.QueryContext(ctx, `SELECT m.uuid,COALESCE((SELECT subject FROM principal_identities WHERE principal_uuid=p.uuid AND provider_type='password' LIMIT 1),p.uuid),p.display_name,(p.state='active' AND m.state='active') FROM city_owner_bindings b JOIN domain_memberships m ON m.uuid=b.membership_uuid AND m.domain_uuid=b.domain_uuid JOIN principals p ON p.uuid=m.principal_uuid WHERE b.domain_uuid=? AND b.node_kind=? AND b.node_uuid=? ORDER BY m.uuid LIMIT 33`, domain, kind, id)
rows, err := tx.QueryContext(ctx, `SELECT m.uuid,COALESCE((SELECT subject FROM principal_identities WHERE principal_uuid=p.uuid AND provider_type='password' ORDER BY subject,uuid LIMIT 1),p.uuid),p.display_name,(p.state='active' AND m.state='active') FROM city_owner_bindings b JOIN domain_memberships m ON m.uuid=b.membership_uuid AND m.domain_uuid=b.domain_uuid JOIN principals p ON p.uuid=m.principal_uuid WHERE b.domain_uuid=`+s.sqlParam(1)+` AND b.node_kind=`+s.sqlParam(2)+` AND b.node_uuid=`+s.sqlParam(3)+` ORDER BY m.uuid LIMIT 33`, domain, kind, id)
if err != nil {
return g, err
}
@@ -182,38 +186,44 @@ func governanceSnapshot(ctx context.Context, tx *sql.Tx, domain, actor, kind, id
return g, rows.Err()
}
func (s *Store) CityGovernance(ctx context.Context, domain, actor, kind, id string) (CityGovernance, error) {
func (s *Store) CityGovernance(ctx context.Context, domain, actor, kind, id string) (result CityGovernance, resultErr error) {
defer func() { resultErr = s.sqlError("City governance read", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
tx, err := s.DB.BeginTx(ctx, s.policyReadOptions())
if err != nil {
return CityGovernance{}, err
}
defer tx.Rollback()
return governanceSnapshot(ctx, tx, domain, actor, kind, id)
return s.governanceSnapshot(ctx, tx, domain, actor, kind, id)
}
// Candidate lookup exposes only active local display identities, never emails,
// credentials or foreign memberships. It is scoped to appointment authority.
func (s *Store) CityGovernanceMembers(ctx context.Context, domain, actor, kind, id, search string) ([]LocalityOwner, error) {
func (s *Store) CityGovernanceMembers(ctx context.Context, domain, actor, kind, id, search string) (returned []LocalityOwner, resultErr error) {
defer func() { resultErr = s.sqlError("City governance candidates", resultErr) }()
if len(search) > 80 {
return nil, ErrGovernanceInvalid
}
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
tx, err := s.DB.BeginTx(ctx, s.policyReadOptions())
if err != nil {
return nil, err
}
defer tx.Rollback()
g, err := governanceSnapshot(ctx, tx, domain, actor, kind, id)
g, err := s.governanceSnapshot(ctx, tx, domain, actor, kind, id)
if err != nil {
return nil, err
}
if !g.CanAppoint {
return nil, ErrAccessDenied
}
rows, err := tx.QueryContext(ctx, `SELECT m.uuid,COALESCE((SELECT subject FROM principal_identities WHERE principal_uuid=p.uuid AND provider_type='password' LIMIT 1),p.uuid) username,p.display_name FROM domain_memberships m JOIN principals p ON p.uuid=m.principal_uuid AND p.state='active' WHERE m.domain_uuid=? AND m.state='active' AND (?='' OR instr(lower(p.display_name),?)>0 OR EXISTS(SELECT 1 FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' AND instr(lower(i.subject),?)>0)) ORDER BY p.display_name,m.uuid LIMIT 30`, domain, search, strings.ToLower(search), strings.ToLower(search))
contains := "instr"
if s.sqlBackend == storePostgreSQL {
contains = "strpos"
}
rows, err := tx.QueryContext(ctx, `SELECT m.uuid,COALESCE((SELECT subject FROM principal_identities WHERE principal_uuid=p.uuid AND provider_type='password' ORDER BY subject,uuid LIMIT 1),p.uuid) username,p.display_name FROM domain_memberships m JOIN principals p ON p.uuid=m.principal_uuid AND p.state='active' WHERE m.domain_uuid=`+s.sqlParam(1)+` AND m.state='active' AND (`+s.sqlParam(2)+`='' OR `+contains+`(lower(p.display_name),`+s.sqlParam(3)+`)>0 OR EXISTS(SELECT 1 FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' AND `+contains+`(lower(i.subject),`+s.sqlParam(4)+`)>0)) ORDER BY p.display_name,m.uuid LIMIT 30`, domain, search, strings.ToLower(search), strings.ToLower(search))
if err != nil {
return nil, err
}
@@ -229,7 +239,8 @@ func (s *Store) CityGovernanceMembers(ctx context.Context, domain, actor, kind,
return result, rows.Err()
}
func (s *Store) ChangeCityGovernance(ctx context.Context, domain, actor, kind, id string, change CityGovernanceChange, preview bool) (CityGovernance, error) {
func (s *Store) ChangeCityGovernance(ctx context.Context, domain, actor, kind, id string, change CityGovernanceChange, preview bool) (result CityGovernance, resultErr error) {
defer func() { resultErr = s.sqlError("City governance update", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
tx, err := s.DB.BeginTx(ctx, nil)
@@ -239,10 +250,13 @@ func (s *Store) ChangeCityGovernance(ctx context.Context, domain, actor, kind, i
defer tx.Rollback()
// Reserve the writer before authority reads: revocation cannot commit
// between validation and mutation. Preview rolls back this short reservation.
if _, err = tx.ExecContext(ctx, `INSERT INTO city_governance_epochs(domain_uuid,version) VALUES(?,0) ON CONFLICT(domain_uuid) DO UPDATE SET version=version`, domain); err != nil {
if err = s.lockPolicyWrite(ctx, tx); err != nil {
return CityGovernance{}, err
}
g, err := governanceSnapshot(ctx, tx, domain, actor, kind, id)
if _, err = tx.ExecContext(ctx, `INSERT INTO city_governance_epochs(domain_uuid,version) VALUES(`+s.sqlParam(1)+`,0) ON CONFLICT(domain_uuid) DO UPDATE SET version=city_governance_epochs.version`, domain); err != nil {
return CityGovernance{}, err
}
g, err := s.governanceSnapshot(ctx, tx, domain, actor, kind, id)
if err != nil {
return g, err
}
@@ -283,7 +297,7 @@ func (s *Store) ChangeCityGovernance(ctx context.Context, domain, actor, kind, i
}
seen[member] = true
o := LocalityOwner{MembershipUUID: member, Active: true}
err = tx.QueryRowContext(ctx, `SELECT COALESCE((SELECT subject FROM principal_identities WHERE principal_uuid=p.uuid AND provider_type='password' LIMIT 1),p.uuid),p.display_name FROM domain_memberships m JOIN principals p ON p.uuid=m.principal_uuid AND p.state='active' WHERE m.uuid=? AND m.domain_uuid=? AND m.state='active'`, member, domain).Scan(&o.Username, &o.DisplayName)
err = tx.QueryRowContext(ctx, `SELECT COALESCE((SELECT subject FROM principal_identities WHERE principal_uuid=p.uuid AND provider_type='password' ORDER BY subject,uuid LIMIT 1),p.uuid),p.display_name FROM domain_memberships m JOIN principals p ON p.uuid=m.principal_uuid AND p.state='active' WHERE m.uuid=`+s.sqlParam(1)+` AND m.domain_uuid=`+s.sqlParam(2)+` AND m.state='active'`, member, domain).Scan(&o.Username, &o.DisplayName)
if err == sql.ErrNoRows {
return g, ErrGovernanceInvalid
}
@@ -299,29 +313,29 @@ func (s *Store) ChangeCityGovernance(ctx context.Context, domain, actor, kind, i
}
now := time.Now().UnixMilli()
if change.Policy != nil {
if _, err = tx.ExecContext(ctx, `INSERT INTO locality_publication_policies(domain_uuid,node_kind,node_uuid,policy,actor_uuid,updated_at_ms) VALUES(?,?,?,?,?,?) ON CONFLICT(domain_uuid,node_kind,node_uuid) DO UPDATE SET policy=excluded.policy,actor_uuid=excluded.actor_uuid,updated_at_ms=excluded.updated_at_ms`, domain, kind, id, g.Policy, actor, now); err != nil {
if _, err = tx.ExecContext(ctx, `INSERT INTO locality_publication_policies(domain_uuid,node_kind,node_uuid,policy,actor_uuid,updated_at_ms) VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`) ON CONFLICT(domain_uuid,node_kind,node_uuid) DO UPDATE SET policy=excluded.policy,actor_uuid=excluded.actor_uuid,updated_at_ms=excluded.updated_at_ms`, domain, kind, id, g.Policy, actor, now); err != nil {
return g, err
}
}
if change.Owners != nil {
if _, err = tx.ExecContext(ctx, `DELETE FROM city_owner_bindings WHERE domain_uuid=? AND node_kind=? AND node_uuid=?`, domain, kind, id); err != nil {
if _, err = tx.ExecContext(ctx, `DELETE FROM city_owner_bindings WHERE domain_uuid=`+s.sqlParam(1)+` AND node_kind=`+s.sqlParam(2)+` AND node_uuid=`+s.sqlParam(3)+``, domain, kind, id); err != nil {
return g, err
}
for _, member := range *change.Owners {
if _, err = tx.ExecContext(ctx, `INSERT INTO city_owner_bindings VALUES(?,?,?,?,?,?)`, domain, kind, id, member, actor, now); err != nil {
if _, err = tx.ExecContext(ctx, `INSERT INTO city_owner_bindings VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`)`, domain, kind, id, member, actor, now); err != nil {
return g, err
}
}
}
if _, err = tx.ExecContext(ctx, `UPDATE city_governance_epochs SET version=version+1 WHERE domain_uuid=?`, domain); err != nil {
if _, err = tx.ExecContext(ctx, `UPDATE city_governance_epochs SET version=version+1 WHERE domain_uuid=`+s.sqlParam(1)+``, domain); err != nil {
return g, err
}
g, err = governanceSnapshot(ctx, tx, domain, actor, kind, id)
g, err = s.governanceSnapshot(ctx, tx, domain, actor, kind, id)
if err != nil {
return g, err
}
after, _ := json.Marshal(g)
if _, err = tx.ExecContext(ctx, `INSERT INTO city_governance_events(domain_uuid,epoch,actor_uuid,node_kind,node_uuid,before_json,after_json,created_at_ms) VALUES(?,?,?,?,?,?,?,?)`, domain, g.Epoch, actor, kind, id, string(before), string(after), now); err != nil {
if _, err = tx.ExecContext(ctx, `INSERT INTO city_governance_events(domain_uuid,epoch,actor_uuid,node_kind,node_uuid,before_json,after_json,created_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)+`)`, domain, g.Epoch, actor, kind, id, string(before), string(after), now); err != nil {
return g, err
}
return g, tx.Commit()
+20 -17
View File
@@ -43,16 +43,17 @@ type CityPathContext struct {
Spot *CityNodeDetail `json:"spot,omitempty"`
}
func (s *Store) GetCityHealth(domainUUID string) (CityHealth, error) {
func (s *Store) GetCityHealth(domainUUID string) (_ CityHealth, resultErr error) {
defer func() { resultErr = s.sqlError("city health", resultErr) }()
health := CityHealth{DomainUUID: domainUUID, TopologyVersion: 1, GeneratedAtMS: time.Now().UnixMilli()}
ctx, cancel := context.WithTimeout(context.Background(), cityReadTimeout)
defer cancel()
tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
tx, err := s.DB.BeginTx(ctx, s.policyReadOptions())
if err != nil {
return health, err
}
defer tx.Rollback()
if err := tx.QueryRowContext(ctx, `SELECT version FROM domain_topology_versions WHERE domain_uuid=?`, domainUUID).Scan(&health.TopologyVersion); err != nil && !errors.Is(err, sql.ErrNoRows) {
if err := tx.QueryRowContext(ctx, `SELECT version FROM domain_topology_versions WHERE domain_uuid=`+s.sqlParam(1), domainUUID).Scan(&health.TopologyVersion); err != nil && !errors.Is(err, sql.ErrNoRows) {
return health, err
}
queries := []struct {
@@ -60,13 +61,13 @@ func (s *Store) GetCityHealth(domainUUID string) (CityHealth, error) {
query string
args []any
}{
{&health.Quartiers, `SELECT COUNT(*) FROM zones WHERE domain_uuid=? AND kind='quartier' AND state!='archived'`, []any{domainUUID}},
{&health.Streets, `SELECT COUNT(*) FROM zones WHERE domain_uuid=? AND kind='street' AND state!='archived'`, []any{domainUUID}},
{&health.Spots, `SELECT COUNT(*) FROM spots WHERE domain_uuid=? AND state!='archived'`, []any{domainUUID}},
{&health.EmptySpots, `SELECT COUNT(*) FROM spots s WHERE s.domain_uuid=? AND s.state!='archived' AND NOT EXISTS(SELECT 1 FROM spot_pages sp JOIN paths p ON p.object_uuid=sp.page_uuid AND p.domain_uuid=s.domain_uuid WHERE sp.spot_uuid=s.uuid) AND NOT EXISTS(SELECT 1 FROM paths p WHERE p.domain_uuid=s.domain_uuid AND ` + cityPathScopeSQL("s.path_prefix", "p.path") + `)`, []any{domainUUID}},
{&health.UnconsolidatedPages, `SELECT COUNT(DISTINCT p.object_uuid) FROM paths p JOIN zones st ON st.domain_uuid=p.domain_uuid AND st.kind='street' AND st.state!='archived' AND ` + cityPathScopeSQL("st.path_prefix", "p.path") + ` WHERE p.domain_uuid=? AND NOT EXISTS(SELECT 1 FROM spots s JOIN street_spots ss ON ss.spot_uuid=s.uuid AND ss.street_uuid=st.uuid WHERE s.domain_uuid=st.domain_uuid AND s.state!='archived' AND ` + cityPathScopeSQL("s.path_prefix", "p.path") + `)`, []any{domainUUID}},
{&health.OrphanPages, `SELECT COUNT(DISTINCT p.object_uuid) FROM paths p WHERE p.domain_uuid=? AND NOT ` + cityPathScopeSQL("'/u'", "p.path") + ` AND NOT EXISTS(SELECT 1 FROM spot_pages sp JOIN spots s ON s.uuid=sp.spot_uuid AND s.domain_uuid=p.domain_uuid AND s.state!='archived' WHERE sp.page_uuid=p.object_uuid) AND NOT EXISTS(SELECT 1 FROM spots s WHERE s.domain_uuid=p.domain_uuid AND s.state!='archived' AND ` + cityPathScopeSQL("s.path_prefix", "p.path") + `)`, []any{domainUUID}},
{&health.BrokenRelations, `SELECT COUNT(*) FROM spot_relations r JOIN spots source ON source.uuid=r.source_spot_uuid AND source.domain_uuid=? WHERE source.state!='archived' AND NOT EXISTS(SELECT 1 FROM spots target WHERE target.uuid=r.target_spot_uuid AND target.domain_uuid=? AND target.state!='archived')`, []any{domainUUID, domainUUID}},
{&health.Quartiers, `SELECT COUNT(*) FROM zones WHERE domain_uuid=` + s.sqlParam(1) + ` AND kind='quartier' AND state!='archived'`, []any{domainUUID}},
{&health.Streets, `SELECT COUNT(*) FROM zones WHERE domain_uuid=` + s.sqlParam(1) + ` AND kind='street' AND state!='archived'`, []any{domainUUID}},
{&health.Spots, `SELECT COUNT(*) FROM spots WHERE domain_uuid=` + s.sqlParam(1) + ` AND state!='archived'`, []any{domainUUID}},
{&health.EmptySpots, `SELECT COUNT(*) FROM spots s WHERE s.domain_uuid=` + s.sqlParam(1) + ` AND s.state!='archived' AND NOT EXISTS(SELECT 1 FROM spot_pages sp JOIN paths p ON p.object_uuid=sp.page_uuid AND p.domain_uuid=s.domain_uuid WHERE sp.spot_uuid=s.uuid) AND NOT EXISTS(SELECT 1 FROM paths p WHERE p.domain_uuid=s.domain_uuid AND ` + s.pathScopeSQL("s.path_prefix", "p.path") + `)`, []any{domainUUID}},
{&health.UnconsolidatedPages, `SELECT COUNT(DISTINCT p.object_uuid) FROM paths p JOIN zones st ON st.domain_uuid=p.domain_uuid AND st.kind='street' AND st.state!='archived' AND ` + s.pathScopeSQL("st.path_prefix", "p.path") + ` WHERE p.domain_uuid=` + s.sqlParam(1) + ` AND NOT EXISTS(SELECT 1 FROM spots s JOIN street_spots ss ON ss.spot_uuid=s.uuid AND ss.street_uuid=st.uuid WHERE s.domain_uuid=st.domain_uuid AND s.state!='archived' AND ` + s.pathScopeSQL("s.path_prefix", "p.path") + `)`, []any{domainUUID}},
{&health.OrphanPages, `SELECT COUNT(DISTINCT p.object_uuid) FROM paths p WHERE p.domain_uuid=` + s.sqlParam(1) + ` AND NOT ` + s.pathScopeSQL("'/u'", "p.path") + ` AND NOT EXISTS(SELECT 1 FROM spot_pages sp JOIN spots s ON s.uuid=sp.spot_uuid AND s.domain_uuid=p.domain_uuid AND s.state!='archived' WHERE sp.page_uuid=p.object_uuid) AND NOT EXISTS(SELECT 1 FROM spots s WHERE s.domain_uuid=p.domain_uuid AND s.state!='archived' AND ` + s.pathScopeSQL("s.path_prefix", "p.path") + `)`, []any{domainUUID}},
{&health.BrokenRelations, `SELECT COUNT(*) FROM spot_relations r JOIN spots source ON source.uuid=r.source_spot_uuid AND source.domain_uuid=` + s.sqlParam(1) + ` WHERE source.state!='archived' AND NOT EXISTS(SELECT 1 FROM spots target WHERE target.uuid=r.target_spot_uuid AND target.domain_uuid=` + s.sqlParam(2) + ` AND target.state!='archived')`, []any{domainUUID, domainUUID}},
}
for _, item := range queries {
if err := tx.QueryRowContext(ctx, item.query, item.args...).Scan(item.target); err != nil {
@@ -76,14 +77,15 @@ func (s *Store) GetCityHealth(domainUUID string) (CityHealth, error) {
return health, nil
}
func (s *Store) ListTopologyEvents(domainUUID string, afterVersion int64, limit int) ([]TopologyEvent, error) {
func (s *Store) ListTopologyEvents(domainUUID string, afterVersion int64, limit int) (_ []TopologyEvent, resultErr error) {
defer func() { resultErr = s.sqlError("city events", resultErr) }()
if limit < 1 {
limit = 50
}
if limit > 200 {
limit = 200
}
rows, err := s.DB.Query(`SELECT id,domain_uuid,topology_version,actor_principal_uuid,operation,target_type,target_uuid,before_json,after_json,request_id,created_at_ms FROM topology_events WHERE domain_uuid=? AND topology_version>? ORDER BY topology_version DESC,id DESC LIMIT ?`, domainUUID, afterVersion, limit)
rows, err := s.DB.Query(`SELECT id,domain_uuid,topology_version,actor_principal_uuid,operation,target_type,target_uuid,before_json,after_json,request_id,created_at_ms FROM topology_events WHERE domain_uuid=`+s.sqlParam(1)+` AND topology_version>`+s.sqlParam(2)+` ORDER BY topology_version DESC,id DESC LIMIT `+s.sqlParam(3), domainUUID, afterVersion, limit)
if err != nil {
return nil, err
}
@@ -118,18 +120,19 @@ func (s *Store) ResolveCityPathContext(domainUUID, path string) (CityPathContext
return s.ResolveCityPathContextWithContext(context.Background(), domainUUID, path)
}
func (s *Store) ResolveCityPathContextWithContext(parent context.Context, domainUUID, path string) (CityPathContext, error) {
func (s *Store) ResolveCityPathContextWithContext(parent context.Context, domainUUID, path string) (_ CityPathContext, resultErr error) {
defer func() { resultErr = s.sqlError("city path context", resultErr) }()
path = normalizePath(path)
result := CityPathContext{}
ctx, cancel := context.WithTimeout(parent, cityReadTimeout)
defer cancel()
tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
tx, err := s.DB.BeginTx(ctx, s.policyReadOptions())
if err != nil {
return result, err
}
defer tx.Rollback()
var q CityNodeDetail
err = tx.QueryRowContext(ctx, `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='quartier' AND state!='archived' AND `+cityPathScopeSQL("path_prefix", "input.candidate")+` ORDER BY length(path_prefix) DESC,uuid LIMIT 1`, path, domainUUID).Scan(&q.UUID, &q.DomainUUID, &q.Kind, &q.ParentUUID, &q.Name, &q.Title, &q.Description, &q.State, &q.PathPrefix, &q.SortKey, &q.Version)
err = tx.QueryRowContext(ctx, `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='quartier' AND state!='archived' AND `+s.pathScopeSQL("path_prefix", "input.candidate")+` ORDER BY length(path_prefix) DESC,uuid LIMIT 1`, path, domainUUID).Scan(&q.UUID, &q.DomainUUID, &q.Kind, &q.ParentUUID, &q.Name, &q.Title, &q.Description, &q.State, &q.PathPrefix, &q.SortKey, &q.Version)
if err != nil && err != sql.ErrNoRows {
return result, err
}
@@ -138,7 +141,7 @@ func (s *Store) ResolveCityPathContextWithContext(parent context.Context, domain
}
result.Quartier = &q
var street CityNodeDetail
err = tx.QueryRowContext(ctx, `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='street' AND parent_uuid=? AND state!='archived' AND `+cityPathScopeSQL("path_prefix", "input.candidate")+` ORDER BY length(path_prefix) DESC,uuid LIMIT 1`, path, domainUUID, q.UUID).Scan(&street.UUID, &street.DomainUUID, &street.Kind, &street.ParentUUID, &street.Name, &street.Title, &street.Description, &street.State, &street.PathPrefix, &street.SortKey, &street.Version)
err = tx.QueryRowContext(ctx, `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='street' AND parent_uuid=`+s.sqlParam(3)+` AND state!='archived' AND `+s.pathScopeSQL("path_prefix", "input.candidate")+` ORDER BY length(path_prefix) DESC,uuid LIMIT 1`, path, domainUUID, q.UUID).Scan(&street.UUID, &street.DomainUUID, &street.Kind, &street.ParentUUID, &street.Name, &street.Title, &street.Description, &street.State, &street.PathPrefix, &street.SortKey, &street.Version)
if err != nil && err != sql.ErrNoRows {
return result, err
}
@@ -147,7 +150,7 @@ func (s *Store) ResolveCityPathContextWithContext(parent context.Context, domain
}
result.Street = &street
var spot CityNodeDetail
err = tx.QueryRowContext(ctx, `SELECT s.uuid,s.domain_uuid,'spot','',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 CROSS JOIN (SELECT ? AS candidate) input WHERE s.domain_uuid=? AND ss.street_uuid=? AND s.state!='archived' AND `+cityPathScopeSQL("s.path_prefix", "input.candidate")+` ORDER BY length(s.path_prefix) DESC,s.uuid LIMIT 1`, path, domainUUID, street.UUID).Scan(&spot.UUID, &spot.DomainUUID, &spot.Kind, &spot.ParentUUID, &spot.Name, &spot.Title, &spot.Description, &spot.State, &spot.PathPrefix, &spot.SortKey, &spot.Version)
err = tx.QueryRowContext(ctx, `SELECT s.uuid,s.domain_uuid,'spot','',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 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.pathScopeSQL("s.path_prefix", "input.candidate")+` ORDER BY length(s.path_prefix) DESC,s.uuid LIMIT 1`, path, domainUUID, street.UUID).Scan(&spot.UUID, &spot.DomainUUID, &spot.Kind, &spot.ParentUUID, &spot.Name, &spot.Title, &spot.Description, &spot.State, &spot.PathPrefix, &spot.SortKey, &spot.Version)
if err != nil && err != sql.ErrNoRows {
return result, err
}
+62 -41
View File
@@ -15,6 +15,19 @@ import (
var ErrCityChanged = errors.New("city_changed")
func (s *Store) cityMutationError(operation string, err error) error {
if err == nil || s.sqlBackend != storePostgreSQL {
return err
}
switch err.Error() {
case "city_invalid_title", "city_invalid_selection", "city_invalid_target", "city_too_many_pages", "city_too_many_relations", "city_name_conflict",
"city name must be 2-64 lowercase letters, digits, underscores, or hyphens",
"City Path boundaries of the same level must not overlap", "Street Path must be a strict descendant of its Quartier Path", "Spot Path must be a strict descendant of its Street Path":
return namespaceValidationError(err.Error())
}
return s.sqlError(operation, err)
}
type CityPageSelection struct {
SpotUUID string `json:"spot_uuid"`
PageUUID string `json:"page_uuid"`
@@ -40,9 +53,9 @@ type CityOrganizeResult struct {
Pages int `json:"pages"`
}
func checkCityVersion(tx *sql.Tx, domain string, expected int64) error {
func (s *Store) checkCityVersion(tx *sql.Tx, domain string, expected int64) error {
var version int64 = 1
err := tx.QueryRow(`SELECT version FROM domain_topology_versions WHERE domain_uuid=?`, domain).Scan(&version)
err := tx.QueryRow(`SELECT version FROM domain_topology_versions WHERE domain_uuid=`+s.sqlParam(1), domain).Scan(&version)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return err
}
@@ -52,8 +65,8 @@ func checkCityVersion(tx *sql.Tx, domain string, expected int64) error {
return nil
}
func recordCityOrganize(tx *sql.Tx, domain, actor, operation, kind, id string, before, after any) error {
if err := bumpTopologyVersion(tx, domain, actor, operation, kind, id); err != nil {
func (s *Store) recordCityOrganize(tx *sql.Tx, domain, actor, operation, kind, id string, before, after any) error {
if err := s.bumpTopologyVersion(tx, domain, actor, operation, kind, id); err != nil {
return err
}
b, err := json.Marshal(before)
@@ -64,13 +77,14 @@ func recordCityOrganize(tx *sql.Tx, domain, actor, operation, kind, id string, b
if err != nil {
return err
}
_, err = tx.Exec(`UPDATE topology_events SET before_json=?,after_json=? WHERE domain_uuid=? AND topology_version=(SELECT version FROM domain_topology_versions WHERE domain_uuid=?)`, string(b), string(a), domain, domain)
_, err = tx.Exec(`UPDATE topology_events SET before_json=`+s.sqlParam(1)+`,after_json=`+s.sqlParam(2)+` WHERE domain_uuid=`+s.sqlParam(3)+` AND topology_version=(SELECT version FROM domain_topology_versions WHERE domain_uuid=`+s.sqlParam(4)+`)`, string(b), string(a), domain, domain)
return err
}
// RenameCityTitle changes only the display title. UUIDs, name routes and Paths
// deliberately remain stable; renaming document URLs is a separate operation.
func (s *Store) RenameCityTitle(domain, actor, kind, id, title string, baseVersion int64) error {
func (s *Store) RenameCityTitle(domain, actor, kind, id, title string, baseVersion int64) (resultErr error) {
defer func() { resultErr = s.cityMutationError("rename city title", resultErr) }()
title = strings.TrimSpace(title)
if title == "" || utf8.RuneCountInString(title) > 160 {
return errors.New("city_invalid_title")
@@ -78,43 +92,45 @@ func (s *Store) RenameCityTitle(domain, actor, kind, id, title string, baseVersi
if kind != "quartier" && kind != "street" && kind != "spot" {
return errors.New("city_invalid_selection")
}
tx, err := s.DB.Begin()
tx, cancel, err := s.beginPathMutation(domain)
defer cancel()
if err != nil {
return err
}
defer tx.Rollback()
if err = checkCityVersion(tx, domain, baseVersion); err != nil {
if err = s.checkCityVersion(tx, domain, baseVersion); err != nil {
return err
}
table, condition := "zones", " AND kind=?"
table, condition := "zones", " AND kind="+s.sqlParam(3)
args := []any{id, domain, kind}
if kind == "spot" {
table, condition, args = "spots", "", []any{id, domain}
}
var old string
if err = tx.QueryRow(`SELECT title FROM `+table+` WHERE uuid=? AND domain_uuid=? AND state!='archived'`+condition, args...).Scan(&old); err != nil {
if err = tx.QueryRow(`SELECT title FROM `+table+` WHERE uuid=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+` AND state!='archived'`+condition, args...).Scan(&old); err != nil {
return err
}
if old == title {
return nil
}
if _, err = tx.Exec(`UPDATE `+table+` SET title=?,version=version+1,updated_at_ms=? WHERE uuid=? AND domain_uuid=?`, title, time.Now().UnixMilli(), id, domain); err != nil {
if _, err = tx.Exec(`UPDATE `+table+` SET title=`+s.sqlParam(1)+`,version=version+1,updated_at_ms=`+s.sqlParam(2)+` WHERE uuid=`+s.sqlParam(3)+` AND domain_uuid=`+s.sqlParam(4), title, time.Now().UnixMilli(), id, domain); err != nil {
return err
}
if err = recordCityOrganize(tx, domain, actor, "city.title.changed", kind, id, map[string]string{"title": old}, map[string]string{"title": title}); err != nil {
if err = s.recordCityOrganize(tx, domain, actor, "city.title.changed", kind, id, map[string]string{"title": old}, map[string]string{"title": title}); err != nil {
return err
}
return tx.Commit()
}
func activeCitySpot(tx *sql.Tx, domain, id string) error {
func (s *Store) activeCitySpot(tx *sql.Tx, domain, id string) error {
var found int
return tx.QueryRow(`SELECT 1 FROM spots s JOIN street_spots ss ON ss.spot_uuid=s.uuid JOIN zones z ON z.uuid=ss.street_uuid AND z.domain_uuid=s.domain_uuid AND z.kind='street' AND z.state!='archived' WHERE s.uuid=? AND s.domain_uuid=? AND s.state!='archived'`, id, domain).Scan(&found)
return tx.QueryRow(`SELECT 1 FROM spots s JOIN street_spots ss ON ss.spot_uuid=s.uuid JOIN zones z ON z.uuid=ss.street_uuid AND z.domain_uuid=s.domain_uuid AND z.kind='street' AND z.state!='archived' WHERE s.uuid=`+s.sqlParam(1)+` AND s.domain_uuid=`+s.sqlParam(2)+` AND s.state!='archived'`, id, domain).Scan(&found)
}
// OrganizeCity changes City membership only, atomically. Document Paths,
// revisions and payloads are never renamed or removed by this operation.
func (s *Store) OrganizeCity(domain, actor string, req CityOrganizeRequest) (CityOrganizeResult, error) {
func (s *Store) OrganizeCity(domain, actor string, req CityOrganizeRequest) (_ CityOrganizeResult, resultErr error) {
defer func() { resultErr = s.cityMutationError("organize city", resultErr) }()
out := CityOrganizeResult{}
if len(req.Spots)+len(req.Pages) == 0 || len(req.Spots)+len(req.Pages) > 200 || (req.Action != "merge" && req.Action != "move") {
return out, errors.New("city_invalid_selection")
@@ -125,12 +141,13 @@ func (s *Store) OrganizeCity(domain, actor string, req CityOrganizeRequest) (Cit
if req.Action == "move" && (len(req.Pages) > 0 || req.StreetUUID == "" || req.NewSpot != nil || req.TargetSpotUUID != "" || (req.PathPrefix != "" && len(req.Spots) != 1)) {
return out, errors.New("city_invalid_target")
}
tx, err := s.DB.Begin()
tx, cancel, err := s.beginPathMutation(domain)
defer cancel()
if err != nil {
return out, err
}
defer tx.Rollback()
if err = checkCityVersion(tx, domain, req.BaseVersion); err != nil {
if err = s.checkCityVersion(tx, domain, req.BaseVersion); err != nil {
return out, err
}
whole := map[string]bool{}
@@ -160,15 +177,15 @@ func (s *Store) OrganizeCity(domain, actor string, req CityOrganizeRequest) (Cit
uniquePages := map[string]bool{}
total := 0
for id, pages := range selected {
if err = activeCitySpot(tx, domain, id); err != nil {
if err = s.activeCitySpot(tx, domain, id); err != nil {
return out, err
}
var oldPath, oldStreet string
if err = tx.QueryRow(`SELECT s.path_prefix,ss.street_uuid FROM spots s JOIN street_spots ss ON ss.spot_uuid=s.uuid WHERE s.uuid=? AND s.domain_uuid=?`, id, domain).Scan(&oldPath, &oldStreet); err != nil {
if err = tx.QueryRow(`SELECT s.path_prefix,ss.street_uuid FROM spots s JOIN street_spots ss ON ss.spot_uuid=s.uuid WHERE s.uuid=`+s.sqlParam(1)+` AND s.domain_uuid=`+s.sqlParam(2), id, domain).Scan(&oldPath, &oldStreet); err != nil {
return out, err
}
sourceBoundaries[id] = map[string]string{"path_prefix": oldPath, "street_uuid": oldStreet}
items, e := listSpotPages(tx, domain, id, 2001)
items, e := s.listSpotPages(tx, domain, id, 2001)
if e != nil {
return out, e
}
@@ -201,10 +218,10 @@ func (s *Store) OrganizeCity(domain, actor string, req CityOrganizeRequest) (Cit
now := time.Now().UnixMilli()
if req.Action == "move" {
var streetPath string
if err = tx.QueryRow(`SELECT path_prefix FROM zones WHERE uuid=? AND domain_uuid=? AND kind='street' AND state!='archived'`, req.StreetUUID, domain).Scan(&streetPath); err != nil {
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'`, req.StreetUUID, domain).Scan(&streetPath); err != nil {
return out, err
}
boundaries, e := loadCityBoundaries(tx, domain)
boundaries, e := s.loadCityBoundaries(tx, domain)
if e != nil {
return out, e
}
@@ -222,10 +239,10 @@ func (s *Store) OrganizeCity(domain, actor string, req CityOrganizeRequest) (Cit
}
for _, b := range boundaries {
if whole[b.id] {
if _, err = tx.Exec(`UPDATE spots SET path_prefix=?,version=version+1,updated_at_ms=? WHERE uuid=? AND domain_uuid=?`, b.path, now, b.id, domain); err != nil {
if _, err = tx.Exec(`UPDATE spots 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), b.path, now, b.id, domain); err != nil {
return out, err
}
if _, err = tx.Exec(`UPDATE street_spots SET street_uuid=? WHERE spot_uuid=?`, req.StreetUUID, b.id); err != nil {
if _, err = tx.Exec(`UPDATE street_spots SET street_uuid=`+s.sqlParam(1)+` WHERE spot_uuid=`+s.sqlParam(2), req.StreetUUID, b.id); err != nil {
return out, err
}
}
@@ -241,7 +258,7 @@ func (s *Store) OrganizeCity(domain, actor string, req CityOrganizeRequest) (Cit
if strings.TrimSpace(n.Title) == "" || utf8.RuneCountInString(n.Title) > 160 || strings.TrimSpace(n.PathPrefix) == "" {
return out, errors.New("city_invalid_title")
}
boundaries, e := loadCityBoundaries(tx, domain)
boundaries, e := s.loadCityBoundaries(tx, domain)
if e != nil {
return out, e
}
@@ -259,20 +276,20 @@ func (s *Store) OrganizeCity(domain, actor string, req CityOrganizeRequest) (Cit
return out, err
}
var collision int
if err = tx.QueryRow(`SELECT COUNT(*) FROM spots WHERE domain_uuid=? AND name=?`, domain, name).Scan(&collision); err != nil {
if err = tx.QueryRow(`SELECT COUNT(*) FROM spots WHERE domain_uuid=`+s.sqlParam(1)+` AND name=`+s.sqlParam(2), domain, name).Scan(&collision); err != nil {
return out, err
}
if collision != 0 {
return out, errors.New("city_name_conflict")
}
if _, err = tx.Exec(`INSERT INTO spots(uuid,domain_uuid,name,title,path_prefix,state,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,'draft',?,?)`, id, domain, name, strings.TrimSpace(n.Title), normalizePath(n.PathPrefix), now, now); err != nil {
if _, err = tx.Exec(`INSERT INTO spots(uuid,domain_uuid,name,title,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)+`,'draft',`+s.sqlParam(6)+`,`+s.sqlParam(7)+`)`, id, domain, name, strings.TrimSpace(n.Title), normalizePath(n.PathPrefix), now, now); err != nil {
return out, err
}
if _, err = tx.Exec(`INSERT INTO street_spots(street_uuid,spot_uuid,created_at_ms) VALUES(?,?,?)`, n.StreetUUID, id, now); err != nil {
if _, err = tx.Exec(`INSERT INTO street_spots(street_uuid,spot_uuid,created_at_ms) VALUES(`+s.sqlValues(3)+`)`, n.StreetUUID, id, now); err != nil {
return out, err
}
out.TargetSpotUUID = id
} else if err = activeCitySpot(tx, domain, out.TargetSpotUUID); err != nil {
} else if err = s.activeCitySpot(tx, domain, out.TargetSpotUUID); err != nil {
return out, err
}
}
@@ -286,14 +303,14 @@ func (s *Store) OrganizeCity(domain, actor string, req CityOrganizeRequest) (Cit
if edge == "path" {
edge = "primary"
}
if _, err = tx.Exec(`INSERT INTO spot_pages(spot_uuid,page_uuid,edge_type,label,sort_key,featured,source,created_at_ms) VALUES(?,?,?,?,?,?,'organizer',?) ON CONFLICT(spot_uuid,page_uuid,edge_type) DO UPDATE SET label=CASE WHEN spot_pages.label='' THEN excluded.label ELSE spot_pages.label END,featured=MAX(spot_pages.featured,excluded.featured)`, dest, item.PageUUID, edge, item.Label, item.SortKey, item.Featured, now); err != nil {
if _, err = tx.Exec(`INSERT INTO spot_pages(spot_uuid,page_uuid,edge_type,label,sort_key,featured,source,created_at_ms) VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`,'organizer',`+s.sqlParam(7)+`) ON CONFLICT(spot_uuid,page_uuid,edge_type) DO UPDATE SET label=CASE WHEN spot_pages.label='' THEN excluded.label ELSE spot_pages.label END,featured=CASE WHEN spot_pages.featured>excluded.featured THEN spot_pages.featured ELSE excluded.featured END`, dest, item.PageUUID, edge, item.Label, item.SortKey, boolToInt(item.Featured), now); err != nil {
return out, err
}
if _, err = tx.Exec(`INSERT INTO city_page_overrides(domain_uuid,page_uuid,spot_uuid) VALUES(?,?,?) ON CONFLICT(domain_uuid,page_uuid) DO UPDATE SET spot_uuid=excluded.spot_uuid`, domain, item.PageUUID, dest); err != nil {
if _, err = tx.Exec(`INSERT INTO city_page_overrides(domain_uuid,page_uuid,spot_uuid) VALUES(`+s.sqlValues(3)+`) ON CONFLICT(domain_uuid,page_uuid) DO UPDATE SET spot_uuid=excluded.spot_uuid`, domain, item.PageUUID, dest); err != nil {
return out, err
}
if req.Action == "merge" && !whole[source] {
if _, err = tx.Exec(`DELETE FROM spot_pages WHERE spot_uuid=? AND page_uuid=?`, source, item.PageUUID); err != nil {
if _, err = tx.Exec(`DELETE FROM spot_pages WHERE spot_uuid=`+s.sqlParam(1)+` AND page_uuid=`+s.sqlParam(2), source, item.PageUUID); err != nil {
return out, err
}
}
@@ -302,7 +319,11 @@ func (s *Store) OrganizeCity(domain, actor string, req CityOrganizeRequest) (Cit
if req.Action == "merge" && len(whole) > 0 {
// Redirect graph relations in one pass; internal/self edges disappear,
// duplicate relations retain the greater weight. No unrelated edges change.
placeholders := strings.TrimSuffix(strings.Repeat("?,", len(req.Spots)), ",")
left, right := make([]string, len(req.Spots)), make([]string, len(req.Spots))
for i := range req.Spots {
left[i] = s.sqlParam(3 + i)
right[i] = s.sqlParam(3 + len(req.Spots) + i)
}
args := []any{domain, domain}
for _, id := range req.Spots {
args = append(args, id)
@@ -310,7 +331,7 @@ func (s *Store) OrganizeCity(domain, actor string, req CityOrganizeRequest) (Cit
for _, id := range req.Spots {
args = append(args, id)
}
rows, e := tx.Query(`SELECT r.source_spot_uuid,r.target_spot_uuid,r.relation_type,r.weight FROM spot_relations r JOIN spots a ON a.uuid=r.source_spot_uuid JOIN spots b ON b.uuid=r.target_spot_uuid WHERE a.domain_uuid=? AND b.domain_uuid=? AND (r.source_spot_uuid IN (`+placeholders+`) OR r.target_spot_uuid IN (`+placeholders+`)) LIMIT 2001`, args...)
rows, e := tx.Query(`SELECT r.source_spot_uuid,r.target_spot_uuid,r.relation_type,r.weight FROM spot_relations r JOIN spots a ON a.uuid=r.source_spot_uuid JOIN spots b ON b.uuid=r.target_spot_uuid WHERE a.domain_uuid=`+s.sqlParam(1)+` AND b.domain_uuid=`+s.sqlParam(2)+` AND (r.source_spot_uuid IN (`+strings.Join(left, ",")+`) OR r.target_spot_uuid IN (`+strings.Join(right, ",")+`)) LIMIT 2001`, args...)
if e != nil {
return out, e
}
@@ -334,7 +355,7 @@ func (s *Store) OrganizeCity(domain, actor string, req CityOrganizeRequest) (Cit
return out, errors.New("city_too_many_relations")
}
for _, r := range relations {
if _, err = tx.Exec(`DELETE FROM spot_relations WHERE source_spot_uuid=? AND target_spot_uuid=? AND relation_type=?`, r.SourceSpotUUID, r.TargetSpotUUID, r.RelationType); err != nil {
if _, 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), r.SourceSpotUUID, r.TargetSpotUUID, r.RelationType); err != nil {
return out, err
}
}
@@ -348,27 +369,27 @@ func (s *Store) OrganizeCity(domain, actor string, req CityOrganizeRequest) (Cit
if r.SourceSpotUUID == r.TargetSpotUUID {
continue
}
if _, err = tx.Exec(`INSERT INTO spot_relations(source_spot_uuid,target_spot_uuid,relation_type,weight,created_at_ms) VALUES(?,?,?,?,?) ON CONFLICT(source_spot_uuid,target_spot_uuid,relation_type) DO UPDATE SET weight=MAX(spot_relations.weight,excluded.weight)`, r.SourceSpotUUID, r.TargetSpotUUID, r.RelationType, r.Weight, now); err != nil {
if _, err = tx.Exec(`INSERT INTO spot_relations(source_spot_uuid,target_spot_uuid,relation_type,weight,created_at_ms) VALUES(`+s.sqlValues(5)+`) ON CONFLICT(source_spot_uuid,target_spot_uuid,relation_type) DO UPDATE SET weight=CASE WHEN spot_relations.weight>excluded.weight THEN spot_relations.weight ELSE excluded.weight END`, r.SourceSpotUUID, r.TargetSpotUUID, r.RelationType, r.Weight, now); err != nil {
return out, err
}
}
for id := range whole {
if _, err = tx.Exec(`UPDATE spots SET state='archived',version=version+1,updated_at_ms=? WHERE uuid=? AND domain_uuid=?`, now, id, domain); err != nil {
if _, 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), now, id, domain); err != nil {
return out, err
}
if _, err = tx.Exec(`DELETE FROM street_spots WHERE spot_uuid=?`, id); err != nil {
if _, err = tx.Exec(`DELETE FROM street_spots WHERE spot_uuid=`+s.sqlParam(1), id); err != nil {
return out, err
}
if _, err = tx.Exec(`DELETE FROM spot_pages WHERE spot_uuid=?`, id); err != nil {
if _, err = tx.Exec(`DELETE FROM spot_pages WHERE spot_uuid=`+s.sqlParam(1), id); err != nil {
return out, err
}
// Includes earlier manual placements whose Page has since disappeared.
if _, err = tx.Exec(`UPDATE city_page_overrides SET spot_uuid=? WHERE domain_uuid=? AND spot_uuid=?`, out.TargetSpotUUID, domain, id); err != nil {
if _, err = tx.Exec(`UPDATE city_page_overrides SET spot_uuid=`+s.sqlParam(1)+` WHERE domain_uuid=`+s.sqlParam(2)+` AND spot_uuid=`+s.sqlParam(3), out.TargetSpotUUID, domain, id); err != nil {
return out, err
}
}
}
if err = recordCityOrganize(tx, domain, actor, "city.organize."+req.Action, "spot", out.TargetSpotUUID, map[string]any{"request": req, "placements": placements, "boundaries": sourceBoundaries}, out); err != nil {
if err = s.recordCityOrganize(tx, domain, actor, "city.organize."+req.Action, "spot", out.TargetSpotUUID, map[string]any{"request": req, "placements": placements, "boundaries": sourceBoundaries}, out); err != nil {
return out, fmt.Errorf("record City operation: %w", err)
}
return out, tx.Commit()
+35 -27
View File
@@ -1,6 +1,7 @@
package store
import (
"context"
"database/sql"
"encoding/json"
"errors"
@@ -32,22 +33,27 @@ type CityPlanPreview struct {
Valid bool `json:"valid"`
}
func (s *Store) PreviewCityPlan(domainUUID string, plan CityPlan) (CityPlanPreview, error) {
tx, err := s.DB.Begin()
func (s *Store) PreviewCityPlan(domainUUID string, plan CityPlan) (result CityPlanPreview, resultErr error) {
defer func() { resultErr = s.sqlError("city plan preview", resultErr) }()
ctx, cancel := context.WithTimeout(context.Background(), cityReadTimeout)
defer cancel()
tx, err := s.DB.BeginTx(ctx, s.policyReadOptions())
if err != nil {
return CityPlanPreview{}, err
}
defer tx.Rollback()
return validateCityPlan(tx, domainUUID, plan)
return s.validateCityPlan(tx, domainUUID, plan)
}
func (s *Store) ApplyCityPlan(domainUUID, actor string, plan CityPlan) (CityPlanPreview, error) {
tx, err := s.DB.Begin()
func (s *Store) ApplyCityPlan(domainUUID, actor string, plan CityPlan) (result CityPlanPreview, resultErr error) {
defer func() { resultErr = s.sqlError("city plan apply", resultErr) }()
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
if err != nil {
return CityPlanPreview{}, err
}
defer tx.Rollback()
preview, err := validateCityPlan(tx, domainUUID, plan)
preview, err := s.validateCityPlan(tx, domainUUID, plan)
if err != nil {
return preview, err
}
@@ -59,50 +65,52 @@ func (s *Store) ApplyCityPlan(domainUUID, actor string, plan CityPlan) (CityPlan
if operation.Kind == "spot" {
table = "spots"
}
if _, err := tx.Exec(`UPDATE `+table+` SET path_prefix=?,version=version+1,updated_at_ms=? WHERE uuid=? AND domain_uuid=? AND state!='archived'`, normalizePath(operation.PathPrefix), now, operation.UUID, domainUUID); err != nil {
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)+` AND state!='archived'`, normalizePath(operation.PathPrefix), now, operation.UUID, domainUUID); err != nil {
return preview, err
}
case "move_street":
if _, 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'`, operation.ParentUUID, operation.SortKey, now, operation.UUID, domainUUID); err != nil {
if _, 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'`, operation.ParentUUID, operation.SortKey, now, operation.UUID, domainUUID); err != nil {
return preview, err
}
case "move_spot":
if _, err := tx.Exec(`UPDATE street_spots SET street_uuid=?,sort_key=? WHERE spot_uuid=?`, operation.StreetUUID, operation.SortKey, operation.UUID); err != nil {
if _, err := tx.Exec(`UPDATE street_spots SET street_uuid=`+s.sqlParam(1)+`,sort_key=`+s.sqlParam(2)+` WHERE spot_uuid=`+s.sqlParam(3)+``, operation.StreetUUID, operation.SortKey, operation.UUID); err != nil {
return preview, err
}
if _, err := tx.Exec(`UPDATE spots SET version=version+1,updated_at_ms=? WHERE uuid=? AND domain_uuid=?`, now, operation.UUID, domainUUID); err != nil {
if _, err := tx.Exec(`UPDATE spots SET version=version+1,updated_at_ms=`+s.sqlParam(1)+` WHERE uuid=`+s.sqlParam(2)+` AND domain_uuid=`+s.sqlParam(3)+``, now, operation.UUID, domainUUID); err != nil {
return preview, err
}
}
}
beforeJSON, _ := json.Marshal(preview.Before)
afterJSON, _ := json.Marshal(preview.After)
if _, 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); err != nil {
if _, 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); err != nil {
return preview, err
}
var version int64
if err := tx.QueryRow(`SELECT version FROM domain_topology_versions WHERE domain_uuid=?`, domainUUID).Scan(&version); err != nil {
if err := tx.QueryRow(`SELECT version FROM domain_topology_versions WHERE domain_uuid=`+s.sqlParam(1)+``, domainUUID).Scan(&version); err != nil {
return preview, err
}
if _, err := tx.Exec(`INSERT INTO topology_events(domain_uuid,topology_version,actor_principal_uuid,operation,target_type,target_uuid,before_json,after_json,request_id,created_at_ms) VALUES(?,?,?,?,?,?,?,?,?,?)`, domainUUID, version, actor, "city.plan.applied", "plan", plan.RequestID, string(beforeJSON), string(afterJSON), plan.RequestID, now); err != nil {
if _, err := tx.Exec(`INSERT INTO topology_events(domain_uuid,topology_version,actor_principal_uuid,operation,target_type,target_uuid,before_json,after_json,request_id,created_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)+`,`+s.sqlParam(9)+`,`+s.sqlParam(10)+`)`, domainUUID, version, actor, "city.plan.applied", "plan", plan.RequestID, string(beforeJSON), string(afterJSON), plan.RequestID, now); err != nil {
return preview, err
}
preview.BaseVersion = version
return preview, tx.Commit()
}
func validateCityPlan(tx *sql.Tx, domainUUID string, plan CityPlan) (CityPlanPreview, error) {
func (s *Store) validateCityPlan(tx *sql.Tx, domainUUID string, plan CityPlan) (CityPlanPreview, error) {
preview := CityPlanPreview{DomainUUID: domainUUID, Before: []map[string]any{}, After: []map[string]any{}}
var version int64 = 1
_ = tx.QueryRow(`SELECT version FROM domain_topology_versions WHERE domain_uuid=?`, domainUUID).Scan(&version)
if err := tx.QueryRow(`SELECT version FROM domain_topology_versions WHERE domain_uuid=`+s.sqlParam(1), domainUUID).Scan(&version); err != nil && !errors.Is(err, sql.ErrNoRows) {
return preview, err
}
preview.BaseVersion = version
if plan.BaseVersion != 0 && plan.BaseVersion != version {
return preview, errors.New("topology version changed; preview the plan again")
return preview, namespaceValidationError("topology version changed; preview the plan again")
}
if len(plan.Operations) == 0 || len(plan.Operations) > 500 {
return preview, errors.New("a City plan requires 1-500 operations")
return preview, namespaceValidationError("a City plan requires 1-500 operations")
}
items, err := loadCityBoundaries(tx, domainUUID)
items, err := s.loadCityBoundaries(tx, domainUUID)
if err != nil {
return preview, err
}
@@ -118,11 +126,11 @@ func validateCityPlan(tx *sql.Tx, domainUUID string, plan CityPlan) (CityPlanPre
op.Kind = strings.ToLower(strings.TrimSpace(op.Kind))
item := byID[op.UUID]
if item == nil {
return preview, errors.New("City plan references an unknown node")
return preview, namespaceValidationError("City plan references an unknown node")
}
key := op.Action + ":" + op.UUID
if seen[key] {
return preview, errors.New("City plan contains a duplicate operation")
return preview, namespaceValidationError("City plan contains a duplicate operation")
}
seen[key] = true
switch op.Action {
@@ -131,32 +139,32 @@ func validateCityPlan(tx *sql.Tx, domainUUID string, plan CityPlan) (CityPlanPre
op.Kind = item.kind
}
if op.Kind != item.kind {
return preview, errors.New("City plan node kind does not match")
return preview, namespaceValidationError("City plan node kind does not match")
}
before := item.path
item.path = normalizePath(op.PathPrefix)
if item.path == "/" && item.kind != "quartier" {
return preview, errors.New("only a Quartier may bind the Domain root")
return preview, namespaceValidationError("only a Quartier may bind the Domain root")
}
changed[item.id] = true
preview.Before = append(preview.Before, map[string]any{"action": op.Action, "kind": item.kind, "uuid": item.id, "path_prefix": before})
preview.After = append(preview.After, map[string]any{"action": op.Action, "kind": item.kind, "uuid": item.id, "path_prefix": item.path})
case "move_street":
if item.kind != "street" || byID[op.ParentUUID] == nil || byID[op.ParentUUID].kind != "quartier" {
return preview, errors.New("move_street requires a Street and destination Quartier")
return preview, namespaceValidationError("move_street requires a Street and destination Quartier")
}
preview.Before = append(preview.Before, map[string]any{"action": op.Action, "uuid": item.id, "parent_uuid": item.parent})
item.parent = op.ParentUUID
preview.After = append(preview.After, map[string]any{"action": op.Action, "uuid": item.id, "parent_uuid": item.parent, "sort_key": op.SortKey})
case "move_spot":
if item.kind != "spot" || byID[op.StreetUUID] == nil || byID[op.StreetUUID].kind != "street" {
return preview, errors.New("move_spot requires a Spot and destination Street")
return preview, namespaceValidationError("move_spot requires a Spot and destination Street")
}
preview.Before = append(preview.Before, map[string]any{"action": op.Action, "uuid": item.id, "street_uuid": item.parent})
item.parent = op.StreetUUID
preview.After = append(preview.After, map[string]any{"action": op.Action, "uuid": item.id, "street_uuid": item.parent, "sort_key": op.SortKey})
default:
return preview, errors.New("unsupported City plan operation")
return preview, namespaceValidationError("unsupported City plan operation")
}
}
if err := validateCityBoundaryChanges(items, changed); err != nil {
@@ -166,13 +174,13 @@ func validateCityPlan(tx *sql.Tx, domainUUID string, plan CityPlan) (CityPlanPre
if item.kind == "street" {
parent := byID[item.parent]
if parent == nil || parent.kind != "quartier" || !cityPathContains(parent.path, item.path) {
return preview, errors.New("Street Path must be a strict descendant of its Quartier Path")
return preview, namespaceValidationError("Street Path must be a strict descendant of its Quartier Path")
}
}
if item.kind == "spot" {
parent := byID[item.parent]
if parent == nil || parent.kind != "street" || !cityPathContains(parent.path, item.path) {
return preview, errors.New("Spot Path must be a strict descendant of its Street Path")
return preview, namespaceValidationError("Spot Path must be a strict descendant of its Street Path")
}
}
}
+61
View File
@@ -0,0 +1,61 @@
package store
import (
"context"
"pageswiki/internal/db"
)
// Native schema shared by City CRUD, governance and publication. Normal server
// and scheduled reconciliation still require the remaining application ports.
func (s *Store) ensurePostgreSQLCityFoundation(ctx context.Context) error {
return db.ApplyPostgreSQLMigrations(ctx, s.DB, "store-city-foundation", []db.PostgreSQLMigration{{
Version: 1, Name: "City hierarchy governance and publication storage",
Statements: []string{
`CREATE TABLE domain_topology_versions (domain_uuid TEXT COLLATE "C" PRIMARY KEY,version BIGINT NOT NULL DEFAULT 1,updated_at_ms BIGINT NOT NULL)`,
`CREATE TABLE zones (uuid TEXT COLLATE "C" PRIMARY KEY,domain_uuid TEXT COLLATE "C" NOT NULL,kind TEXT COLLATE "C" NOT NULL,parent_uuid TEXT COLLATE "C",name TEXT COLLATE "C" NOT NULL,title TEXT COLLATE "C" NOT NULL DEFAULT '',description TEXT COLLATE "C" NOT NULL DEFAULT '',path_prefix TEXT COLLATE "C" NOT NULL DEFAULT '',charter_json TEXT COLLATE "C" NOT NULL DEFAULT '{}',policy_json TEXT COLLATE "C" NOT NULL DEFAULT '{}',state TEXT COLLATE "C" NOT NULL DEFAULT 'draft',sort_key BIGINT NOT NULL DEFAULT 0,version BIGINT NOT NULL DEFAULT 1,created_at_ms BIGINT NOT NULL,updated_at_ms BIGINT NOT NULL,UNIQUE(domain_uuid,parent_uuid,name))`,
`CREATE UNIQUE INDEX idx_zones_quartier_name ON zones(domain_uuid,name) WHERE kind='quartier'`,
`CREATE INDEX idx_zones_parent ON zones(domain_uuid,parent_uuid,sort_key,name)`,
`CREATE TABLE spots (uuid TEXT COLLATE "C" PRIMARY KEY,domain_uuid TEXT COLLATE "C" NOT NULL,name TEXT COLLATE "C" NOT NULL,title TEXT COLLATE "C" NOT NULL DEFAULT '',summary TEXT COLLATE "C" NOT NULL DEFAULT '',path_prefix TEXT COLLATE "C" NOT NULL DEFAULT '',charter_json TEXT COLLATE "C" NOT NULL DEFAULT '{}',schema_json TEXT COLLATE "C" NOT NULL DEFAULT '{}',landing_json TEXT COLLATE "C" NOT NULL DEFAULT '{}',state TEXT COLLATE "C" NOT NULL DEFAULT 'draft',version BIGINT NOT NULL DEFAULT 1,created_at_ms BIGINT NOT NULL,updated_at_ms BIGINT NOT NULL,UNIQUE(domain_uuid,name))`,
`CREATE TABLE street_spots (street_uuid TEXT COLLATE "C" NOT NULL,spot_uuid TEXT COLLATE "C" NOT NULL UNIQUE,sort_key BIGINT NOT NULL DEFAULT 0,section TEXT COLLATE "C" NOT NULL DEFAULT '',created_at_ms BIGINT NOT NULL,PRIMARY KEY(street_uuid,spot_uuid))`,
`CREATE TABLE spot_pages (spot_uuid TEXT COLLATE "C" NOT NULL,page_uuid TEXT COLLATE "C" NOT NULL,edge_type TEXT COLLATE "C" NOT NULL DEFAULT 'primary',label TEXT COLLATE "C" NOT NULL DEFAULT '',sort_key BIGINT NOT NULL DEFAULT 0,featured BIGINT NOT NULL DEFAULT 0,source TEXT COLLATE "C" NOT NULL DEFAULT 'local',created_at_ms BIGINT NOT NULL,PRIMARY KEY(spot_uuid,page_uuid,edge_type))`,
`CREATE TABLE spot_relations (source_spot_uuid TEXT COLLATE "C" NOT NULL,target_spot_uuid TEXT COLLATE "C" NOT NULL,relation_type TEXT COLLATE "C" NOT NULL,weight DOUBLE PRECISION NOT NULL DEFAULT 1.0,created_at_ms BIGINT NOT NULL,PRIMARY KEY(source_spot_uuid,target_spot_uuid,relation_type))`,
`CREATE INDEX idx_spot_relations_target ON spot_relations(target_spot_uuid,source_spot_uuid,relation_type)`,
`CREATE TABLE street_inbox_pages (street_uuid TEXT COLLATE "C" NOT NULL,page_uuid TEXT COLLATE "C" NOT NULL,created_at_ms BIGINT NOT NULL,PRIMARY KEY(street_uuid,page_uuid))`,
`CREATE TABLE city_page_overrides (domain_uuid TEXT COLLATE "C" NOT NULL,page_uuid TEXT COLLATE "C" NOT NULL,spot_uuid TEXT COLLATE "C" NOT NULL,PRIMARY KEY(domain_uuid,page_uuid))`,
`CREATE INDEX idx_city_page_overrides_spot ON city_page_overrides(domain_uuid,spot_uuid,page_uuid)`,
`CREATE TABLE topology_events (id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,domain_uuid TEXT COLLATE "C" NOT NULL,topology_version BIGINT NOT NULL,actor_principal_uuid TEXT COLLATE "C" NOT NULL DEFAULT '',operation TEXT COLLATE "C" NOT NULL,target_type TEXT COLLATE "C" NOT NULL,target_uuid TEXT COLLATE "C" NOT NULL,before_json TEXT COLLATE "C" NOT NULL DEFAULT '{}',after_json TEXT COLLATE "C" NOT NULL DEFAULT '{}',request_id TEXT COLLATE "C" NOT NULL DEFAULT '',created_at_ms BIGINT NOT NULL)`,
`CREATE TABLE city_governance_epochs(domain_uuid TEXT COLLATE "C" PRIMARY KEY,version BIGINT NOT NULL DEFAULT 0)`,
`CREATE TABLE locality_publication_policies(domain_uuid TEXT COLLATE "C" NOT NULL,node_kind TEXT COLLATE "C" NOT NULL CHECK(node_kind IN ('domain','quartier','street','spot')),node_uuid TEXT COLLATE "C" NOT NULL,policy TEXT COLLATE "C" NOT NULL CHECK(policy IN ('inherit','public','authenticated_acl')),actor_uuid TEXT COLLATE "C" NOT NULL,updated_at_ms BIGINT NOT NULL,PRIMARY KEY(domain_uuid,node_kind,node_uuid))`,
`CREATE TABLE city_owner_bindings(domain_uuid TEXT COLLATE "C" NOT NULL,node_kind TEXT COLLATE "C" NOT NULL CHECK(node_kind IN ('quartier','spot')),node_uuid TEXT COLLATE "C" NOT NULL,membership_uuid TEXT COLLATE "C" NOT NULL,actor_uuid TEXT COLLATE "C" NOT NULL,created_at_ms BIGINT NOT NULL,PRIMARY KEY(domain_uuid,node_kind,node_uuid,membership_uuid))`,
`CREATE INDEX idx_city_owner_member ON city_owner_bindings(domain_uuid,membership_uuid,node_kind,node_uuid)`,
`CREATE TABLE city_governance_events(id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,domain_uuid TEXT COLLATE "C" NOT NULL,epoch BIGINT NOT NULL,actor_uuid TEXT COLLATE "C" NOT NULL,node_kind TEXT COLLATE "C" NOT NULL,node_uuid TEXT COLLATE "C" NOT NULL,before_json TEXT COLLATE "C" NOT NULL,after_json TEXT COLLATE "C" NOT NULL,created_at_ms BIGINT NOT NULL)`,
`CREATE INDEX idx_city_governance_events ON city_governance_events(domain_uuid,epoch)`,
`CREATE TABLE locality_publication_versions(domain_uuid TEXT COLLATE "C" NOT NULL,node_kind TEXT COLLATE "C" NOT NULL,node_uuid TEXT COLLATE "C" NOT NULL,version BIGINT NOT NULL,PRIMARY KEY(domain_uuid,node_kind,node_uuid))`,
`CREATE TABLE locality_publication_manifests(domain_uuid TEXT COLLATE "C" NOT NULL,node_kind TEXT COLLATE "C" NOT NULL,node_uuid TEXT COLLATE "C" NOT NULL,epoch BIGINT NOT NULL,topology_version BIGINT NOT NULL,actor_uuid TEXT COLLATE "C" NOT NULL,created_at_ms BIGINT NOT NULL,PRIMARY KEY(domain_uuid,node_kind,node_uuid))`,
`CREATE TABLE locality_publication_entries(domain_uuid TEXT COLLATE "C" NOT NULL,node_kind TEXT COLLATE "C" NOT NULL,node_uuid TEXT COLLATE "C" NOT NULL,path TEXT COLLATE "C" NOT NULL,object_uuid TEXT COLLATE "C" NOT NULL,revision_uuid TEXT COLLATE "C" NOT NULL,document_hash TEXT COLLATE "C" NOT NULL,lang TEXT COLLATE "C" NOT NULL,PRIMARY KEY(domain_uuid,node_kind,node_uuid,path,lang))`,
`CREATE INDEX idx_publication_path ON locality_publication_entries(domain_uuid,path)`,
`CREATE INDEX idx_publication_object ON locality_publication_entries(object_uuid,lang)`,
`CREATE INDEX idx_publication_revision ON locality_publication_entries(revision_uuid)`,
`CREATE TABLE locality_auto_publication(domain_uuid TEXT COLLATE "C" NOT NULL,node_kind TEXT COLLATE "C" NOT NULL,node_uuid TEXT COLLATE "C" NOT NULL,mode TEXT COLLATE "C" NOT NULL CHECK(mode IN ('inherit','required','automatic')),scope_path TEXT COLLATE "C" NOT NULL,actor_uuid TEXT COLLATE "C" NOT NULL,version BIGINT NOT NULL,PRIMARY KEY(domain_uuid,node_kind,node_uuid))`,
},
Assertions: []string{
`SELECT domain_uuid,version,updated_at_ms FROM domain_topology_versions WHERE 1=0`,
`SELECT uuid,domain_uuid,kind,parent_uuid,name,title,description,path_prefix,charter_json,policy_json,state,sort_key,version,created_at_ms,updated_at_ms FROM zones WHERE 1=0`,
`SELECT uuid,domain_uuid,name,title,summary,path_prefix,charter_json,schema_json,landing_json,state,version,created_at_ms,updated_at_ms FROM spots WHERE 1=0`,
`SELECT street_uuid,spot_uuid,sort_key,section,created_at_ms FROM street_spots WHERE 1=0`,
`SELECT spot_uuid,page_uuid,edge_type,label,sort_key,featured,source,created_at_ms FROM spot_pages WHERE 1=0`,
`SELECT source_spot_uuid,target_spot_uuid,relation_type,weight,created_at_ms FROM spot_relations WHERE 1=0`,
`SELECT street_uuid,page_uuid,created_at_ms FROM street_inbox_pages WHERE 1=0`,
`SELECT domain_uuid,page_uuid,spot_uuid FROM city_page_overrides WHERE 1=0`,
`SELECT id,domain_uuid,topology_version,actor_principal_uuid,operation,target_type,target_uuid,before_json,after_json,request_id,created_at_ms FROM topology_events WHERE 1=0`,
`SELECT domain_uuid,version FROM city_governance_epochs WHERE 1=0`,
`SELECT domain_uuid,node_kind,node_uuid,policy,actor_uuid,updated_at_ms FROM locality_publication_policies WHERE 1=0`,
`SELECT domain_uuid,node_kind,node_uuid,membership_uuid,actor_uuid,created_at_ms FROM city_owner_bindings WHERE 1=0`,
`SELECT id,domain_uuid,epoch,actor_uuid,node_kind,node_uuid,before_json,after_json,created_at_ms FROM city_governance_events WHERE 1=0`,
`SELECT domain_uuid,node_kind,node_uuid,version FROM locality_publication_versions WHERE 1=0`,
`SELECT domain_uuid,node_kind,node_uuid,epoch,topology_version,actor_uuid,created_at_ms FROM locality_publication_manifests WHERE 1=0`,
`SELECT domain_uuid,node_kind,node_uuid,path,object_uuid,revision_uuid,document_hash,lang FROM locality_publication_entries WHERE 1=0`,
`SELECT domain_uuid,node_kind,node_uuid,mode,scope_path,actor_uuid,version FROM locality_auto_publication WHERE 1=0`,
},
}})
}
+20 -14
View File
@@ -63,15 +63,16 @@ func (s *Store) GetCityMap(domainUUID string) (CityMap, error) {
// ListSpotPagesContext is the bounded HTTP/read projection. The existing
// ListSpotPages remains available to trusted callers that need a complete set.
func (s *Store) ListSpotPagesContext(parent context.Context, domainUUID, spotUUID string) ([]CityPagePlacement, error) {
func (s *Store) ListSpotPagesContext(parent context.Context, domainUUID, spotUUID string) (_ []CityPagePlacement, resultErr error) {
defer func() { resultErr = s.sqlError("spot pages", resultErr) }()
ctx, cancel := context.WithTimeout(parent, cityReadTimeout)
defer cancel()
tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
tx, err := s.DB.BeginTx(ctx, s.policyReadOptions())
if err != nil {
return nil, err
}
defer tx.Rollback()
pages, err := listSpotPages(cityReadQuery{ctx: ctx, tx: tx}, domainUUID, spotUUID, MaxCityMapPagePlacements+1)
pages, err := s.listSpotPages(cityReadQuery{ctx: ctx, tx: tx}, domainUUID, spotUUID, MaxCityMapPagePlacements+1)
if err != nil {
return nil, err
}
@@ -84,16 +85,17 @@ func (s *Store) ListSpotPagesContext(parent context.Context, domainUUID, spotUUI
// GetCityMapContext reads one consistent topology/Page snapshot using exactly
// one connection. Bulk topology cursors are closed before Page queries. Limits
// reject a partial model instead of silently showing misleading counts/links.
func (s *Store) GetCityMapContext(parent context.Context, domainUUID string) (CityMap, error) {
func (s *Store) GetCityMapContext(parent context.Context, domainUUID string) (_ CityMap, resultErr error) {
defer func() { resultErr = s.sqlError("city map", resultErr) }()
empty := CityMap{DomainUUID: domainUUID, Version: 1, Quartiers: []CityQuartier{}, Relations: []CitySpotRelation{}}
ctx, cancel := context.WithTimeout(parent, cityReadTimeout)
defer cancel()
tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
tx, err := s.DB.BeginTx(ctx, s.policyReadOptions())
if err != nil {
return empty, err
}
defer tx.Rollback()
result, err := readCityMapTx(cityReadQuery{ctx: ctx, tx: tx}, domainUUID)
result, err := s.readCityMapTx(cityReadQuery{ctx: ctx, tx: tx}, domainUUID)
if err != nil {
return empty, err
}
@@ -101,8 +103,12 @@ func (s *Store) GetCityMapContext(parent context.Context, domainUUID string) (Ci
}
func readCityMapTx(query cityReadQuery, domainUUID string) (CityMap, error) {
return (&Store{}).readCityMapTx(query, domainUUID)
}
func (s *Store) readCityMapTx(query cityReadQuery, domainUUID string) (CityMap, error) {
result := CityMap{DomainUUID: domainUUID, Version: 1, Quartiers: []CityQuartier{}, Relations: []CitySpotRelation{}}
err := query.tx.QueryRowContext(query.ctx, `SELECT version FROM domain_topology_versions WHERE domain_uuid=?`, domainUUID).Scan(&result.Version)
err := query.tx.QueryRowContext(query.ctx, `SELECT version FROM domain_topology_versions WHERE domain_uuid=`+s.sqlParam(1), domainUUID).Scan(&result.Version)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return result, err
}
@@ -115,7 +121,7 @@ func readCityMapTx(query cityReadQuery, domainUUID string) (CityMap, error) {
return nil
}
quartiers := map[string]int{}
err = query.visit(`SELECT uuid,name,title,description,state,sort_key,path_prefix FROM zones WHERE domain_uuid=? AND kind='quartier' AND state!='archived' ORDER BY sort_key,lower(title),name,uuid LIMIT ?`, []any{domainUUID, MaxCityMapNodes + 1}, func(rows *sql.Rows) error {
err = query.visit(`SELECT uuid,name,title,description,state,sort_key,path_prefix FROM zones WHERE domain_uuid=`+s.sqlParam(1)+` AND kind='quartier' AND state!='archived' ORDER BY sort_key,lower(title),name,uuid LIMIT `+s.sqlParam(2), []any{domainUUID, MaxCityMapNodes + 1}, func(rows *sql.Rows) error {
if err := checkNode(); err != nil {
return err
}
@@ -134,7 +140,7 @@ func readCityMapTx(query cityReadQuery, domainUUID string) (CityMap, error) {
streets := map[string]streetIndex{}
err = query.visit(`SELECT st.parent_uuid,st.uuid,st.name,st.title,st.description,st.state,st.sort_key,st.path_prefix
FROM zones st JOIN zones q ON q.uuid=st.parent_uuid AND q.domain_uuid=st.domain_uuid AND q.kind='quartier' AND q.state!='archived'
WHERE st.domain_uuid=? AND st.kind='street' AND st.state!='archived' ORDER BY st.sort_key,lower(st.title),st.name,st.uuid LIMIT ?`, []any{domainUUID, MaxCityMapNodes - nodes + 1}, func(rows *sql.Rows) error {
WHERE st.domain_uuid=`+s.sqlParam(1)+` AND st.kind='street' AND st.state!='archived' ORDER BY st.sort_key,lower(st.title),st.name,st.uuid LIMIT `+s.sqlParam(2), []any{domainUUID, MaxCityMapNodes - nodes + 1}, func(rows *sql.Rows) error {
if err := checkNode(); err != nil {
return err
}
@@ -159,7 +165,7 @@ func readCityMapTx(query cityReadQuery, domainUUID string) (CityMap, error) {
FROM street_spots ss JOIN spots p ON p.uuid=ss.spot_uuid
JOIN zones st ON st.uuid=ss.street_uuid AND st.domain_uuid=p.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'
WHERE p.domain_uuid=? AND p.state!='archived' ORDER BY ss.sort_key,lower(p.title),p.name,p.uuid LIMIT ?`, []any{domainUUID, MaxCityMapNodes - nodes + 1}, func(rows *sql.Rows) error {
WHERE p.domain_uuid=`+s.sqlParam(1)+` AND p.state!='archived' ORDER BY ss.sort_key,lower(p.title),p.name,p.uuid LIMIT `+s.sqlParam(2), []any{domainUUID, MaxCityMapNodes - nodes + 1}, func(rows *sql.Rows) error {
if err := checkNode(); err != nil {
return err
}
@@ -185,7 +191,7 @@ func readCityMapTx(query cityReadQuery, domainUUID string) (CityMap, error) {
for si := range result.Quartiers[qi].Streets {
for pi := range result.Quartiers[qi].Streets[si].Spots {
spot := &result.Quartiers[qi].Streets[si].Spots[pi]
pages, err := listSpotPages(query, domainUUID, spot.UUID, MaxCityMapPagePlacements-pageCount+1)
pages, err := s.listSpotPages(query, domainUUID, spot.UUID, MaxCityMapPagePlacements-pageCount+1)
if err != nil {
return result, err
}
@@ -212,9 +218,9 @@ func readCityMapTx(query cityReadQuery, domainUUID string) (CityMap, error) {
}
relations := 0
err = query.visit(`SELECT r.source_spot_uuid,r.target_spot_uuid,r.relation_type,r.weight FROM spot_relations r
JOIN spots a ON a.uuid=r.source_spot_uuid AND a.domain_uuid=? AND a.state!='archived'
JOIN spots b ON b.uuid=r.target_spot_uuid AND b.domain_uuid=? AND b.state!='archived'
ORDER BY r.relation_type,r.source_spot_uuid,r.target_spot_uuid LIMIT ?`, []any{domainUUID, domainUUID, MaxCityMapRelations + 1}, func(rows *sql.Rows) error {
JOIN spots a ON a.uuid=r.source_spot_uuid AND a.domain_uuid=`+s.sqlParam(1)+` AND a.state!='archived'
JOIN spots b ON b.uuid=r.target_spot_uuid AND b.domain_uuid=`+s.sqlParam(2)+` AND b.state!='archived'
ORDER BY r.relation_type,r.source_spot_uuid,r.target_spot_uuid LIMIT `+s.sqlParam(3), []any{domainUUID, domainUUID, MaxCityMapRelations + 1}, func(rows *sql.Rows) error {
relations++
if relations > MaxCityMapRelations {
return fmt.Errorf("%w: more than %d relations", ErrCityMapBudget, MaxCityMapRelations)
+6 -5
View File
@@ -24,6 +24,7 @@ func (s *Store) CityNode(domainUUID, kind, id string) (CityNodeDetail, error) {
// <Quartier-name>/<Street-name>. Qualified lookup and parent checks happen in
// the same SQL snapshot, without enumerating the City or opening nested cursors.
func (s *Store) CityNodeContext(parent context.Context, domainUUID, kind, id string) (detail CityNodeDetail, lookupErr error) {
defer func() { lookupErr = s.sqlError("city node", lookupErr) }()
id = strings.ToLower(strings.TrimSpace(id))
if kind != "quartier" && kind != "street" && kind != "spot" {
return detail, sql.ErrNoRows
@@ -50,7 +51,7 @@ func (s *Store) CityNodeContext(parent context.Context, domainUUID, kind, id str
from := "zones n"
columns := `n.uuid,n.domain_uuid,n.kind,COALESCE(n.parent_uuid,''),n.name,n.title,n.description,n.state,n.path_prefix,n.sort_key,n.version`
ancestors := `,'','','','','','','',''`
where := `n.domain_uuid=? AND n.state!='archived' AND n.kind=?`
where := `n.domain_uuid=` + s.sqlParam(1) + ` AND n.state!='archived' AND n.kind=` + s.sqlParam(2)
args := []any{domainUUID, kind}
if kind == "street" {
from += ` JOIN zones q ON q.uuid=n.parent_uuid AND q.domain_uuid=n.domain_uuid AND q.kind='quartier' AND q.state!='archived'`
@@ -61,19 +62,19 @@ func (s *Store) CityNodeContext(parent context.Context, domainUUID, kind, id str
JOIN zones q ON q.uuid=st.parent_uuid AND q.domain_uuid=st.domain_uuid AND q.kind='quartier' AND q.state!='archived'`
columns = `n.uuid,n.domain_uuid,'spot',st.uuid,n.name,n.title,n.summary,n.state,n.path_prefix,ss.sort_key,n.version`
ancestors = `,q.uuid,q.name,q.title,q.path_prefix,st.uuid,st.name,st.title,st.path_prefix`
where = `n.domain_uuid=? AND n.state!='archived'`
where = `n.domain_uuid=` + s.sqlParam(1) + ` AND n.state!='archived'`
args = []any{domainUUID}
}
if len(parts) == 2 {
// A qualified URL is name based. Explicit UUID selectors use the short
// /s/uuid:... route instead of mixing two different identity models.
where += " AND q.name=? AND n.name=?"
where += " AND q.name=" + s.sqlParam(len(args)+1) + " AND n.name=" + s.sqlParam(len(args)+2)
args = append(args, parts[0], parts[1])
} else if strings.HasPrefix(id, "uuid:") {
where += " AND n.uuid=?"
where += " AND n.uuid=" + s.sqlParam(len(args)+1)
args = append(args, strings.TrimPrefix(id, "uuid:"))
} else {
where += " AND n.name=?"
where += " AND n.name=" + s.sqlParam(len(args)+1)
args = append(args, id)
}
rows, err := s.DB.QueryContext(ctx, `SELECT `+columns+ancestors+` FROM `+from+` WHERE `+where+` LIMIT 2`, args...)
+3
View File
@@ -14,5 +14,8 @@ const (
)
func (s *Store) SearchCityInDomain(ctx context.Context, domainUUID, scope, query string, limit int, allowed func(string) bool, options SearchOptions) ([]CitySearchResult, error) {
if s.sqlBackend == storePostgreSQL {
return mestionora.NewPostgreSQL(s.DB).SearchCityInDomain(ctx, domainUUID, scope, query, limit, allowed, options)
}
return mestionora.NewSQLite(s.DB).SearchCityInDomain(ctx, domainUUID, scope, query, limit, allowed, options)
}
+23 -8
View File
@@ -1,8 +1,15 @@
package store
import "database/sql"
import (
"context"
"database/sql"
"time"
)
func (s *Store) EnsureConfigTable() error {
if s.sqlBackend == storePostgreSQL {
return s.ensurePostgreSQLNamespaces(context.Background())
}
if _, err := s.DB.Exec(`CREATE TABLE IF NOT EXISTS personal_appearance (
domain_uuid TEXT NOT NULL, owner_uuid TEXT NOT NULL, version INTEGER NOT NULL,
data TEXT NOT NULL, PRIMARY KEY(domain_uuid,owner_uuid))`); err != nil {
@@ -98,15 +105,19 @@ func (s *Store) GetConfig(key string) (string, error) {
}
func (s *Store) GetConfigInDomain(domainUUID, key string) (string, error) {
return s.GetConfigInDomainContext(context.Background(), domainUUID, key)
}
func (s *Store) GetConfigInDomainContext(ctx context.Context, domainUUID, key string) (string, error) {
var value string
err := s.DB.QueryRow(`
err := s.DB.QueryRowContext(ctx, `
SELECT value FROM config
WHERE domain_uuid = ? AND key = ?
WHERE domain_uuid = `+s.sqlParam(1)+` AND key = `+s.sqlParam(2)+`
`, domainUUID, key).Scan(&value)
if err == sql.ErrNoRows {
return "", nil
}
return value, err
return value, s.sqlError("read configuration", err)
}
func (s *Store) SetConfig(key, value string) error {
@@ -118,13 +129,17 @@ func (s *Store) SetConfig(key, value string) error {
}
func (s *Store) SetConfigInDomain(domainUUID, key, value string) error {
_, err := s.DB.Exec(`
return s.SetConfigInDomainContext(context.Background(), domainUUID, key, value)
}
func (s *Store) SetConfigInDomainContext(ctx context.Context, domainUUID, key, value string) error {
_, err := s.DB.ExecContext(ctx, `
INSERT INTO config (domain_uuid, key, value, updated_at)
VALUES (?, ?, ?, strftime('%s','now'))
VALUES (`+s.sqlValues(4)+`)
ON CONFLICT(domain_uuid, key)
DO UPDATE SET
value = excluded.value,
updated_at = excluded.updated_at
`, domainUUID, key, value)
return err
`, domainUUID, key, value, time.Now().Unix())
return s.sqlError("write configuration", err)
}
+45 -24
View File
@@ -10,6 +10,7 @@ import (
"fmt"
"strconv"
"strings"
"time"
"github.com/google/uuid"
)
@@ -59,7 +60,8 @@ type ContactDAVSnapshot struct {
// Scope and epoch bind opaque tokens to this database, domain and owner. Each
// resource retains only its latest sequence; soft-deleted rows are tombstones.
func (s *Store) ContactDAVSnapshot(ctx context.Context, domain, actor, token string, limit int) (ContactDAVSnapshot, error) {
func (s *Store) ContactDAVSnapshot(ctx context.Context, domain, actor, token string, limit int) (result ContactDAVSnapshot, resultErr error) {
defer func() { resultErr = s.sqlError("contacts repository", resultErr) }()
if limit < 0 || limit > 200 {
return ContactDAVSnapshot{}, ErrTaskInvalid
}
@@ -68,21 +70,31 @@ func (s *Store) ContactDAVSnapshot(ctx context.Context, domain, actor, token str
// PROPFIND inventories contain metadata only, never thousands of vCard bodies.
// The same read transaction supplies both the inventory and its change token.
func (s *Store) ContactDAVInventory(ctx context.Context, domain, actor string) (ContactDAVSnapshot, error) {
func (s *Store) ContactDAVInventory(ctx context.Context, domain, actor string) (result ContactDAVSnapshot, resultErr error) {
defer func() { resultErr = s.sqlError("contacts repository", resultErr) }()
return s.contactDAVSnapshot(ctx, domain, actor, "", 5000, true)
}
func (s *Store) contactDAVSnapshot(ctx context.Context, domain, actor, token string, limit int, metadata bool) (ContactDAVSnapshot, error) {
func (s *Store) contactDAVSnapshot(ctx context.Context, domain, actor, token string, limit int, metadata bool) (result ContactDAVSnapshot, resultErr error) {
defer func() { resultErr = s.sqlError("contacts repository", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
out := ContactDAVSnapshot{Items: []ContactDAVItem{}}
tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
options := &sql.TxOptions{ReadOnly: true}
if s.sqlBackend == storePostgreSQL {
// High-water mark and resource rows must be the same snapshot;
// READ COMMITTED can skip a concurrent change permanently.
options.Isolation = sql.LevelRepeatableRead
}
tx, err := s.DB.BeginTx(ctx, options)
if err != nil {
return out, err
}
defer tx.Rollback()
if err = taskActor(ctx, tx, domain, actor, false); err != nil {
if err = s.taskActor(ctx, tx, domain, actor, false); err != nil {
return out, err
}
if err = contactEnabled(ctx, tx, domain); err != nil {
if err = s.contactEnabled(ctx, tx, domain); err != nil {
return out, err
}
var epoch string
@@ -92,7 +104,7 @@ func (s *Store) contactDAVSnapshot(ctx context.Context, domain, actor, token str
hash := sha256.Sum256([]byte(epoch + "\x00" + domain + "\x00" + actor))
prefix := "urn:pageswiki:contacts:" + hex.EncodeToString(hash[:]) + ":"
var high int64
if err = tx.QueryRowContext(ctx, `SELECT COALESCE(MAX(sequence),0) FROM organizer_contact_changes WHERE domain_uuid=? AND owner_uuid=?`, domain, actor).Scan(&high); err != nil {
if err = tx.QueryRowContext(ctx, `SELECT COALESCE(MAX(sequence),0) FROM organizer_contact_changes WHERE domain_uuid=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2), domain, actor).Scan(&high); err != nil {
return out, err
}
since := int64(0)
@@ -112,8 +124,11 @@ func (s *Store) contactDAVSnapshot(ctx context.Context, domain, actor, token str
fields := `c.data,n.name,x.sequence,0`
if metadata {
fields = `json_object('uuid',c.uuid,'version',c.version),n.name,x.sequence,length(CAST(json_extract(c.data,'$.vcard') AS BLOB))`
if s.sqlBackend == storePostgreSQL {
fields = `json_build_object('uuid',c.uuid,'version',c.version)::text,n.name,x.sequence,octet_length(c.data::jsonb->>'vcard')`
}
}
rows, err := tx.QueryContext(ctx, `SELECT `+fields+` FROM organizer_contact_changes x JOIN organizer_contacts c USING(domain_uuid,owner_uuid,uuid) JOIN organizer_contact_names n USING(domain_uuid,owner_uuid,uuid) WHERE x.domain_uuid=? AND x.owner_uuid=? AND x.sequence>? AND (?<>'' OR c.deleted=0) ORDER BY x.sequence LIMIT ?`, domain, actor, since, token, limit+1)
rows, err := tx.QueryContext(ctx, `SELECT `+fields+` FROM organizer_contact_changes x JOIN organizer_contacts c USING(domain_uuid,owner_uuid,uuid) JOIN organizer_contact_names n USING(domain_uuid,owner_uuid,uuid) WHERE x.domain_uuid=`+s.sqlParam(1)+` AND x.owner_uuid=`+s.sqlParam(2)+` AND x.sequence>`+s.sqlParam(3)+` AND (`+s.sqlParam(4)+`<>'' OR c.deleted=0) ORDER BY x.sequence LIMIT `+s.sqlParam(5), domain, actor, since, token, limit+1)
if err != nil {
return out, err
}
@@ -137,18 +152,19 @@ func (s *Store) contactDAVSnapshot(ctx context.Context, domain, actor, token str
return out, rows.Err()
}
func (s *Store) ContactDAVResource(ctx context.Context, domain, actor, name string) (Contact, error) {
func (s *Store) ContactDAVResource(ctx context.Context, domain, actor, name string) (result Contact, resultErr error) {
defer func() { resultErr = s.sqlError("contacts repository", resultErr) }()
if !ValidContactDAVName(name) {
return Contact{}, ErrTaskInvalid
}
if err := taskActor(ctx, s.DB, domain, actor, false); err != nil {
if err := s.taskActor(ctx, s.DB, domain, actor, false); err != nil {
return Contact{}, err
}
if err := contactEnabled(ctx, s.DB, domain); err != nil {
if err := s.contactEnabled(ctx, s.DB, domain); err != nil {
return Contact{}, err
}
var id string
err := s.DB.QueryRowContext(ctx, `SELECT uuid FROM organizer_contact_names WHERE domain_uuid=? AND owner_uuid=? AND name=?`, domain, actor, name).Scan(&id)
err := s.DB.QueryRowContext(ctx, `SELECT uuid FROM organizer_contact_names WHERE domain_uuid=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND name=`+s.sqlParam(3), domain, actor, name).Scan(&id)
if err != nil {
return Contact{}, err
}
@@ -157,7 +173,8 @@ func (s *Store) ContactDAVResource(ctx context.Context, domain, actor, name stri
// The version is compared under the same write lock as credential revocation,
// membership and extension state. No read-modify-write bypass for DAV clients.
func (s *Store) SaveContactDAV(ctx context.Context, domain, actor, credential, name, raw string, version int64, remove bool) (Contact, error) {
func (s *Store) SaveContactDAV(ctx context.Context, domain, actor, credential, name, raw string, version int64, remove bool) (result Contact, resultErr error) {
defer func() { resultErr = s.sqlError("contacts repository", resultErr) }()
if !ValidContactDAVName(name) {
return Contact{}, ErrTaskInvalid
}
@@ -191,11 +208,12 @@ type ContactRevision struct {
CreatedMS int64 `json:"created_ms"`
}
func (s *Store) ContactHistory(ctx context.Context, domain, actor, id string, before int64) ([]ContactRevision, error) {
func (s *Store) ContactHistory(ctx context.Context, domain, actor, id string, before int64) (result []ContactRevision, resultErr error) {
defer func() { resultErr = s.sqlError("contacts repository", resultErr) }()
if _, err := s.Contact(ctx, domain, actor, id); err != nil {
return nil, err
}
rows, err := s.DB.QueryContext(ctx, `SELECT version,deleted,created_ms FROM organizer_contact_revisions WHERE domain_uuid=? AND owner_uuid=? AND uuid=? AND (?=0 OR version<?) ORDER BY version DESC LIMIT 100`, domain, actor, id, before, before)
rows, err := s.DB.QueryContext(ctx, `SELECT version,deleted,created_ms FROM organizer_contact_revisions WHERE domain_uuid=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND uuid=`+s.sqlParam(3)+` AND (CAST(`+s.sqlParam(4)+` AS BIGINT)=0 OR version<`+s.sqlParam(5)+`) ORDER BY version DESC LIMIT 100`, domain, actor, id, before, before)
if err != nil {
return nil, err
}
@@ -210,7 +228,8 @@ func (s *Store) ContactHistory(ctx context.Context, domain, actor, id string, be
}
return out, rows.Err()
}
func (s *Store) RestoreContactRevision(ctx context.Context, domain, actor, id string, revision, version int64) (Contact, error) {
func (s *Store) RestoreContactRevision(ctx context.Context, domain, actor, id string, revision, version int64) (result Contact, resultErr error) {
defer func() { resultErr = s.sqlError("contacts repository", resultErr) }()
old, err := s.Contact(ctx, domain, actor, id)
if err != nil {
return old, err
@@ -219,7 +238,7 @@ func (s *Store) RestoreContactRevision(ctx context.Context, domain, actor, id st
return old, ErrTaskConflict
}
var hash string
if err = s.DB.QueryRowContext(ctx, `SELECT hash FROM organizer_contact_revisions WHERE domain_uuid=? AND owner_uuid=? AND uuid=? AND version=?`, domain, actor, id, revision).Scan(&hash); err != nil {
if err = s.DB.QueryRowContext(ctx, `SELECT hash FROM organizer_contact_revisions WHERE domain_uuid=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND uuid=`+s.sqlParam(3)+` AND version=`+s.sqlParam(4), domain, actor, id, revision).Scan(&hash); err != nil {
return old, err
}
raw, err := s.readDocument(hash)
@@ -229,13 +248,14 @@ func (s *Store) RestoreContactRevision(ctx context.Context, domain, actor, id st
return s.saveContact(ctx, domain, actor, Contact{UUID: id, Version: version, VCard: raw}, "dav", "", "")
}
func (s *Store) ContactAtRevision(ctx context.Context, domain, actor, id string, version int64) (Contact, error) {
func (s *Store) ContactAtRevision(ctx context.Context, domain, actor, id string, version int64) (result Contact, resultErr error) {
defer func() { resultErr = s.sqlError("contacts repository", resultErr) }()
if _, err := s.Contact(ctx, domain, actor, id); err != nil {
return Contact{}, err
}
var hash string
var deleted bool
if err := s.DB.QueryRowContext(ctx, `SELECT hash,deleted FROM organizer_contact_revisions WHERE domain_uuid=? AND owner_uuid=? AND uuid=? AND version=?`, domain, actor, id, version).Scan(&hash, &deleted); err != nil {
if err := s.DB.QueryRowContext(ctx, `SELECT hash,deleted FROM organizer_contact_revisions WHERE domain_uuid=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND uuid=`+s.sqlParam(3)+` AND version=`+s.sqlParam(4), domain, actor, id, version).Scan(&hash, &deleted); err != nil {
return Contact{}, err
}
raw, err := s.readDocument(hash)
@@ -249,16 +269,17 @@ func (s *Store) ContactAtRevision(ctx context.Context, domain, actor, id string,
return c, err
}
// One SQLite read snapshot, bounded before headers are sent. An export must
// One SQL statement snapshot, bounded before headers are sent. An export must
// never look successful when contacts have been silently truncated.
func (s *Store) ExportContacts(ctx context.Context, domain, actor string) (string, error) {
if err := taskActor(ctx, s.DB, domain, actor, false); err != nil {
func (s *Store) ExportContacts(ctx context.Context, domain, actor string) (result string, resultErr error) {
defer func() { resultErr = s.sqlError("contacts repository", resultErr) }()
if err := s.taskActor(ctx, s.DB, domain, actor, false); err != nil {
return "", err
}
if err := contactEnabled(ctx, s.DB, domain); err != nil {
if err := s.contactEnabled(ctx, s.DB, domain); err != nil {
return "", err
}
rows, err := s.DB.QueryContext(ctx, `SELECT data FROM organizer_contacts WHERE domain_uuid=? AND owner_uuid=? AND deleted=0 ORDER BY uuid LIMIT 5001`, domain, actor)
rows, err := s.DB.QueryContext(ctx, `SELECT data FROM organizer_contacts WHERE domain_uuid=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND deleted=0 ORDER BY uuid LIMIT 5001`, domain, actor)
if err != nil {
return "", err
}
Loaded 100 of 243 files, more files were not shown because too many files have changed in this diff. Show more