go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/projects/nodes/pkg/dbmodel/store.go

/*

Copyright (c) 2023 - Present. Will Charczuk. All rights reserved.
Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.

*/

package dbmodel

import (
	"bytes"
	"context"
	"fmt"
	"sync"
	"time"

	"github.com/wcharczuk/go-incr"
	"go.charczuk.com/projects/nodes/pkg/incrutil"
	"go.charczuk.com/projects/nodes/pkg/model"
	"go.charczuk.com/projects/nodes/pkg/types"
	"go.charczuk.com/sdk/errutil"
	"go.charczuk.com/sdk/iter"
	"go.charczuk.com/sdk/uuid"
)

// Store is a wrapper for a model manager that
// implements the graph store api against the database
// for a given graph by identifier.
type Store struct {
	GraphID uuid.UUID
	UserID  uuid.UUID
	Model   *Manager
}

func (s Store) Save(ctx context.Context) (*types.GraphFull, error) {
	return s.Model.Deserialize(ctx, s.GraphID, false, false)
}

func (s Store) Load(ctx context.Context, graph *types.GraphFull) (id incr.Identifier, err error) {
	// create a new graph essentially based on the file.
	graphObj := GraphFromType(graph.Graph)
	graphObj.ID = uuid.V4()
	graphObj.UserID = s.UserID
	graphObj.CreatedUTC = time.Now().UTC()
	graphObj.UpdatedUTC = time.Now().UTC()
	if err = s.Model.Invoke(ctx).Create(graphObj); err != nil {
		return
	}

	id = incr.Identifier(graphObj.ID)

	// nodes
	nodeRemap := make(map[incr.Identifier]uuid.UUID)
	for _, n := range graph.Nodes {
		nodeObj := NodeFromTypeNode(graphObj.ID, s.UserID, &n)
		nodeObj.ID = uuid.V4()
		nodeRemap[n.ID] = nodeObj.ID
		if err = s.Model.Invoke(ctx).Create(nodeObj); err != nil {
			return
		}
	}

	// edges
	for _, e := range graph.Edges {
		edgeObj := EdgeFromType(graphObj, e)
		edgeObj.ParentID = nodeRemap[e.ParentID]
		edgeObj.ChildID = nodeRemap[e.ChildID]
		if err = s.Model.Invoke(ctx).Create(edgeObj); err != nil {
			return
		}
	}

	// node values
	for _, v := range graph.Values {
		nv := &NodeValue{
			NodeID:    nodeRemap[v.ID],
			GraphID:   graphObj.ID,
			UserID:    graphObj.UserID,
			ValueType: v.ValueType,
			Value:     v.Value,
		}
		if err = s.Model.Invoke(ctx).Create(nv); err != nil {
			return
		}
	}
	return
}

func (s Store) Graph(ctx context.Context) (*types.Graph, error) {
	var graphObj Graph
	found, err := s.Model.Invoke(ctx).Get(&graphObj, s.GraphID)
	if err != nil {
		return nil, err
	}
	if !found {
		return nil, nil
	}

	return &types.Graph{
		ID:               incr.Identifier(graphObj.ID),
		Label:            graphObj.Label,
		StabilizationNum: graphObj.StabilizationNum,
		Metadata: types.GraphMetadata{
			UserID:       graphObj.UserID,
			CreatedUTC:   graphObj.CreatedUTC,
			UpdatedUTC:   graphObj.UpdatedUTC,
			ViewportX:    graphObj.ViewportX,
			ViewportY:    graphObj.ViewportY,
			ViewportZoom: graphObj.ViewportZoom,
		},
	}, nil
}

func (s Store) Logs(ctx context.Context) (string, error) {
	logsLatest, found, err := s.Model.GraphLogsLatest(ctx, s.GraphID)
	if err != nil {
		return "", err
	}
	if !found {
		return "", nil
	}
	return logsLatest.Logs, nil
}

func (s Store) SetViewport(ctx context.Context, viewport types.Viewport) error {
	return s.Model.SetViewport(ctx, s.GraphID, viewport)
}

