feat: SavePreparedInlineMessage

Stores an inline message a Mini App user can later send
(messages.savePreparedInlineMessage), reusing the existing
InlineQueryResult.toTg machinery. WithAllow{User,Bot,Group,Channel}Chats
options map to MTProto inline query peer types. Returns
PreparedInlineMessage{id, expiration_date}.

Factors the repeated nil-result error into errNilInlineResult().
Hermetic test; lint clean.

Author: ernado

answer.go

@@ -132,7 +132,7 @@ func (b *Bot) AnswerInlineQuery(
 	tgResults := make([]tg.InputBotInlineResultClass, 0, len(results))
 	for _, r := range results {
 		if r == nil {
-			return &Error{Code: 400, Description: "Bad Request: inline query result is nil"}
+			return errNilInlineResult()
 		}
 
 		converted, err := r.toTg(ctx, b)

answer_webapp.go

@@ -20,7 +20,7 @@ type SentWebAppMessage struct {
 // originated. webAppQueryID is the query id from the Web App.
 func (b *Bot) AnswerWebAppQuery(ctx context.Context, webAppQueryID string, result InlineQueryResult) (*SentWebAppMessage, error) {
 	if result == nil {
-		return nil, &Error{Code: 400, Description: "Bad Request: inline query result is nil"}
+		return nil, errNilInlineResult()
 	}
 
 	converted, err := result.toTg(ctx, b)

inline_query_result.go

@@ -9,6 +9,11 @@ import (
 // mimeImageJPEG is the default thumbnail MIME type for inline results.
 const mimeImageJPEG = "image/jpeg"
 
+// errNilInlineResult is returned when a method is given a nil InlineQueryResult.
+func errNilInlineResult() *Error {
+	return &Error{Code: 400, Description: "Bad Request: inline query result is nil"}
+}
+
 // InlineQueryResult is a sealed union describing one result of an inline query.
 //
 // Concrete variants cover articles, fresh-by-URL media (photo/gif/mpeg4

prepared_inline.go

@@ -0,0 +1,109 @@
+package botapi
+
+import (
+	"context"
+
+	"github.com/gotd/td/tg"
+)
+
+// PreparedInlineMessage describes an inline message to be sent by a user of a Mini
+// App. It is the result of SavePreparedInlineMessage.
+type PreparedInlineMessage struct {
+	// ID is the unique identifier of the prepared message.
+	ID string `json:"id"`
+	// ExpirationDate is the Unix time when the prepared message can no longer be
+	// used.
+	ExpirationDate int `json:"expiration_date"`
+}
+
+// PreparedInlineMessageOption configures the set of chat types a prepared inline
+// message may be sent to.
+type PreparedInlineMessageOption func(*preparedInlineConfig)
+
+type preparedInlineConfig struct {
+	allowUsers    bool
+	allowBots     bool
+	allowGroups   bool
+	allowChannels bool
+}
+
+// WithAllowUserChats permits the message to be sent to private chats with users.
+func WithAllowUserChats() PreparedInlineMessageOption {
+	return func(c *preparedInlineConfig) { c.allowUsers = true }
+}
+
+// WithAllowBotChats permits the message to be sent to private chats with bots.
+func WithAllowBotChats() PreparedInlineMessageOption {
+	return func(c *preparedInlineConfig) { c.allowBots = true }
+}
+
+// WithAllowGroupChats permits the message to be sent to group and supergroup chats.
+func WithAllowGroupChats() PreparedInlineMessageOption {
+	return func(c *preparedInlineConfig) { c.allowGroups = true }
+}
+
+// WithAllowChannelChats permits the message to be sent to channel chats.
+func WithAllowChannelChats() PreparedInlineMessageOption {
+	return func(c *preparedInlineConfig) { c.allowChannels = true }
+}
+
+// peerTypes turns the allow-* flags into MTProto inline query peer types.
+func (c preparedInlineConfig) peerTypes() []tg.InlineQueryPeerTypeClass {
+	var out []tg.InlineQueryPeerTypeClass
+
+	if c.allowUsers {
+		out = append(out, &tg.InlineQueryPeerTypePM{})
+	}
+
+	if c.allowBots {
+		out = append(out, &tg.InlineQueryPeerTypeBotPM{})
+	}
+
+	if c.allowGroups {
+		out = append(out, &tg.InlineQueryPeerTypeChat{}, &tg.InlineQueryPeerTypeMegagroup{})
+	}
+
+	if c.allowChannels {
+		out = append(out, &tg.InlineQueryPeerTypeBroadcast{})
+	}
+
+	return out
+}
+
+// SavePreparedInlineMessage stores a message that can later be sent by a user of a
+// Mini App. By default the message may not be sent anywhere; use the WithAllow*
+// options to permit specific chat types.
+func (b *Bot) SavePreparedInlineMessage(
+	ctx context.Context, userID int64, result InlineQueryResult, opts ...PreparedInlineMessageOption,
+) (*PreparedInlineMessage, error) {
+	if result == nil {
+		return nil, errNilInlineResult()
+	}
+
+	var cfg preparedInlineConfig
+
+	for _, o := range opts {
+		o(&cfg)
+	}
+
+	user, err := b.resolveInputUser(ctx, userID)
+	if err != nil {
+		return nil, err
+	}
+
+	converted, err := result.toTg(ctx, b)
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := b.raw.MessagesSavePreparedInlineMessage(ctx, &tg.MessagesSavePreparedInlineMessageRequest{
+		Result:    converted,
+		UserID:    user,
+		PeerTypes: cfg.peerTypes(),
+	})
+	if err != nil {
+		return nil, asAPIError(err)
+	}
+
+	return &PreparedInlineMessage{ID: res.ID, ExpirationDate: res.ExpireDate}, nil
+}

prepared_inline_test.go

@@ -0,0 +1,64 @@
+package botapi
+
+import (
+	"context"
+	"testing"
+
+	"github.com/gotd/td/tg"
+)
+
+func TestSavePreparedInlineMessage(t *testing.T) {
+	inv := newMockInvoker()
+	inv.reply(tg.MessagesSavePreparedInlineMessageRequestTypeID, &tg.MessagesBotPreparedInlineMessage{
+		ID:         "prep1",
+		ExpireDate: 1700000000,
+	})
+
+	result := &InlineQueryResultArticle{
+		ID:                  "r1",
+		Title:               "Title",
+		InputMessageContent: &InputTextMessageContent{MessageText: "hi"},
+	}
+
+	got, err := newMockBot(inv).SavePreparedInlineMessage(context.Background(), 99, result,
+		WithAllowUserChats(), WithAllowChannelChats())
+	if err != nil {
+		t.Fatalf("SavePreparedInlineMessage: %v", err)
+	}
+
+	if got.ID != "prep1" || got.ExpirationDate != 1700000000 {
+		t.Fatalf("got = %#v", got)
+	}
+
+	var req tg.MessagesSavePreparedInlineMessageRequest
+
+	inv.decode(t, tg.MessagesSavePreparedInlineMessageRequestTypeID, &req)
+
+	if _, ok := req.Result.(*tg.InputBotInlineResult); !ok {
+		t.Fatalf("result = %#v, want inline result", req.Result)
+	}
+
+	if len(req.PeerTypes) != 2 {
+		t.Fatalf("peer types = %#v, want user + broadcast", req.PeerTypes)
+	}
+
+	if _, ok := req.PeerTypes[0].(*tg.InlineQueryPeerTypePM); !ok {
+		t.Fatalf("peer type 0 = %#v, want PM", req.PeerTypes[0])
+	}
+
+	if _, ok := req.PeerTypes[1].(*tg.InlineQueryPeerTypeBroadcast); !ok {
+		t.Fatalf("peer type 1 = %#v, want broadcast", req.PeerTypes[1])
+	}
+}
+
+func TestSavePreparedInlineMessageNilResult(t *testing.T) {
+	inv := newMockInvoker()
+
+	if _, err := newMockBot(inv).SavePreparedInlineMessage(context.Background(), 99, nil); err == nil {
+		t.Fatal("expected error for nil result")
+	}
+
+	if inv.count() != 0 {
+		t.Fatalf("made %d RPC calls, want 0", inv.count())
+	}
+}