package pp import ( "crypto/sha256" "encoding/hex" "encoding/json" "fmt" "sort" "strconv" "knowledge-governance/internal/governance" ) type ImportPlan struct { Connection governance.SourceConnection SourceItems []governance.SourceItem ContentObjects []governance.ContentObject Versions []governance.SourceItemVersion Publications []governance.Publication } func BuildImportPlan(snapshot Snapshot) (ImportPlan, error) { if err := ValidateSnapshot(snapshot); err != nil { return ImportPlan{}, err } connectionID := stableID("sc", snapshot.KBID) plan := ImportPlan{ Connection: governance.SourceConnection{ ID: connectionID, Type: governance.SourceTypePP, Name: "PP legacy " + connectionID, SecretRef: "", Enabled: false, }, SourceItems: make([]governance.SourceItem, 0, len(snapshot.Items)), ContentObjects: make([]governance.ContentObject, 0), Versions: make([]governance.SourceItemVersion, 0, len(snapshot.Items)), Publications: make([]governance.Publication, 0), } contentBySHA := make(map[string]governance.ContentObject) publicationByKnowledgeID := make(map[string]struct{}) for _, item := range snapshot.Items { itemID := stableID("si", connectionID, item.SourceURLHash) sizeBytes := item.Bytes revision := item.SHA256 if item.Status == StatusOverLimit { revision = metadataRevision(item) } plan.SourceItems = append(plan.SourceItems, governance.SourceItem{ ID: itemID, SourceConnectionID: connectionID, StableExternalID: item.SourceURLHash, CanonicalURIHash: item.SourceURLHash, Title: "", ItemType: governance.ItemTypeDocument, SizeBytes: &sizeBytes, Revision: revision, Visibility: governance.VisibilityExternal, VisibilityOrigin: governance.VisibilityOriginPPPublicTag, SourceChange: governance.SourceChangeUnchanged, }) rawSummary := map[string]any{ "legacy_status": item.Status, "source_ids": item.SourceIDs, } if item.Status == StatusContentAlias { rawSummary["canonical_source_url_hash"] = item.CanonicalSourceURLHash } rawJSON, err := json.Marshal(rawSummary) if err != nil { return ImportPlan{}, fmt.Errorf("marshal legacy record summary: %w", err) } versionID := stableID("sv", itemID, revision) if item.Status == StatusOverLimit { plan.Versions = append(plan.Versions, governance.SourceItemVersion{ ID: versionID, SourceItemID: itemID, Revision: revision, ContentState: governance.ContentOverLimit, DownloadError: "legacy_50_mib_limit", RawRecordSummary: rawJSON, }) continue } content, ok := contentBySHA[item.SHA256] if !ok { content = governance.ContentObject{ ID: stableID("co", item.SHA256), SHA256: item.SHA256, SizeBytes: item.Bytes, State: governance.ContentVerified, } contentBySHA[item.SHA256] = content plan.ContentObjects = append(plan.ContentObjects, content) } else if content.SizeBytes != item.Bytes { return ImportPlan{}, fmt.Errorf("same SHA-256 has conflicting byte sizes") } contentID := content.ID plan.Versions = append(plan.Versions, governance.SourceItemVersion{ ID: versionID, SourceItemID: itemID, Revision: item.SHA256, ContentObjectID: &contentID, ContentState: governance.ContentVerified, RawRecordSummary: rawJSON, }) if item.Status != StatusCompleted { continue } if _, exists := publicationByKnowledgeID[item.KnowledgeID]; exists { return ImportPlan{}, fmt.Errorf("completed records share a knowledge ID") } publicationByKnowledgeID[item.KnowledgeID] = struct{}{} plan.Publications = append(plan.Publications, governance.Publication{ ID: stableID("tp", snapshot.KBID, item.KnowledgeID), SourceItemVersionID: versionID, TestKBID: snapshot.KBID, KnowledgeID: item.KnowledgeID, IngestState: governance.IngestUploaded, ProcessingState: governance.ProcessingCompleted, RetrievalState: governance.RetrievalUnpublished, }) } return plan, nil } func stableID(prefix string, parts ...string) string { digest := sha256.New() for _, part := range parts { _, _ = digest.Write([]byte{0}) _, _ = digest.Write([]byte(part)) } return prefix + "-" + hex.EncodeToString(digest.Sum(nil))[:32] } func metadataRevision(item Item) string { sourceIDs := append([]string(nil), item.SourceIDs...) sort.Strings(sourceIDs) parts := []string{item.SourceURLHash, strconv.FormatInt(item.Bytes, 10)} parts = append(parts, sourceIDs...) digest := sha256.New() for _, part := range parts { _, _ = digest.Write([]byte{0}) _, _ = digest.Write([]byte(part)) } return "metadata-sha256:" + hex.EncodeToString(digest.Sum(nil)) }