relysqlite_converters.go raw
1 package main
2
3 import (
4 "encoding/hex"
5 "fmt"
6
7 "github.com/nbd-wtf/go-nostr"
8
9 orlyEvent "next.orly.dev/pkg/nostr/encoders/event"
10 orlyFilter "next.orly.dev/pkg/nostr/encoders/filter"
11 orlyTag "next.orly.dev/pkg/nostr/encoders/tag"
12 )
13
14 // convertToNostrEvent converts an ORLY event to a go-nostr event
15 func convertToNostrEvent(ev *orlyEvent.E) (*nostr.Event, error) {
16 if ev == nil {
17 return nil, fmt.Errorf("nil event")
18 }
19
20 nostrEv := &nostr.Event{
21 ID: hex.EncodeToString(ev.ID),
22 PubKey: hex.EncodeToString(ev.Pubkey),
23 CreatedAt: nostr.Timestamp(ev.CreatedAt),
24 Kind: int(ev.Kind),
25 Content: string(ev.Content),
26 Sig: hex.EncodeToString(ev.Sig),
27 }
28
29 // Convert tags
30 if ev.Tags != nil && len(*ev.Tags) > 0 {
31 nostrEv.Tags = make(nostr.Tags, 0, len(*ev.Tags))
32 for _, orlyTag := range *ev.Tags {
33 if orlyTag != nil && len(orlyTag.T) > 0 {
34 tag := make(nostr.Tag, len(orlyTag.T))
35 for i, val := range orlyTag.T {
36 tag[i] = string(val)
37 }
38 nostrEv.Tags = append(nostrEv.Tags, tag)
39 }
40 }
41 }
42
43 return nostrEv, nil
44 }
45
46 // convertFromNostrEvent converts a go-nostr event to an ORLY event
47 func convertFromNostrEvent(ne *nostr.Event) (*orlyEvent.E, error) {
48 if ne == nil {
49 return nil, fmt.Errorf("nil event")
50 }
51
52 ev := orlyEvent.New()
53
54 // Convert ID
55 idBytes, err := hex.DecodeString(ne.ID)
56 if err != nil {
57 return nil, fmt.Errorf("failed to decode ID: %w", err)
58 }
59 ev.ID = idBytes
60
61 // Convert Pubkey
62 pubkeyBytes, err := hex.DecodeString(ne.PubKey)
63 if err != nil {
64 return nil, fmt.Errorf("failed to decode pubkey: %w", err)
65 }
66 ev.Pubkey = pubkeyBytes
67
68 // Convert Sig
69 sigBytes, err := hex.DecodeString(ne.Sig)
70 if err != nil {
71 return nil, fmt.Errorf("failed to decode signature: %w", err)
72 }
73 ev.Sig = sigBytes
74
75 // Simple fields
76 ev.CreatedAt = int64(ne.CreatedAt)
77 ev.Kind = uint16(ne.Kind)
78 ev.Content = []byte(ne.Content)
79
80 // Convert tags
81 if len(ne.Tags) > 0 {
82 ev.Tags = orlyTag.NewS()
83 for _, nostrTag := range ne.Tags {
84 if len(nostrTag) > 0 {
85 tag := orlyTag.NewWithCap(len(nostrTag))
86 for _, val := range nostrTag {
87 tag.T = append(tag.T, []byte(val))
88 }
89 *ev.Tags = append(*ev.Tags, tag)
90 }
91 }
92 } else {
93 ev.Tags = orlyTag.NewS()
94 }
95
96 return ev, nil
97 }
98
99 // convertToNostrFilter converts an ORLY filter to a go-nostr filter
100 func convertToNostrFilter(f *orlyFilter.F) (nostr.Filter, error) {
101 if f == nil {
102 return nostr.Filter{}, fmt.Errorf("nil filter")
103 }
104
105 filter := nostr.Filter{}
106
107 // Convert IDs
108 if f.Ids != nil && len(f.Ids.T) > 0 {
109 filter.IDs = make([]string, 0, len(f.Ids.T))
110 for _, id := range f.Ids.T {
111 filter.IDs = append(filter.IDs, hex.EncodeToString(id))
112 }
113 }
114
115 // Convert Authors
116 if f.Authors != nil && len(f.Authors.T) > 0 {
117 filter.Authors = make([]string, 0, len(f.Authors.T))
118 for _, author := range f.Authors.T {
119 filter.Authors = append(filter.Authors, hex.EncodeToString(author))
120 }
121 }
122
123 // Convert Kinds
124 if f.Kinds != nil && len(f.Kinds.K) > 0 {
125 filter.Kinds = make([]int, 0, len(f.Kinds.K))
126 for _, kind := range f.Kinds.K {
127 filter.Kinds = append(filter.Kinds, int(kind.K))
128 }
129 }
130
131 // Convert Tags
132 if f.Tags != nil && len(*f.Tags) > 0 {
133 filter.Tags = make(nostr.TagMap)
134 for _, tag := range *f.Tags {
135 if tag != nil && len(tag.T) >= 2 {
136 tagName := string(tag.T[0])
137 tagValues := make([]string, 0, len(tag.T)-1)
138 for i := 1; i < len(tag.T); i++ {
139 tagValues = append(tagValues, string(tag.T[i]))
140 }
141 filter.Tags[tagName] = tagValues
142 }
143 }
144 }
145
146 // Convert timestamps
147 if f.Since != nil {
148 ts := nostr.Timestamp(f.Since.V)
149 filter.Since = &ts
150 }
151
152 if f.Until != nil {
153 ts := nostr.Timestamp(f.Until.V)
154 filter.Until = &ts
155 }
156
157 // Convert limit
158 if f.Limit != nil {
159 limit := int(*f.Limit)
160 filter.Limit = limit
161 }
162
163 return filter, nil
164 }
165