25707480509

Committed 12 May 2026 01:24AM UTC coverage: 84.081% (-0.5%) from 84.61%

Build # 25707480509

Build Type

push

github

Committed by

orneryd

Commit Message

fix(test) flush span kind propert missing

Coverage Stats

1 of 1 new or added line in 1 file covered. (100.0%)

5095 existing lines in 65 files now uncovered.

123467 of 146843 relevant lines covered (84.08%)

0.98 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.68

/pkg/replication/codec.go

package replication

import (
        "bytes"
        "encoding/gob"
        "encoding/json"
        "fmt"
        "time"

        "github.com/orneryd/nornicdb/pkg/storage"
)

// NodePayload is the replication-safe representation of storage.Node, including embeddings.
type NodePayload struct {
        ID              string
        Labels          []string
        Properties      map[string]any
        NamedEmbeddings map[string][]float32
        ChunkEmbeddings [][]float32
        CreatedAtUnixNs int64
        UpdatedAtUnixNs int64
}

// EdgePayload is the replication-safe representation of storage.Edge.
type EdgePayload struct {
        ID            string
        StartNode     string
        EndNode       string
        Type          string
        Properties    map[string]any
        CreatedAt     int64
        Confidence    float64
        AutoGenerated bool
}

func init() {
        // Register common concrete types used in Properties to help gob handle interface{} values.
        gob.Register(map[string]any{})
        gob.Register([]any{})
        gob.Register([]string{})
        gob.Register([]float64{})
        gob.Register([]float32{})
        gob.Register([]int{})
        gob.Register([]int64{})
}

func encodeGob(v any) ([]byte, error) {
        var buf bytes.Buffer
        if err := gob.NewEncoder(&buf).Encode(v); err != nil {
                return nil, err
        }
        return buf.Bytes(), nil
}

func decodeGob(data []byte, v any) error {
        if err := gob.NewDecoder(bytes.NewReader(data)).Decode(v); err == nil {
                return nil
        }
        // Fallback to JSON for backward compatibility/tests that still marshal JSON.
        return json.Unmarshal(data, v)
}

func encodeNodePayload(node *storage.Node) ([]byte, error) {
        if node == nil {
                return nil, fmt.Errorf("nil node")
        }
        payload := NodePayload{
                ID:              string(node.ID),
                Labels:          node.Labels,
                Properties:      node.Properties,
                NamedEmbeddings: node.NamedEmbeddings,
                ChunkEmbeddings: node.ChunkEmbeddings,
                CreatedAtUnixNs: node.CreatedAt.UnixNano(),
                UpdatedAtUnixNs: node.UpdatedAt.UnixNano(),
        }
        return encodeGob(&payload)
}

func decodeNodePayload(data []byte) (*storage.Node, error) {
        var payload NodePayload
        if err := decodeGob(data, &payload); err == nil && payload.ID != "" {
                node := &storage.Node{
                        ID:              storage.NodeID(payload.ID),
                        Labels:          payload.Labels,
                        Properties:      payload.Properties,
                        NamedEmbeddings: payload.NamedEmbeddings,
                        ChunkEmbeddings: payload.ChunkEmbeddings,
                }
                if payload.CreatedAtUnixNs != 0 {
                        node.CreatedAt = time.Unix(0, payload.CreatedAtUnixNs)
                }
                if payload.UpdatedAtUnixNs != 0 {
                        node.UpdatedAt = time.Unix(0, payload.UpdatedAtUnixNs)
                }
                return node, nil
        }
        // Fallback: legacy JSON encoding of storage.Node (no embeddings).
        var legacy storage.Node
        if err := json.Unmarshal(data, &legacy); err != nil {
                return nil, err
        }
        return &legacy, nil
}

func encodeEdgePayload(edge *storage.Edge) ([]byte, error) {
        if edge == nil {
                return nil, fmt.Errorf("nil edge")
        }
        payload := EdgePayload{
                ID:            string(edge.ID),
                StartNode:     string(edge.StartNode),
                EndNode:       string(edge.EndNode),
                Type:          edge.Type,
                Properties:    edge.Properties,
                Confidence:    edge.Confidence,
                AutoGenerated: edge.AutoGenerated,
        }
        if !edge.CreatedAt.IsZero() {
                payload.CreatedAt = edge.CreatedAt.UnixNano()
        }
        return encodeGob(&payload)
}

func decodeEdgePayload(data []byte) (*storage.Edge, error) {
        var payload EdgePayload
        if err := decodeGob(data, &payload); err == nil && payload.ID != "" {
                edge := &storage.Edge{
                        ID:            storage.EdgeID(payload.ID),
                        StartNode:     storage.NodeID(payload.StartNode),
                        EndNode:       storage.NodeID(payload.EndNode),
                        Type:          payload.Type,
                        Properties:    payload.Properties,
                        Confidence:    payload.Confidence,
                        AutoGenerated: payload.AutoGenerated,
                }
                if payload.CreatedAt != 0 {
                        edge.CreatedAt = time.Unix(0, payload.CreatedAt)
                }
                return edge, nil
        }
        // Fallback legacy JSON encoding of storage.Edge.
        var legacy storage.Edge
        if err := json.Unmarshal(data, &legacy); err != nil {
                return nil, err
        }
        return &legacy, nil
}

