Create an FFEnum type and tag structure for OpenAPI annotations

Signed-off-by: Peter Broadhurst <peter.broadhurst@kaleido.io>

Author: peterbroadhurst

internal/events/subscription_manager_test.go

@@ -631,7 +631,7 @@ func TestDeleteDurableSubscriptionOk(t *testing.T) {
 	}
 
 	mdi.On("GetSubscriptionByID", mock.Anything, subID).Return(subDef, nil)
-	mdi.On("DeleteOffset", mock.Anything, fftypes.LowerCasedType("subscription"), subID.String()).Return(fmt.Errorf("this error is logged and swallowed"))
+	mdi.On("DeleteOffset", mock.Anything, fftypes.FFEnum("subscription"), subID.String()).Return(fmt.Errorf("this error is logged and swallowed"))
 	sm.deletedDurableSubscription(subID)
 
 	assert.Empty(t, sm.connections["conn1"].dispatchers)

internal/events/webhooks/webhooks.go

@@ -364,9 +364,9 @@ func (wh *WebHooks) doDelivery(connID string, reply bool, sub *fftypes.Subscript
 
 	// Emit the response
 	if reply {
-		txType := fftypes.LowerCasedType(strings.ToLower(sub.Options.TransportOptions().GetString("replytx")))
+		txType := fftypes.FFEnum(strings.ToLower(sub.Options.TransportOptions().GetString("replytx")))
 		if req != nil && req.replyTx != "" {
-			txType = fftypes.LowerCasedType(strings.ToLower(req.replyTx))
+			txType = fftypes.FFEnum(strings.ToLower(req.replyTx))
 		}
 		wh.callbacks.DeliveryResponse(connID, &fftypes.EventDeliveryResponse{
 			ID:           event.ID,

internal/tokens/https/https.go

@@ -154,7 +154,7 @@ func (h *HTTPS) handleTokenPoolCreate(ctx context.Context, data fftypes.JSONObje
 		},
 		Namespace:  ns,
 		Name:       name,
-		Type:       fftypes.LowerCasedType(tokenType),
+		Type:       fftypes.FFEnum(tokenType),
 		ProtocolID: protocolID,
 	}
 

pkg/fftypes/datatype.go

@@ -22,20 +22,20 @@ import (
 	"github.com/hyperledger-labs/firefly/internal/i18n"
 )
 
-type ValidatorType = LowerCasedType
+type ValidatorType = FFEnum
 
-const (
+var (
 	// ValidatorTypeJSON is the validator type for JSON Schema validation
-	ValidatorTypeJSON ValidatorType = "json"
+	ValidatorTypeJSON ValidatorType = ffEnum("validatortype", "json")
 	// ValidatorTypeSystemDefinition is the validator type for system definitions
-	ValidatorTypeSystemDefinition ValidatorType = "definition"
+	ValidatorTypeSystemDefinition ValidatorType = ffEnum("validatortype", "definition")
 )
 
 // Datatype is the structure defining a data definition, such as a JSON schema
 type Datatype struct {
 	ID        *UUID         `json:"id,omitempty"`
 	Message   *UUID         `json:"message,omitempty"`
-	Validator ValidatorType `json:"validator"`
+	Validator ValidatorType `json:"validator" ffenum:"validatortype"`
 	Namespace string        `json:"namespace,omitempty"`
 	Name      string        `json:"name,omitempty"`
 	Version   string        `json:"version,omitempty"`

pkg/fftypes/enum.go

@@ -0,0 +1,56 @@
+// Copyright © 2021 Kaleido, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package fftypes
+
+import (
+	"database/sql/driver"
+	"strings"
+)
+
+type FFEnum string
+
+var enumValues = map[string][]FFEnum{}
+
+func ffEnum(t string, val FFEnum) FFEnum {
+	enumValues[t] = append(enumValues[t], val)
+	return val
+}
+
+func FFEnumValues(t string) []FFEnum {
+	return enumValues[t]
+}
+
+func (ts FFEnum) String() string {
+	return strings.ToLower(string(ts))
+}
+
+func (ts FFEnum) Lower() FFEnum {
+	return FFEnum(strings.ToLower(string(ts)))
+}
+
+func (ts FFEnum) Equals(ts2 FFEnum) bool {
+	return strings.EqualFold(string(ts), string(ts2))
+}
+
+func (ts FFEnum) Value() (driver.Value, error) {
+	return ts.String(), nil
+}
+
+func (ts *FFEnum) UnmarshalText(b []byte) error {
+	*ts = FFEnum(strings.ToLower(string(b)))
+	return nil
+}

pkg/fftypes/enum_test.go

@@ -0,0 +1,29 @@
+// Copyright © 2021 Kaleido, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package fftypes
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFFEnumValues(t *testing.T) {
+	assert.Equal(t, FFEnum("test1"), ffEnum("ut", "test1"))
+	assert.Equal(t, FFEnum("test2"), ffEnum("ut", "test2"))
+	assert.Equal(t, []FFEnum{"test1", "test2"}, FFEnumValues("ut"))
+}

pkg/fftypes/event.go

@@ -17,31 +17,31 @@
 package fftypes
 
 // EventType indicates what the event means, as well as what the Reference in the event refers to
-type EventType = LowerCasedType
+type EventType = FFEnum
 
-const (
+var (
 	// EventTypeMessageConfirmed is the most important event type in the system. This means a message and all of its data
 	// is available for processing by an application. Most applications only need to listen to this event type
-	EventTypeMessageConfirmed EventType = "message_confirmed"
+	EventTypeMessageConfirmed EventType = ffEnum("eventtype", "message_confirmed")
 	// EventTypeMessageRejected occurs if a message is received and confirmed from a sequencing perspective, but is rejected as invalid (mismatch to schema, or duplicate system broadcast)
-	EventTypeMessageRejected EventType = "message_rejected"
+	EventTypeMessageRejected EventType = ffEnum("eventtype", "message_rejected")
 	// EventTypeNamespaceConfirmed occurs when a new namespace is ready for use (on the namespace itself)
-	EventTypeNamespaceConfirmed EventType = "namespace_confirmed"
+	EventTypeNamespaceConfirmed EventType = ffEnum("eventtype", "namespace_confirmed")
 	// EventTypeDatatypeConfirmed occurs when a new datatype is ready for use (on the namespace of the datatype)
-	EventTypeDatatypeConfirmed EventType = "datatype_confirmed"
+	EventTypeDatatypeConfirmed EventType = ffEnum("eventtype", "datatype_confirmed")
 	// EventTypeGroupConfirmed occurs when a new group is ready to use (on the namespace of the group, on all group participants)
-	EventTypeGroupConfirmed EventType = "group_confirmed"
+	EventTypeGroupConfirmed EventType = ffEnum("eventtype", "group_confirmed")
 	// EventTypePoolConfirmed occurs when a new token pool is ready for use
-	EventTypePoolConfirmed EventType = "token_pool_confirmed"
+	EventTypePoolConfirmed EventType = ffEnum("eventtype", "token_pool_confirmed")
 	// EventTypePoolRejected occurs when a new token pool is rejected (due to validation errors, duplicates, etc)
-	EventTypePoolRejected EventType = "token_pool_rejected"
+	EventTypePoolRejected EventType = ffEnum("eventtype", "token_pool_rejected")
 )
 
 // Event is an activity in the system, delivered reliably to applications, that indicates something has happened in the network
 type Event struct {
 	ID        *UUID     `json:"id"`
 	Sequence  int64     `json:"sequence"`
-	Type      EventType `json:"type"`
+	Type      EventType `json:"type" ffenum:"eventtype"`
 	Namespace string    `json:"namespace"`
 	Reference *UUID     `json:"reference"`
 	Created   *FFTime   `json:"created"`

pkg/fftypes/message.go

@@ -30,25 +30,25 @@ const (
 )
 
 // MessageType is the fundamental type of a message
-type MessageType = LowerCasedType
+type MessageType = FFEnum
 
-const (
+var (
 	// MessageTypeDefinition is a message broadcasting a definition of a system type, pre-defined by firefly (namespaces, members, data definitions, etc.)
-	MessageTypeDefinition MessageType = "definition"
+	MessageTypeDefinition MessageType = ffEnum("messagetype", "definition")
 	// MessageTypeBroadcast is a broadcast message, meaning it is intended to be visible by all parties in the network
-	MessageTypeBroadcast MessageType = "broadcast"
+	MessageTypeBroadcast MessageType = ffEnum("messagetype", "broadcast")
 	// MessageTypePrivate is a private message, meaning it is only sent explicitly to individual parties in the network
-	MessageTypePrivate MessageType = "private"
+	MessageTypePrivate MessageType = ffEnum("messagetype", "private")
 	// MessageTypeGroupInit is a special private message that contains the definition of the group
-	MessageTypeGroupInit MessageType = "groupinit"
+	MessageTypeGroupInit MessageType = ffEnum("messagetype", "groupinit")
 )
 
 // MessageHeader contains all fields that contribute to the hash
 // The order of the serialization mut not change, once released
 type MessageHeader struct {
 	ID        *UUID           `json:"id,omitempty"`
 	CID       *UUID           `json:"cid,omitempty"`
-	Type      MessageType     `json:"type"`
+	Type      MessageType     `json:"type" ffenum:"messagetype"`
 	TxType    TransactionType `json:"txtype,omitempty"`
 	Author    string          `json:"author,omitempty"`
 	Created   *FFTime         `json:"created,omitempty"`

pkg/fftypes/namespace.go

@@ -24,15 +24,15 @@ import (
 )
 
 // NamespaceType describes when the namespace was created from local configuration, or broadcast through the network
-type NamespaceType = LowerCasedType
+type NamespaceType = FFEnum
 
-const (
+var (
 	// NamespaceTypeLocal is a namespace that only exists because it was defined in the local configuration of the node
-	NamespaceTypeLocal NamespaceType = "local"
+	NamespaceTypeLocal NamespaceType = ffEnum("namespacetype", "local")
 	// NamespaceTypeBroadcast is a namespace that was broadcast through the network. Broadcast namespaces can overwrite a local namespace
-	NamespaceTypeBroadcast NamespaceType = "broadcast"
+	NamespaceTypeBroadcast NamespaceType = ffEnum("namespacetype", "broadcast")
 	// NamespaceTypeSystem is a reserved namespace used by FireFly itself
-	NamespaceTypeSystem NamespaceType = "system"
+	NamespaceTypeSystem NamespaceType = ffEnum("namespacetype", "system")
 )
 
 // Namespace is a isolate set of named resources, to allow multiple applications to co-exist in the same network, with the same named objects.
@@ -42,7 +42,7 @@ type Namespace struct {
 	Message     *UUID         `json:"message,omitempty"`
 	Name        string        `json:"name"`
 	Description string        `json:"description"`
-	Type        NamespaceType `json:"type"`
+	Type        NamespaceType `json:"type" ffenum:"namespacetype"`
 	Created     *FFTime       `json:"created"`
 }
 

pkg/fftypes/offset.go

@@ -16,20 +16,20 @@
 
 package fftypes
 
-type OffsetType = LowerCasedType
+type OffsetType = FFEnum
 
-const (
+var (
 	// OffsetTypeBatch is an offset stored by the batch manager on the messages table
-	OffsetTypeBatch OffsetType = "batch"
+	OffsetTypeBatch OffsetType = ffEnum("offsettype", "batch")
 	// OffsetTypeAggregator is an offset stored by the aggregator on the events table
-	OffsetTypeAggregator OffsetType = "aggregator"
+	OffsetTypeAggregator OffsetType = ffEnum("offsettype", "aggregator")
 	// OffsetTypeSubscription is an offeset stored by a dispatcher on the events table
-	OffsetTypeSubscription OffsetType = "subscription"
+	OffsetTypeSubscription OffsetType = ffEnum("offsettype", "subscription")
 )
 
 // Offset is a simple stored data structure that records a sequence position within another collection
 type Offset struct {
-	Type    OffsetType `json:"type"`
+	Type    OffsetType `json:"type" ffenum:"offsettype"`
 	Name    string     `json:"name"`
 	Current int64      `json:"current,omitempty"`