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.
362 lines
15 KiB
Go
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, ¬null, &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()
|
|
}
|