14548602918

Committed 19 Apr 2025 11:16AM UTC coverage: 56.92%. Remained the same

Build # 14548602918

Build Type

push

github

Committed by

web-flow

Commit Message

simplify event definition for sync api (#122)

Run Details

4 of 5 new or added lines in 4 files covered. (80.0%)

987 of 1734 relevant lines covered (56.92%)

0.62 hits per line

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

0.0

/kernel/encoding/codec.go

//
// Copyright (C) 2021 - 2024 Dmitry Kolesnikov
//
// This file may be modified and distributed under the terms
// of the Apache License Version 2.0. See the LICENSE file for details.
// https://github.com/fogfish/swarm
//

package encoding

import (
        "encoding/json"
        "time"

        "github.com/fogfish/curie/v2"
        "github.com/fogfish/golem/optics"
        "github.com/fogfish/guid/v2"
        "github.com/fogfish/swarm"
)

//------------------------------------------------------------------------------

// JSON encoding for typed objects
type Typed[T any] string

func (c Typed[T]) Category() string { return string(c) }

func (Typed[T]) Encode(x T) ([]byte, error) {
        return json.Marshal(x)
}

func (Typed[T]) Decode(b []byte) (x T, err error) {
        err = json.Unmarshal(b, &x)
        return
}

// Create JSON codec for typed objects
func ForTyped[T any](category ...string) Typed[T] {
        return Typed[T](swarm.TypeOf[T](category...))
}

//------------------------------------------------------------------------------

// JSON encoding for events
type Event[M, T any] struct {
        source string
        cat    string
        shape  optics.Lens4[M, string, curie.IRI, curie.IRI, time.Time]
}

func (c Event[M, T]) Category() string { return c.cat }

func (c Event[M, T]) Encode(obj swarm.Event[M, T]) ([]byte, error) {
        _, knd, src, _ := c.shape.Get(obj.Meta)
        if knd == "" {
                knd = curie.IRI(c.cat)
        }

        if src == "" {
                src = curie.IRI(c.source)
        }

        c.shape.Put(obj.Meta, guid.G(guid.Clock).String(), knd, src, time.Now())

        return json.Marshal(obj)
}

func (c Event[M, T]) Decode(b []byte) (swarm.Event[M, T], error) {
        var x swarm.Event[M, T]
        err := json.Unmarshal(b, &x)

        return x, err
}

// Creates JSON codec for events
func ForEvent[E swarm.Event[M, T], M, T any](source string, category ...string) Event[M, T] {
        return Event[M, T]{
                source: source,
                cat:    swarm.TypeOf[T](category...),
                shape:  optics.ForShape4[M, string, curie.IRI, curie.IRI, time.Time]("ID", "Type", "Agent", "Created"),
        }
}

//------------------------------------------------------------------------------

// Identity encoding for bytes
type Bytes string

func (c Bytes) Category() string              { return string(c) }
func (Bytes) Encode(x []byte) ([]byte, error) { return x, nil }
func (Bytes) Decode(x []byte) ([]byte, error) { return x, nil }

// Create bytes identity codec
func ForBytes(cat string) Bytes { return Bytes(cat) }

//------------------------------------------------------------------------------

// Base64 encoding for bytes, sent as JSON
type BytesJB64 string

type packet struct {
        Octets []byte `json:"p,omitempty"`
}

func (c BytesJB64) Category() string { return string(c) }

func (BytesJB64) Encode(x []byte) ([]byte, error) {
        b, err := json.Marshal(packet{Octets: x})
        return b, err
}
func (BytesJB64) Decode(x []byte) ([]byte, error) {
        var pckt packet
        err := json.Unmarshal(x, &pckt)
        return pckt.Octets, err
}

// Creates bytes codec for Base64 encapsulated into Json "packat"
func ForBytesJB64(cat string) BytesJB64 { return BytesJB64(cat) }

1	//
2	// Copyright (C) 2021 - 2024 Dmitry Kolesnikov
3	//
4	// This file may be modified and distributed under the terms
5	// of the Apache License Version 2.0. See the LICENSE file for details.
6	// https://github.com/fogfish/swarm
7	//
8
9	package encoding
10
11	import (
12	"encoding/json"
13	"time"
14
15	"github.com/fogfish/curie/v2"
16	"github.com/fogfish/golem/optics"
17	"github.com/fogfish/guid/v2"
18	"github.com/fogfish/swarm"
19	)
20
21	//------------------------------------------------------------------------------
22
23	// JSON encoding for typed objects
24	type Typed[T any] string
25
26	func (c Typed[T]) Category() string { return string(c) }	×
27
28	func (Typed[T]) Encode(x T) ([]byte, error) {	×
29	return json.Marshal(x)	×
30	}	×
31
32	func (Typed[T]) Decode(b []byte) (x T, err error) {	×
33	err = json.Unmarshal(b, &x)	×
34	return	×
35	}	×
36
37	// Create JSON codec for typed objects
38	func ForTyped[T any](category ...string) Typed[T] {	×
39	return Typed[T](swarm.TypeOf[T](category...))	×
40	}	×
41
42	//------------------------------------------------------------------------------
43
44	// JSON encoding for events
45	type Event[M, T any] struct {
46	source string
47	cat string
48	shape optics.Lens4[M, string, curie.IRI, curie.IRI, time.Time]
49	}
50
51	func (c Event[M, T]) Category() string { return c.cat }	×
52
53	func (c Event[M, T]) Encode(obj swarm.Event[M, T]) ([]byte, error) {	×
54	_, knd, src, _ := c.shape.Get(obj.Meta)	×
55	if knd == "" {	×
56	knd = curie.IRI(c.cat)	×
57	}	×
58
59	if src == "" {	×
60	src = curie.IRI(c.source)	×
61	}	×
62
63	c.shape.Put(obj.Meta, guid.G(guid.Clock).String(), knd, src, time.Now())	×
64		×
65	return json.Marshal(obj)	×
66	}
67
68	func (c Event[M, T]) Decode(b []byte) (swarm.Event[M, T], error) {	×
69	var x swarm.Event[M, T]	×
70	err := json.Unmarshal(b, &x)	×
71		×
72	return x, err	×
73	}	×
74
75	// Creates JSON codec for events
NEW 76	func ForEvent[E swarm.Event[M, T], M, T any](source string, category ...string) Event[M, T] {	×
77	return Event[M, T]{	×
78	source: source,	×
79	cat: swarm.TypeOf[T](category...),	×
80	shape: optics.ForShape4[M, string, curie.IRI, curie.IRI, time.Time]("ID", "Type", "Agent", "Created"),	×
81	}	×
82	}	×
83
84	//------------------------------------------------------------------------------
85
86	// Identity encoding for bytes
87	type Bytes string
88
89	func (c Bytes) Category() string { return string(c) }	×
90	func (Bytes) Encode(x []byte) ([]byte, error) { return x, nil }	×
91	func (Bytes) Decode(x []byte) ([]byte, error) { return x, nil }	×
92
93	// Create bytes identity codec
94	func ForBytes(cat string) Bytes { return Bytes(cat) }	×
95
96	//------------------------------------------------------------------------------
97
98	// Base64 encoding for bytes, sent as JSON
99	type BytesJB64 string
100
101	type packet struct {
102	Octets []byte `json:"p,omitempty"`
103	}
104
105	func (c BytesJB64) Category() string { return string(c) }	×
106
107	func (BytesJB64) Encode(x []byte) ([]byte, error) {	×
108	b, err := json.Marshal(packet{Octets: x})	×
109	return b, err	×
110	}	×
111	func (BytesJB64) Decode(x []byte) ([]byte, error) {	×
112	var pckt packet	×
113	err := json.Unmarshal(x, &pckt)	×
114	return pckt.Octets, err	×
115	}	×
116
117	// Creates bytes codec for Base64 encapsulated into Json "packat"
118	func ForBytesJB64(cat string) BytesJB64 { return BytesJB64(cat) }	×

fogfish / swarm / 14548602918

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