Files
2026-11-15 05:47:14 +09:00

411 lines
12 KiB
Go

package store
import (
"database/sql"
"encoding/json"
"errors"
"path/filepath"
"strings"
"time"
"github.com/google/uuid"
)
var (
ErrPathNotFound = errors.New("semantic path does not exist")
ErrPathConflict = errors.New("destination semantic path already exists")
)
type pathRename struct {
OldPath string
NewPath string
ObjectUUID string
CreatedAt int64
IsPrimary int
}
func (s *Store) RenamePath(oldPath, newPath string) error {
domainUUID, err := s.defaultDomainUUID()
if err != nil {
return err
}
_, err = s.RenamePathsInDomain(domainUUID, oldPath, newPath, false)
return err
}
func (s *Store) RenamePathInDomain(domainUUID, oldPath, newPath string) error {
_, err := s.RenamePathsInDomain(domainUUID, oldPath, newPath, false)
return err
}
// RenamePathsInDomain performs rename as an atomic link/unlink operation.
// Page identity and Revision history remain stable while Path reachability
// changes. When a file-like basename changes, a new immutable Revision records
// the corresponding filename metadata.
func (s *Store) RenamePathsInDomain(
domainUUID, oldPath, newPath string,
recursive bool,
) (int, error) {
return s.renamePathsInDomain(domainUUID, oldPath, newPath, recursive, nil)
}
// RenamePathsInDomainChecked requires the exact store snapshot authorized by
// the caller. Trusted local tools can use RenamePathsInDomain without grants.
func (s *Store) RenamePathsInDomainChecked(domainUUID, oldPath, newPath string, recursive bool, snapshot *PathMutationSnapshot) (int, error) {
if snapshot == nil {
return 0, ErrPathSnapshotChanged
}
count, err := s.renamePathsInDomain(domainUUID, oldPath, newPath, recursive, snapshot)
return count, pathMutationTransactionError(err)
}
func (s *Store) renamePathsInDomain(domainUUID, oldPath, newPath string, recursive bool, snapshot *PathMutationSnapshot) (_ int, resultErr error) {
defer func() { resultErr = s.cityMutationError("rename paths", resultErr) }()
if err := s.ensureLocalDomain(domainUUID); err != nil {
return 0, err
}
oldPath = normalizePath(oldPath)
newPath = normalizePath(newPath)
if oldPath == "/" || newPath == "/" || oldPath == newPath {
return 0, ErrPathConflict
}
if recursive && strings.HasPrefix(newPath+"/", oldPath+"/") {
return 0, ErrPathConflict
}
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
if err != nil {
return 0, err
}
defer tx.Rollback()
renames, err := s.listMutationPaths(tx, domainUUID, oldPath, recursive)
if err != nil {
return 0, err
}
if snapshot != nil {
if err := snapshot.validate(domainUUID, oldPath, recursive, renames); err != nil {
return 0, err
}
}
if len(renames) == 0 {
return 0, ErrPathNotFound
}
for i := range renames {
renames[i].NewPath = newPath + strings.TrimPrefix(renames[i].OldPath, oldPath)
}
sourcePaths := make(map[string]bool, len(renames))
for _, item := range renames {
sourcePaths[item.OldPath] = true
}
for _, item := range renames {
var exists int
if err := tx.QueryRow(`
SELECT COUNT(*) FROM paths
WHERE domain_uuid = `+s.sqlParam(1)+` AND path = `+s.sqlParam(2)+`
`, domainUUID, item.NewPath).Scan(&exists); err != nil {
return 0, err
}
if exists > 0 && !sourcePaths[item.NewPath] {
return 0, ErrPathConflict
}
}
// Link all destinations before unlinking sources. Temporary source rows
// remain valid until the transaction commits.
for _, item := range renames {
if _, err := tx.Exec(`
INSERT INTO paths (
domain_uuid, path, object_uuid, created_at, is_primary
) VALUES (`+s.sqlValues(5)+`)
`, domainUUID, item.NewPath, item.ObjectUUID, item.CreatedAt, item.IsPrimary); err != nil {
return 0, err
}
}
if err := s.renameUserSpacePathPoliciesTx(tx, domainUUID, oldPath, newPath, recursive); err != nil {
return 0, err
}
for _, item := range renames {
if _, err := tx.Exec(`
DELETE FROM paths WHERE domain_uuid = `+s.sqlParam(1)+` AND path = `+s.sqlParam(2)+`
`, domainUUID, item.OldPath); err != nil {
return 0, err
}
}
if err := s.renameBrowserNavigationPathsTx(tx, domainUUID, oldPath, newPath, recursive); err != nil {
return 0, err
}
renamedObjects := map[string][2]string{}
for _, item := range renames {
oldName := filepath.Base(item.OldPath)
newName := filepath.Base(item.NewPath)
if oldName != newName && filepath.Ext(oldName) != "" {
renamedObjects[item.ObjectUUID] = [2]string{oldName, newName}
}
}
for objectUUID, names := range renamedObjects {
if err := s.cloneLatestRevisionFilenames(
tx,
domainUUID,
objectUUID,
names[0],
names[1],
); err != nil {
return 0, err
}
}
if recursive {
changed, err := s.renameCityPathPrefixesTx(tx, domainUUID, oldPath, newPath)
if err != nil {
return 0, err
}
if changed > 0 {
if err := s.bumpTopologyVersion(tx, domainUUID, "system:path-rename", "city.paths.renamed", "path", oldPath); err != nil {
return 0, err
}
}
}
operationID := uuid.NewString()
payload, err := json.Marshal(map[string]any{
"operation_uuid": operationID, "old_path": oldPath, "new_path": newPath,
"recursive": recursive, "count": len(renames),
})
if err != nil {
return 0, err
}
if err := s.appendActivityOutboxIfAvailable(tx, ActivityOutboxEvent{
DomainUUID: domainUUID, EventType: "path.renamed", TargetKind: "path",
Payload: string(payload), IdempotencyKey: "path.renamed:" + operationID,
}); err != nil {
return 0, err
}
if err := tx.Commit(); err != nil {
return 0, err
}
s.InvalidatePathCaches()
return len(renames), nil
}
func cloneLatestRevisionFilenames(
tx *sql.Tx,
objectUUID, oldName, newName string,
) error {
rows, err := tx.Query(`
WITH ranked AS (
SELECT
uuid, object_uuid, body, document_hash, lang, content_type,
filename, message, created_at_ms, created_at,
ROW_NUMBER() OVER (
PARTITION BY COALESCE(NULLIF(lang, ''), 'und')
ORDER BY COALESCE(created_at_ms, created_at * 1000) DESC, rowid DESC
) AS rn
FROM revisions
WHERE object_uuid = ?
)
SELECT
COALESCE(body, ''), COALESCE(document_hash, ''),
COALESCE(NULLIF(lang, ''), 'und'),
COALESCE(NULLIF(content_type, ''), 'application/octet-stream'),
COALESCE(filename, ''), COALESCE(message, '')
FROM ranked WHERE rn = 1
`, objectUUID)
if err != nil {
return err
}
type latestRevision struct {
body, hash, lang, contentType, filename, message string
}
var revisions []latestRevision
for rows.Next() {
var revision latestRevision
if err := rows.Scan(
&revision.body,
&revision.hash,
&revision.lang,
&revision.contentType,
&revision.filename,
&revision.message,
); err != nil {
rows.Close()
return err
}
if revision.filename == "" || revision.filename == oldName {
revisions = append(revisions, revision)
}
}
if err := rows.Err(); err != nil {
rows.Close()
return err
}
if err := rows.Close(); err != nil {
return err
}
now := time.Now()
for index, revision := range revisions {
createdAtMS := now.UnixMilli() + int64(index)
if _, err := tx.Exec(`
INSERT INTO revisions (
uuid, object_uuid, body, document_hash, lang, content_type,
filename, message, created_at_ms, created_at
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`,
uuid.NewString(),
objectUUID,
revision.body,
revision.hash,
revision.lang,
revision.contentType,
newName,
"rename filename: "+oldName+" -> "+newName,
createdAtMS,
createdAtMS/1000,
); err != nil {
return err
}
}
return nil
}
func (s *Store) RemovePath(path string) error {
domainUUID, err := s.defaultDomainUUID()
if err != nil {
return err
}
return s.RemovePathInDomain(domainUUID, path)
}
func (s *Store) RemovePathInDomain(domainUUID, path string) (resultErr error) {
defer func() { resultErr = s.sqlError("remove path", resultErr) }()
if err := s.ensureLocalDomain(domainUUID); err != nil {
return err
}
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
if err != nil {
return err
}
defer tx.Rollback()
_, err = tx.Exec(`
DELETE FROM paths WHERE domain_uuid = `+s.sqlParam(1)+` AND path = `+s.sqlParam(2)+`
`, domainUUID, normalizePath(path))
if err == nil {
err = tx.Commit()
}
if err == nil {
s.InvalidatePathCaches()
}
return err
}
// CopyPathsInDomain duplicates a Page or a virtual-folder subtree. Document
// blobs remain content-addressed and are reused, while Object and Revision
// identities are newly allocated so later edits do not affect the source.
func (s *Store) CopyPathsInDomain(
domainUUID, sourcePath, destinationPath string,
recursive bool,
) (int, error) {
return s.copyPathsInDomain(domainUUID, sourcePath, destinationPath, recursive, nil)
}
func (s *Store) CopyPathsInDomainChecked(domainUUID, sourcePath, destinationPath string, recursive bool, snapshot *PathMutationSnapshot) (int, error) {
if snapshot == nil {
return 0, ErrPathSnapshotChanged
}
count, err := s.copyPathsInDomain(domainUUID, sourcePath, destinationPath, recursive, snapshot)
return count, pathMutationTransactionError(err)
}
func (s *Store) copyPathsInDomain(domainUUID, sourcePath, destinationPath string, recursive bool, snapshot *PathMutationSnapshot) (_ int, resultErr error) {
defer func() { resultErr = s.sqlError("copy paths", resultErr) }()
if err := s.ensureLocalDomain(domainUUID); err != nil {
return 0, err
}
sourcePath = normalizePath(sourcePath)
destinationPath = normalizePath(destinationPath)
if sourcePath == "/" || destinationPath == "/" || sourcePath == destinationPath {
return 0, ErrPathConflict
}
if recursive && strings.HasPrefix(destinationPath+"/", sourcePath+"/") {
return 0, ErrPathConflict
}
tx, cancel, err := s.beginPathMutation(domainUUID)
defer cancel()
if err != nil {
return 0, err
}
defer tx.Rollback()
paths, err := s.listMutationPaths(tx, domainUUID, sourcePath, recursive)
if err != nil {
return 0, err
}
if snapshot != nil {
if err := snapshot.validate(domainUUID, sourcePath, recursive, paths); err != nil {
return 0, err
}
}
if len(paths) == 0 {
return 0, ErrPathNotFound
}
for i := range paths {
paths[i].NewPath = destinationPath + strings.TrimPrefix(paths[i].OldPath, sourcePath)
}
for _, item := range paths {
var exists int
if err := tx.QueryRow(`SELECT COUNT(*) FROM paths WHERE domain_uuid=`+s.sqlParam(1)+` AND path=`+s.sqlParam(2),
domainUUID, item.NewPath).Scan(&exists); err != nil {
return 0, err
}
if exists != 0 {
return 0, ErrPathConflict
}
}
objectCopies := map[string]string{}
for _, item := range paths {
newObjectUUID := objectCopies[item.ObjectUUID]
if newObjectUUID == "" {
newObjectUUID = uuid.NewString()
objectCopies[item.ObjectUUID] = newObjectUUID
if _, err := tx.Exec(`
INSERT INTO objects (uuid, kind, created_at)
SELECT `+s.sqlParam(1)+`, kind, `+s.sqlParam(2)+` FROM objects WHERE uuid=`+s.sqlParam(3),
newObjectUUID, time.Now().Unix(), item.ObjectUUID); err != nil {
return 0, err
}
if s.sqlBackend == storePostgreSQL {
if err := s.copyNativeRevisionsTx(tx, domainUUID, item.ObjectUUID, newObjectUUID, item.NewPath); err != nil {
return 0, err
}
} else if _, err := tx.Exec(`
INSERT INTO revisions (
uuid, object_uuid, body, document_hash, lang, content_type,
filename, message, created_at_ms, created_at
)
SELECT lower(hex(randomblob(4))) || '-' || lower(hex(randomblob(2))) || '-4' ||
substr(lower(hex(randomblob(2))),2) || '-' ||
substr('89ab',abs(random()) % 4 + 1,1) ||
substr(lower(hex(randomblob(2))),2) || '-' || lower(hex(randomblob(6))),
?, body, document_hash, lang, content_type, filename,
message, created_at_ms, created_at
FROM revisions WHERE object_uuid=?`,
newObjectUUID, item.ObjectUUID); err != nil {
return 0, err
}
}
if _, err := tx.Exec(`
INSERT INTO paths(domain_uuid,path,object_uuid,created_at,is_primary)
VALUES(`+s.sqlValues(5)+`)`,
domainUUID, item.NewPath, newObjectUUID, time.Now().Unix(), item.IsPrimary); err != nil {
return 0, err
}
}
if err := tx.Commit(); err != nil {
return 0, err
}
s.InvalidatePathCaches()
return len(paths), nil
}