feat: change name (#3)

Author: bxcodec

README.md

@@ -1,2 +1,3 @@
-# goqu
-GoQu - Golang Queue Wrapper for all queue platforms
+# goqueue
+
+GoQueue - Golang Queue Wrapper for all queue platforms

consumer.go

@@ -1,4 +1,4 @@
-package goqu
+package goqueue
 
 import "context"
 

consumer/option.go

@@ -1,6 +1,6 @@
 package consumer
 
-import "github.com/bxcodec/goqu"
+import "github.com/bxcodec/goqueue"
 
 // Option represents the configuration options for the consumer.
 type Option struct {
@@ -9,7 +9,7 @@ type Option struct {
 	// QueueName specifies the name of the queue to consume messages from.
 	QueueName string
 	// Middlewares is a list of middleware functions to be applied to the inbound message handler.
-	Middlewares []goqu.InboundMessageHandlerMiddlewareFunc
+	Middlewares []goqueue.InboundMessageHandlerMiddlewareFunc
 }
 
 // OptionFunc is a function type that takes an `opt` parameter of type `*Option`.
@@ -35,7 +35,7 @@ func WithQueueName(name string) OptionFunc {
 // WithMiddlewares is an OptionFunc that sets the provided middlewares for the consumer.
 // Middlewares are used to process inbound messages before they are handled by the consumer.
 // The middlewares are applied in the order they are provided.
-func WithMiddlewares(middlewares ...goqu.InboundMessageHandlerMiddlewareFunc) OptionFunc {
+func WithMiddlewares(middlewares ...goqueue.InboundMessageHandlerMiddlewareFunc) OptionFunc {
 	return func(opt *Option) {
 		opt.Middlewares = middlewares
 	}

consumer/rabbitmq/consumer.go

@@ -9,11 +9,11 @@ import (
 	amqp "github.com/rabbitmq/amqp091-go"
 	"github.com/sirupsen/logrus"
 
-	"github.com/bxcodec/goqu"
-	"github.com/bxcodec/goqu/consumer"
-	headerKey "github.com/bxcodec/goqu/headers/key"
-	headerVal "github.com/bxcodec/goqu/headers/value"
-	"github.com/bxcodec/goqu/middleware"
+	"github.com/bxcodec/goqueue"
+	"github.com/bxcodec/goqueue/consumer"
+	headerKey "github.com/bxcodec/goqueue/headers/key"
+	headerVal "github.com/bxcodec/goqueue/headers/value"
+	"github.com/bxcodec/goqueue/middleware"
 )
 
 // rabbitMQ is the subscriber handler for rabbitmq
@@ -28,7 +28,7 @@ type rabbitMQ struct {
 
 var defaultOption = func() *consumer.Option {
 	return &consumer.Option{
-		Middlewares: []goqu.InboundMessageHandlerMiddlewareFunc{},
+		Middlewares: []goqueue.InboundMessageHandlerMiddlewareFunc{},
 	}
 }
 
@@ -37,7 +37,7 @@ func NewConsumer(
 	client *amqp.Connection,
 	consumerChannel *amqp.Channel,
 	requeueChannel *amqp.Channel,
-	opts ...consumer.OptionFunc) goqu.Consumer {
+	opts ...consumer.OptionFunc) goqueue.Consumer {
 	opt := defaultOption()
 	for _, o := range opts {
 		o(opt)
@@ -84,7 +84,7 @@ func (r *rabbitMQ) initConsumer() {
 		false,
 		// queue arguments
 		// TODO(bxcodec): to support custom queue arguments on consumer initialization
-		// https://github.com/bxcodec/goqu/issues/1
+		// https://github.com/bxcodec/goqueue/issues/1
 		nil,
 	)
 	if err != nil {
@@ -99,7 +99,7 @@ func (r *rabbitMQ) initConsumer() {
 // If the context is canceled, the method stops consuming messages and returns.
 // The method returns an error if there was an issue consuming messages.
 func (r *rabbitMQ) Consume(ctx context.Context,
-	h goqu.InboundMessageHandler,
+	h goqueue.InboundMessageHandler,
 	meta map[string]interface{}) (err error) {
 	logrus.WithFields(logrus.Fields{
 		"queue_name":    r.option.QueueName,
@@ -115,7 +115,7 @@ func (r *rabbitMQ) Consume(ctx context.Context,
 			}).Info("stopping the worker")
 			return
 		case receivedMsg := <-r.msgReceiver:
-			msg := &goqu.Message{
+			msg := &goqueue.Message{
 				ID:           extractHeaderString(receivedMsg.Headers, headerKey.AppID),
 				Timestamp:    extractHeaderTime(receivedMsg.Headers, headerKey.PublishedTimestamp),
 				Action:       receivedMsg.RoutingKey,
@@ -126,7 +126,7 @@ func (r *rabbitMQ) Consume(ctx context.Context,
 				ServiceAgent: headerVal.GoquServiceAgent(extractHeaderString(receivedMsg.Headers, headerKey.QueueServiceAgent)),
 			}
 			msg.SetSchemaVersion(extractHeaderString(receivedMsg.Headers, headerKey.SchemaVer))
-			m := goqu.InboundMessage{
+			m := goqueue.InboundMessage{
 				Message:    *msg,
 				RetryCount: extractHeaderInt(receivedMsg.Headers, headerKey.RetryCount),
 				Metadata: map[string]interface{}{
@@ -161,9 +161,9 @@ func (r *rabbitMQ) Consume(ctx context.Context,
 					err = receivedMsg.Nack(false, false)
 					return
 				},
-				Requeue: func(ctx context.Context, delayFn goqu.DelayFn) (err error) {
+				Requeue: func(ctx context.Context, delayFn goqueue.DelayFn) (err error) {
 					if delayFn == nil {
-						delayFn = goqu.DefaultDelayFn
+						delayFn = goqueue.DefaultDelayFn
 					}
 					retries := extractHeaderInt(receivedMsg.Headers, headerKey.RetryCount)
 					retries++

delayfn.go

@@ -1,4 +1,4 @@
-package goqu
+package goqueue
 
 type DelayFn func(retries int64) (delay int64)
 

encoding.go

@@ -1,11 +1,11 @@
-package goqu
+package goqueue
 
 import (
 	"context"
 	"encoding/json"
 	"sync"
 
-	headerVal "github.com/bxcodec/goqu/headers/value"
+	headerVal "github.com/bxcodec/goqueue/headers/value"
 )
 
 type EncoderFn func(ctx context.Context, m Message) (data []byte, err error)

go.mod

@@ -1,4 +1,4 @@
-module github.com/bxcodec/goqu
+module github.com/bxcodec/goqueue
 
 go 1.20
 

headers/key/const.go

@@ -1,12 +1,12 @@
 package key
 
 const (
-	AppID              = "goqu-app-id"
-	PublishedTimestamp = "goqu-published-timestamp"
-	RequeuedTimestamp  = "goqu-requeued-timestamp"
-	RetryCount         = "goqu-retry-count"
-	SchemaVer          = "goqu-schema-version"
-	ContentType        = "goqu-content-type"
-	QueueServiceAgent  = "goqu-queue-service-agent"
-	MessageID          = "goqu-message-id"
+	AppID              = "goqueue-app-id"
+	PublishedTimestamp = "goqueue-published-timestamp"
+	RequeuedTimestamp  = "goqueue-requeued-timestamp"
+	RetryCount         = "goqueue-retry-count"
+	SchemaVer          = "goqueue-schema-version"
+	ContentType        = "goqueue-content-type"
+	QueueServiceAgent  = "goqueue-queue-service-agent"
+	MessageID          = "goqueue-message-id"
 )

message.go

@@ -1,9 +1,9 @@
-package goqu
+package goqueue
 
 import (
 	"time"
 
-	headerVal "github.com/bxcodec/goqu/headers/value"
+	headerVal "github.com/bxcodec/goqueue/headers/value"
 )
 
 // Message represents a message that will be published to the queue

middleware/middleware.go

@@ -3,15 +3,15 @@ package middleware
 import (
 	"context"
 
-	"github.com/bxcodec/goqu"
+	"github.com/bxcodec/goqueue"
 	"github.com/sirupsen/logrus"
 )
 
 // ApplyHandlerMiddleware applies a series of middleware functions to an inbound message handler function.
 // It takes an inbound message handler function `h` and a variadic list of middleware functions `middleware`.
 // Each middleware function is applied to the handler function in the order they are provided.
 // The resulting handler function with all the middleware applied is returned.
-func ApplyHandlerMiddleware(h goqu.InboundMessageHandlerFunc, middleware ...goqu.InboundMessageHandlerMiddlewareFunc) goqu.InboundMessageHandlerFunc {
+func ApplyHandlerMiddleware(h goqueue.InboundMessageHandlerFunc, middleware ...goqueue.InboundMessageHandlerMiddlewareFunc) goqueue.InboundMessageHandlerFunc {
 	for _, middleware := range middleware {
 		h = middleware(h)
 	}
@@ -21,7 +21,7 @@ func ApplyHandlerMiddleware(h goqu.InboundMessageHandlerFunc, middleware ...goqu
 // ApplyPublisherMiddleware applies the given publisher middleware functions to the provided publisher function.
 // It iterates over the middleware functions and applies them in the order they are provided.
 // The resulting publisher function is returned.
-func ApplyPublisherMiddleware(p goqu.PublisherFunc, middleware ...goqu.PublisherMiddlewareFunc) goqu.PublisherFunc {
+func ApplyPublisherMiddleware(p goqueue.PublisherFunc, middleware ...goqueue.PublisherMiddlewareFunc) goqueue.PublisherFunc {
 	for _, middleware := range middleware {
 		p = middleware(p)
 	}
@@ -32,9 +32,9 @@ func ApplyPublisherMiddleware(p goqu.PublisherFunc, middleware ...goqu.Publisher
 // It wraps the provided `next` inbound message handler function and executes some additional logic after it.
 // The additional logic includes logging any error that occurred during the execution of the `next` function
 // and logging a message indicating that the middleware has been executed.
-func HelloWorldMiddlewareExecuteAfterHandler() goqu.InboundMessageHandlerMiddlewareFunc {
-	return func(next goqu.InboundMessageHandlerFunc) goqu.InboundMessageHandlerFunc {
-		return func(ctx context.Context, m goqu.InboundMessage) (err error) {
+func HelloWorldMiddlewareExecuteAfterHandler() goqueue.InboundMessageHandlerMiddlewareFunc {
+	return func(next goqueue.InboundMessageHandlerFunc) goqueue.InboundMessageHandlerFunc {
+		return func(ctx context.Context, m goqueue.InboundMessage) (err error) {
 			err = next(ctx, m)
 			if err != nil {
 				logrus.Error("Error: ", err, "processing to sent the error to Sentry")
@@ -46,9 +46,9 @@ func HelloWorldMiddlewareExecuteAfterHandler() goqu.InboundMessageHandlerMiddlew
 }
 
 // HelloWorldMiddlewareExecuteBeforeHandler returns a middleware function that logs a message before executing the handler.
-func HelloWorldMiddlewareExecuteBeforeHandler() goqu.InboundMessageHandlerMiddlewareFunc {
-	return func(next goqu.InboundMessageHandlerFunc) goqu.InboundMessageHandlerFunc {
-		return func(ctx context.Context, m goqu.InboundMessage) (err error) {
+func HelloWorldMiddlewareExecuteBeforeHandler() goqueue.InboundMessageHandlerMiddlewareFunc {
+	return func(next goqueue.InboundMessageHandlerFunc) goqueue.InboundMessageHandlerFunc {
+		return func(ctx context.Context, m goqueue.InboundMessage) (err error) {
 			logrus.Info("hello-world-first-middleware executed")
 			return next(ctx, m)
 		}
@@ -57,9 +57,9 @@ func HelloWorldMiddlewareExecuteBeforeHandler() goqu.InboundMessageHandlerMiddle
 
 // HelloWorldMiddlewareExecuteAfterPublisher returns a PublisherMiddlewareFunc that executes after the publisher function.
 // It logs any error that occurs during publishing and logs a message indicating that the last middleware has been executed.
-func HelloWorldMiddlewareExecuteAfterPublisher() goqu.PublisherMiddlewareFunc {
-	return func(next goqu.PublisherFunc) goqu.PublisherFunc {
-		return func(ctx context.Context, m goqu.Message) (err error) {
+func HelloWorldMiddlewareExecuteAfterPublisher() goqueue.PublisherMiddlewareFunc {
+	return func(next goqueue.PublisherFunc) goqueue.PublisherFunc {
+		return func(ctx context.Context, m goqueue.Message) (err error) {
 			err = next(ctx, m)
 			if err != nil {
 				logrus.Error("got error while publishing the message: ", err)
@@ -73,9 +73,9 @@ func HelloWorldMiddlewareExecuteAfterPublisher() goqu.PublisherMiddlewareFunc {
 
 // HelloWorldMiddlewareExecuteBeforePublisher is a function that returns a PublisherMiddlewareFunc.
 // It wraps the provided PublisherFunc with a middleware that logs a message before executing the next function.
-func HelloWorldMiddlewareExecuteBeforePublisher() goqu.PublisherMiddlewareFunc {
-	return func(next goqu.PublisherFunc) goqu.PublisherFunc {
-		return func(ctx context.Context, e goqu.Message) (err error) {
+func HelloWorldMiddlewareExecuteBeforePublisher() goqueue.PublisherMiddlewareFunc {
+	return func(next goqueue.PublisherFunc) goqueue.PublisherFunc {
+		return func(ctx context.Context, e goqueue.Message) (err error) {
 			logrus.Info("hello-world-first-middleware executed")
 			return next(ctx, e)
 		}