package v071 import ( "context" "encoding/json" "errors" "fmt" "regexp" "sort" "strings" "github.com/jackc/pgx/v5" "knowledge-governance/internal/librarysnapshot" ) type libraryClosureReader interface { QueryRow(context.Context, string, ...any) pgx.Row } // Check edges before JOIN-based export can erase a scoped orphan. Either parent // can establish scope; an edge is not safe merely because its other parent is absent. func verifyLibraryRelationalClosure(ctx context.Context, db libraryClosureReader, identity PostgresIdentity, includeDeleted bool) error { var invalid bool err := db.QueryRow(ctx, `/* library-relational-closure */ SELECT EXISTS(SELECT 1 FROM chunks c LEFT JOIN knowledges k ON k.id=c.knowledge_id WHERE c.tenant_id=$1 AND c.knowledge_base_id=$2 AND ($3 OR c.deleted_at IS NULL) AND (k.id IS NULL OR k.tenant_id IS DISTINCT FROM c.tenant_id OR k.knowledge_base_id IS DISTINCT FROM c.knowledge_base_id OR (NOT $3 AND k.deleted_at IS NOT NULL))) OR EXISTS(SELECT 1 FROM knowledge_tag_relations r LEFT JOIN knowledges k ON k.id=r.knowledge_id LEFT JOIN knowledge_tags t ON t.id=r.tag_id WHERE ((k.tenant_id=$1 AND k.knowledge_base_id=$2 AND ($3 OR k.deleted_at IS NULL)) OR (t.tenant_id=$1 AND t.knowledge_base_id=$2 AND ($3 OR t.deleted_at IS NULL))) AND (k.id IS NULL OR t.id IS NULL OR k.tenant_id IS DISTINCT FROM t.tenant_id OR k.knowledge_base_id IS DISTINCT FROM t.knowledge_base_id OR (NOT $3 AND (k.deleted_at IS NOT NULL OR t.deleted_at IS NOT NULL)))) OR EXISTS(SELECT 1 FROM resource_bindings b WHERE b.tenant_id=$1 AND (EXISTS(SELECT 1 FROM knowledges k WHERE k.id=b.owner_id AND k.tenant_id=$1 AND k.knowledge_base_id=$2 AND ($3 OR k.deleted_at IS NULL)) OR EXISTS(SELECT 1 FROM chunks c WHERE c.id=b.owner_id AND c.tenant_id=$1 AND c.knowledge_base_id=$2 AND ($3 OR c.deleted_at IS NULL))) AND (b.owner_type NOT IN ('knowledge','chunk') OR b.owner_type IS NULL))`, identity.TenantID, identity.KnowledgeBaseID, includeDeleted).Scan(&invalid) if err != nil { return fmt.Errorf("read library reference closure: %w", err) } if invalid { return errors.New("unresolved or cross-parent library relationship") } return nil } func verifyLibraryResourceOwners(ctx context.Context, db libraryClosureReader, ids []string) error { var invalid bool err := db.QueryRow(ctx, `/* library-resource-owner-closure */ SELECT EXISTS( SELECT 1 FROM resource_bindings b JOIN resources r ON r.id=b.resource_id WHERE r.id=ANY($1::text[]) AND ( b.tenant_id IS DISTINCT FROM r.tenant_id OR b.owner_type IS NULL OR NOT ( (b.owner_type='knowledge' AND EXISTS(SELECT 1 FROM knowledges k WHERE k.id=b.owner_id AND k.tenant_id=b.tenant_id)) OR (b.owner_type='chunk' AND EXISTS(SELECT 1 FROM chunks c JOIN knowledges k ON k.id=c.knowledge_id AND k.tenant_id=c.tenant_id AND k.knowledge_base_id=c.knowledge_base_id WHERE c.id=b.owner_id AND c.tenant_id=b.tenant_id)))))`, ids).Scan(&invalid) if err != nil { return fmt.Errorf("read referenced resource owners: %w", err) } if invalid { return errors.New("referenced resource has unknown or unresolved owner") } return nil } var libraryResourceToken = regexp.MustCompile(`resource://([A-Za-z0-9_-]*)`) // Decode JSON before scanning string leaves (including nested metadata). The // v071 reader accepts exactly 22 URL-safe characters, not URI query/path suffixes. // Opaque escaped/encoded representations are refused rather than silently omitted. func libraryResourceHandles(rows []json.RawMessage) ([]string, error) { seen := map[string]bool{} var visit func(any) error visit = func(value any) error { switch v := value.(type) { case map[string]any: for _, x := range v { if e := visit(x); e != nil { return e } } case []any: for _, x := range v { if e := visit(x); e != nil { return e } } case string: rest := v for strings.Contains(rest, "resource:") { start := strings.Index(rest, "resource:") rest = rest[start:] match := libraryResourceToken.FindStringSubmatchIndex(rest) if match == nil || match[0] != 0 || match[3]-match[2] != 22 { return errors.New("unsupported resource reference representation") } if match[1] < len(rest) && strings.ContainsRune("/?#=%\\", rune(rest[match[1]])) { return errors.New("unsupported resource reference suffix") } seen[rest[match[2]:match[3]]] = true rest = rest[match[1]:] } } return nil } for _, raw := range rows { var value any decoder := json.NewDecoder(strings.NewReader(string(raw))) decoder.UseNumber() if e := decoder.Decode(&value); e != nil { return nil, e } if e := visit(value); e != nil { return nil, e } } handles := make([]string, 0, len(seen)) for handle := range seen { handles = append(handles, handle) } sort.Strings(handles) return handles, nil } // Revalidate frozen source content at the actual planning boundary. A sealed // manifest proves bytes, not that every row has a parent or a supported owner. func validateArchivedLibraryClosure(archive *librarysnapshot.Archive, manifest librarysnapshot.Manifest) error { var pg PostgresSnapshot es := SearchSnapshot{MappingSHA256: manifest.Compatibility.IndexMappingSHA256} for _, part := range manifest.Parts { if part.Kind != "database" && part.Kind != "wiki" && part.Kind != "index" { continue } reader, e := archive.OpenPart(part) if e != nil { return e } if part.Kind == "index" { e = json.NewDecoder(reader).Decode(&es.Documents) } else { var rows []json.RawMessage e = json.NewDecoder(reader).Decode(&rows) pg.Tables = append(pg.Tables, newTableSnapshot(part.Name, rows)) } reader.Close() if e != nil { return e } } es.DocumentsSHA256, _ = searchDocumentsDigest(es.Documents) return validateLibraryCandidate(PostgresIdentity{TenantID: manifest.TenantID, KnowledgeBaseID: manifest.KnowledgeBaseID}, pg, es) }