From a1a521b6709b7bf68eff4b6aae0e158f13df5d46 Mon Sep 17 00:00:00 2001 From: Louis FRADIN Date: Fri, 12 Jun 2026 18:33:49 +0200 Subject: [PATCH] feat(v3): generate a send function per message for multi-message operations (#140) Operations carrying more than one message only exposed the first one. Now, when an operation (or its channel) has several messages, one send function is generated per message (SendAsFor), each sending its own message type. Single-message operations are unchanged (byte-identical output). Also makes Channel.GetMessage deterministic (it ranged a map, which could produce unstable / non-compiling generated code for channels with several messages). Reception of multiple message types on a channel is left for a follow-up (it requires reworking the address-keyed subscription map); the subscribe side still handles the first message. Addresses #140 Co-Authored-By: Claude Opus 4.8 (1M context) --- README.md | 24 + pkg/asyncapi/v3/channel.go | 19 +- pkg/asyncapi/v3/operation.go | 27 +- .../generators/v3/templates/controller.tmpl | 53 ++ .../generators/v3/templates/helpers.go | 22 + test/v3/issues/140/asyncapi.gen.go | 608 ++++++++++++++++++ test/v3/issues/140/asyncapi.yaml | 34 + test/v3/issues/140/gen.go | 3 + test/v3/issues/140/suite_test.go | 67 ++ 9 files changed, 852 insertions(+), 5 deletions(-) create mode 100644 test/v3/issues/140/asyncapi.gen.go create mode 100644 test/v3/issues/140/asyncapi.yaml create mode 100644 test/v3/issues/140/gen.go create mode 100644 test/v3/issues/140/suite_test.go 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") +}