feat(updates): map dispatched tg updates to Bot API objects

messageFromTg converts a dispatched message (reusing convertMessage),
callbackQueryFromTg and inlineQueryFromTg build their Bot API objects from the
update plus the harvested Entities (sender resolved without an extra RPC). These
feed the handler routing added next.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: ernado

updates_map.go

@@ -0,0 +1,51 @@
+package botapi
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/gotd/td/tg"
+)
+
+// messageFromTg converts a dispatched message into a Bot API Message. Service
+// and empty messages yield (nil, nil) so callers can skip them.
+func (b *Bot) messageFromTg(ctx context.Context, msg tg.MessageClass) (*Message, error) {
+	m, ok := msg.(*tg.Message)
+	if !ok {
+		return nil, nil
+	}
+	return b.convertMessage(ctx, m)
+}
+
+// callbackQueryFromTg builds a CallbackQuery from a bot callback update. The
+// sender is taken from the update entities (already harvested by the peer hook),
+// so no extra RPC is needed.
+func callbackQueryFromTg(e tg.Entities, u *tg.UpdateBotCallbackQuery) *CallbackQuery {
+	cq := &CallbackQuery{
+		ID:            strconv.FormatInt(u.QueryID, 10),
+		ChatInstance:  strconv.FormatInt(u.ChatInstance, 10),
+		Data:          string(u.Data),
+		GameShortName: u.GameShortName,
+	}
+	if user, ok := e.Users[u.UserID]; ok {
+		cq.From = userFromTgUser(user)
+	} else {
+		cq.From = User{ID: u.UserID}
+	}
+	return cq
+}
+
+// inlineQueryFromTg builds an InlineQuery from a bot inline-query update.
+func inlineQueryFromTg(e tg.Entities, u *tg.UpdateBotInlineQuery) *InlineQuery {
+	iq := &InlineQuery{
+		ID:     strconv.FormatInt(u.QueryID, 10),
+		Query:  u.Query,
+		Offset: u.Offset,
+	}
+	if user, ok := e.Users[u.UserID]; ok {
+		iq.From = userFromTgUser(user)
+	} else {
+		iq.From = User{ID: u.UserID}
+	}
+	return iq
+}

updates_map_test.go

@@ -0,0 +1,37 @@
+package botapi
+
+import (
+	"testing"
+
+	"github.com/gotd/td/tg"
+)
+
+func TestCallbackQueryFromTg(t *testing.T) {
+	e := tg.Entities{Users: map[int64]*tg.User{5: {ID: 5, FirstName: "Ada", Username: "ada"}}}
+	u := &tg.UpdateBotCallbackQuery{QueryID: 100, UserID: 5, ChatInstance: 77, Data: []byte("vote:1")}
+
+	cq := callbackQueryFromTg(e, u)
+	if cq.ID != "100" || cq.ChatInstance != "77" || cq.Data != "vote:1" {
+		t.Fatalf("scalar fields: %+v", cq)
+	}
+	if cq.From.ID != 5 || cq.From.Username != "ada" {
+		t.Fatalf("from from entities: %+v", cq.From)
+	}
+}
+
+func TestCallbackQueryFromTgUnknownUser(t *testing.T) {
+	cq := callbackQueryFromTg(tg.Entities{}, &tg.UpdateBotCallbackQuery{QueryID: 1, UserID: 9})
+	if cq.From.ID != 9 {
+		t.Fatalf("fallback from id: %+v", cq.From)
+	}
+}
+
+func TestInlineQueryFromTg(t *testing.T) {
+	e := tg.Entities{Users: map[int64]*tg.User{3: {ID: 3, FirstName: "Bob"}}}
+	u := &tg.UpdateBotInlineQuery{QueryID: 42, UserID: 3, Query: "cats", Offset: "10"}
+
+	iq := inlineQueryFromTg(e, u)
+	if iq.ID != "42" || iq.Query != "cats" || iq.Offset != "10" || iq.From.ID != 3 {
+		t.Fatalf("inline query: %+v", iq)
+	}
+}