Files
knowledge-governance/internal/releaseadapter/v071/library_reference_closure.go
T
姚章浩 8d838d9cb4
build / build (push) Successful in 1m45s
feat(library): 整库发布身份、写集合与收尾边界
执行时真实时钟与持久授权回读(撤销/过期即停并保留预备份)、写集合写前落盘、
租约与 attempt 身份、恢复队列与原发送身份分离、成功收尾必须释放维护后再登记终态。
2026-11-01 11:35:10 +08:00

146 lines
5.8 KiB
Go

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)
}