Files
pages/internal/store/asset_freeze.go
T
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

125 lines
3.7 KiB
Go

package store
import (
"bytes"
"database/sql"
"errors"
"fmt"
"io"
"strings"
"golang.org/x/net/html"
)
var ErrEmbeddedAssetUnavailable = errors.New("embedded asset is unavailable")
// freezeEmbeddedAssets resolves mutable asset: HEADs only in HTML embedding
// attributes. Plain text and code examples containing asset: remain unchanged.
func (s *Store) freezeEmbeddedAssets(objectUUID string, payload []byte, contentType string) ([]byte, []string, error) {
return freezeEmbeddedAssetsFrom(s.DB, objectUUID, payload, contentType)
}
func freezeEmbeddedAssetsFrom(q interface{ QueryRow(string, ...any) *sql.Row }, objectUUID string, payload []byte, contentType string) ([]byte, []string, error) {
if !strings.HasPrefix(strings.ToLower(strings.TrimSpace(contentType)), "text/html") {
return payload, nil, nil
}
z := html.NewTokenizer(bytes.NewReader(payload))
var output bytes.Buffer
seen := map[string]bool{}
resolved := map[string]string{}
var hashes []string
resolve := func(address string) (string, error) {
if hash := resolved[address]; hash != "" {
return hash, nil
}
var hash string
err := q.QueryRow(`SELECT COALESCE(a.head_document_hash,'') FROM assets a JOIN paths p ON p.domain_uuid=a.domain_uuid WHERE p.object_uuid=? AND a.address=? ORDER BY COALESCE(p.is_primary,0) DESC LIMIT 1`, objectUUID, address).Scan(&hash)
if err != nil || !validDocumentHash(hash) {
if errors.Is(err, sql.ErrNoRows) || err == nil {
return "", fmt.Errorf("%w: %s", ErrEmbeddedAssetUnavailable, address)
}
return "", err
}
resolved[address] = hash
if !seen[hash] {
seen[hash] = true
hashes = append(hashes, hash)
}
return hash, nil
}
for {
typeOfToken := z.Next()
if typeOfToken == html.ErrorToken {
if errors.Is(z.Err(), io.EOF) {
return output.Bytes(), hashes, nil
}
return nil, nil, z.Err()
}
if typeOfToken != html.StartTagToken && typeOfToken != html.SelfClosingTagToken {
output.Write(z.Raw())
continue
}
token := z.Token()
changed := false
assetRef := tokenAttribute(token.Attr, "asset-ref")
legacyImmutableRef := tokenAttribute(token.Attr, "immutable-ref")
if assetRef == "" && strings.HasPrefix(legacyImmutableRef, "asset:") {
assetRef = legacyImmutableRef
}
if strings.HasPrefix(assetRef, "asset:") {
hash, err := resolve(assetRef)
if err != nil {
return nil, nil, err
}
setTokenAttribute(&token, "asset-ref", assetRef)
setTokenAttribute(&token, "immutable-ref", "sha256:"+hash)
changed = true
}
for _, name := range []string{"src", "href", "poster", "data"} {
provenanceName := "data-pageswiki-asset-" + name
address := tokenAttribute(token.Attr, provenanceName)
if address == "" {
candidate := tokenAttribute(token.Attr, name)
if strings.HasPrefix(candidate, "asset:") {
address = candidate
}
}
if !strings.HasPrefix(address, "asset:") {
continue
}
hash, err := resolve(address)
if err != nil {
return nil, nil, err
}
setTokenAttribute(&token, provenanceName, address)
setTokenAttribute(&token, name, "/_/obj/sha256:"+hash)
changed = true
}
if changed {
output.WriteString(token.String())
} else {
output.Write(z.Raw())
}
}
}
func tokenAttribute(attributes []html.Attribute, name string) string {
for _, attribute := range attributes {
if strings.EqualFold(attribute.Key, name) {
return strings.TrimSpace(attribute.Val)
}
}
return ""
}
func setTokenAttribute(token *html.Token, name, value string) {
for index := range token.Attr {
if strings.EqualFold(token.Attr[index].Key, name) {
token.Attr[index].Key = name
token.Attr[index].Val = value
return
}
}
token.Attr = append(token.Attr, html.Attribute{Key: name, Val: value})
}