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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
package namespace
import (
"fmt"
"strings"
"github.com/rs/zerolog"
"github.com/authzed/spicedb/internal/sharederrors"
)
// NamespaceNotFoundError occurs when a namespace was not found.
type NamespaceNotFoundError struct {
error
namespaceName string
}
// NotFoundNamespaceName is the name of the namespace not found.
func (err NamespaceNotFoundError) NotFoundNamespaceName() string {
return err.namespaceName
}
// MarshalZerologObject implements zerolog object marshalling.
func (err NamespaceNotFoundError) MarshalZerologObject(e *zerolog.Event) {
e.Err(err.error).Str("namespace", err.namespaceName)
}
// DetailsMetadata returns the metadata for details for this error.
func (err NamespaceNotFoundError) DetailsMetadata() map[string]string {
return map[string]string{
"definition_name": err.namespaceName,
}
}
// RelationNotFoundError occurs when a relation was not found under a namespace.
type RelationNotFoundError struct {
error
namespaceName string
relationName string
}
// NamespaceName returns the name of the namespace in which the relation was not found.
func (err RelationNotFoundError) NamespaceName() string {
return err.namespaceName
}
// NotFoundRelationName returns the name of the relation not found.
func (err RelationNotFoundError) NotFoundRelationName() string {
return err.relationName
}
func (err RelationNotFoundError) MarshalZerologObject(e *zerolog.Event) {
e.Err(err.error).Str("namespace", err.namespaceName).Str("relation", err.relationName)
}
// DetailsMetadata returns the metadata for details for this error.
func (err RelationNotFoundError) DetailsMetadata() map[string]string {
return map[string]string{
"definition_name": err.namespaceName,
"relation_or_permission_name": err.relationName,
}
}
// DuplicateRelationError occurs when a duplicate relation was found inside a namespace.
type DuplicateRelationError struct {
error
namespaceName string
relationName string
}
// MarshalZerologObject implements zerolog object marshalling.
func (err DuplicateRelationError) MarshalZerologObject(e *zerolog.Event) {
e.Err(err.error).Str("namespace", err.namespaceName).Str("relation", err.relationName)
}
// DetailsMetadata returns the metadata for details for this error.
func (err DuplicateRelationError) DetailsMetadata() map[string]string {
return map[string]string{
"definition_name": err.namespaceName,
"relation_or_permission_name": err.relationName,
}
}
// PermissionsCycleError occurs when a cycle exists within permissions.
type PermissionsCycleError struct {
error
namespaceName string
permissionNames []string
}
// MarshalZerologObject implements zerolog object marshalling.
func (err PermissionsCycleError) MarshalZerologObject(e *zerolog.Event) {
e.Err(err.error).Str("namespace", err.namespaceName).Str("permissions", strings.Join(err.permissionNames, ", "))
}
// DetailsMetadata returns the metadata for details for this error.
func (err PermissionsCycleError) DetailsMetadata() map[string]string {
return map[string]string{
"definition_name": err.namespaceName,
"permission_names": strings.Join(err.permissionNames, ","),
}
}
// UnusedCaveatParameterError indicates that a caveat parameter is unused in the caveat expression.
type UnusedCaveatParameterError struct {
error
caveatName string
paramName string
}
// MarshalZerologObject implements zerolog object marshalling.
func (err UnusedCaveatParameterError) MarshalZerologObject(e *zerolog.Event) {
e.Err(err.error).Str("caveat", err.caveatName).Str("param", err.paramName)
}
// DetailsMetadata returns the metadata for details for this error.
func (err UnusedCaveatParameterError) DetailsMetadata() map[string]string {
return map[string]string{
"caveat_name": err.caveatName,
"parameter_name": err.paramName,
}
}
// NewNamespaceNotFoundErr constructs a new namespace not found error.
func NewNamespaceNotFoundErr(nsName string) error {
return NamespaceNotFoundError{
error: fmt.Errorf("object definition `%s` not found", nsName),
namespaceName: nsName,
}
}
// NewRelationNotFoundErr constructs a new relation not found error.
func NewRelationNotFoundErr(nsName string, relationName string) error {
return RelationNotFoundError{
error: fmt.Errorf("relation/permission `%s` not found under definition `%s`", relationName, nsName),
namespaceName: nsName,
relationName: relationName,
}
}
// NewDuplicateRelationError constructs an error indicating that a relation was defined more than once in a namespace.
func NewDuplicateRelationError(nsName string, relationName string) error {
return DuplicateRelationError{
error: fmt.Errorf("found duplicate relation/permission name `%s` under definition `%s`", relationName, nsName),
namespaceName: nsName,
relationName: relationName,
}
}
// NewPermissionsCycleErr constructs an error indicating that a cycle exists amongst permissions.
func NewPermissionsCycleErr(nsName string, permissionNames []string) error {
return PermissionsCycleError{
error: fmt.Errorf("under definition `%s`, there exists a cycle in permissions: %s", nsName, strings.Join(permissionNames, ", ")),
namespaceName: nsName,
permissionNames: permissionNames,
}
}
// NewUnusedCaveatParameterErr constructs indicating that a parameter was unused in a caveat expression.
func NewUnusedCaveatParameterErr(caveatName string, paramName string) error {
return UnusedCaveatParameterError{
error: fmt.Errorf("parameter `%s` for caveat `%s` is unused", paramName, caveatName),
caveatName: caveatName,
paramName: paramName,
}
}
var (
_ sharederrors.UnknownNamespaceError = NamespaceNotFoundError{}
_ sharederrors.UnknownRelationError = RelationNotFoundError{}
)
|
