Files
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +09:00

362 lines
15 KiB
Go

package store
import (
"database/sql"
"errors"
"fmt"
"strings"
"time"
"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 {
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, error) {
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=? 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, error) {
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=? AND a.address=?`, 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, error) {
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=? AND a.head_document_hash=? 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.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, error) {
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=? AND address=? 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, error) {
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=? AND h.address=?
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) {
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=? AND address=? AND id=?`, 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
}
reader, err := s.OpenDocument(historical.DocumentHash)
if err != nil {
return nil, err
}
_ = reader.Close()
now := time.Now().UnixMilli()
tx, err := s.DB.Begin()
if err != nil {
return nil, err
}
defer tx.Rollback()
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=?`, 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(?,?,'restore',?,?,?,?,?,?)`, 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 {
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, err := s.DB.Begin()
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(?,?,'delete',?,?,?,?,?,?)`, 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=? AND address=? AND head_document_hash=?`, domainUUID, address, a.HeadDocumentHash)
if err != nil {
return err
}
if n, _ := result.RowsAffected(); n != 1 {
return ErrAssetConflict
}
return tx.Commit()
}