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

342 lines
6.2 KiB
Go

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
}