1	package replication
2
3	import (
4	"bytes"
5	"encoding/gob"
6	"encoding/json"
7	"fmt"
8	"time"
9
10	"github.com/orneryd/nornicdb/pkg/storage"
11	)
12
13	// NodePayload is the replication-safe representation of storage.Node, including embeddings.
14	type NodePayload struct {
15	ID string
16	Labels []string
17	Properties map[string]any
18	NamedEmbeddings map[string][]float32
19	ChunkEmbeddings [][]float32
20	CreatedAtUnixNs int64
21	UpdatedAtUnixNs int64
22	}
23
24	// EdgePayload is the replication-safe representation of storage.Edge.
25	type EdgePayload struct {
26	ID string
27	StartNode string
28	EndNode string
29	Type string
30	Properties map[string]any
31	CreatedAt int64
32	Confidence float64
33	AutoGenerated bool
34	}
35
36	func init() {	1✔
37	// Register common concrete types used in Properties to help gob handle interface{} values.	1✔
38	gob.Register(map[string]any{})	1✔
39	gob.Register([]any{})	1✔
40	gob.Register([]string{})	1✔
41	gob.Register([]float64{})	1✔
42	gob.Register([]float32{})	1✔
43	gob.Register([]int{})	1✔
44	gob.Register([]int64{})	1✔
45	}	1✔
46
47	func encodeGob(v any) ([]byte, error) {	1✔
48	var buf bytes.Buffer	1✔
49	if err := gob.NewEncoder(&buf).Encode(v); err != nil {	2✔
50	return nil, err	1✔
51	}	1✔
52	return buf.Bytes(), nil	1✔
53	}
54
55	func decodeGob(data []byte, v any) error {	1✔
56	if err := gob.NewDecoder(bytes.NewReader(data)).Decode(v); err == nil {	2✔
57	return nil	1✔
58	}	1✔
59	// Fallback to JSON for backward compatibility/tests that still marshal JSON.
60	return json.Unmarshal(data, v)	1✔
61	}
62
63	func encodeNodePayload(node *storage.Node) ([]byte, error) {	1✔
64	if node == nil {	2✔
65	return nil, fmt.Errorf("nil node")	1✔
66	}	1✔
67	payload := NodePayload{	1✔
68	ID: string(node.ID),	1✔
69	Labels: node.Labels,	1✔
70	Properties: node.Properties,	1✔
71	NamedEmbeddings: node.NamedEmbeddings,	1✔
72	ChunkEmbeddings: node.ChunkEmbeddings,	1✔
73	CreatedAtUnixNs: node.CreatedAt.UnixNano(),	1✔
74	UpdatedAtUnixNs: node.UpdatedAt.UnixNano(),	1✔
75	}	1✔
76	return encodeGob(&payload)	1✔
77	}
78
79	func decodeNodePayload(data []byte) (*storage.Node, error) {	1✔
80	var payload NodePayload	1✔
81	if err := decodeGob(data, &payload); err == nil && payload.ID != "" {	2✔
82	node := &storage.Node{	1✔
83	ID: storage.NodeID(payload.ID),	1✔
84	Labels: payload.Labels,	1✔
85	Properties: payload.Properties,	1✔
86	NamedEmbeddings: payload.NamedEmbeddings,	1✔
87	ChunkEmbeddings: payload.ChunkEmbeddings,	1✔
88	}	1✔
89	if payload.CreatedAtUnixNs != 0 {	2✔
90	node.CreatedAt = time.Unix(0, payload.CreatedAtUnixNs)	1✔
91	}	1✔
92	if payload.UpdatedAtUnixNs != 0 {	2✔
93	node.UpdatedAt = time.Unix(0, payload.UpdatedAtUnixNs)	1✔
94	}	1✔
95	return node, nil	1✔
96	}
97	// Fallback: legacy JSON encoding of storage.Node (no embeddings).
98	var legacy storage.Node	1✔
99	if err := json.Unmarshal(data, &legacy); err != nil {	2✔
100	return nil, err	1✔
101	}	1✔
UNCOV 102	return &legacy, nil	×
103	}
104
105	func encodeEdgePayload(edge *storage.Edge) ([]byte, error) {	1✔
106	if edge == nil {	2✔
107	return nil, fmt.Errorf("nil edge")	1✔
108	}	1✔
109	payload := EdgePayload{	1✔
110	ID: string(edge.ID),	1✔
111	StartNode: string(edge.StartNode),	1✔
112	EndNode: string(edge.EndNode),	1✔
113	Type: edge.Type,	1✔
114	Properties: edge.Properties,	1✔
115	Confidence: edge.Confidence,	1✔
116	AutoGenerated: edge.AutoGenerated,	1✔
117	}	1✔
118	if !edge.CreatedAt.IsZero() {	1✔
UNCOV 119	payload.CreatedAt = edge.CreatedAt.UnixNano()	×
UNCOV 120	}	×
121	return encodeGob(&payload)	1✔
122	}
123
124	func decodeEdgePayload(data []byte) (*storage.Edge, error) {	1✔
125	var payload EdgePayload	1✔
126	if err := decodeGob(data, &payload); err == nil && payload.ID != "" {	2✔
127	edge := &storage.Edge{	1✔
128	ID: storage.EdgeID(payload.ID),	1✔
129	StartNode: storage.NodeID(payload.StartNode),	1✔
130	EndNode: storage.NodeID(payload.EndNode),	1✔
131	Type: payload.Type,	1✔
132	Properties: payload.Properties,	1✔
133	Confidence: payload.Confidence,	1✔
134	AutoGenerated: payload.AutoGenerated,	1✔
135	}	1✔
136	if payload.CreatedAt != 0 {	1✔
UNCOV 137	edge.CreatedAt = time.Unix(0, payload.CreatedAt)	×
UNCOV 138	}	×
139	return edge, nil	1✔
140	}
141	// Fallback legacy JSON encoding of storage.Edge.
142	var legacy storage.Edge	1✔
143	if err := json.Unmarshal(data, &legacy); err != nil {	2✔
144	return nil, err	1✔
145	}	1✔
UNCOV 146	return &legacy, nil	×
147	}

orneryd / NornicDB / 25707480509

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous