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, ¬null, &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 }