func (s Store) Stabilize(ctx context.Context, parallel bool) (stabilizationNum uint64, err error) {
	var data *types.GraphFull
	data, err = s.Model.Deserialize(ctx, s.GraphID, false, false)
	if err != nil {
		return
	}

	var graph *incr.Graph
	var nodes map[incr.Identifier]incr.INode
	graph, nodes, err = s.buildGraph(ctx, data)
	if err != nil {
		return
	}

	var valuesMu sync.Mutex
	values := make(map[uuid.UUID]any)
	nodeMetadata := make(map[uuid.UUID]Node)
	logs := new(bytes.Buffer)
	eg := incr.ExpertGraph(graph)

	defer func() {
		if r := recover(); r != nil {
			err = errutil.Append(err, errutil.New(fmt.Errorf("stabilization panic: %v", r)))
		}
	}()

	updateHandler := func(n incr.INode) func(context.Context) {
		en := incr.ExpertNode(n)
		nodeID := uuid.UUID(n.Node().ID())
		return func(_ context.Context) {
			valuesMu.Lock()
			defer valuesMu.Unlock()
			values[nodeID] = incrutil.GetNodeValue(n)
			nodeMetadata[nodeID] = Node{
				SetAt:        en.SetAt(),
				ChangedAt:    en.ChangedAt(),
				RecomputedAt: en.RecomputedAt(),
			}
		}
	}
	for _, n := range nodes {
		n.Node().OnUpdate(updateHandler(n))
	}
	ctx = incr.WithTracingOutputs(ctx, logs, logs)
	if parallel {
		err = graph.ParallelStabilize(ctx)
	} else {
		err = graph.Stabilize(ctx)
	}

	func() {
		defer func() {
			if r := recover(); r != nil {
				err = errutil.Append(err, errutil.New(fmt.Errorf("stabilization post-actions panic: %v", r)))
			}
		}()

		var postErrs []error
		var postErr error
		stabilizationNum = eg.StabilizationNum()

		postErr = s.Model.UpdateGraphPostStabilization(ctx, s.GraphID, stabilizationNum)
		if postErr != nil {
			postErrs = append(postErrs, errutil.New(postErr))
		}

		postErr = s.Model.TouchGraph(ctx, s.GraphID)
		if postErr != nil {
			postErrs = append(postErrs, errutil.New(postErr))
		}

		postErr = s.Model.Invoke(ctx).Create(GraphLogs{GraphID: s.GraphID, UserID: s.UserID, StabilizationNum: stabilizationNum, Logs: logs.String()})
		if postErr != nil {
			postErrs = append(postErrs, errutil.New(postErr))
		}

		postErr = s.Model.SetNodeMetadata(ctx, s.GraphID, nodeMetadata)
		if postErr != nil {
			postErrs = append(postErrs, errutil.New(postErr))
		}

		postErr = s.Model.SetNodeValues(ctx, s.GraphID, s.UserID, values)
		if postErr != nil {
			postErrs = append(postErrs, errutil.New(postErr))
		}

		recomputeHeapIDs := iter.Apply(eg.RecomputeHeapIDs(), func(id incr.Identifier) uuid.UUID { return uuid.UUID(id) })
		postErr = s.Model.SetRecomputeHeap(ctx, s.GraphID, s.UserID, recomputeHeapIDs...)
		if postErr != nil {
			postErrs = append(postErrs, errutil.New(postErr))
		}

		if len(postErrs) > 0 {
			err = errutil.Append(err, postErrs...)
		}
	}()
	return
}

func (s Store) AddNode(ctx context.Context, n *types.Node) (id incr.Identifier, err error) {
	dn := NodeFromTypeNode(s.GraphID, s.UserID, n)
	dn.ID = uuid.V4()
	if err = s.Model.Invoke(ctx).Create(&dn); err != nil {
		return
	}
	if err = s.Model.TouchGraph(ctx, s.GraphID); err != nil {
		return
	}
	id = incr.Identifier(dn.ID)
	return
}

func (s Store) RemoveNode(ctx context.Context, id incr.Identifier) (found bool, err error) {
	found, err = s.Model.DeleteNode(ctx, uuid.UUID(id))
	if err != nil {
		return
	}
	if err = s.Model.TouchGraph(ctx, s.GraphID); err != nil {
		return
	}
	return
}

func (s Store) Nodes(ctx context.Context) ([]types.Node, error) {
	nodes, err := s.Model.Nodes(ctx, s.GraphID)
	if err != nil {
		return nil, err
	}
	return iter.Apply(nodes, TypeNodeFromNode), nil
}

