package store import ( "context" "database/sql" "encoding/json" "errors" "strings" "time" "pageswiki/internal/metadata" "github.com/google/uuid" ) func (s *Store) BindPath( path string, objectUUID string, ) error { domainUUID, err := s.defaultDomainUUID() if err != nil { return err } return s.BindPathInDomain(domainUUID, path, objectUUID) } func (s *Store) BindPathInDomain( domainUUID string, path string, objectUUID string, ) error { path = normalizePath(path) if err := s.ensureLocalDomain(domainUUID); err != nil { return err } result, err := s.DB.Exec(` INSERT OR REPLACE INTO paths ( domain_uuid, path, object_uuid, created_at ) SELECT ?, ?, ?, ? WHERE EXISTS(SELECT 1 FROM objects WHERE uuid=?) `, domainUUID, path, objectUUID, time.Now().Unix(), objectUUID, ) if err == nil { if n, countErr := result.RowsAffected(); countErr != nil { return countErr } else if n != 1 { return ErrPageNotFound } s.InvalidatePathCaches() } return err } func (s *Store) ResolvePath( path string, ) (string, error) { domainUUID, err := s.defaultDomainUUID() if err != nil { return "", err } return s.ResolvePathInDomain(domainUUID, path) } func (s *Store) ResolvePathInDomain( domainUUID string, path string, ) (string, error) { return s.ResolvePathInDomainContext(context.Background(), domainUUID, path) } func (s *Store) ResolvePathInDomainContext(ctx context.Context, domainUUID, path string) (string, error) { path = normalizePath(path) if err := s.ensureLocalDomainContext(ctx, domainUUID); err != nil { return "", err } // The application Store remains SQLite-only until all repositories are // ported. Share this read contract now without invoking portable bootstrap // or changing the existing application's schema and initialization order. backend := metadata.SQLite if s.sqlBackend == storePostgreSQL { backend = metadata.PostgreSQL } repository, err := metadata.New(s.DB, backend) if err != nil { return "", err } objectUUID, err := repository.ResolvePath(ctx, domainUUID, path) if errors.Is(err, metadata.ErrNotFound) { return "", sql.ErrNoRows } return objectUUID, err } func normalizePath( path string, ) string { path = strings.TrimSpace(path) if path == "" { return "/" } if !strings.HasPrefix(path, "/") { path = "/" + path } if path != "/" { path = strings.TrimRight(path, "/") } return path } func (s *Store) ListChildren( prefix string, ) ([]string, error) { domainUUID, err := s.defaultDomainUUID() if err != nil { return nil, err } return s.ListChildrenInDomain(domainUUID, prefix) } func (s *Store) ListChildrenInDomain( domainUUID string, prefix string, ) ([]string, error) { prefix = strings.TrimRight(normalizePath(prefix), "/") rows, err := s.DB.Query(` SELECT path FROM paths WHERE domain_uuid = `+s.sqlParam(1)+` AND path >= `+s.sqlParam(2)+` AND path < `+s.sqlParam(3)+` ORDER BY path `, domainUUID, prefix+"/", prefix+"0", ) if err != nil { return nil, err } defer rows.Close() var out []string for rows.Next() { var p string err := rows.Scan(&p) if err != nil { return nil, err } out = append(out, p) } return out, nil } func (s *Store) PathExists( path string, ) bool { domainUUID, err := s.defaultDomainUUID() if err != nil { return false } return s.PathExistsInDomain(domainUUID, path) } func (s *Store) PathExistsInDomain( domainUUID string, path string, ) bool { row := s.DB.QueryRow(` SELECT COUNT(*) FROM paths WHERE domain_uuid = `+s.sqlParam(1)+` AND path = `+s.sqlParam(2)+` `, domainUUID, normalizePath(path)) var count int _ = row.Scan(&count) return count > 0 } func (s *Store) CreatePageAtPath( path string, ) (string, error) { domainUUID, err := s.defaultDomainUUID() if err != nil { return "", err } return s.CreatePageAtPathInDomain(domainUUID, path) } func (s *Store) CreatePageAtPathInDomain( domainUUID string, path string, ) (string, error) { if s.ReadOnly { return "", ErrReadOnly } if s.sqlBackend == storePostgreSQL { ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) defer cancel() repo, err := metadata.NewApplication(s.DB, metadata.PostgreSQL) if err != nil { return "", err } return repo.CreatePage(ctx, domainUUID, normalizePath(path)) } if err := s.ensureLocalDomain(domainUUID); err != nil { return "", err } path = normalizePath( path, ) tx, err := s.DB.Begin() if err != nil { return "", err } defer tx.Rollback() objectUUID := uuid.NewString() _, err = tx.Exec(` INSERT INTO objects ( uuid, kind, created_at ) VALUES ( ?, 'page', strftime('%s','now') ) `, objectUUID, ) if err != nil { return "", err } _, err = tx.Exec(` INSERT INTO paths ( domain_uuid, path, object_uuid, created_at ) VALUES ( ?, ?, ?, strftime('%s','now') ) `, domainUUID, path, objectUUID, ) if err != nil { return "", err } payload, payloadErr := json.Marshal(map[string]string{"path": path, "object_uuid": objectUUID}) if payloadErr != nil { return "", payloadErr } if err := s.appendActivityOutboxIfAvailable(tx, ActivityOutboxEvent{ DomainUUID: domainUUID, EventType: "page.created", TargetKind: "page", TargetUUID: objectUUID, Payload: string(payload), IdempotencyKey: "page.created:" + objectUUID, }); err != nil { return "", err } if err := tx.Commit(); err != nil { return "", err } return objectUUID, nil } func (s *Store) GetPathByUUID( uuid string, ) (string, error) { domainUUID, err := s.defaultDomainUUID() if err != nil { return "", err } return s.GetPathByUUIDInDomain(domainUUID, uuid) } func (s *Store) GetPathByUUIDInDomain( domainUUID string, uuid string, ) (string, error) { row := s.DB.QueryRow(` SELECT path FROM paths WHERE domain_uuid = ? AND object_uuid = ? ORDER BY is_primary DESC, path LIMIT 1 `, domainUUID, uuid) var path string err := row.Scan(&path) if err != nil { return "", err } return path, nil } func IsNotFound(err error) bool { return err == sql.ErrNoRows }