diff --git a/README.md b/README.md index 942f5be3..981a54ee 100644 --- a/README.md +++ b/README.md @@ -877,6 +877,30 @@ func (t *Settings) SetDefaults() { Defaults are supported for scalar properties (string, boolean, integer, number). +### Multiple messages per operation (AsyncAPI v3) + +When an operation (or its channel) declares more than one message, a dedicated +send function is generated for each one, named after the operation and the +message: + +```yaml +channels: + events: + address: app.events + messages: + userCreated: { $ref: '#/components/messages/userCreated' } + userDeleted: { $ref: '#/components/messages/userDeleted' } +operations: + sendEvents: + action: send + channel: { $ref: '#/channels/events' } +``` + +generates `SendAsSendEventsOperationForUserCreated` and +`...ForUserDeleted`, each sending its own message type. Operations with a single +message are unchanged. Reception of multiple message types on a single channel +is not covered yet (the subscribe side still handles the first message only). + ### Channel parameters from message location (AsyncAPI v3) When a channel parameter declares a `location` runtime expression, the generated diff --git a/pkg/asyncapi/v3/channel.go b/pkg/asyncapi/v3/channel.go index c330824c..cef5f379 100644 --- a/pkg/asyncapi/v3/channel.go +++ b/pkg/asyncapi/v3/channel.go @@ -2,6 +2,7 @@ package asyncapiv3 import ( "fmt" + "sort" "github.com/lerenn/asyncapi-codegen/pkg/extensions" ) @@ -154,10 +155,20 @@ func (ch *Channel) Follow() *Channel { return ch } -// GetMessage will return the channel message. +// GetMessage will return the channel message. When the channel has several +// messages, the one with the lowest name is returned deterministically (ranging +// a map directly would be non-deterministic, producing unstable generated code). func (ch Channel) GetMessage() (*Message, error) { - for _, m := range ch.Follow().Messages { - return m.Follow(), nil // TODO: change + messages := ch.Follow().Messages + if len(messages) == 0 { + return nil, fmt.Errorf("%w: channel %q", ErrNoMessageInChannel, ch.Name) } - return nil, fmt.Errorf("%w: channel %q", ErrNoMessageInChannel, ch.Name) + + names := make([]string, 0, len(messages)) + for name := range messages { + names = append(names, name) + } + sort.Strings(names) + + return messages[names[0]].Follow(), nil } diff --git a/pkg/asyncapi/v3/operation.go b/pkg/asyncapi/v3/operation.go index cf4b55aa..97053d33 100644 --- a/pkg/asyncapi/v3/operation.go +++ b/pkg/asyncapi/v3/operation.go @@ -1,6 +1,9 @@ package asyncapiv3 -import "strings" +import ( + "sort" + "strings" +) // OperationAction represents an OperationAction. type OperationAction string @@ -247,6 +250,28 @@ func (op Operation) GetMessage() (*Message, error) { return op.Channel.GetMessage() } +// GetMessages returns all the resolved messages of the operation, sorted by +// name for deterministic generation. It falls back to the channel messages when +// the operation itself does not list any. +func (op Operation) GetMessages() []*Message { + var msgs []*Message + + switch { + case len(op.Messages) > 0: + for _, m := range op.Messages { + msgs = append(msgs, m.Follow()) + } + case op.Channel != nil: + for _, m := range op.Channel.Follow().Messages { + msgs = append(msgs, m.Follow()) + } + } + + sort.Slice(msgs, func(i, j int) bool { return msgs[i].Name < msgs[j].Name }) + + return msgs +} + // ApplyTrait applies a trait to the operation. func (op *Operation) ApplyTrait(ot *OperationTrait, spec Specification) { // Check operation is not nil diff --git a/pkg/codegen/generators/v3/templates/controller.tmpl b/pkg/codegen/generators/v3/templates/controller.tmpl index 5749316a..5bfbe4d0 100644 --- a/pkg/codegen/generators/v3/templates/controller.tmpl +++ b/pkg/codegen/generators/v3/templates/controller.tmpl @@ -312,6 +312,58 @@ func (c *{{ $.Prefix }}Controller) UnsubscribeFrom{{ namify $value.Follow.Name } {{- end}} {{- range $key, $value := .Operations.Send}} +{{- if and (gt (operationMessageCount $value) 1) (not .Reply) (not .ReplyOf)}} +{{- /* Multiple messages: generate one send function per message (#140) */}} +{{- range $msg := $value.GetMessages}} + +// {{ sendFuncNameForMessage $value $.Prefix $msg }} will send a {{ cutSuffix (messageTypeName $msg) "Message" }} message on {{ cutSuffix (opToChannelTypeName $value) "Channel" }} channel. +func (c *{{ $.Prefix }}Controller) {{ sendFuncNameForMessage $value $.Prefix $msg }}( + ctx context.Context, + {{- if $value.Channel.Follow.Parameters }} + params {{namifyWithoutParam $value.Channel.Follow.Name}}Parameters, + {{- end}} + {{- if eq $value.Channel.Follow.Address "" }} + chanAddr string, + {{- end}} + msg {{messageTypeName $msg}}, +) error { + // Set channel address + {{- if eq $value.Channel.Follow.Address "" }} + addr := chanAddr + {{- else }} + addr := {{ generateChannelAddrFromOp $value }} + {{- end }} + + {{if $msg.HaveCorrelationID -}} + // Set correlation ID if it does not exist + if id := msg.CorrelationID(); id == "" { + msg.SetCorrelationID(uuid.New().String()) + } + {{- end}} + + // Set context + ctx = add{{ $.Prefix }}ContextValues(ctx, addr) + ctx = context.WithValue(ctx, extensions.ContextKeyIsDirection, "publication") + {{if $msg.HaveCorrelationID -}} + ctx = context.WithValue(ctx, extensions.ContextKeyIsCorrelationID, msg.CorrelationID()) + {{- end}} + + // Convert to BrokerMessage + brokerMsg, err := msg.toBrokerMessage() + if err != nil { + return err + } + + // Set broker message to context + ctx = context.WithValue(ctx, extensions.ContextKeyIsBrokerMessage, brokerMsg.String()) + + // Send the message on event-broker through middlewares + return c.executeMiddlewares(ctx, &brokerMsg, func(ctx context.Context) error { + return c.broker.Publish(ctx, addr, brokerMsg) + }) +} +{{- end}} +{{- else}} // {{ sendFuncName $value $.Prefix }} will send a {{ cutSuffix (opToMsgTypeName $value) "Message" }} message on {{ cutSuffix (opToChannelTypeName $value) "Channel" }} channel. // @@ -371,6 +423,7 @@ func (c *{{ $.Prefix }}Controller) {{ sendFuncName $value $.Prefix }}( return c.broker.Publish(ctx, addr, brokerMsg) }) } +{{- end}} {{if .Reply -}} diff --git a/pkg/codegen/generators/v3/templates/helpers.go b/pkg/codegen/generators/v3/templates/helpers.go index 49957dd5..8c6f93c8 100644 --- a/pkg/codegen/generators/v3/templates/helpers.go +++ b/pkg/codegen/generators/v3/templates/helpers.go @@ -4,6 +4,7 @@ import ( "fmt" "regexp" "strconv" + "strings" "text/template" asyncapi "github.com/lerenn/asyncapi-codegen/pkg/asyncapi/v3" @@ -190,6 +191,24 @@ func RequestFuncName(op *asyncapi.Operation, prefix string) string { return verb + templateutil.Namify(op.Follow().Name) } +// OperationMessageCount returns the number of messages of an operation. +func OperationMessageCount(op *asyncapi.Operation) int { + return len(op.Follow().GetMessages()) +} + +// MessageTypeName returns the generated Go type name of a message. +func MessageTypeName(msg *asyncapi.Message) string { + return templateutil.Namify(msg.Follow().Name) +} + +// SendFuncNameForMessage returns the name of the per-message send function +// generated when an operation carries more than one message (issue #140). It is +// the operation send function name suffixed with "For" and the message name. +func SendFuncNameForMessage(op *asyncapi.Operation, prefix string, msg *asyncapi.Message) string { + base := strings.TrimSuffix(MessageTypeName(msg), "Message") + return SendFuncName(op, prefix) + "For" + base +} + // HelpersFunctions returns the functions that can be used as helpers // in a golang template. func HelpersFunctions() template.FuncMap { @@ -212,5 +231,8 @@ func HelpersFunctions() template.FuncMap { "replyFuncName": ReplyFuncName, "sendFuncName": SendFuncName, "requestFuncName": RequestFuncName, + "operationMessageCount": OperationMessageCount, + "messageTypeName": MessageTypeName, + "sendFuncNameForMessage": SendFuncNameForMessage, } } diff --git a/test/v3/issues/140/asyncapi.gen.go b/test/v3/issues/140/asyncapi.gen.go new file mode 100644 index 00000000..77146bb4 --- /dev/null +++ b/test/v3/issues/140/asyncapi.gen.go @@ -0,0 +1,608 @@ +// Package "issue140" provides primitives to interact with the AsyncAPI specification. +// +// Code generated by github.com/lerenn/asyncapi-codegen version (devel) DO NOT EDIT. +package issue140 + +import ( + "context" + "encoding/json" + "fmt" + + "github.com/lerenn/asyncapi-codegen/pkg/extensions" +) + +// controller is the controller that will be used to communicate with the broker +// It will be used internally by AppController and UserController +type controller struct { + // broker is the broker controller that will be used to communicate + broker extensions.BrokerController + // subscriptions is a map of all subscriptions + subscriptions map[string]extensions.BrokerChannelSubscription + // logger is the logger that will be used to log operations on controller + logger extensions.Logger + // middlewares are the middlewares that will be executed when sending or + // receiving messages + middlewares []extensions.Middleware + // handler to handle errors from consumers and middlewares + errorHandler extensions.ErrorHandler +} + +// ControllerOption is the type of the options that can be passed +// when creating a new Controller +type ControllerOption func(controller *controller) + +// WithLogger attaches a logger to the controller +func WithLogger(logger extensions.Logger) ControllerOption { + return func(controller *controller) { + controller.logger = logger + } +} + +// WithMiddlewares attaches middlewares that will be executed when sending or receiving messages +func WithMiddlewares(middlewares ...extensions.Middleware) ControllerOption { + return func(controller *controller) { + controller.middlewares = middlewares + } +} + +// WithErrorHandler attaches a errorhandler to handle errors from subscriber functions +func WithErrorHandler(handler extensions.ErrorHandler) ControllerOption { + return func(controller *controller) { + controller.errorHandler = handler + } +} + +// AppController is the structure that provides sending capabilities to the +// developer and and connect the broker with the App +type AppController struct { + controller +} + +// NewAppController links the App to the broker +func NewAppController(bc extensions.BrokerController, options ...ControllerOption) (*AppController, error) { + // Check if broker controller has been provided + if bc == nil { + return nil, extensions.ErrNilBrokerController + } + + // Create default controller + controller := controller{ + broker: bc, + subscriptions: make(map[string]extensions.BrokerChannelSubscription), + logger: extensions.DummyLogger{}, + middlewares: make([]extensions.Middleware, 0), + errorHandler: extensions.DefaultErrorHandler(), + } + + // Apply options + for _, option := range options { + option(&controller) + } + + return &AppController{controller: controller}, nil +} + +func (c AppController) wrapMiddlewares( + middlewares []extensions.Middleware, + callback extensions.NextMiddleware, +) func(ctx context.Context, msg *extensions.BrokerMessage) error { + var called bool + + // If there is no more middleware + if len(middlewares) == 0 { + return func(ctx context.Context, msg *extensions.BrokerMessage) error { + // Call the callback if it exists and it has not been called already + if callback != nil && !called { + called = true + return callback(ctx) + } + + // Nil can be returned, as the callback has already been called + return nil + } + } + + // Get the next function to call from next middlewares or callback + next := c.wrapMiddlewares(middlewares[1:], callback) + + // Wrap middleware into a check function that will call execute the middleware + // and call the next wrapped middleware if the returned function has not been + // called already + return func(ctx context.Context, msg *extensions.BrokerMessage) error { + // Call the middleware and the following if it has not been done already + if !called { + // Create the next call with the context and the message + nextWithArgs := func(ctx context.Context) error { + return next(ctx, msg) + } + + // Call the middleware and register it as already called + called = true + if err := middlewares[0](ctx, msg, nextWithArgs); err != nil { + return err + } + + // If next has already been called in middleware, it should not be executed again + return nextWithArgs(ctx) + } + + // Nil can be returned, as the next middleware has already been called + return nil + } +} + +func (c AppController) executeMiddlewares(ctx context.Context, msg *extensions.BrokerMessage, callback extensions.NextMiddleware) error { + // Wrap middleware to have 'next' function when calling them + wrapped := c.wrapMiddlewares(c.middlewares, callback) + + // Execute wrapped middlewares + return wrapped(ctx, msg) +} + +func addAppContextValues(ctx context.Context, addr string) context.Context { + ctx = context.WithValue(ctx, extensions.ContextKeyIsVersion, "1.0.0") + ctx = context.WithValue(ctx, extensions.ContextKeyIsProvider, "app") + return context.WithValue(ctx, extensions.ContextKeyIsChannel, addr) +} + +// Close will clean up any existing resources on the controller +func (c *AppController) Close(ctx context.Context) { + // Unsubscribing remaining channels +} + +// SendAsSendEventsOperationForUserCreated will send a UserCreated message on Events channel. +func (c *AppController) SendAsSendEventsOperationForUserCreated( + ctx context.Context, + msg UserCreatedMessage, +) error { + // Set channel address + addr := "v3.issue140.events" + + // Set context + ctx = addAppContextValues(ctx, addr) + ctx = context.WithValue(ctx, extensions.ContextKeyIsDirection, "publication") + + // Convert to BrokerMessage + brokerMsg, err := msg.toBrokerMessage() + if err != nil { + return err + } + + // Set broker message to context + ctx = context.WithValue(ctx, extensions.ContextKeyIsBrokerMessage, brokerMsg.String()) + + // Send the message on event-broker through middlewares + return c.executeMiddlewares(ctx, &brokerMsg, func(ctx context.Context) error { + return c.broker.Publish(ctx, addr, brokerMsg) + }) +} + +// SendAsSendEventsOperationForUserDeleted will send a UserDeleted message on Events channel. +func (c *AppController) SendAsSendEventsOperationForUserDeleted( + ctx context.Context, + msg UserDeletedMessage, +) error { + // Set channel address + addr := "v3.issue140.events" + + // Set context + ctx = addAppContextValues(ctx, addr) + ctx = context.WithValue(ctx, extensions.ContextKeyIsDirection, "publication") + + // Convert to BrokerMessage + brokerMsg, err := msg.toBrokerMessage() + if err != nil { + return err + } + + // Set broker message to context + ctx = context.WithValue(ctx, extensions.ContextKeyIsBrokerMessage, brokerMsg.String()) + + // Send the message on event-broker through middlewares + return c.executeMiddlewares(ctx, &brokerMsg, func(ctx context.Context) error { + return c.broker.Publish(ctx, addr, brokerMsg) + }) +} + +// UserSubscriber contains all handlers that are listening messages for User +type UserSubscriber interface { + // SendEventsOperationReceived receive all UserCreated messages from Events channel. + SendEventsOperationReceived(ctx context.Context, msg UserCreatedMessage) error +} + +// UserController is the structure that provides sending capabilities to the +// developer and and connect the broker with the User +type UserController struct { + controller +} + +// NewUserController links the User to the broker +func NewUserController(bc extensions.BrokerController, options ...ControllerOption) (*UserController, error) { + // Check if broker controller has been provided + if bc == nil { + return nil, extensions.ErrNilBrokerController + } + + // Create default controller + controller := controller{ + broker: bc, + subscriptions: make(map[string]extensions.BrokerChannelSubscription), + logger: extensions.DummyLogger{}, + middlewares: make([]extensions.Middleware, 0), + errorHandler: extensions.DefaultErrorHandler(), + } + + // Apply options + for _, option := range options { + option(&controller) + } + + return &UserController{controller: controller}, nil +} + +func (c UserController) wrapMiddlewares( + middlewares []extensions.Middleware, + callback extensions.NextMiddleware, +) func(ctx context.Context, msg *extensions.BrokerMessage) error { + var called bool + + // If there is no more middleware + if len(middlewares) == 0 { + return func(ctx context.Context, msg *extensions.BrokerMessage) error { + // Call the callback if it exists and it has not been called already + if callback != nil && !called { + called = true + return callback(ctx) + } + + // Nil can be returned, as the callback has already been called + return nil + } + } + + // Get the next function to call from next middlewares or callback + next := c.wrapMiddlewares(middlewares[1:], callback) + + // Wrap middleware into a check function that will call execute the middleware + // and call the next wrapped middleware if the returned function has not been + // called already + return func(ctx context.Context, msg *extensions.BrokerMessage) error { + // Call the middleware and the following if it has not been done already + if !called { + // Create the next call with the context and the message + nextWithArgs := func(ctx context.Context) error { + return next(ctx, msg) + } + + // Call the middleware and register it as already called + called = true + if err := middlewares[0](ctx, msg, nextWithArgs); err != nil { + return err + } + + // If next has already been called in middleware, it should not be executed again + return nextWithArgs(ctx) + } + + // Nil can be returned, as the next middleware has already been called + return nil + } +} + +func (c UserController) executeMiddlewares(ctx context.Context, msg *extensions.BrokerMessage, callback extensions.NextMiddleware) error { + // Wrap middleware to have 'next' function when calling them + wrapped := c.wrapMiddlewares(c.middlewares, callback) + + // Execute wrapped middlewares + return wrapped(ctx, msg) +} + +func addUserContextValues(ctx context.Context, addr string) context.Context { + ctx = context.WithValue(ctx, extensions.ContextKeyIsVersion, "1.0.0") + ctx = context.WithValue(ctx, extensions.ContextKeyIsProvider, "user") + return context.WithValue(ctx, extensions.ContextKeyIsChannel, addr) +} + +// Close will clean up any existing resources on the controller +func (c *UserController) Close(ctx context.Context) { + // Unsubscribing remaining channels + c.UnsubscribeFromAllChannels(ctx) + + c.logger.Info(ctx, "Closed user controller") +} + +// SubscribeToAllChannels will receive messages from channels where channel has +// no parameter on which the app is expecting messages. For channels with parameters, +// they should be subscribed independently. +func (c *UserController) SubscribeToAllChannels(ctx context.Context, as UserSubscriber) error { + if as == nil { + return extensions.ErrNilUserSubscriber + } + + if err := c.SubscribeToSendEventsOperation(ctx, as.SendEventsOperationReceived); err != nil { + return err + } + + return nil +} + +// UnsubscribeFromAllChannels will stop the subscription of all remaining subscribed channels +func (c *UserController) UnsubscribeFromAllChannels(ctx context.Context) { + c.UnsubscribeFromSendEventsOperation(ctx) +} + +// SubscribeToSendEventsOperation will receive UserCreated messages from Events channel. +// +// Callback function 'fn' will be called each time a new message is received. +// +// NOTE: for now, this only support the first message from AsyncAPI list. +// +// NOTE: for now, this only support the first message from AsyncAPI list. +// If you need support for other messages, please raise an issue. +func (c *UserController) SubscribeToSendEventsOperation( + ctx context.Context, + fn func(ctx context.Context, msg UserCreatedMessage) error, +) error { + // Get channel address + addr := "v3.issue140.events" + + // Set context + ctx = addUserContextValues(ctx, addr) + ctx = context.WithValue(ctx, extensions.ContextKeyIsDirection, "reception") + + // Check if the controller is already subscribed + _, exists := c.subscriptions[addr] + if exists { + err := fmt.Errorf("%w: controller is already subscribed on channel %q", extensions.ErrAlreadySubscribedChannel, addr) + c.logger.Error(ctx, err.Error()) + return err + } + + // Subscribe to broker channel + sub, err := c.broker.Subscribe(ctx, addr) + if err != nil { + c.logger.Error(ctx, err.Error()) + return err + } + c.logger.Info(ctx, "Subscribed to channel") + + // Asynchronously listen to new messages and pass them to app receiver + go func() { + for { + // Listen to next message + stop, err := c.listenToSendEventsOperationNextMessage(addr, sub, fn) + if err != nil { + c.logger.Error(ctx, err.Error()) + } + + // Stop if required + if stop { + return + } + } + }() + + // Add the cancel channel to the inside map + c.subscriptions[addr] = sub + + return nil +} + +func (c *UserController) listenToSendEventsOperationNextMessage( + addr string, + sub extensions.BrokerChannelSubscription, + fn func(ctx context.Context, msg UserCreatedMessage) error, +) (stop bool, err error) { + // Create a context for the received response + msgCtx, cancel := context.WithCancel(context.Background()) + msgCtx = addUserContextValues(msgCtx, addr) + msgCtx = context.WithValue(msgCtx, extensions.ContextKeyIsDirection, "reception") + defer cancel() + + // Wait for next message + acknowledgeableBrokerMessage, open := <-sub.MessagesChannel() + + // If subscription is closed and there is no more message + // (i.e. uninitialized message), then exit the function + if !open && acknowledgeableBrokerMessage.IsUninitialized() { + return true, nil + } + + // Set broker message to context + msgCtx = context.WithValue(msgCtx, extensions.ContextKeyIsBrokerMessage, acknowledgeableBrokerMessage.String()) + + // Execute middlewares before handling the message + if err := c.executeMiddlewares(msgCtx, &acknowledgeableBrokerMessage.BrokerMessage, func(middlewareCtx context.Context) error { + // Process message + msg, err := brokerMessageToUserCreatedMessage(acknowledgeableBrokerMessage.BrokerMessage) + if err != nil { + return err + } + + // Execute the subscription function + if err := fn(middlewareCtx, msg); err != nil { + return err + } + + acknowledgeableBrokerMessage.Ack() + + return nil + }); err != nil { + c.errorHandler(msgCtx, addr, &acknowledgeableBrokerMessage, err) + // On error execute the acknowledgeableBrokerMessage nack() function and + // let the BrokerAcknowledgment decide what is the right nack behavior for the broker + acknowledgeableBrokerMessage.Nak() + } + + return false, nil +} + +// UnsubscribeFromSendEventsOperation will stop the reception of UserCreated messages from Events channel. +// A timeout can be set in context to avoid blocking operation, if needed. +func (c *UserController) UnsubscribeFromSendEventsOperation( + ctx context.Context, +) { + // Get channel address + addr := "v3.issue140.events" + + // Check if there receivers for this channel + sub, exists := c.subscriptions[addr] + if !exists { + return + } + + // Set context + ctx = addUserContextValues(ctx, addr) + + // Stop the subscription + sub.Cancel(ctx) + + // Remove if from the receivers + delete(c.subscriptions, addr) + + c.logger.Info(ctx, "Unsubscribed from channel") +} + +// AsyncAPIVersion is the version of the used AsyncAPI document +const AsyncAPIVersion = "1.0.0" + +// MessageWithCorrelationID is implemented by messages that carry a correlation ID. +type MessageWithCorrelationID interface { + CorrelationID() string + SetCorrelationID(id string) +} + +// Error is the error structure returned by the controller operations. +type Error struct { + Channel string + Err error +} + +// Error returns a string representation of the error. +func (e *Error) Error() string { + return fmt.Sprintf("channel %q: err %v", e.Channel, e.Err) +} + +// Message 'UserCreatedMessageFromEventsChannel' reference another one at '#/components/messages/userCreated'. +// This should be fixed in a future version to allow message override. +// If you encounter this message, feel free to open an issue on this subject +// to let know that you need this functionnality. + +// Message 'UserDeletedMessageFromEventsChannel' reference another one at '#/components/messages/userDeleted'. +// This should be fixed in a future version to allow message override. +// If you encounter this message, feel free to open an issue on this subject +// to let know that you need this functionnality. + +// UserCreatedMessagePayload is a schema from the AsyncAPI specification required in messages +type UserCreatedMessagePayload struct { + Id *string `json:"id,omitempty"` +} + +// UserCreatedMessage is the message expected for 'UserCreatedMessage' channel. +type UserCreatedMessage struct { + // Payload will be inserted in the message payload + Payload UserCreatedMessagePayload +} + +// NewUserCreatedMessage creates a new UserCreatedMessage with default values if any. +func NewUserCreatedMessage() UserCreatedMessage { + var msg UserCreatedMessage + + return msg +} + +// brokerMessageToUserCreatedMessage will fill a new UserCreatedMessage with data from generic broker message +func brokerMessageToUserCreatedMessage(bMsg extensions.BrokerMessage) (UserCreatedMessage, error) { + var msg UserCreatedMessage + + // Unmarshal payload to expected message payload format + err := json.Unmarshal(bMsg.Payload, &msg.Payload) + if err != nil { + return msg, err + } + + // TODO: run checks on msg type + + return msg, nil +} + +// toBrokerMessage will generate a generic broker message from UserCreatedMessage data +func (msg UserCreatedMessage) toBrokerMessage() (extensions.BrokerMessage, error) { + // TODO: implement checks on message + + // Marshal payload to JSON + payload, err := json.Marshal(msg.Payload) + if err != nil { + return extensions.BrokerMessage{}, err + } + + // There is no headers here + headers := make(map[string][]byte, 0) + + return extensions.BrokerMessage{ + Headers: headers, + Payload: payload, + }, nil +} + +// UserDeletedMessagePayload is a schema from the AsyncAPI specification required in messages +type UserDeletedMessagePayload struct { + Id *string `json:"id,omitempty"` +} + +// UserDeletedMessage is the message expected for 'UserDeletedMessage' channel. +type UserDeletedMessage struct { + // Payload will be inserted in the message payload + Payload UserDeletedMessagePayload +} + +// NewUserDeletedMessage creates a new UserDeletedMessage with default values if any. +func NewUserDeletedMessage() UserDeletedMessage { + var msg UserDeletedMessage + + return msg +} + +// brokerMessageToUserDeletedMessage will fill a new UserDeletedMessage with data from generic broker message +func brokerMessageToUserDeletedMessage(bMsg extensions.BrokerMessage) (UserDeletedMessage, error) { + var msg UserDeletedMessage + + // Unmarshal payload to expected message payload format + err := json.Unmarshal(bMsg.Payload, &msg.Payload) + if err != nil { + return msg, err + } + + // TODO: run checks on msg type + + return msg, nil +} + +// toBrokerMessage will generate a generic broker message from UserDeletedMessage data +func (msg UserDeletedMessage) toBrokerMessage() (extensions.BrokerMessage, error) { + // TODO: implement checks on message + + // Marshal payload to JSON + payload, err := json.Marshal(msg.Payload) + if err != nil { + return extensions.BrokerMessage{}, err + } + + // There is no headers here + headers := make(map[string][]byte, 0) + + return extensions.BrokerMessage{ + Headers: headers, + Payload: payload, + }, nil +} + +const ( + // EventsChannelPath is the constant representing the 'EventsChannel' channel path. + EventsChannelPath = "v3.issue140.events" +) + +// ChannelsPaths is an array of all channels paths +var ChannelsPaths = []string{ + EventsChannelPath, +} diff --git a/test/v3/issues/140/asyncapi.yaml b/test/v3/issues/140/asyncapi.yaml new file mode 100644 index 00000000..4687fdce --- /dev/null +++ b/test/v3/issues/140/asyncapi.yaml @@ -0,0 +1,34 @@ +asyncapi: 3.0.0 +info: + title: Issue 140 - multiple messages per operation + version: 1.0.0 + +channels: + events: + address: v3.issue140.events + messages: + userCreated: + $ref: '#/components/messages/userCreated' + userDeleted: + $ref: '#/components/messages/userDeleted' + +operations: + sendEvents: + action: send + channel: + $ref: '#/channels/events' + +components: + messages: + userCreated: + payload: + type: object + properties: + id: + type: string + userDeleted: + payload: + type: object + properties: + id: + type: string diff --git a/test/v3/issues/140/gen.go b/test/v3/issues/140/gen.go new file mode 100644 index 00000000..a08cf89f --- /dev/null +++ b/test/v3/issues/140/gen.go @@ -0,0 +1,3 @@ +//go:generate go run ../../../../cmd/asyncapi-codegen -p issue140 -i ./asyncapi.yaml -o ./asyncapi.gen.go + +package issue140 diff --git a/test/v3/issues/140/suite_test.go b/test/v3/issues/140/suite_test.go new file mode 100644 index 00000000..8ddf89d1 --- /dev/null +++ b/test/v3/issues/140/suite_test.go @@ -0,0 +1,67 @@ +package issue140 + +import ( + "context" + "testing" + + "github.com/lerenn/asyncapi-codegen/pkg/extensions" + "github.com/lerenn/asyncapi-codegen/pkg/utils" + "github.com/stretchr/testify/suite" +) + +func TestSuite(t *testing.T) { + suite.Run(t, NewSuite()) +} + +// capturingBroker records the channel address and payload of the last published +// message. +type capturingBroker struct { + channel string + payload []byte +} + +func (b *capturingBroker) Publish(_ context.Context, channel string, msg extensions.BrokerMessage) error { + b.channel = channel + b.payload = msg.Payload + return nil +} + +func (b *capturingBroker) Subscribe( + _ context.Context, + _ string, +) (extensions.BrokerChannelSubscription, error) { + return extensions.NewBrokerChannelSubscription( + make(chan extensions.AcknowledgeableBrokerMessage), + make(chan any), + ), nil +} + +type Suite struct { + suite.Suite +} + +func NewSuite() *Suite { + return &Suite{} +} + +// TestEachMessageHasItsOwnSendFunction ensures an operation that carries more +// than one message generates one send function per message, each sending its +// own payload on the channel (issue #140). +func (suite *Suite) TestEachMessageHasItsOwnSendFunction() { + broker := &capturingBroker{} + ctrl, err := NewAppController(broker) + suite.Require().NoError(err) + defer ctrl.Close(context.Background()) + + created := NewUserCreatedMessage() + created.Payload.Id = utils.ToPointer("created-1") + suite.Require().NoError(ctrl.SendAsSendEventsOperationForUserCreated(context.Background(), created)) + suite.Require().Equal("v3.issue140.events", broker.channel) + suite.Require().Contains(string(broker.payload), "created-1") + + deleted := NewUserDeletedMessage() + deleted.Payload.Id = utils.ToPointer("deleted-1") + suite.Require().NoError(ctrl.SendAsSendEventsOperationForUserDeleted(context.Background(), deleted)) + suite.Require().Equal("v3.issue140.events", broker.channel) + suite.Require().Contains(string(broker.payload), "deleted-1") +}