func (s Store) Node(ctx context.Context, id incr.Identifier) (output types.Node, found bool, err error) {
	var nodeObj Node
	nodeObj, found, err = s.Model.Node(ctx, uuid.UUID(id))
	if err != nil {
		return
	}
	if !found {
		return
	}
	output = TypeNodeFromNode(nodeObj)
	return
}

func (s Store) PatchNodes(ctx context.Context, ps types.PatchSet) (err error) {
	if err = s.Model.PatchNodes(ctx, s.GraphID, ps); err != nil {
		return
	}
	if err = s.Model.TouchGraph(ctx, s.GraphID); err != nil {
		return
	}
	return
}

func (s Store) PatchNode(ctx context.Context, id incr.Identifier, ps types.PatchSet) (found bool, err error) {
	// handle marking the node stale (and adding it to the recompute heap) if we change the expression.
	// for multi-node patches we do _not_ have to do we never set the expression that way.
	if _, includesExpression := ps["expression"]; includesExpression {
		graph, found, err := s.Model.Graph(ctx, s.GraphID)
		if err != nil {
			return false, err
		}
		if !found {
			return false, nil
		}
		ps["set_at"] = graph.StabilizationNum
		if err := s.Model.Invoke(ctx).Upsert(&GraphRecomputeHeap{
			GraphID: s.GraphID,
			UserID:  s.UserID,
			NodeID:  uuid.UUID(id),
		}); err != nil {
			return false, err
		}
	}
	found, err = s.Model.PatchNode(ctx, uuid.UUID(id), ps)
	if err != nil {
		return
	}
	if err = s.Model.TouchGraph(ctx, s.GraphID); err != nil {
		return
	}
	return
}

func (s Store) NodeValue(ctx context.Context, id incr.Identifier) (any, bool, error) {
	nv, found, err := s.Model.NodeValue(ctx, s.GraphID, uuid.UUID(id))
	if err != nil {
		return nil, false, err
	}
	if !found {
		return nil, false, nil
	}
	parsedValue, err := nv.ParsedValue()
	if err != nil {
		return nil, true, err
	}
	return parsedValue, true, nil
}

func (s Store) NodeValues(ctx context.Context, nodeIDs ...incr.Identifier) ([]types.NodeValue, error) {
	values, err := s.Model.NodeValues(ctx, s.GraphID, iter.Apply(nodeIDs, func(id incr.Identifier) uuid.UUID { return uuid.UUID(id) })...)
	if err != nil {
		return nil, err
	}
	return iter.Apply(values, func(v NodeValue) types.NodeValue {
		parsed, _ := v.ParsedValue()
		return types.NodeValue{
			ID:    incr.Identifier(v.NodeID),
			Value: parsed,
		}
	}), nil
}

func (s Store) SetNodeValue(ctx context.Context, nodeID incr.Identifier, value any) (bool, error) {
	node, found, err := s.Model.Node(ctx, uuid.UUID(nodeID))
	if err != nil {
		return false, fmt.Errorf("%w; set node value; get node", err)
	}
	if !found {
		return false, nil
	}
	graph, _, err := s.Model.Graph(ctx, s.GraphID)
	if err != nil {
		return false, fmt.Errorf("%w; set node value; get node graph", err)
	}
	node.SetAt = graph.StabilizationNum
	if _, err = s.Model.Invoke(ctx).Update(node); err != nil {
		return false, err
	}
	if err := s.Model.Invoke(ctx).Upsert(&GraphRecomputeHeap{
		GraphID: s.GraphID,
		UserID:  s.UserID,
		NodeID:  node.ID,
	}); err != nil {
		return false, fmt.Errorf("%w; set node value; upsert graph recompute heap", err)
	}
	var nv = NodeValue{
		NodeID:    uuid.UUID(nodeID),
		GraphID:   s.GraphID,
		UserID:    s.UserID,
		ValueType: DetectValueType(value),
		Value:     value,
	}
	if err := s.Model.Invoke(ctx).Upsert(&nv); err != nil {
		return false, fmt.Errorf("%w; set node value; upsert node value", err)
	}
	if err := s.Model.TouchGraph(ctx, s.GraphID); err != nil {
		return false, fmt.Errorf("%w; set node value; touch graph", err)
	}
	return true, nil
}

