/
repository.go
122 lines (89 loc) · 3.15 KB
/
repository.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
package client
import (
"context"
"github.com/apibrew/apibrew/pkg/abs"
"github.com/apibrew/apibrew/pkg/model"
"github.com/apibrew/apibrew/pkg/service"
)
type repository[Entity interface{}] struct {
client Client
UpdateCheckVersion bool
mapper abs.EntityMapper[Entity]
}
func (r repository[T]) Create(ctx context.Context, entity T) (T, error) {
resp, err := r.client.CreateRecord(ctx, r.mapper.ResourceIdentity().Namespace, r.mapper.ResourceIdentity().Name, r.mapper.ToRecord(entity))
if err != nil {
return entity, err
}
updatedEntity := r.mapper.FromRecord(resp)
return updatedEntity, nil
}
func (r repository[T]) Update(ctx context.Context, entity T) (T, error) {
resp, err := r.client.UpdateRecord(ctx, r.mapper.ResourceIdentity().Namespace, r.mapper.ResourceIdentity().Name, r.mapper.ToRecord(entity))
if err != nil {
return entity, err
}
updatedEntity := r.mapper.FromRecord(resp)
return updatedEntity, nil
}
func (r repository[T]) Apply(ctx context.Context, entity T) (T, error) {
resp, err := r.client.ApplyRecord(ctx, r.mapper.ResourceIdentity().Namespace, r.mapper.ResourceIdentity().Name, r.mapper.ToRecord(entity))
if err != nil {
return entity, err
}
updatedEntity := r.mapper.FromRecord(resp)
return updatedEntity, nil
}
func (r repository[T]) Get(ctx context.Context, id string) (T, error) {
resp, err := r.client.GetRecord(ctx, r.mapper.ResourceIdentity().Namespace, r.mapper.ResourceIdentity().Name, id)
if err != nil {
return r.mapper.New(), err
}
updatedEntity := r.mapper.FromRecord(resp)
return updatedEntity, nil
}
func (r repository[T]) Find(ctx context.Context, params FindParams) ([]T, uint32, error) {
var filters map[string]interface{}
if params.Filters != nil {
filters = make(map[string]interface{})
for k, v := range params.Filters {
filters[k] = v
}
}
listParams := service.RecordListParams{
Namespace: r.mapper.ResourceIdentity().Namespace,
Resource: r.mapper.ResourceIdentity().Name,
Filters: filters,
Limit: params.Limit,
Offset: params.Offset,
UseHistory: params.UseHistory,
ResolveReferences: params.ResolveReferences,
}
resp, total, err := r.client.ListRecords(ctx, listParams)
if err != nil {
return nil, 0, err
}
var result = make([]T, len(resp))
for i, record := range resp {
result[i] = r.mapper.FromRecord(record)
}
return result, total, nil
}
func (r repository[T]) Listen(ctx context.Context, consumer func(records []T)) error {
return r.client.ListenRecords(ctx, r.mapper.ResourceIdentity().Namespace, r.mapper.ResourceIdentity().Name, func(records []*model.Record) {
var result = make([]T, len(records))
for i, record := range records {
result[i] = r.mapper.FromRecord(record)
}
consumer(result)
})
}
func (r repository[T]) Mapper() abs.EntityMapper[T] {
return r.mapper
}
func R[Entity interface{}](client Client, mapper abs.EntityMapper[Entity]) Repository[Entity] {
return NewRepository(client, mapper)
}
func NewRepository[Entity interface{}](client Client, mapper abs.EntityMapper[Entity]) Repository[Entity] {
return repository[Entity]{client: client, mapper: mapper}
}