package metadata import ( "context" "database/sql" "errors" "strings" "time" "github.com/google/uuid" ) type Asset struct { DomainUUID string Address string ObjectUUID string HeadDocumentHash string ContentType string Filename string SizeBytes int64 CreatedAtMS int64 UpdatedAtMS int64 } const assetColumns = `domain_uuid,address,object_uuid,head_document_hash,content_type,filename,size_bytes,created_at_ms,updated_at_ms` func scanAsset(row interface{ Scan(...any) error }) (Asset, error) { var a Asset err := row.Scan(&a.DomainUUID, &a.Address, &a.ObjectUUID, &a.HeadDocumentHash, &a.ContentType, &a.Filename, &a.SizeBytes, &a.CreatedAtMS, &a.UpdatedAtMS) return a, err } func (r *Repository) GetAsset(ctx context.Context, domain, address string) (Asset, error) { a, err := scanAsset(r.database.QueryRowContext(ctx, `SELECT `+assetColumns+` FROM assets WHERE domain_uuid=`+r.p(1)+` AND address=`+r.p(2), domain, address)) return a, r.failure(err) } // PutAsset publishes an already-durable Document hash and appends its audit // history in the same transaction. Empty expected is create-only; overwrites // compare the previous hash and keep the asset's object UUID stable. func (r *Repository) PutAsset(ctx context.Context, a Asset, expected, actor string) (Asset, error) { a.Address = strings.TrimSpace(a.Address) parts := strings.SplitN(a.Address, ":", 3) if a.DomainUUID == "" || len(parts) != 3 || parts[0] != "asset" || strings.TrimSpace(parts[1]) == "" || strings.TrimSpace(parts[2]) == "" || strings.ContainsAny(a.Address, "\x00\r\n") || !validHash(a.HeadDocumentHash) || strings.TrimSpace(a.ContentType) == "" || a.SizeBytes < 0 { return Asset{}, ErrInvalid } err := r.write(ctx, "domain/"+a.DomainUUID, func(tx *sql.Tx) error { old, err := scanAsset(tx.QueryRowContext(ctx, `SELECT `+assetColumns+` FROM assets WHERE domain_uuid=`+r.p(1)+` AND address=`+r.p(2), a.DomainUUID, a.Address)) if err != nil && !errors.Is(err, sql.ErrNoRows) { return r.failure(err) } if old.HeadDocumentHash != expected { return ErrConflict } if r.applicationNamespace && err == nil && old.HeadDocumentHash == a.HeadDocumentHash && old.ContentType == a.ContentType && old.Filename == a.Filename && old.SizeBytes == a.SizeBytes { a = old return nil } a.UpdatedAtMS = time.Now().UnixMilli() if err == nil { a.ObjectUUID = old.ObjectUUID a.CreatedAtMS = old.CreatedAtMS if a.UpdatedAtMS <= old.UpdatedAtMS { a.UpdatedAtMS = old.UpdatedAtMS + 1 } _, err = tx.ExecContext(ctx, `UPDATE assets SET head_document_hash=`+r.p(1)+`,content_type=`+r.p(2)+`,filename=`+r.p(3)+`,size_bytes=`+r.p(4)+`,updated_at_ms=`+r.p(5)+` WHERE domain_uuid=`+r.p(6)+` AND address=`+r.p(7), a.HeadDocumentHash, a.ContentType, a.Filename, a.SizeBytes, a.UpdatedAtMS, a.DomainUUID, a.Address) } else { a.ObjectUUID = uuid.NewString() a.CreatedAtMS = a.UpdatedAtMS if _, err = tx.ExecContext(ctx, `INSERT INTO objects(uuid,kind,created_at) VALUES (`+r.p(1)+`,'asset',`+r.p(2)+`)`, a.ObjectUUID, a.CreatedAtMS/1000); err != nil { return r.failure(err) } if _, err = tx.ExecContext(ctx, `INSERT INTO object_origins(object_uuid,domain_uuid,created_at) VALUES (`+r.p(1)+`,`+r.p(2)+`,`+r.p(3)+`)`, a.ObjectUUID, a.DomainUUID, a.CreatedAtMS/1000); err != nil { return r.failure(err) } _, err = tx.ExecContext(ctx, `INSERT INTO assets (`+assetColumns+`) VALUES (`+r.p(1)+`,`+r.p(2)+`,`+r.p(3)+`,`+r.p(4)+`,`+r.p(5)+`,`+r.p(6)+`,`+r.p(7)+`,`+r.p(8)+`,`+r.p(9)+`)`, a.DomainUUID, a.Address, a.ObjectUUID, a.HeadDocumentHash, a.ContentType, a.Filename, a.SizeBytes, a.CreatedAtMS, a.UpdatedAtMS) } if err != nil { return r.failure(err) } _, err = tx.ExecContext(ctx, `INSERT INTO asset_head_history(domain_uuid,address,action,document_hash,content_type,filename,size_bytes,actor_uuid,created_at_ms) VALUES (`+r.p(1)+`,`+r.p(2)+`,'put',`+r.p(3)+`,`+r.p(4)+`,`+r.p(5)+`,`+r.p(6)+`,`+r.p(7)+`,`+r.p(8)+`)`, a.DomainUUID, a.Address, a.HeadDocumentHash, a.ContentType, a.Filename, a.SizeBytes, actor, a.UpdatedAtMS) return r.failure(err) }) if err != nil { return Asset{}, err } return a, nil }