runners and some fixes

.gitignore

@@ -1 +1,2 @@
 .idea/
+test/

api.go

@@ -0,0 +1,68 @@
+package laniakea
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+)
+
+type ApiResponse struct {
+	Ok          bool   `json:"ok"`
+	Description string `json:"description,omitempty"`
+	Result      any    `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) {
+	var buf bytes.Buffer
+	err := json.NewEncoder(&buf).Encode(params)
+	if err != nil {
+		return nil, err
+	}
+
+	if b.debug && b.requestLogger != nil {
+		b.requestLogger.Debugln(strings.ReplaceAll(fmt.Sprintf(
+			"POST https://api.telegram.org/bot%s/%s %s",
+			"<TOKEN>",
+			methodName,
+			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)
+	err = json.Unmarshal(data, &response)
+	if err != nil {
+		return nil, err
+	}
+
+	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")
+}

bot.go

@@ -1,17 +1,15 @@
 package laniakea
 
 import (
-	"bytes"
 	"encoding/json"
 	"fmt"
-	"io"
 	"log"
-	"net/http"
 	"os"
 	"sort"
 	"strings"
 	"time"
 
+	"git.nix13.pw/scuroneko/slog"
 	"github.com/redis/go-redis/v9"
 	"github.com/vinovest/sqlx"
 	"go.mongodb.org/mongo-driver/v2/mongo"
@@ -30,12 +28,13 @@ type Bot struct {
 	debug         bool
 	errorTemplate string
 
-	logger        *Logger
-	requestLogger *Logger
+	logger        *slog.Logger
+	requestLogger *slog.Logger
 
 	plugins     []*Plugin
 	middlewares []*Middleware
 	prefixes    []string
+	runners     []Runner
 
 	dbContext *DatabaseContext
 
@@ -67,29 +66,18 @@ func LoadSettingsFromEnv() *BotSettings {
 	}
 }
 
-type MsgContext struct {
-	Bot           *Bot
-	Msg           *Message
-	Update        *Update
-	From          *User
-	CallbackMsgId int
-	FromID        int
-	Prefix        string
-	Text          string
-	Args          []string
+func LoadPrefixesFromEnv() []string {
+	prefixesS, exists := os.LookupEnv("PREFIXES")
+	if !exists {
+		return []string{"!"}
+	}
+	return strings.Split(prefixesS, ";")
 }
-
-type DatabaseContext struct {
-	PostgresSQL *sqlx.DB
-	MongoDB     *mongo.Client
-	Redis       *redis.Client
-}
-
 func NewBot(settings *BotSettings) *Bot {
 	updateQueue := CreateQueue[*Update](256)
 	bot := &Bot{
 		updateOffset: 0, plugins: make([]*Plugin, 0), debug: settings.Debug, errorTemplate: "%s",
-		prefixes: settings.Prefixes, updateTypes: make([]string, 0),
+		prefixes: settings.Prefixes, updateTypes: make([]string, 0), runners: make([]Runner, 0),
 		updateQueue: updateQueue,
 		token:       settings.Token,
 	}
@@ -97,16 +85,16 @@ func NewBot(settings *BotSettings) *Bot {
 	if len(settings.ErrorTemplate) > 0 {
 		bot.errorTemplate = settings.ErrorTemplate
 	}
-
 	if len(settings.LoggerBasePath) == 0 {
 		settings.LoggerBasePath = "./"
 	}
-	level := FATAL
+
+	level := slog.FATAL
 	if settings.Debug {
-		level = DEBUG
+		level = slog.DEBUG
 	}
 
-	bot.logger = CreateLogger().Level(level)
+	bot.logger = slog.CreateLogger().Level(level).Prefix("BOT")
 	bot.logger.AddWriter(bot.logger.CreateJsonStdoutWriter())
 	if settings.WriteToFile {
 		path := fmt.Sprintf("%s/main.log", strings.TrimRight(settings.LoggerBasePath, "/"))
@@ -118,7 +106,7 @@ func NewBot(settings *BotSettings) *Bot {
 	}
 
 	if settings.UseRequestLogger {
-		bot.requestLogger = CreateLogger().Level(level).Prefix("REQUESTS")
+		bot.requestLogger = slog.CreateLogger().Level(level).Prefix("REQUESTS")
 		bot.requestLogger.AddWriter(bot.requestLogger.CreateJsonStdoutWriter())
 		if settings.WriteToFile {
 			path := fmt.Sprintf("%s/requests.log", strings.TrimRight(settings.LoggerBasePath, "/"))
@@ -134,19 +122,23 @@ func NewBot(settings *BotSettings) *Bot {
 }
 
 func (b *Bot) Close() {
-	for _, writer := range b.logger.writers {
-		err := writer.Close()
-		if err != nil {
-			log.Println(err)
-		}
+	err := b.logger.Close()
+	if err != nil {
+		log.Println(err)
+	}
+	err = b.requestLogger.Close()
+	if err != nil {
+		log.Println(err)
 	}
 }
 
-func (b *Bot) InitDatabaseContext(ctx *DatabaseContext) *Bot {
-	b.dbContext = ctx
-	return b
+type DatabaseContext struct {
+	PostgresSQL *sqlx.DB
+	MongoDB     *mongo.Client
+	Redis       *redis.Client
 }
-func (b *Bot) AddDatabaseLogger(writer func(db *DatabaseContext) LoggerWriter) *Bot {
+
+func (b *Bot) AddDatabaseLogger(writer func(db *DatabaseContext) slog.LoggerWriter) *Bot {
 	w := writer(b.dbContext)
 	b.logger.AddWriter(w)
 	if b.requestLogger != nil {
@@ -155,6 +147,10 @@ func (b *Bot) AddDatabaseLogger(writer func(db *DatabaseContext) LoggerWriter) *
 	return b
 }
 
+func (b *Bot) DatabaseContext(ctx *DatabaseContext) *Bot {
+	b.dbContext = ctx
+	return b
+}
 func (b *Bot) UpdateTypes(t ...string) *Bot {
 	b.updateTypes = make([]string, 0)
 	b.updateTypes = append(b.updateTypes, t...)
@@ -164,38 +160,25 @@ func (b *Bot) AddUpdateType(t ...string) *Bot {
 	b.updateTypes = append(b.updateTypes, t...)
 	return b
 }
-
 func (b *Bot) AddPrefixes(prefixes ...string) *Bot {
 	b.prefixes = append(b.prefixes, prefixes...)
 	return b
 }
-
-func LoadPrefixesFromEnv() []string {
-	prefixesS, exists := os.LookupEnv("PREFIXES")
-	if !exists {
-		return []string{"!"}
-	}
-	return strings.Split(prefixesS, ";")
-}
-
 func (b *Bot) ErrorTemplate(s string) *Bot {
 	b.errorTemplate = s
 	return b
 }
-
 func (b *Bot) Debug(debug bool) *Bot {
 	b.debug = debug
 	return b
 }
-
 func (b *Bot) AddPlugins(plugin ...*Plugin) *Bot {
 	b.plugins = append(b.plugins, plugin...)
 	for _, p := range plugin {
-		b.logger.Debug(fmt.Sprintf("plugins with name \"%s\" registered", p.Name))
+		b.logger.Debugln(fmt.Sprintf("plugins with name \"%s\" registered", p.Name))
 	}
 	return b
 }
-
 func (b *Bot) AddMiddleware(middleware ...*Middleware) *Bot {
 	sort.Slice(middleware, func(a, b int) bool {
 		first := middleware[a]
@@ -208,31 +191,43 @@ func (b *Bot) AddMiddleware(middleware ...*Middleware) *Bot {
 
 	b.middlewares = append(b.middlewares, middleware...)
 	for _, m := range middleware {
-		b.logger.Debug(fmt.Sprintf("middleware with name \"%s\" registered", m.Name))
+		b.logger.Debugln(fmt.Sprintf("middleware with name \"%s\" registered", m.Name))
 	}
 	return b
 }
+func (b *Bot) AddRunner(runner Runner) *Bot {
+	b.runners = append(b.runners, runner)
+	b.logger.Debugln(fmt.Sprintf("runner with name \"%s\" registered", runner.Name))
+	return b
+}
+func (b *Bot) Logger() *slog.Logger {
+	return b.logger
+}
+func (b *Bot) GetDBContext() *DatabaseContext {
+	return b.dbContext
+}
 
 func (b *Bot) Run() {
 	if len(b.prefixes) == 0 {
-		b.logger.Fatal("no prefixes defined")
+		b.logger.Fatalln("no prefixes defined")
 		return
 	}
 
 	if len(b.plugins) == 0 {
-		b.logger.Fatal("no plugins defined")
+		b.logger.Fatalln("no plugins defined")
 		return
 	}
 
-	b.logger.Info("Bot running. Press CTRL+C to exit.")
+	b.logger.Infoln("Executing runners...")
+	b.ExecRunners()
 
+	b.logger.Infoln("Bot running. Press CTRL+C to exit.")
 	go func() {
 		for {
 			_, err := b.Updates()
 			if err != nil {
-				b.logger.Error(err)
+				b.logger.Errorln(err)
 			}
-			time.Sleep(time.Millisecond * 10)
 		}
 	}()
 
@@ -245,12 +240,11 @@ func (b *Bot) Run() {
 
 		u := queue.Dequeue()
 		if u == nil {
-			b.logger.Error("update is nil")
+			b.logger.Errorln("update is nil")
 			continue
 		}
 		ctx := &MsgContext{
-			Bot:    b,
-			Update: u,
+			Bot: b, Update: u,
 		}
 		for _, middleware := range b.middlewares {
 			middleware.Execute(ctx, b.dbContext)
@@ -273,25 +267,26 @@ 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) {
-	var text string
 	if update.Message == nil {
 		return
 	}
+
+	var text string
 	if len(update.Message.Text) > 0 {
 		text = update.Message.Text
 	} else {
 		text = update.Message.Caption
 	}
 
-	ctx.FromID = update.Message.From.ID
-	ctx.From = update.Message.From
-	ctx.Msg = update.Message
 	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):])
 
@@ -306,6 +301,7 @@ func (b *Bot) handleMessage(update *Update, ctx *MsgContext) {
 			ctx.Args = strings.Split(ctx.Text, " ")
 
 			go plugin.Execute(cmd, ctx, b.dbContext)
+			return
 		}
 	}
 }
@@ -314,7 +310,7 @@ func (b *Bot) handleCallback(update *Update, ctx *MsgContext) {
 	data := new(CallbackData)
 	err := json.Unmarshal([]byte(update.CallbackQuery.Data), data)
 	if err != nil {
-		b.logger.Error(err)
+		b.logger.Errorln(err)
 		return
 	}
 
@@ -330,7 +326,7 @@ func (b *Bot) handleCallback(update *Update, ctx *MsgContext) {
 			continue
 		}
 		go plugin.ExecutePayload(data.Command, ctx, b.dbContext)
-		break
+		return
 	}
 }
 
@@ -342,219 +338,3 @@ func (b *Bot) checkPrefixes(text string) (string, bool) {
 	}
 	return "", false
 }
-
-type AnswerMessage struct {
-	MessageID int
-	Text      string
-	IsMedia   bool
-	Keyboard  *InlineKeyboard
-	ctx       *MsgContext
-}
-
-func (ctx *MsgContext) edit(messageId int, text string, keyboard *InlineKeyboard) *AnswerMessage {
-	params := &EditMessageTextP{
-		MessageID: messageId,
-		ChatID:    ctx.Msg.Chat.ID,
-		Text:      text,
-		ParseMode: ParseMD,
-	}
-	if keyboard != nil {
-		params.ReplyMarkup = keyboard.Get()
-	}
-	msg, err := ctx.Bot.EditMessageText(params)
-	if err != nil {
-		ctx.Bot.logger.Error(err)
-		return nil
-	}
-	return &AnswerMessage{
-		MessageID: msg.MessageID, ctx: ctx, Text: text, IsMedia: false,
-	}
-}
-func (m *AnswerMessage) Edit(text string) *AnswerMessage {
-	return m.ctx.edit(m.MessageID, text, nil)
-}
-func (ctx *MsgContext) EditCallback(text string, keyboard *InlineKeyboard) *AnswerMessage {
-	if ctx.CallbackMsgId == 0 {
-		ctx.Bot.logger.Error("Can't edit non-callback update message")
-		return nil
-	}
-
-	return ctx.edit(ctx.CallbackMsgId, text, keyboard)
-}
-func (ctx *MsgContext) EditCallbackf(format string, keyboard *InlineKeyboard, args ...any) *AnswerMessage {
-	return ctx.EditCallback(fmt.Sprintf(format, args...), keyboard)
-}
-
-func (ctx *MsgContext) editPhotoText(messageId int, text string, kb *InlineKeyboard) *AnswerMessage {
-	params := &EditMessageCaptionP{
-		ChatID:    ctx.Msg.Chat.ID,
-		MessageID: messageId,
-		Caption:   text,
-		ParseMode: ParseMD,
-	}
-	if kb != nil {
-		params.ReplyMarkup = kb.Get()
-	}
-	msg, err := ctx.Bot.EditMessageCaption(params)
-	if err != nil {
-		ctx.Bot.logger.Error(err)
-	}
-	return &AnswerMessage{
-		MessageID: msg.MessageID, ctx: ctx, Text: text, IsMedia: true,
-	}
-}
-func (m *AnswerMessage) EditCaption(text string) *AnswerMessage {
-	return m.ctx.editPhotoText(m.MessageID, text, nil)
-}
-func (m *AnswerMessage) EditCaptionKeyboard(text string, kb *InlineKeyboard) *AnswerMessage {
-	return m.ctx.editPhotoText(m.MessageID, text, kb)
-}
-
-func (ctx *MsgContext) answer(text string, keyboard *InlineKeyboard) *AnswerMessage {
-	params := &SendMessageP{
-		ChatID:    ctx.Msg.Chat.ID,
-		Text:      text,
-		ParseMode: ParseMD,
-	}
-	if keyboard != nil {
-		params.ReplyMarkup = keyboard.Get()
-	}
-
-	msg, err := ctx.Bot.SendMessage(params)
-	if err != nil {
-		ctx.Bot.logger.Error(err)
-		return nil
-	}
-	return &AnswerMessage{
-		MessageID: msg.MessageID, ctx: ctx, IsMedia: false, Text: text,
-	}
-}
-func (ctx *MsgContext) Answer(text string) *AnswerMessage {
-	return ctx.answer(text, nil)
-}
-func (ctx *MsgContext) Answerf(template string, args ...any) *AnswerMessage {
-	return ctx.answer(fmt.Sprintf(template, args...), nil)
-}
-func (ctx *MsgContext) Keyboard(text string, kb *InlineKeyboard) *AnswerMessage {
-	return ctx.answer(text, kb)
-}
-
-func (ctx *MsgContext) answerPhoto(photoId, text string, kb *InlineKeyboard) *AnswerMessage {
-	params := &SendPhotoP{
-		ChatID:    ctx.Msg.Chat.ID,
-		Caption:   text,
-		Photo:     photoId,
-		ParseMode: ParseMD,
-	}
-	if kb != nil {
-		params.ReplyMarkup = kb.Get()
-	}
-	msg, err := ctx.Bot.SendPhoto(params)
-	if err != nil {
-		ctx.Bot.logger.Error(err)
-	}
-	return &AnswerMessage{
-		MessageID: msg.MessageID, ctx: ctx, Text: text, IsMedia: true,
-	}
-}
-func (ctx *MsgContext) AnswerPhoto(photoId, text string) *AnswerMessage {
-	return ctx.answerPhoto(photoId, text, nil)
-}
-func (ctx *MsgContext) AnswerPhotoKeyboard(photoId, text string, kb *InlineKeyboard) *AnswerMessage {
-	return ctx.answerPhoto(photoId, text, kb)
-}
-
-func (ctx *MsgContext) delete(messageId int) {
-	_, err := ctx.Bot.DeleteMessage(&DeleteMessageP{
-		ChatID:    ctx.Msg.Chat.ID,
-		MessageID: messageId,
-	})
-	if err != nil {
-		ctx.Bot.logger.Error(err)
-	}
-}
-func (m *AnswerMessage) Delete() {
-	m.ctx.delete(m.MessageID)
-}
-func (ctx *MsgContext) CallbackDelete() {
-	ctx.delete(ctx.CallbackMsgId)
-}
-
-func (ctx *MsgContext) Error(err error) {
-	_, sendErr := ctx.Bot.SendMessage(&SendMessageP{
-		ChatID: ctx.Msg.Chat.ID,
-		Text:   fmt.Sprintf(ctx.Bot.errorTemplate, EscapeMarkdown(err.Error())),
-	})
-	ctx.Bot.logger.Error(err)
-
-	if sendErr != nil {
-		ctx.Bot.logger.Error(sendErr)
-	}
-}
-
-func (b *Bot) Logger() *Logger {
-	return b.logger
-}
-
-type ApiResponse struct {
-	Ok          bool           `json:"ok"`
-	Result      map[string]any `json:"result,omitempty"`
-	Description string         `json:"description,omitempty"`
-	ErrorCode   int            `json:"error_code,omitempty"`
-}
-
-type ApiResponseA struct {
-	Ok          bool   `json:"ok"`
-	Result      []any  `json:"result,omitempty"`
-	Description string `json:"description,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]interface{}, error) {
-	var buf bytes.Buffer
-	err := json.NewEncoder(&buf).Encode(params)
-	if err != nil {
-		return nil, err
-	}
-
-	if b.debug && b.requestLogger != nil {
-		b.requestLogger.Debug(strings.ReplaceAll(fmt.Sprintf(
-			"POST https://api.telegram.org/bot%s/%s %s",
-			"<TOKEN>",
-			methodName,
-			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.Debug(fmt.Sprintf("RES %s %s", methodName, string(data)))
-	response := new(ApiResponse)
-
-	var result map[string]any
-
-	err = json.Unmarshal(data, &response)
-	if err != nil {
-		responseArray := new(ApiResponseA)
-		err = json.Unmarshal(data, responseArray)
-		if err != nil {
-			return nil, err
-		}
-		result = map[string]interface{}{
-			"data": responseArray.Result,
-		}
-	} else {
-		result = response.Result
-	}
-	if !response.Ok {
-		return nil, fmt.Errorf("[%d] %s", response.ErrorCode, response.Description)
-	}
-	return result, err
-}

go.mod

@@ -1,9 +1,9 @@
 module git.nix13.pw/scuroneko/laniakea
 
-go 1.25.6
+go 1.25
 
 require (
-	github.com/fatih/color v1.18.0
+	git.nix13.pw/scuroneko/slog v1.0.0
 	github.com/redis/go-redis/v9 v9.17.3
 	github.com/vinovest/sqlx v1.7.1
 	go.mongodb.org/mongo-driver/v2 v2.4.2
@@ -12,17 +12,18 @@ require (
 require (
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
+	github.com/fatih/color v1.18.0 // indirect
 	github.com/golang/snappy v1.0.0 // indirect
 	github.com/klauspost/compress v1.16.7 // indirect
-	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/muir/sqltoken v0.1.0 // indirect
 	github.com/xdg-go/pbkdf2 v1.0.0 // indirect
 	github.com/xdg-go/scram v1.1.2 // indirect
 	github.com/xdg-go/stringprep v1.0.4 // indirect
 	github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect
-	golang.org/x/crypto v0.33.0 // indirect
+	golang.org/x/crypto v0.45.0 // indirect
 	golang.org/x/sync v0.11.0 // indirect
-	golang.org/x/sys v0.30.0 // indirect
+	golang.org/x/sys v0.40.0 // indirect
 	golang.org/x/text v0.22.0 // indirect
 )

go.sum

@@ -1,5 +1,7 @@
 filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
 filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
+git.nix13.pw/scuroneko/slog v1.0.0 h1:PI0YePrmCopjrljUfwCtBIEwNYB+PBgDzPcCXbetpcE=
+git.nix13.pw/scuroneko/slog v1.0.0/go.mod h1:3Qm2wzkR5KjwOponMfG7TcGSDjmYaFqRAmLvSPTuWJI=
 github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
 github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
 github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
@@ -22,9 +24,8 @@ github.com/klauspost/compress v1.16.7 h1:2mk3MPGNzKyxErAw8YaohYh69+pa4sIQSC0fPGC
 github.com/klauspost/compress v1.16.7/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
 github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
 github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
-github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
-github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
+github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y=
@@ -67,10 +68,9 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
-golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ=
+golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=

logger.go

@@ -1,372 +0,0 @@
-package laniakea
-
-import (
-	"bufio"
-	"encoding/json"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"runtime"
-	"sort"
-	"strings"
-	"time"
-
-	"github.com/fatih/color"
-)
-
-type LoggerWriter interface {
-	Close() error
-	Write(p []byte) (n int, err error)
-	Print(level LogLevel, prefix string, traceback []*MethodTraceback, messages ...any) error
-}
-type LoggerTextWriter struct {
-	LoggerWriter
-	writer         io.Writer
-	printTraceback bool
-	printTime      bool
-}
-
-func (w *LoggerTextWriter) Write(p []byte) (n int, err error) {
-	n, err = w.writer.Write(p)
-	if err != nil {
-		return n, err
-	}
-	err = bufio.NewWriter(w.writer).Flush()
-	return n, err
-}
-func (w *LoggerTextWriter) Print(level LogLevel, prefix string, tb []*MethodTraceback, messages ...any) error {
-	s := buildString(level, prefix, true, w.printTraceback, w.printTime, messages...)
-	_, err := w.Write([]byte(s))
-	return err
-}
-func (w *LoggerTextWriter) Close() error {
-	return w.writer.(io.Closer).Close()
-}
-
-type LoggerJsonWriter struct {
-	LoggerWriter
-	writer io.Writer
-	pretty bool
-}
-type LoggerJsonMessage struct {
-	Time      time.Time          `json:"time"`
-	Level     string             `json:"level"`
-	Prefix    string             `json:"prefix"`
-	Message   string             `json:"message"`
-	Traceback []*MethodTraceback `json:"traceback"`
-}
-
-func (w *LoggerJsonWriter) Write(data []byte) (int, error) {
-	n, err := w.writer.Write(data)
-	if err != nil {
-		return n, err
-	}
-	err = bufio.NewWriter(w.writer).Flush()
-	return n, err
-}
-func (w *LoggerJsonWriter) Print(level LogLevel, prefix string, traceback []*MethodTraceback, messages ...any) error {
-	msg := Map(messages, func(el any) string {
-		return fmt.Sprintf("%v", el)
-	})
-	m := LoggerJsonMessage{
-		Time:      time.Now(),
-		Level:     level.GetName(),
-		Prefix:    prefix,
-		Message:   strings.Join(msg, " "),
-		Traceback: traceback,
-	}
-	var data []byte
-	var err error
-	if w.pretty {
-		data, err = json.MarshalIndent(m, "", "  ")
-	} else {
-		data, err = json.Marshal(m)
-	}
-	if err != nil {
-		return err
-	}
-	_, err = w.Write(append(data, []byte("\n")...))
-	return err
-}
-func (w *LoggerJsonWriter) Close() error {
-	return w.writer.(io.Closer).Close()
-}
-
-type Logger struct {
-	prefix         string
-	level          LogLevel
-	printTraceback bool
-	printTime      bool
-	jsonPretty     bool
-	writers        []LoggerWriter
-}
-
-type LogLevel struct {
-	n uint8
-	t string
-	c color.Attribute
-}
-
-func (l *LogLevel) GetName() string {
-	return l.t
-}
-
-type MethodTraceback struct {
-	Package   string `json:"package"`
-	Method    string `json:"method"`
-	fullPath  string
-	signature string
-	Filename  string `json:"filename"`
-	Line      int    `json:"line"`
-}
-
-var (
-	INFO  = LogLevel{n: 0, t: "info", c: color.FgWhite}
-	WARN  = LogLevel{n: 1, t: "warn", c: color.FgHiYellow}
-	ERROR = LogLevel{n: 2, t: "error", c: color.FgHiRed}
-	FATAL = LogLevel{n: 3, t: "fatal", c: color.FgRed}
-	DEBUG = LogLevel{n: 4, t: "debug", c: color.FgGreen}
-)
-
-func CreateLogger() *Logger {
-	return &Logger{
-		prefix:         "LOG",
-		level:          FATAL,
-		printTraceback: false,
-		printTime:      true,
-	}
-}
-
-func (l *Logger) CreateTextFileWriter(path string) (*LoggerTextWriter, error) {
-	err := os.MkdirAll(filepath.Dir(path), os.ModePerm)
-	if err != nil {
-		return nil, err
-	}
-	file, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
-	if err != nil {
-		return nil, err
-	}
-
-	writer := &LoggerTextWriter{
-		writer: file, printTraceback: l.printTraceback, printTime: l.printTime,
-	}
-	return writer, nil
-}
-func (l *Logger) CreateTextStdoutWriter() *LoggerTextWriter {
-	writer := &LoggerTextWriter{
-		writer: os.Stdout, printTraceback: l.printTraceback, printTime: l.printTime,
-	}
-	return writer
-}
-func (l *Logger) CreateJsonStdoutWriter() *LoggerJsonWriter {
-	writer := &LoggerJsonWriter{
-		writer: os.Stdout, pretty: l.jsonPretty,
-	}
-	return writer
-}
-func (l *Logger) CreateJsonFileWriter(path string) (*LoggerJsonWriter, error) {
-	err := os.MkdirAll(filepath.Dir(path), os.ModePerm)
-	if err != nil {
-		return nil, err
-	}
-	file, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
-	if err != nil {
-		return nil, err
-	}
-	writer := &LoggerJsonWriter{
-		writer: file, pretty: l.jsonPretty,
-	}
-	return writer, nil
-}
-func (l *Logger) CreateTextWriter(w io.Writer) *LoggerTextWriter {
-	writer := &LoggerTextWriter{
-		writer: w, printTraceback: l.printTraceback, printTime: l.printTime,
-	}
-	return writer
-}
-func (l *Logger) CreateJsonWriter(w io.Writer) *LoggerJsonWriter {
-	writer := &LoggerJsonWriter{
-		writer: w, pretty: l.jsonPretty,
-	}
-	return writer
-}
-
-func (l *Logger) Prefix(prefix string) *Logger {
-	l.prefix = prefix
-	return l
-}
-func (l *Logger) Level(level LogLevel) *Logger {
-	l.level = level
-	return l
-}
-func (l *Logger) PrintTraceback(b bool) *Logger {
-	l.printTraceback = b
-	return l
-}
-func (l *Logger) PrintTime(b bool) *Logger {
-	l.printTime = b
-	return l
-}
-func (l *Logger) JsonPretty(b bool) *Logger {
-	l.jsonPretty = b
-	return l
-}
-func (l *Logger) AddWriters(writers ...LoggerWriter) *Logger {
-	l.writers = append(l.writers, writers...)
-	return l
-}
-func (l *Logger) AddWriter(writer LoggerWriter) *Logger {
-	l.writers = append(l.writers, writer)
-	return l
-}
-
-func (l *Logger) Infof(format string, args ...any) {
-	l.print(INFO, fmt.Sprintf(format, args...))
-}
-func (l *Logger) Info(m ...any) {
-	l.println(INFO, m...)
-}
-
-func (l *Logger) Warnf(format string, args ...any) {
-	l.print(WARN, fmt.Sprintf(format, args...))
-}
-func (l *Logger) Warn(m ...any) {
-	l.println(WARN, m...)
-}
-
-func (l *Logger) Error(m ...any) {
-	l.println(ERROR, m...)
-}
-
-func (l *Logger) Fatal(m ...any) {
-	l.println(FATAL, m...)
-	os.Exit(1)
-}
-
-func (l *Logger) Debug(m ...any) {
-	l.println(DEBUG, m...)
-}
-
-func formatTime(t time.Time) string {
-	return fmt.Sprintf("%02d.%02d.%02d %02d:%02d:%02d", t.Day(), t.Month(), t.Year(), t.Hour(), t.Minute(), t.Second())
-}
-func formatTraceback(mt *MethodTraceback) string {
-	return fmt.Sprintf("%s:%s:%d", mt.Filename, mt.Method, mt.Line)
-}
-func FormatFullTraceback(tracebacks []*MethodTraceback) string {
-	formatted := make([]string, 0)
-	for _, tb := range tracebacks {
-		formatted = append(formatted, formatTraceback(tb))
-	}
-	return strings.Join(formatted, "->")
-}
-
-func getTraceback() *MethodTraceback {
-	caller, _, _, _ := runtime.Caller(4)
-	details := runtime.FuncForPC(caller)
-	signature := details.Name()
-	path, line := details.FileLine(caller)
-	splitPath := strings.Split(path, "/")
-
-	splitSignature := strings.Split(signature, ".")
-	pkg, method := splitSignature[0], splitSignature[len(splitSignature)-1]
-
-	tb := &MethodTraceback{
-		Filename:  splitPath[len(splitPath)-1],
-		fullPath:  path,
-		Line:      line,
-		signature: signature,
-		Package:   pkg,
-		Method:    method,
-	}
-
-	return tb
-}
-func getFullTraceback(skip int) []*MethodTraceback {
-	pc := make([]uintptr, 15)
-	runtime.Callers(skip, pc)
-	list := make([]*MethodTraceback, 0)
-	frames := runtime.CallersFrames(pc)
-	for {
-		frame, more := frames.Next()
-		if !more {
-			break
-		}
-		details := runtime.FuncForPC(frame.PC)
-		signature := details.Name()
-		path, line := details.FileLine(frame.PC)
-		splitPath := strings.Split(path, "/")
-
-		splitSignature := strings.Split(signature, ".")
-		pkg, method := splitSignature[0], splitSignature[len(splitSignature)-1]
-
-		tb := &MethodTraceback{
-			Filename:  splitPath[len(splitPath)-1],
-			fullPath:  path,
-			Line:      line,
-			signature: signature,
-			Package:   pkg,
-			Method:    method,
-		}
-		list = append(list, tb)
-	}
-	sort.Slice(list, func(i, j int) bool {
-		return j < i
-	})
-	return list
-}
-
-func buildString(level LogLevel, prefix string, newline, printTime, printTraceback bool, m ...any) string {
-	args := []string{
-		fmt.Sprintf("[%s]", prefix),
-		fmt.Sprintf("[%s]", strings.ToUpper(level.t)),
-	}
-
-	if printTraceback {
-		args = append(args, fmt.Sprintf("[%s]", formatTraceback(getTraceback())))
-	}
-
-	if printTime {
-		args = append(args, fmt.Sprintf("[%s]", formatTime(time.Now())))
-	}
-
-	msg := Map(m, func(el any) string {
-		return fmt.Sprintf("%v", el)
-	})
-	s := fmt.Sprintf("%s %s", strings.Join(args, " "), strings.Join(msg, " "))
-	if newline {
-		s += "\n"
-	}
-	return s
-}
-
-func (l *Logger) print(level LogLevel, m ...any) {
-	if l.level.n < level.n {
-		return
-	}
-
-	tb := getFullTraceback(0)
-	for _, writer := range l.writers {
-		err := writer.Print(level, l.prefix, tb, m...)
-		if err != nil {
-			l.Error(err)
-		}
-	}
-}
-
-// Docker requires "\n" at end to write to log.
-// print not work for docker, otherwise it will work and write into stdout
-func (l *Logger) println(level LogLevel, m ...any) {
-	if l.level.n < level.n {
-		return
-	}
-
-	tb := getFullTraceback(0)
-	for _, writer := range l.writers {
-		err := writer.Print(level, l.prefix, tb, m...)
-		if err != nil {
-			l.Error(err)
-		}
-	}
-}

methods.go

@@ -18,33 +18,25 @@ func (b *Bot) Updates() ([]*Update, error) {
 		return nil, err
 	}
 	res := make([]*Update, 0)
-	for _, u := range data["data"].([]any) {
-		updateObj := new(Update)
-		data, err := json.Marshal(u)
+	err = AnyToStruct(data["data"], &res)
+	if err != nil {
+		return res, err
+	}
+	
+	for _, u := range res {
+		b.updateOffset = u.UpdateID + 1
+		err = b.updateQueue.Enqueue(u)
 		if err != nil {
 			return res, err
 		}
-		err = json.Unmarshal(data, updateObj)
-		if err != nil {
-			return res, err
-		}
-		//err = MapToStruct(u.(map[string]any), updateObj)
-		//if err != nil {
-		//	return res, err
-		//}
-		b.updateOffset = updateObj.UpdateID + 1
-		err = b.updateQueue.Enqueue(updateObj)
-		if err != nil {
-			return res, err
-		}
-		res = append(res, updateObj)
+		res = append(res, u)
 
 		if b.debug && b.requestLogger != nil {
-			j, err := MapToJson(u.(map[string]interface{}))
+			j, err := json.Marshal(u)
 			if err != nil {
 				b.logger.Error(err)
 			}
-			b.requestLogger.Debug(fmt.Sprintf("UPDATE %s", j))
+			b.requestLogger.Debugln(fmt.Sprintf("UPDATE %s", j))
 		}
 	}
 	return res, err

msg_context.go

@@ -0,0 +1,164 @@
+package laniakea
+
+import "fmt"
+
+type MsgContext struct {
+	Bot           *Bot
+	Msg           *Message
+	Update        *Update
+	From          *User
+	CallbackMsgId int
+	FromID        int
+	Prefix        string
+	Text          string
+	Args          []string
+}
+
+type AnswerMessage struct {
+	MessageID int
+	Text      string
+	IsMedia   bool
+	Keyboard  *InlineKeyboard
+	ctx       *MsgContext
+}
+
+func (ctx *MsgContext) edit(messageId int, text string, keyboard *InlineKeyboard) *AnswerMessage {
+	params := &EditMessageTextP{
+		MessageID: messageId,
+		ChatID:    ctx.Msg.Chat.ID,
+		Text:      text,
+		ParseMode: ParseMD,
+	}
+	if keyboard != nil {
+		params.ReplyMarkup = keyboard.Get()
+	}
+	msg, err := ctx.Bot.EditMessageText(params)
+	if err != nil {
+		ctx.Bot.logger.Errorln(err)
+		return nil
+	}
+	return &AnswerMessage{
+		MessageID: msg.MessageID, ctx: ctx, Text: text, IsMedia: false,
+	}
+}
+func (m *AnswerMessage) Edit(text string) *AnswerMessage {
+	return m.ctx.edit(m.MessageID, text, nil)
+}
+func (ctx *MsgContext) EditCallback(text string, keyboard *InlineKeyboard) *AnswerMessage {
+	if ctx.CallbackMsgId == 0 {
+		ctx.Bot.logger.Errorln("Can't edit non-callback update message")
+		return nil
+	}
+
+	return ctx.edit(ctx.CallbackMsgId, text, keyboard)
+}
+func (ctx *MsgContext) EditCallbackf(format string, keyboard *InlineKeyboard, args ...any) *AnswerMessage {
+	return ctx.EditCallback(fmt.Sprintf(format, args...), keyboard)
+}
+
+func (ctx *MsgContext) editPhotoText(messageId int, text string, kb *InlineKeyboard) *AnswerMessage {
+	params := &EditMessageCaptionP{
+		ChatID:    ctx.Msg.Chat.ID,
+		MessageID: messageId,
+		Caption:   text,
+		ParseMode: ParseMD,
+	}
+	if kb != nil {
+		params.ReplyMarkup = kb.Get()
+	}
+	msg, err := ctx.Bot.EditMessageCaption(params)
+	if err != nil {
+		ctx.Bot.logger.Errorln(err)
+	}
+	return &AnswerMessage{
+		MessageID: msg.MessageID, ctx: ctx, Text: text, IsMedia: true,
+	}
+}
+func (m *AnswerMessage) EditCaption(text string) *AnswerMessage {
+	return m.ctx.editPhotoText(m.MessageID, text, nil)
+}
+func (m *AnswerMessage) EditCaptionKeyboard(text string, kb *InlineKeyboard) *AnswerMessage {
+	return m.ctx.editPhotoText(m.MessageID, text, kb)
+}
+
+func (ctx *MsgContext) answer(text string, keyboard *InlineKeyboard) *AnswerMessage {
+	params := &SendMessageP{
+		ChatID:    ctx.Msg.Chat.ID,
+		Text:      text,
+		ParseMode: ParseMD,
+	}
+	if keyboard != nil {
+		params.ReplyMarkup = keyboard.Get()
+	}
+
+	msg, err := ctx.Bot.SendMessage(params)
+	if err != nil {
+		ctx.Bot.logger.Errorln(err)
+		return nil
+	}
+	return &AnswerMessage{
+		MessageID: msg.MessageID, ctx: ctx, IsMedia: false, Text: text,
+	}
+}
+func (ctx *MsgContext) Answer(text string) *AnswerMessage {
+	return ctx.answer(text, nil)
+}
+func (ctx *MsgContext) Answerf(template string, args ...any) *AnswerMessage {
+	return ctx.answer(fmt.Sprintf(template, args...), nil)
+}
+func (ctx *MsgContext) Keyboard(text string, kb *InlineKeyboard) *AnswerMessage {
+	return ctx.answer(text, kb)
+}
+
+func (ctx *MsgContext) answerPhoto(photoId, text string, kb *InlineKeyboard) *AnswerMessage {
+	params := &SendPhotoP{
+		ChatID:    ctx.Msg.Chat.ID,
+		Caption:   text,
+		Photo:     photoId,
+		ParseMode: ParseMD,
+	}
+	if kb != nil {
+		params.ReplyMarkup = kb.Get()
+	}
+	msg, err := ctx.Bot.SendPhoto(params)
+	if err != nil {
+		ctx.Bot.logger.Errorln(err)
+	}
+	return &AnswerMessage{
+		MessageID: msg.MessageID, ctx: ctx, Text: text, IsMedia: true,
+	}
+}
+func (ctx *MsgContext) AnswerPhoto(photoId, text string) *AnswerMessage {
+	return ctx.answerPhoto(photoId, text, nil)
+}
+func (ctx *MsgContext) AnswerPhotoKeyboard(photoId, text string, kb *InlineKeyboard) *AnswerMessage {
+	return ctx.answerPhoto(photoId, text, kb)
+}
+
+func (ctx *MsgContext) delete(messageId int) {
+	_, err := ctx.Bot.DeleteMessage(&DeleteMessageP{
+		ChatID:    ctx.Msg.Chat.ID,
+		MessageID: messageId,
+	})
+	if err != nil {
+		ctx.Bot.logger.Errorln(err)
+	}
+}
+func (m *AnswerMessage) Delete() {
+	m.ctx.delete(m.MessageID)
+}
+func (ctx *MsgContext) CallbackDelete() {
+	ctx.delete(ctx.CallbackMsgId)
+}
+
+func (ctx *MsgContext) Error(err error) {
+	_, sendErr := ctx.Bot.SendMessage(&SendMessageP{
+		ChatID: ctx.Msg.Chat.ID,
+		Text:   fmt.Sprintf(ctx.Bot.errorTemplate, EscapeMarkdown(err.Error())),
+	})
+	ctx.Bot.logger.Errorln(err)
+
+	if sendErr != nil {
+		ctx.Bot.logger.Errorln(sendErr)
+	}
+}

queue.go

@@ -1,10 +1,12 @@
 package laniakea
 
 import (
-	"fmt"
+	"errors"
 	"sync"
 )
 
+var QueueFullErr = errors.New("queue is full")
+
 type Queue[T any] struct {
 	size  uint64
 	mu    sync.RWMutex
@@ -20,7 +22,7 @@ func CreateQueue[T any](size uint64) *Queue[T] {
 
 func (q *Queue[T]) Enqueue(el T) error {
 	if q.IsFull() {
-		return fmt.Errorf("queue full")
+		return QueueFullErr
 	}
 	q.queue = append(q.queue, el)
 	return nil

runners.go

@@ -0,0 +1,80 @@
+package laniakea
+
+import (
+	"time"
+)
+
+type RunnerFn func(*Bot) error
+type RunnerBuilder struct {
+	name    string
+	onetime bool
+	async   bool
+	timeout time.Duration
+	fn      RunnerFn
+}
+type Runner struct {
+	Name    string
+	Onetime bool
+	Async   bool
+	Timeout time.Duration
+	Fn      RunnerFn
+}
+
+func NewRunner(name string, fn RunnerFn) *RunnerBuilder {
+	return &RunnerBuilder{
+		name: name, fn: fn, async: true,
+	}
+}
+func (b *RunnerBuilder) Onetime(onetime bool) *RunnerBuilder {
+	b.onetime = onetime
+	return b
+}
+func (b *RunnerBuilder) Async(async bool) *RunnerBuilder {
+	b.async = async
+	return b
+}
+func (b *RunnerBuilder) Timeout(timeout time.Duration) *RunnerBuilder {
+	b.timeout = timeout
+	return b
+}
+func (b *RunnerBuilder) Build() Runner {
+	return Runner{
+		Name: b.name, Onetime: b.onetime, Async: b.async, Fn: b.fn, Timeout: b.timeout,
+	}
+}
+
+func (b *Bot) ExecRunners() {
+	for _, runner := range b.runners {
+		if !runner.Onetime && !runner.Async {
+			b.logger.Warnf("Runner %s not onetime, but sync\n", runner.Name)
+			continue
+		}
+		if !runner.Onetime && runner.Async && runner.Timeout == (time.Second*0) {
+			b.logger.Warnf("Background runner \"%s\" should have timeout", runner.Name)
+		}
+
+		if runner.Async && runner.Onetime {
+			go func() {
+				err := runner.Fn(b)
+				if err != nil {
+					b.logger.Warnf("Runner %s failed: %s\n", runner.Name, err)
+				}
+			}()
+		} else if !runner.Async && runner.Onetime {
+			err := runner.Fn(b)
+			if err != nil {
+				b.logger.Warnf("Runner %s failed: %s\n", runner.Name, err)
+			}
+		} else if !runner.Onetime {
+			go func() {
+				for {
+					err := runner.Fn(b)
+					if err != nil {
+						b.logger.Warnf("Runner %s failed: %s\n", runner.Name, err)
+					}
+					time.Sleep(runner.Timeout)
+				}
+			}()
+		}
+	}
+}

utils.go

@@ -6,7 +6,8 @@ import (
 	"strings"
 )
 
-func MapToStruct(m map[string]interface{}, s interface{}) error {
+// MapToStruct unsafe function
+func MapToStruct(m map[string]any, s any) error {
 	data, err := json.Marshal(m)
 	if err != nil {
 		return err
@@ -15,7 +16,27 @@ func MapToStruct(m map[string]interface{}, s interface{}) error {
 	return err
 }
 
-func MapToJson(m map[string]interface{}) (string, error) {
+// SliceToStruct unsafe function
+func SliceToStruct(sl []any, s any) error {
+	data, err := json.Marshal(sl)
+	if err != nil {
+		return err
+	}
+	err = json.Unmarshal(data, s)
+	return err
+}
+
+// AnyToStruct unsafe function
+func AnyToStruct(src, dest any) error {
+	data, err := json.Marshal(src)
+	if err != nil {
+		return err
+	}
+	err = json.Unmarshal(data, dest)
+	return err
+}
+
+func MapToJson(m map[string]any) (string, error) {
 	data, err := json.Marshal(m)
 	return string(data), err
 }

version.go

@@ -1,12 +1,8 @@
 package laniakea
 
-import "os"
-
 const (
-	VersionString = "0.2.0"
+	VersionString = "0.3.0"
 	VersionMajor  = 0
-	VersionMinor  = 2
+	VersionMinor  = 3
 	VersionPatch  = 0
 )
-
-var GoVersion = os.Getenv("GoV")