func (s Store) MarkNodeStale(ctx context.Context, nodeID incr.Identifier) (found bool, err error) {
	found, err = s.Model.MarkNodeStale(ctx, s.GraphID, s.UserID, uuid.UUID(nodeID))
	if err != nil {
		return
	}
	if err = s.Model.TouchGraph(ctx, s.GraphID); err != nil {
		return
	}
	return
}

func (s Store) Edges(ctx context.Context) ([]types.Edge, error) {
	edges, err := s.Model.Edges(ctx, s.GraphID)
	if err != nil {
		return nil, err
	}
	return iter.Apply(edges, func(e Edge) types.Edge {
		return types.Edge{
			ParentID:       incr.Identifier(e.ParentID),
			ChildID:        incr.Identifier(e.ChildID),
			ChildInputName: e.ChildInputName,
		}
	}), nil
}

func (s Store) LinkInput(ctx context.Context, te types.Edge) error {
	graph, nodes, err := s.fetchGraphBasic(ctx)
	if err != nil {
		return err
	}
	child, ok := nodes[te.ChildID]
	if !ok {
		return fmt.Errorf("child node not found with id %v", te.ChildID)
	}
	parent, ok := nodes[te.ParentID]
	if !ok {
		return fmt.Errorf("parent node not found with id %v", te.ParentID)
	}
	if err = s.linkInputToChildUnsafe(ctx, graph, nodes, child, parent, te.ChildInputName); err != nil {
		return err
	}
	if err := s.Model.Invoke(ctx).Create(Edge{
		GraphID:        s.GraphID,
		UserID:         s.UserID,
		CreatedUTC:     time.Now().UTC(),
		ParentID:       uuid.UUID(te.ParentID),
		ChildID:        uuid.UUID(te.ChildID),
		ChildInputName: te.ChildInputName,
	}); err != nil {
		return err
	}

	if incr.ExpertNode(child).IsNecessary() || s.isObserver(child) {
		if err := s.Model.Invoke(ctx).Upsert(&GraphRecomputeHeap{
			GraphID: s.GraphID,
			UserID:  s.UserID,
			NodeID:  uuid.UUID(te.ChildID),
		}); err != nil {
			return err
		}
	}
	if err := s.recomputeHeights(ctx, nodes); err != nil {
		return err
	}
	if err := s.Model.TouchGraph(ctx, s.GraphID); err != nil {
		return err
	}
	return nil
}

func (s Store) UnlinkInput(ctx context.Context, te types.Edge) error {
	if err := s.Model.DeleteEdge(ctx, uuid.UUID(te.ParentID), uuid.UUID(te.ChildID), te.ChildInputName); err != nil {
		return err
	}
	_, nodes, err := s.fetchGraphBasic(ctx)
	if err != nil {
		return err
	}
	if err := s.recomputeHeights(ctx, nodes); err != nil {
		return err
	}
	if err := s.Model.TouchGraph(ctx, s.GraphID); err != nil {
		return err
	}
	return nil
}

func (s Store) PatchNodeTable(ctx context.Context, nodeID incr.Identifier, ops ...types.TableOp) (bool, error) {
	value, found, err := s.NodeValue(ctx, nodeID)
	if err != nil {
		return false, err
	}
	if !found {
		table := new(types.Table)
		table.Columns = []types.TableColumn{
			{
				Name:   "New Column",
				Values: []any{},
			},
		}
		if err := table.ApplyOps(ops...); err != nil {
			return true, err
		}
		if _, err := s.SetNodeValue(ctx, nodeID, table); err != nil {
			return true, err
		}
		return true, nil
	}
	typed, ok := value.(*types.Table)
	if !ok {
		return true, fmt.Errorf("value is not a table for table ops")
	}
	if err := typed.ApplyOps(ops...); err != nil {
		return true, err
	}
	if _, err := s.SetNodeValue(ctx, nodeID, typed); err != nil {
		return true, err
	}
	if err := s.Model.TouchGraph(ctx, s.GraphID); err != nil {
		return true, err
	}
	return true, nil
}

//
// internal helpers
//

