Initial release of go-telegram

A fully-generated, strongly-typed Go client for the Telegram Bot API.

* 176 methods + 301 types generated from Bot API v10.0
* 1408 auto-generated tests (8 scenarios per method)
* Typed unions throughout — no 'any' in the public surface
* Pluggable HTTP transport and JSON codec (default goccy/go-json)
* Built-in retry middleware honouring Telegram's retry_after
* Generic dispatcher with filters and conversation handlers
* Self-verifying codegen pipeline (regen → audit → emit → run tests)
* 14 example bots covering common patterns

examples/middleware/README.md

@@ -0,0 +1,11 @@
+# middleware
+
+Demonstrates two custom dispatch middlewares: timing (logs handler latency) and auth (restricts updates to a single owner via `OWNER_USER_ID` env var).
+
+## Run
+
+```bash
+export TELEGRAM_BOT_TOKEN=...
+export OWNER_USER_ID=123456789  # optional
+go run ./examples/middleware
+```

examples/middleware/main.go

@@ -0,0 +1,86 @@
+// Package main demonstrates custom middleware for go-telegram.
+//
+//	TELEGRAM_BOT_TOKEN=xxx go run ./examples/middleware
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/lukaszraczylo/go-telegram/api"
+	"github.com/lukaszraczylo/go-telegram/client"
+	"github.com/lukaszraczylo/go-telegram/dispatch"
+	"github.com/lukaszraczylo/go-telegram/transport"
+)
+
+// timing wraps a handler chain with start-end timing logged via stdlib log.
+func timing() dispatch.Middleware[*api.Update] {
+	return func(next dispatch.Handler[*api.Update]) dispatch.Handler[*api.Update] {
+		return func(c *dispatch.Context, u *api.Update) error {
+			start := time.Now()
+			err := next(c, u)
+			log.Printf("update %d processed in %s err=%v", u.UpdateID, time.Since(start), err)
+			return err
+		}
+	}
+}
+
+// auth restricts updates to a single allowed user ID via env var.
+func auth(allowedUserID int64) dispatch.Middleware[*api.Update] {
+	return func(next dispatch.Handler[*api.Update]) dispatch.Handler[*api.Update] {
+		return func(c *dispatch.Context, u *api.Update) error {
+			sender := senderID(u)
+			if allowedUserID != 0 && sender != allowedUserID {
+				log.Printf("blocked update %d from user %d", u.UpdateID, sender)
+				return nil
+			}
+			return next(c, u)
+		}
+	}
+}
+
+func senderID(u *api.Update) int64 {
+	switch {
+	case u.Message != nil && u.Message.From != nil:
+		return u.Message.From.ID
+	case u.CallbackQuery != nil:
+		return u.CallbackQuery.From.ID
+	}
+	return 0
+}
+
+func main() {
+	token := os.Getenv("TELEGRAM_BOT_TOKEN")
+	if token == "" {
+		log.Fatal("TELEGRAM_BOT_TOKEN required")
+	}
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer stop()
+
+	bot := client.New(token)
+	router := dispatch.New(bot)
+	router.Use(timing())
+	// To restrict to a single owner, set OWNER_USER_ID env to your numeric ID.
+	var ownerID int64
+	_, _ = fmt.Sscanf(os.Getenv("OWNER_USER_ID"), "%d", &ownerID)
+	if ownerID != 0 {
+		router.Use(auth(ownerID))
+	}
+
+	router.OnCommand("/start", func(c *dispatch.Context, m *api.Message) error {
+		_, err := api.SendMessage(c.Ctx, c.Bot, &api.SendMessageParams{
+			ChatID: api.ChatIDFromInt(m.Chat.ID),
+			Text:   "middleware demo: this update was timed and (optionally) auth-checked",
+		})
+		return err
+	})
+
+	if err := router.Run(ctx, transport.NewLongPoller(bot)); err != nil && err != context.Canceled {
+		log.Printf("router exited: %v", err)
+	}
+}