Files

332 lines
13 KiB
Go

// Canonical 模型持久化及旧快照投影;数据库模型表是权威来源,canvas_document 是内部兼容视图。
package platform
import (
"context"
"database/sql"
"encoding/json"
"net/http"
"sort"
)
// canonicalRoot 查询所属模型根,尚未迁移返回空字符串而非缺行错误。
func canonicalRoot(ctx context.Context, tx *sql.Tx, project, workspace, board string) (string, error) {
var root string
err := tx.QueryRowContext(ctx, `SELECT root_id::text FROM canvas_model_canvases WHERE project=$1 AND workspace_id=$2 AND canvas_id=$3`, project, workspace, board).Scan(&root)
if err == sql.ErrNoRows {
return "", nil
}
return root, err
}
// loadCanvasModel 读取根下所有画布/元素,保留归档版本与删除记录,重建后执行完整模型校验。
func loadCanvasModel(ctx context.Context, tx *sql.Tx, project, workspace, root string) (canvasModel, error) {
model := emptyModel(root)
rows, err := tx.QueryContext(ctx, `SELECT canvas_id::text,parent_canvas_id::text,entry_element_id,version,archived FROM canvas_model_canvases WHERE project=$1 AND workspace_id=$2 AND root_id=$3 ORDER BY canvas_id`, project, workspace, root)
if err != nil {
return model, err
}
for rows.Next() {
var canvas modelCanvas
var parent, entry sql.NullString
var version int64
var archived bool
if err = rows.Scan(&canvas.ID, &parent, &entry, &version, &archived); err != nil {
rows.Close()
return model, err
}
if parent.Valid {
canvas.Parent = &modelParent{CanvasID: parent.String, EntryElementID: entry.String}
}
model.Versions[canvas.ID] = version
if !archived {
model.Canvases[canvas.ID] = canvas
}
}
err = rows.Err()
rows.Close()
if err != nil {
return model, err
}
rows, err = tx.QueryContext(ctx, `SELECT element_id,record,deleted,deleted_incarnation FROM canvas_model_elements WHERE project=$1 AND workspace_id=$2 AND root_id=$3 ORDER BY element_id`, project, workspace, root)
if err != nil {
return model, err
}
defer rows.Close()
for rows.Next() {
var id string
var raw json.RawMessage
var deleted bool
var dead int64
if err = rows.Scan(&id, &raw, &deleted, &dead); err != nil {
return model, err
}
if dead > 0 {
model.Tombstones[id] = dead
}
var element map[string]any
if err = json.Unmarshal(raw, &element); err != nil {
return model, err
}
if dead > 0 {
model.TombstoneOwners[id] = modelString(element["ownerCanvasId"])
}
if !deleted {
model.Elements[id] = element
} else {
model.DeadRecords[id] = element
}
}
if err = rows.Err(); err != nil {
return model, err
}
return model, validateCanvasModel(model)
}
// Only changed element rows are written. canvas_document is a compatibility
// projection for internal AI readers, never the source of a canonical GET/replay.
// saveCanvasModel 在调用方事务中写参与画布与真正变化的元素,更新所有权关系并同步兼容快照。
// 先按 canonical 稳定身份使 AI 目标失效,再开启事务级 canonical_writer 以通过数据库旧写入屏障。
func (s *service) saveCanvasModel(r *http.Request, tx *sql.Tx, project, workspace, account string, before, after canvasModel, participants map[string]bool) error {
ctx := r.Context()
if err := invalidateCanonicalAIIdentities(r, tx, project, workspace, before, after); err != nil {
return err
}
if _, err := tx.ExecContext(ctx, `SELECT set_config('foundry.canonical_writer','on',true)`); err != nil {
return err
}
projection, err := projectCanvasModel(after)
if err != nil {
return err
}
for _, id := range sortedKeys(participants) {
canvas, active := after.Canvases[id]
if active {
if _, existed := before.Versions[id]; !existed {
title := "Canvas"
if canvas.Parent != nil {
data := after.Elements[canvas.Parent.EntryElementID]["data"].(map[string]any)
if value := modelString(data["title"]); value != "" {
title = value
}
}
if _, err = tx.ExecContext(ctx, `INSERT INTO materials(project,workspace_id,id,kind,title,created_by) VALUES($1,$2,$3,'board',$4,$5)`, project, workspace, id, title, account); err != nil {
return err
}
}
var parent, entry any
if canvas.Parent != nil {
parent, entry = canvas.Parent.CanvasID, canvas.Parent.EntryElementID
}
_, err = tx.ExecContext(ctx, `INSERT INTO canvas_model_canvases(project,workspace_id,root_id,canvas_id,parent_canvas_id,entry_element_id,version) VALUES($1,$2,$3,$4,$5,$6,$7) ON CONFLICT(project,workspace_id,canvas_id) DO UPDATE SET parent_canvas_id=EXCLUDED.parent_canvas_id,entry_element_id=EXCLUDED.entry_element_id,version=EXCLUDED.version,archived=false`, project, workspace, after.Root, id, parent, entry, after.Versions[id])
} else {
_, err = tx.ExecContext(ctx, `UPDATE canvas_model_canvases SET archived=true,version=$4 WHERE project=$1 AND workspace_id=$2 AND canvas_id=$3`, project, workspace, id, after.Versions[id])
}
if err != nil {
return err
}
}
// 只更新变化记录;同项目元素 ID 已属于其他 workspace/root 时,受限 upsert 不覆盖并报冲突。
for _, id := range sortedKeys(after.Elements) {
element := after.Elements[id]
if modelEqual(before.Elements[id], element) && before.Tombstones[id] == after.Tombstones[id] {
continue
}
raw, err := json.Marshal(element)
if err != nil {
return err
}
written, err := tx.ExecContext(ctx, `INSERT INTO canvas_model_elements(project,workspace_id,root_id,element_id,owner_canvas_id,incarnation,deleted_incarnation,record) VALUES($1,$2,$3,$4,$5,$6,$7,$8) ON CONFLICT(project,element_id) DO UPDATE SET owner_canvas_id=EXCLUDED.owner_canvas_id,incarnation=EXCLUDED.incarnation,deleted_incarnation=EXCLUDED.deleted_incarnation,record=EXCLUDED.record,deleted=false WHERE canvas_model_elements.workspace_id=EXCLUDED.workspace_id AND canvas_model_elements.root_id=EXCLUDED.root_id`, project, workspace, after.Root, id, element["ownerCanvasId"], modelInt(element["incarnation"]), after.Tombstones[id], raw)
if err != nil {
return err
}
if count, err := written.RowsAffected(); err != nil {
return err
} else if count != 1 {
return errModelConflict
}
}
// 删除也持久保留最后记录及代数,后续恢复/去重不能把墓碑当成从未存在。
for _, id := range sortedKeys(after.Tombstones) {
if after.Elements[id] != nil || before.Elements[id] == nil && before.Tombstones[id] == after.Tombstones[id] {
continue
}
record := after.DeadRecords[id]
if record == nil {
return errCanvasModel
}
raw, err := json.Marshal(record)
if err != nil {
return err
}
written, err := tx.ExecContext(ctx, `INSERT INTO canvas_model_elements(project,workspace_id,root_id,element_id,owner_canvas_id,incarnation,deleted_incarnation,record,deleted) VALUES($1,$2,$3,$4,$5,$6,$6,$7,true) ON CONFLICT(project,element_id) DO UPDATE SET owner_canvas_id=EXCLUDED.owner_canvas_id,incarnation=EXCLUDED.incarnation,deleted_incarnation=EXCLUDED.deleted_incarnation,record=EXCLUDED.record,deleted=true WHERE canvas_model_elements.workspace_id=EXCLUDED.workspace_id AND canvas_model_elements.root_id=EXCLUDED.root_id`, project, workspace, after.Root, id, record["ownerCanvasId"], after.Tombstones[id], raw)
if err != nil {
return err
}
if count, err := written.RowsAffected(); err != nil {
return err
} else if count != 1 {
return errModelConflict
}
}
// Archive relations first; parent/entry changes then install the final owning tree.
for _, id := range sortedKeys(participants) {
if id != after.Root {
if _, err = tx.ExecContext(ctx, `UPDATE canvas_subgraphs SET archived_at=now() WHERE project=$1 AND workspace_id=$2 AND child_board_id=$3`, project, workspace, id); err != nil {
return err
}
}
}
// 先归档旧关系,再按祖先深度由外向内安装最终树,避免父入口变动时出现重复活跃关系。
canvases := sortedKeys(after.Canvases)
sort.SliceStable(canvases, func(i, j int) bool {
a, _ := modelAncestors(after, canvases[i])
b, _ := modelAncestors(after, canvases[j])
return len(a) < len(b)
})
for _, id := range canvases {
canvas := after.Canvases[id]
if !participants[id] || canvas.Parent == nil {
continue
}
_, err = tx.ExecContext(ctx, `INSERT INTO canvas_subgraphs(project,workspace_id,parent_board_id,frame_id,child_board_id) VALUES($1,$2,$3,$4,$5) ON CONFLICT(project,workspace_id,child_board_id) DO UPDATE SET parent_board_id=EXCLUDED.parent_board_id,frame_id=EXCLUDED.frame_id,archived_at=NULL`, project, workspace, canvas.Parent.CanvasID, canvas.Parent.EntryElementID, id)
if err != nil {
return err
}
}
for _, id := range sortedKeys(participants) {
if _, active := after.Canvases[id]; !active {
_, err = tx.ExecContext(ctx, `UPDATE materials SET canvas_version=$4 WHERE project=$1 AND workspace_id=$2 AND id=$3`, project, workspace, id, after.Versions[id])
if err != nil {
return err
}
continue
}
// Asset bindings still run through service checks; canonical identity
// invalidation has already run on the normalized before/after models.
if err = s.saveCanvas(r, tx, project, workspace, canvasSnapshot{BoardID: id, Version: after.Versions[id], Document: projection[id]}); err != nil {
return err
}
}
return nil
}
// projectCanvasModel 为旧 AI reader 生成 v2 快照,只投影已知 v1 组件,未知组件仍完整保存在 canonical 表。
func projectCanvasModel(model canvasModel) (map[string]json.RawMessage, error) {
documents := map[string]map[string]any{}
for id := range model.Canvases {
documents[id] = map[string]any{"schema_version": float64(2), "nodes": []any{}, "edges": []any{}, "viewport": map[string]any{"x": float64(0), "y": float64(0), "zoom": float64(1)}}
}
elements := sortedKeys(model.Elements)
sort.SliceStable(elements, func(i, j int) bool {
return modelString(model.Elements[elements[i]]["orderKey"]) < modelString(model.Elements[elements[j]]["orderKey"])
})
childByEntry := map[string]string{}
for id, canvas := range model.Canvases {
if canvas.Parent != nil {
childByEntry[canvas.Parent.EntryElementID] = id
}
}
for _, id := range elements {
element := model.Elements[id]
if element["structure"] != "node" {
continue
}
kind := modelString(element["componentId"])
if modelInt(element["dataVersion"]) != 1 || !canvasChoice(kind, "text", "script", "image", "plain-text", "plain-image", "icon", "frame") {
continue
}
data := map[string]any{}
for key, value := range element["data"].(map[string]any) {
data[key] = value
}
data["kind"] = kind
geometry := element["geometry"].(map[string]any)
data["rotation"] = geometry["rotation"]
typ := "material"
switch kind {
case "plain-text":
typ = "plainText"
case "plain-image":
typ = "plainImage"
case "icon":
typ = "icon"
case "frame":
typ = "frame"
}
if child := childByEntry[id]; child != "" {
data["subgraph"], data["ports"] = map[string]any{"boardId": child}, []any{}
}
node := map[string]any{"id": id, "type": typ, "position": map[string]any{"x": geometry["x"], "y": geometry["y"]}, "width": geometry["width"], "height": geometry["height"], "data": data}
owner := modelString(element["ownerCanvasId"])
documents[owner]["nodes"] = append(documents[owner]["nodes"].([]any), node)
}
// Canonical 连接直接指真实元素;投影时才沿祖先树生成旧式 frame/port 链,不能反向作为权威身份。
for _, id := range elements {
element := model.Elements[id]
if element["structure"] != "connection" || element["componentId"] != "connection" || modelInt(element["dataVersion"]) != 1 {
continue
}
owner := modelString(element["ownerCanvasId"])
endpoints := []canvasConnectionEndpoint{}
skip := false
for index, field := range []string{"source", "target"} {
endpoint := element[field].(map[string]any)
node := model.Elements[modelString(endpoint["elementId"])]
board := modelString(node["ownerCanvasId"])
if connectionNode(documents[board], modelString(node["id"])) == nil {
skip = true
break
}
handle := modelString(endpoint["portId"])
if handle == "" {
handle = "left"
if index == 0 {
handle = "right"
}
}
path := []subgraphRelation{}
for next := board; next != owner; {
canvas := model.Canvases[next]
if canvas.Parent == nil {
return nil, errCanvasModel
}
path = append(path, subgraphRelation{Parent: canvas.Parent.CanvasID, Frame: canvas.Parent.EntryElementID, Child: next})
next = canvas.Parent.CanvasID
}
direction := "output"
if index == 1 {
direction = "input"
}
resolved, _, err := exposeConnectionEndpoint(canvasConnectionEndpoint{Board: board, Node: modelString(node["id"]), Handle: handle}, direction, path, documents)
// Direct frame/icon endpoints are canonical concepts; old AI readers cannot execute them.
if err != nil {
skip = true
break
}
endpoints = append(endpoints, resolved)
}
if skip {
continue
}
data := map[string]any{}
for key, value := range element["data"].(map[string]any) {
data[key] = value
}
if element["path"] != nil {
data["path"] = element["path"]
}
edge := map[string]any{"id": id, "source": endpoints[0].Node, "target": endpoints[1].Node, "sourceHandle": endpoints[0].Handle, "targetHandle": endpoints[1].Handle, "data": data}
documents[owner]["edges"] = append(documents[owner]["edges"].([]any), edge)
}
result := map[string]json.RawMessage{}
for id, document := range documents {
raw, err := json.Marshal(document)
if err != nil {
return nil, err
}
result[id] = raw
}
return result, nil
}