103 lines
3.4 KiB
Go
103 lines
3.4 KiB
Go
package source
|
|
|
|
import (
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"fmt"
|
|
)
|
|
|
|
// DigestDocument returns a deterministic digest of the canonical source
|
|
// document content. The existing Digest field is excluded from its own digest.
|
|
func DigestDocument(doc *SourceDocument) (string, error) {
|
|
if doc == nil {
|
|
return "", fmt.Errorf("source document must not be nil")
|
|
}
|
|
payload := struct {
|
|
ID string `json:"id"`
|
|
Kind string `json:"kind"`
|
|
Format string `json:"format"`
|
|
Units []SourceUnit `json:"units"`
|
|
Metadata map[string]any `json:"metadata,omitempty"`
|
|
}{
|
|
ID: doc.ID,
|
|
Kind: doc.Kind,
|
|
Format: doc.Format,
|
|
Units: doc.Units,
|
|
Metadata: doc.Metadata,
|
|
}
|
|
encoded, err := json.Marshal(payload)
|
|
if err != nil {
|
|
return "", fmt.Errorf("encode source document for digest: %w", err)
|
|
}
|
|
sum := sha256.Sum256(encoded)
|
|
return "sha256:" + hex.EncodeToString(sum[:]), nil
|
|
}
|
|
|
|
// DigestChunk returns a deterministic digest of a chunk, including its source
|
|
// provenance, content, units, and metadata.
|
|
func DigestChunk(chunk Chunk) (string, error) {
|
|
annotations, err := CanonicalizeChunkAnnotations(chunk.Annotations)
|
|
if err != nil {
|
|
return "", fmt.Errorf("canonicalize source chunk annotations: %w", err)
|
|
}
|
|
planAnnotations, err := CanonicalizeChunkAnnotations(chunk.PlanAnnotations)
|
|
if err != nil {
|
|
return "", fmt.Errorf("canonicalize source chunk plan annotations: %w", err)
|
|
}
|
|
payload := struct {
|
|
ID string `json:"id"`
|
|
SourceID string `json:"source_id"`
|
|
Index int `json:"index"`
|
|
Ref SourceRef `json:"ref"`
|
|
Content []byte `json:"content"`
|
|
MediaType string `json:"media_type"`
|
|
Units []SourceUnit `json:"units"`
|
|
Metadata map[string]any `json:"metadata,omitempty"`
|
|
Annotations ChunkAnnotations `json:"annotations,omitempty"`
|
|
PlanAnnotations ChunkAnnotations `json:"plan_annotations,omitempty"`
|
|
}{
|
|
ID: chunk.ID,
|
|
SourceID: chunk.SourceID,
|
|
Index: chunk.Index,
|
|
Ref: chunk.Ref,
|
|
Content: chunk.Content,
|
|
MediaType: chunk.MediaType,
|
|
Units: chunk.Units,
|
|
Metadata: chunk.Metadata,
|
|
Annotations: annotations,
|
|
PlanAnnotations: planAnnotations,
|
|
}
|
|
encoded, err := json.Marshal(payload)
|
|
if err != nil {
|
|
return "", fmt.Errorf("encode source chunk for digest: %w", err)
|
|
}
|
|
sum := sha256.Sum256(encoded)
|
|
return "sha256:" + hex.EncodeToString(sum[:]), nil
|
|
}
|
|
|
|
// DigestChunkPlan returns a deterministic digest of the logical plan. Storage
|
|
// schema, producer provenance, warnings, and timestamps are intentionally not
|
|
// part of the digest.
|
|
func DigestChunkPlan(plan ChunkPlan) (string, error) {
|
|
canonical, err := CanonicalizeChunkPlan(plan)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if isBlank(canonical.SourceDigest) {
|
|
return "", fmt.Errorf("chunk plan source_digest must not be empty")
|
|
}
|
|
if hasSurroundingWhitespace(canonical.SourceDigest) {
|
|
return "", fmt.Errorf("chunk plan source_digest must not contain leading or trailing whitespace")
|
|
}
|
|
if len(canonical.Ranges) == 0 {
|
|
return "", fmt.Errorf("chunk plan ranges must not be empty")
|
|
}
|
|
encoded, err := json.Marshal(canonical)
|
|
if err != nil {
|
|
return "", fmt.Errorf("encode chunk plan for digest: %w", err)
|
|
}
|
|
sum := sha256.Sum256(encoded)
|
|
return "sha256:" + hex.EncodeToString(sum[:]), nil
|
|
}
|