api.go

@@ -3,48 +3,56 @@ package laniakea
 import (
 	"bytes"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"net/http"
 	"strings"
 )
 
-type ApiResponse struct {
+type ApiResponse[R any] struct {
 	Ok          bool   `json:"ok"`
 	Description string `json:"description,omitempty"`
-	Result      any    `json:"result,omitempty"`
+	Result      R      `json:"result,omitempty"`
 	ErrorCode   int    `json:"error_code,omitempty"`
 }
 
-// request is a low-level call to api.
-func (b *Bot) request(methodName string, params any) (map[string]any, error) {
+type TelegramRequest[R, P any] struct {
+	method string
+	params P
+}
+
+func NewRequest[R, P any](method string, params P) TelegramRequest[R, P] {
+	return TelegramRequest[R, P]{method: method, params: params}
+}
+func (r TelegramRequest[R, P]) Do(bot *Bot) (*R, error) {
 	var buf bytes.Buffer
-	err := json.NewEncoder(&buf).Encode(params)
+	err := json.NewEncoder(&buf).Encode(r.params)
 	if err != nil {
 		return nil, err
 	}
 
-	if b.debug && b.requestLogger != nil {
-		b.requestLogger.Debugln(strings.ReplaceAll(fmt.Sprintf(
+	if bot.requestLogger != nil {
+		bot.requestLogger.Debugln(strings.ReplaceAll(fmt.Sprintf(
 			"POST https://api.telegram.org/bot%s/%s %s",
-			"<TOKEN>",
-			methodName,
-			buf.String(),
+			"<TOKEN>", r.method, buf.String(),
 		), "\n", ""))
 	}
-	r, err := http.Post(fmt.Sprintf("https://api.telegram.org/bot%s/%s", b.token, methodName), "application/json", &buf)
-	if err != nil {
-		return nil, err
-	}
-	defer r.Body.Close()
-	data, err := io.ReadAll(r.Body)
-	if err != nil {
-		return nil, err
-	}
-	b.requestLogger.Debugln(fmt.Sprintf("RES %s %s", methodName, string(data)))
 
-	response := new(ApiResponse)
+	req, err := http.Post(fmt.Sprintf("https://api.telegram.org/bot%s/%s", bot.token, r.method), "application/json", &buf)
+	if err != nil {
+		return nil, err
+	}
+	defer req.Body.Close()
+	data, err := io.ReadAll(req.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	if bot.requestLogger != nil {
+		bot.requestLogger.Debugln(fmt.Sprintf("RES %s %s", r.method, string(data)))
+	}
+
+	response := new(ApiResponse[R])
 	err = json.Unmarshal(data, &response)
 	if err != nil {
 		return nil, err
@@ -53,16 +61,5 @@ func (b *Bot) request(methodName string, params any) (map[string]any, error) {
 	if !response.Ok {
 		return nil, fmt.Errorf("[%d] %s", response.ErrorCode, response.Description)
 	}
-	if res, ok := response.Result.(bool); ok {
-		return map[string]any{
-			"data": res,
-		}, nil
-	} else if res, ok := response.Result.([]any); ok {
-		return map[string]any{
-			"data": res,
-		}, nil
-	} else if res, ok := response.Result.(map[string]any); ok {
-		return res, nil
-	}
-	return map[string]any{}, errors.New("can't parse response")
+	return &response.Result, nil
 }

bot.go

@@ -1,7 +1,6 @@
 package laniakea
 
 import (
-	"encoding/json"
 	"fmt"
 	"log"
 	"os"
@@ -180,19 +179,20 @@ func (b *Bot) AddPlugins(plugin ...*Plugin) *Bot {
 	return b
 }
 func (b *Bot) AddMiddleware(middleware ...*Middleware) *Bot {
-	sort.Slice(middleware, func(a, b int) bool {
-		first := middleware[a]
-		second := middleware[b]
-		if first.Order == second.Order {
-			return first.Name < second.Name
-		}
-		return middleware[a].Order < middleware[b].Order
-	})
-
 	b.middlewares = append(b.middlewares, middleware...)
 	for _, m := range middleware {
 		b.logger.Debugln(fmt.Sprintf("middleware with name \"%s\" registered", m.Name))
 	}
+
+	sort.Slice(&b.middlewares, func(i, j int) bool {
+		first := b.middlewares[i]
+		second := b.middlewares[j]
+		if first.Order == second.Order {
+			return first.Name < second.Name
+		}
+		return first.Order < second.Order
+	})
+
 	return b
 }
 func (b *Bot) AddRunner(runner Runner) *Bot {
@@ -243,6 +243,7 @@ func (b *Bot) Run() {
 			b.logger.Errorln("update is nil")
 			continue
 		}
+
 		ctx := &MsgContext{
 			Bot: b, Update: u,
 		}
@@ -263,78 +264,3 @@ func (b *Bot) Run() {
 		}
 	}
 }
-
-// {"callback_query":{"chat_instance":"6202057960757700762","data":"aboba","from":{"first_name":"scuroneko","id":314834933,"is_bot":false,"language_code":"ru","username":"scuroneko"},"id":"1352205741990111553","message":{"chat":{"first_name":"scuroneko","id":314834933,"type":"private","username":"scuroneko"},"date":1734338107,"from":{"first_name":"Kurumi","id":7718900880,"is_bot":true,"username":"kurumi_game_bot"},"message_id":19,"reply_markup":{"inline_keyboard":[[{"callback_data":"aboba","text":"Test"},{"callback_data":"another","text":"Another"}]]},"text":"Aboba"}},"update_id":350979488}
-
-func (b *Bot) handleMessage(update *Update, ctx *MsgContext) {
-	if update.Message == nil {
-		return
-	}
-
-	var text string
-	if len(update.Message.Text) > 0 {
-		text = update.Message.Text
-	} else {
-		text = update.Message.Caption
-	}
-
-	text = strings.TrimSpace(text)
-	prefix, hasPrefix := b.checkPrefixes(text)
-	if !hasPrefix {
-		return
-	}
-	ctx.Prefix = prefix
-	ctx.FromID = update.Message.From.ID
-	ctx.From = update.Message.From
-	ctx.Msg = update.Message
-
-	text = strings.TrimSpace(text[len(prefix):])
-
-	for _, plugin := range b.plugins {
-		// Check every command
-		for cmd := range plugin.Commands {
-			if !strings.HasPrefix(text, cmd) {
-				continue
-			}
-
-			ctx.Text = strings.TrimSpace(text[len(cmd):])
-			ctx.Args = strings.Split(ctx.Text, " ")
-
-			go plugin.Execute(cmd, ctx, b.dbContext)
-			return
-		}
-	}
-}
-
-func (b *Bot) handleCallback(update *Update, ctx *MsgContext) {
-	data := new(CallbackData)
-	err := json.Unmarshal([]byte(update.CallbackQuery.Data), data)
-	if err != nil {
-		b.logger.Errorln(err)
-		return
-	}
-
-	ctx.FromID = update.CallbackQuery.From.ID
-	ctx.From = update.CallbackQuery.From
-	ctx.Msg = update.CallbackQuery.Message
-	ctx.CallbackMsgId = update.CallbackQuery.Message.MessageID
-	ctx.Args = data.Args
-
-	for _, plugin := range b.plugins {
-		_, ok := plugin.Payloads[data.Command]
-		if !ok {
-			continue
-		}
-		go plugin.ExecutePayload(data.Command, ctx, b.dbContext)
-		return
-	}
-}
-
-func (b *Bot) checkPrefixes(text string) (string, bool) {
-	for _, prefix := range b.prefixes {
-		if strings.HasPrefix(text, prefix) {
-			return prefix, true
-		}
-	}
-	return "", false
-}

handler.go

@@ -0,0 +1,79 @@
+package laniakea
+
+import (
+	"encoding/json"
+	"strings"
+)
+
+func (b *Bot) handleMessage(update *Update, ctx *MsgContext) {
+	if update.Message == nil {
+		return
+	}
+
+	var text string
+	if len(update.Message.Text) > 0 {
+		text = update.Message.Text
+	} else {
+		text = update.Message.Caption
+	}
+
+	text = strings.TrimSpace(text)
+	prefix, hasPrefix := b.checkPrefixes(text)
+	if !hasPrefix {
+		return
+	}
+	ctx.Prefix = prefix
+	ctx.FromID = update.Message.From.ID
+	ctx.From = update.Message.From
+	ctx.Msg = update.Message
+
+	text = strings.TrimSpace(text[len(prefix):])
+
+	for _, plugin := range b.plugins {
+		// Check every command
+		for cmd := range plugin.Commands {
+			if !strings.HasPrefix(text, cmd) {
+				continue
+			}
+
+			ctx.Text = strings.TrimSpace(text[len(cmd):])
+			ctx.Args = strings.Split(ctx.Text, " ")
+
+			go plugin.Execute(cmd, ctx, b.dbContext)
+			return
+		}
+	}
+}
+
+func (b *Bot) handleCallback(update *Update, ctx *MsgContext) {
+	data := new(CallbackData)
+	err := json.Unmarshal([]byte(update.CallbackQuery.Data), data)
+	if err != nil {
+		b.logger.Errorln(err)
+		return
+	}
+
+	ctx.FromID = update.CallbackQuery.From.ID
+	ctx.From = update.CallbackQuery.From
+	ctx.Msg = update.CallbackQuery.Message
+	ctx.CallbackMsgId = update.CallbackQuery.Message.MessageID
+	ctx.Args = data.Args
+
+	for _, plugin := range b.plugins {
+		_, ok := plugin.Payloads[data.Command]
+		if !ok {
+			continue
+		}
+		go plugin.ExecutePayload(data.Command, ctx, b.dbContext)
+		return
+	}
+}
+
+func (b *Bot) checkPrefixes(text string) (string, bool) {
+	for _, prefix := range b.prefixes {
+		if strings.HasPrefix(text, prefix) {
+			return prefix, true
+		}
+	}
+	return "", false
+}

methods.go

@@ -5,31 +5,36 @@ import (
 	"fmt"
 )
 
-var NoParams = make(map[string]any)
+type EmptyParams struct{}
+
+var NoParams = EmptyParams{}
+
+type UpdateParams struct {
+	Offset         int      `json:"offset"`
+	Timeout        int      `json:"timeout"`
+	AllowedUpdates []string `json:"allowed_updates"`
+}
 
 func (b *Bot) Updates() ([]*Update, error) {
-	params := make(map[string]any)
-	params["offset"] = b.updateOffset
-	params["timeout"] = 30
-	params["allowed_updates"] = b.updateTypes
-
-	data, err := b.request("getUpdates", params)
-	if err != nil {
-		return nil, err
-	}
-	res := make([]*Update, 0)
-	err = AnyToStruct(data["data"], &res)
-	if err != nil {
-		return res, err
+	params := UpdateParams{
+		Offset:         b.updateOffset,
+		Timeout:        30,
+		AllowedUpdates: b.updateTypes,
 	}
 
-	for _, u := range res {
+	req := NewRequest[[]*Update]("getUpdates", params)
+	res, err := req.Do(b)
+	if err != nil {
+		return []*Update{}, err
+	}
+	updates := *res
+
+	for _, u := range updates {
 		b.updateOffset = u.UpdateID + 1
 		err = b.updateQueue.Enqueue(u)
 		if err != nil {
-			return res, err
+			return updates, err
 		}
-		res = append(res, u)
 
 		if b.debug && b.requestLogger != nil {
 			j, err := json.Marshal(u)
@@ -39,17 +44,12 @@ func (b *Bot) Updates() ([]*Update, error) {
 			b.requestLogger.Debugln(fmt.Sprintf("UPDATE %s", j))
 		}
 	}
-	return res, err
+	return updates, err
 }
 
 func (b *Bot) GetMe() (*User, error) {
-	data, err := b.request("getMe", NoParams)
-	if err != nil {
-		return nil, err
-	}
-	user := new(User)
-	err = MapToStruct(data, user)
-	return user, err
+	req := NewRequest[User, EmptyParams]("getMe", NoParams)
+	return req.Do(b)
 }
 
 type SendMessageP struct {
@@ -69,13 +69,8 @@ type SendMessageP struct {
 }
 
 func (b *Bot) SendMessage(params *SendMessageP) (*Message, error) {
-	data, err := b.request("sendMessage", params)
-	if err != nil {
-		return nil, err
-	}
-	message := new(Message)
-	err = MapToStruct(data, message)
-	return message, err
+	req := NewRequest[Message, SendMessageP]("sendMessage", *params)
+	return req.Do(b)
 }
 
 type SendPhotoP struct {
@@ -96,13 +91,8 @@ type SendPhotoP struct {
 }
 
 func (b *Bot) SendPhoto(params *SendPhotoP) (*Message, error) {
-	data, err := b.request("sendPhoto", params)
-	if err != nil {
-		return nil, err
-	}
-	message := new(Message)
-	err = MapToStruct(data, message)
-	return message, err
+	req := NewRequest[Message]("sendPhoto", params)
+	return req.Do(b)
 }
 
 type EditMessageTextP struct {
@@ -116,13 +106,8 @@ type EditMessageTextP struct {
 }
 
 func (b *Bot) EditMessageText(params *EditMessageTextP) (*Message, error) {
-	data, err := b.request("editMessageText", params)
-	if err != nil {
-		return nil, err
-	}
-	message := new(Message)
-	err = MapToStruct(data, message)
-	return message, err
+	req := NewRequest[Message]("editMessageText", params)
+	return req.Do(b)
 }
 
 type EditMessageCaptionP struct {
@@ -136,13 +121,8 @@ type EditMessageCaptionP struct {
 }
 
 func (b *Bot) EditMessageCaption(params *EditMessageCaptionP) (*Message, error) {
-	data, err := b.request("editMessageCaption", params)
-	if err != nil {
-		return nil, err
-	}
-	message := new(Message)
-	err = MapToStruct(data, message)
-	return message, err
+	req := NewRequest[Message]("editMessageCaption", params)
+	return req.Do(b)
 }
 
 type DeleteMessageP struct {
@@ -151,11 +131,6 @@ type DeleteMessageP struct {
 }
 
 func (b *Bot) DeleteMessage(params *DeleteMessageP) (*Message, error) {
-	data, err := b.request("deleteMessage", params)
-	if err != nil {
-		return nil, err
-	}
-	message := new(Message)
-	err = MapToStruct(data, message)
-	return message, err
+	req := NewRequest[Message]("deleteMessage", params)
+	return req.Do(b)
 }

queue.go

@@ -5,7 +5,7 @@ import (
 	"sync"
 )
 
-var QueueFullErr = errors.New("queue is full")
+var QueueFullErr = errors.New("queue full")
 
 type Queue[T any] struct {
 	size  uint64

runners.go

@@ -61,10 +61,15 @@ func (b *Bot) ExecRunners() {
 				}
 			}()
 		} else if !runner.Async && runner.Onetime {
+			t := time.Now()
 			err := runner.Fn(b)
 			if err != nil {
 				b.logger.Warnf("Runner %s failed: %s\n", runner.Name, err)
 			}
+			elapsed := time.Since(t)
+			if elapsed > time.Second*2 {
+				b.logger.Warnf("Runner %s too slow. Elapsed time %s>=2s", runner.Name, elapsed)
+			}
 		} else if !runner.Onetime {
 			go func() {
 				for {

version.go

@@ -1,8 +1,8 @@
 package laniakea
 
 const (
-	VersionString = "0.3.0"
+	VersionString = "0.3.2"
 	VersionMajor  = 0
 	VersionMinor  = 3
-	VersionPatch  = 0
+	VersionPatch  = 2
 )