func (s Store) isObserver(n incr.INode) bool {
	if n == nil {
		return false
	}
	metadata, ok := n.Node().Metadata().(*types.NodeMetadata)
	if !ok {
		return false
	}
	return metadata.NodeType == incrutil.NodeTypeObserver
}

func (s Store) fetchGraphBasic(ctx context.Context) (graph *incr.Graph, nodes map[incr.Identifier]incr.INode, err error) {
	var data *types.GraphFull
	data, err = s.Model.Deserialize(ctx, s.GraphID, true, true)
	if err != nil {
		return
	}
	graph, nodes, err = s.buildGraph(ctx, data)
	return
}

func (s Store) recomputeHeights(ctx context.Context, nodes map[incr.Identifier]incr.INode) (err error) {
	updatedHeights := make(map[uuid.UUID]int)
	for _, n := range nodes {
		fmt.Println("recompute height of", n.Node().String())
		en := incr.ExpertNode(n)
		newHeight := en.ComputePseudoHeight()
		updatedHeights[uuid.UUID(n.Node().ID())] = newHeight
	}
	return s.Model.SetNodeHeights(ctx, s.GraphID, updatedHeights)
}

func (s Store) buildGraph(ctx context.Context, data *types.GraphFull) (graph *incr.Graph, nodes map[incr.Identifier]incr.INode, err error) {
	graph = incr.New()
	expertGraph := incr.ExpertGraph(graph)
	nodes = make(map[incr.Identifier]incr.INode)
	graph.SetLabel(data.Graph.Label)
	graph.SetMetadata(&data.Graph.Metadata)
	expertGraph.SetStabilizationNum(data.Graph.StabilizationNum)

	for x := 0; x < len(data.Nodes); x++ {
		n := data.Nodes[x]
		if _, err = s.addNodeUnsafe(graph, nodes, &n); err != nil {
			return
		}
	}
	for _, e := range data.Edges {
		child, ok := nodes[e.ChildID]
		if !ok {
			err = fmt.Errorf("edge child node not found with id %v", e.ChildID)
			return
		}
		input, ok := nodes[e.ParentID]
		if !ok {
			err = fmt.Errorf("edge parent node not found with id %v", e.ParentID)
			return
		}
		if err = s.linkInputToChildUnsafe(ctx, graph, nodes, child, input, e.ChildInputName); err != nil {
			return
		}
	}

	for x := 0; x < len(data.Values); x++ {
		v := data.Values[x]
		if _, err = s.setNodeValueUnsafe(graph, nodes, v.ID, v.Value); err != nil {
			return
		}
	}

	for _, nodeID := range data.RecomputeHeap {
		n, ok := nodes[nodeID]
		if !ok {
			continue
		}
		expertGraph.RecomputeHeapAdd(n)
	}
	return
}

func (s Store) addNodeUnsafe(graph *incr.Graph, nodes map[incr.Identifier]incr.INode, n *types.Node) (id incr.Identifier, err error) {
	if n.Metadata.NodeType == "" {
		err = fmt.Errorf(`"node_type" is required`)
		return
	}
	var in incr.INode
	in, err = model.INodeFromNode(graph, n)
	if err != nil {
		return
	}
	id = in.Node().ID()
	nodes[id] = in
	return
}

func (s Store) setNodeValueUnsafe(_ *incr.Graph, nodes map[incr.Identifier]incr.INode, id incr.Identifier, value any) (ok bool, err error) {
	var in incr.INode
	in, ok = nodes[id]
	if in == nil || !ok {
		return
	}
	err = incrutil.SetNodeValueDuringDeserialization(in, value)
	return
}

func (s Store) linkInputToChildUnsafe(_ context.Context, _ *incr.Graph, _ map[incr.Identifier]incr.INode, child, input incr.INode, inputName string) error {
	if err := incr.DetectCycleIfLinked(child, input); err != nil {
		return err
	}
	if typed, ok := child.(incrutil.IAddInput); ok {
		if err := typed.AddInput(input); err != nil {
			return err
		}
	} else if typed, ok := child.(incrutil.ISetInput); ok {
		if err := typed.SetInput(inputName, input, true); err != nil {
			return err
		}
	} else {
		return fmt.Errorf("cannot add input node: %v", child)
	}
	return nil
}