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

450 lines
19 KiB
Go

package store
import (
"bytes"
"context"
"database/sql"
"errors"
"fmt"
"strings"
"time"
"pageswiki/internal/metadata"
"github.com/google/uuid"
)
var (
ErrAssetNotFound = errors.New("asset not found")
ErrAssetConflict = errors.New("asset HEAD conflict")
)
type Asset struct {
DomainUUID string `json:"domain_uuid"`
Address string `json:"address"`
ObjectUUID string `json:"object_uuid"`
HeadDocumentHash string `json:"head_document_hash"`
ContentType string `json:"content_type"`
Filename string `json:"filename"`
SizeBytes int64 `json:"size_bytes"`
CreatedAtMS int64 `json:"created_at_ms"`
UpdatedAtMS int64 `json:"updated_at_ms"`
ReferenceCount int `json:"reference_count"`
}
type AssetHistory struct {
ID int64 `json:"id"`
Action string `json:"action"`
DocumentHash string `json:"document_hash"`
ContentType string `json:"content_type"`
Filename string `json:"filename"`
SizeBytes int64 `json:"size_bytes"`
ActorUUID string `json:"actor_uuid"`
CreatedAtMS int64 `json:"created_at_ms"`
}
type AssetDependency struct {
DocumentHash string `json:"document_hash"`
RevisionUUID string `json:"revision_uuid"`
ObjectUUID string `json:"object_uuid"`
Path string `json:"path"`
CreatedAtMS int64 `json:"created_at_ms"`
}
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
}
if len(columns) == 0 {
if _, err = s.DB.Exec(assetTableSQL); err != nil {
return err
}
} else if !columns["domain_uuid"] {
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
if _, err = tx.Exec(`ALTER TABLE assets RENAME TO assets_legacy`); err != nil {
return err
}
if _, err = tx.Exec(assetTableSQL); err != nil {
return err
}
if _, err = tx.Exec(`
INSERT INTO assets(domain_uuid,address,object_uuid,head_document_hash,content_type,filename,size_bytes,created_at_ms,updated_at_ms)
SELECT COALESCE((SELECT uuid FROM domains WHERE name='default' ORDER BY id LIMIT 1),(SELECT uuid FROM domains ORDER BY id LIMIT 1)),address,object_uuid,head_document_hash,'application/octet-stream','',0,created_at_ms,updated_at_ms
FROM assets_legacy
`); err != nil {
return err
}
if _, err = tx.Exec(`DROP TABLE assets_legacy`); err != nil {
return err
}
if err = tx.Commit(); err != nil {
return err
}
} else if _, err = s.DB.Exec(assetTableSQL); err != nil {
return err
}
_, err = s.DB.Exec(`CREATE TABLE IF NOT EXISTS asset_head_history(
id INTEGER PRIMARY KEY AUTOINCREMENT,domain_uuid TEXT NOT NULL,address TEXT NOT NULL,
action TEXT NOT NULL DEFAULT 'put',
document_hash TEXT NOT NULL,content_type TEXT NOT NULL DEFAULT 'application/octet-stream',
filename TEXT NOT NULL DEFAULT '',size_bytes INTEGER NOT NULL DEFAULT 0,
actor_uuid TEXT NOT NULL DEFAULT '',created_at_ms INTEGER NOT NULL
)`)
_, _ = s.DB.Exec(`ALTER TABLE asset_head_history ADD COLUMN action TEXT NOT NULL DEFAULT 'put'`)
if err != nil {
return err
}
_, err = s.DB.Exec(`CREATE INDEX IF NOT EXISTS idx_asset_history_domain_address_hash ON asset_head_history(domain_uuid,address,document_hash)`)
if err != nil {
return err
}
return err
}
const assetTableSQL = `CREATE TABLE IF NOT EXISTS assets(
domain_uuid TEXT NOT NULL,address TEXT NOT NULL,object_uuid TEXT NOT NULL,
head_document_hash TEXT,content_type TEXT NOT NULL DEFAULT 'application/octet-stream',
filename TEXT NOT NULL DEFAULT '',size_bytes INTEGER NOT NULL DEFAULT 0,
created_at_ms INTEGER NOT NULL,updated_at_ms INTEGER NOT NULL,
PRIMARY KEY(domain_uuid,address),UNIQUE(object_uuid)
)`
func assetTableColumns(db *sql.DB, table string) (map[string]bool, error) {
rows, err := db.Query(`PRAGMA table_info(` + table + `)`)
if err != nil {
return nil, err
}
defer rows.Close()
out := map[string]bool{}
for rows.Next() {
var cid, notnull, pk int
var name, kind string
var defaultValue any
if err := rows.Scan(&cid, &name, &kind, &notnull, &defaultValue, &pk); err != nil {
return nil, err
}
out[name] = true
}
return out, rows.Err()
}
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
}
defer rows.Close()
var assets []Asset
for rows.Next() {
var a Asset
if err := rows.Scan(&a.DomainUUID, &a.Address, &a.ObjectUUID, &a.HeadDocumentHash, &a.ContentType, &a.Filename, &a.SizeBytes, &a.CreatedAtMS, &a.UpdatedAtMS, &a.ReferenceCount); err != nil {
return nil, err
}
assets = append(assets, a)
}
return assets, rows.Err()
}
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=`+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, 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=`+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
}
return &a, err
}
func normalizeAssetAddress(address string) (string, error) {
address = strings.TrimSpace(address)
parts := strings.SplitN(address, ":", 3)
if len(parts) != 3 || parts[0] != "asset" || strings.TrimSpace(parts[1]) == "" || strings.TrimSpace(parts[2]) == "" {
return "", fmt.Errorf("invalid asset address")
}
return address, nil
}
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")
}
address, err := normalizeAssetAddress(address)
if err != nil {
return nil, false, err
}
current, getErr := s.GetAsset(domainUUID, address)
if getErr != nil && !errors.Is(getErr, ErrAssetNotFound) {
return nil, false, getErr
}
if getErr == nil && expectedHash == "" {
return nil, false, ErrAssetConflict
}
if strings.TrimSpace(contentType) == "" {
contentType = "application/octet-stream"
}
filename = strings.TrimSpace(filename)
if expectedHash != "" && (getErr != nil || current.HeadDocumentHash != strings.Trim(expectedHash, "\"")) {
return nil, false, ErrAssetConflict
}
hash := revisionHash(string(payload))
if getErr == nil && current.HeadDocumentHash == hash && current.ContentType == contentType && current.Filename == filename {
return current, false, nil
}
if err := s.persistDocument(hash, string(payload)); err != nil {
return nil, false, err
}
if strings.TrimSpace(contentType) == "" {
contentType = "application/octet-stream"
}
filename = strings.TrimSpace(filename)
now := time.Now().UnixMilli()
tx, err := s.DB.Begin()
if err != nil {
return nil, false, err
}
defer tx.Rollback()
if getErr != nil {
objectUUID := uuid.NewString()
if _, err = tx.Exec(`INSERT INTO objects(uuid,kind,created_at) VALUES(?,'asset',?)`, objectUUID, now/1000); err != nil {
return nil, false, err
}
_, err = tx.Exec(`INSERT INTO assets(domain_uuid,address,object_uuid,head_document_hash,content_type,filename,size_bytes,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?,?,?,?)`, domainUUID, address, objectUUID, hash, contentType, filename, len(payload), now, now)
} else {
var result sql.Result
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=?`, hash, contentType, filename, len(payload), now, domainUUID, address, current.HeadDocumentHash)
if err == nil {
if n, _ := result.RowsAffected(); n != 1 {
return nil, false, ErrAssetConflict
}
}
}
if err != nil {
return nil, false, err
}
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(?,?,'put',?,?,?,?,?,?)`, domainUUID, address, hash, contentType, filename, len(payload), actorUUID, now); err != nil {
return nil, false, err
}
if err = tx.Commit(); err != nil {
return nil, false, err
}
a, err := s.GetAsset(domainUUID, address)
return a, true, err
}
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
}
defer rows.Close()
var out []AssetHistory
for rows.Next() {
var x AssetHistory
if err := rows.Scan(&x.ID, &x.Action, &x.DocumentHash, &x.ContentType, &x.Filename, &x.SizeBytes, &x.ActorUUID, &x.CreatedAtMS); err != nil {
return nil, err
}
out = append(out, x)
}
return out, rows.Err()
}
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)
FROM (SELECT domain_uuid,address,document_hash FROM asset_head_history
UNION SELECT domain_uuid,address,head_document_hash FROM assets) h
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=`+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)
if err != nil {
return nil, err
}
defer rows.Close()
var out []AssetDependency
for rows.Next() {
var x AssetDependency
if err := rows.Scan(&x.DocumentHash, &x.RevisionUUID, &x.ObjectUUID, &x.Path, &x.CreatedAtMS); err != nil {
return nil, err
}
out = append(out, x)
}
return out, rows.Err()
}
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
}
if expectedHash == "" || current.HeadDocumentHash != strings.Trim(expectedHash, "\"") {
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=`+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, 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=`+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
}
affected, _ := result.RowsAffected()
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(`+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 {
return nil, err
}
return s.GetAsset(domainUUID, address)
}
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
}
if expectedHash == "" || a.HeadDocumentHash != strings.Trim(expectedHash, "\"") {
return ErrAssetConflict
}
now := time.Now().UnixMilli()
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(`+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=`+s.sqlParam(1)+` AND address=`+s.sqlParam(2)+` AND head_document_hash=`+s.sqlParam(3), domainUUID, address, a.HeadDocumentHash)
if err != nil {
return err
}
if n, _ := result.RowsAffected(); n != 1 {
return ErrAssetConflict
}
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
}