gramio 0.0.35 → 0.0.37

package/README.md

@@ -36,7 +36,7 @@ and GramIO customize your project the way you want it!
 ```typescript
 import { Bot } from "gramio";
 
-const bot = new Bot()
+const bot = new Bot(process.env.TOKEN as string)
     .command("start", (context) => context.send("Hello!"))
     .onStart(({ info }) => console.log(`✨ Bot ${info.username} was started!`));
 

package/dist/bot.d.ts

@@ -44,8 +44,12 @@ export declare class Bot<Errors extends ErrorDefinitions = {}, Derives extends D
     /** This instance handle updates */
     updates: Updates;
     private hooks;
-    /** Create new Bot instance */
-    constructor(token: string, options?: Omit<BotOptions, "token">);
+    constructor(token: string, options?: Omit<BotOptions, "token" | "api"> & {
+        api?: Partial<BotOptions["api"]>;
+    });
+    constructor(options: Omit<BotOptions, "api"> & {
+        api?: Partial<BotOptions["api"]>;
+    });
     private runHooks;
     private runImmutableHooks;
     private _callApi;

package/dist/bot.js

@@ -81,7 +81,7 @@ let Bot = (() => {
         /** @internal. Remap generic */
         __Derives;
         /** Options provided to instance */
-        options = {};
+        options;
         /** Bot data (filled in when calling bot.init/bot.start) */
         info;
         /**
@@ -106,6 +106,8 @@ let Bot = (() => {
             TELEGRAM: errors_1.TelegramError,
         };
         errorHandler(context, error) {
+            if (!this.hooks.onError.length)
+                throw error;
             return this.runImmutableHooks("onError", {
                 context,
                 //@ts-expect-error ErrorKind exists if user register error-class with .error("kind", SomeError);
@@ -123,11 +125,17 @@ let Bot = (() => {
             onStart: [],
             onStop: [],
         };
-        /** Create new Bot instance */
-        constructor(token, options) {
+        constructor(tokenOrOptions, options) {
+            const token = typeof tokenOrOptions === "string"
+                ? tokenOrOptions
+                : tokenOrOptions?.token;
             if (!token || typeof token !== "string")
                 throw new Error(`Token is ${typeof token} but it should be a string!`);
-            this.options = { ...options, token };
+            this.options = {
+                ...(typeof tokenOrOptions === "object" ? tokenOrOptions : options),
+                token,
+                api: { ...options?.api, baseURL: "https://api.telegram.org/bot" },
+            };
             if (!(options?.plugins &&
                 "format" in options.plugins &&
                 !options.plugins.format))
@@ -156,7 +164,7 @@ let Bot = (() => {
             }
         }
         async _callApi(method, params = {}) {
-            const url = `https://api.telegram.org/bot${this.options.token}/${method}`;
+            const url = `${this.options.api.baseURL}${this.options.token}/${method}`;
             const reqOptions = {
                 method: "POST",
             };
@@ -212,7 +220,7 @@ let Bot = (() => {
             }
             const fileId = typeof attachment === "string" ? attachment : getFileId(attachment);
             const file = await this.api.getFile({ file_id: fileId });
-            const url = `https://api.telegram.org/file/bot${this.options.token}/${file.file_path}`;
+            const url = `${this.options.api.baseURL.replace("/bot", "/file/bot")}${this.options.token}/${file.file_path}`;
             const res = await (0, undici_1.request)(url);
             const buffer = await res.body.arrayBuffer();
             if (path) {
@@ -539,8 +547,9 @@ let Bot = (() => {
                     return next();
                 if (trigger instanceof RegExp && !trigger.test(context.data))
                     return next();
-                // @ts-expect-error
-                context.queryData = trigger.unpack(context.data);
+                if (trigger instanceof callback_data_1.CallbackData)
+                    // @ts-expect-error
+                    context.queryData = trigger.unpack(context.data);
                 //@ts-expect-error
                 return handler(context);
             });

package/dist/composer.js

@@ -11,9 +11,7 @@ class Composer {
     constructor(onError) {
         this.onError =
             onError ||
-                ((context, error) => {
-                    // @ts-expect-error
-                    error.context = context;
+                ((_, error) => {
                     throw error;
                 });
         this.recompose();

package/dist/plugin.d.ts

@@ -138,7 +138,7 @@ export declare class Plugin<Errors extends ErrorDefinitions = {}, Derives extend
     preRequest<Methods extends keyof APIMethods, Handler extends Hooks.PreRequest<Methods>>(methods: MaybeArray<Methods>, handler: Handler): this;
     preRequest(handler: Hooks.PreRequest): this;
     /**
-     * This hook called when API return sucesfull response
+     * This hook called when API return successful response
      *
      * [Documentation](https://gramio.dev/hooks/on-response.html)
      * */

package/dist/types.d.ts

@@ -6,10 +6,26 @@ import type { TelegramError } from "./errors";
 import type { Plugin } from "./plugin";
 /** Bot options that you can provide to {@link Bot} constructor */
 export interface BotOptions {
-    token?: string;
+    /** Bot token */
+    token: string;
+    /** List of plugins enabled by default */
     plugins?: {
+        /** Pass `false` to disable plugin. @default true */
         format?: boolean;
     };
+    /** Options to configure how to send requests to the Telegram Bot API */
+    api: {
+        /** URL which will be used to send requests to. @default "https://api.telegram.org/bot" */
+        baseURL: string;
+        /**
+         * 	Should we send requests to `test` data center?
+         * 	The test environment is completely separate from the main environment, so you will need to create a new user account and a new bot with `@BotFather`.
+         *
+         * 	[Documentation](https://core.telegram.org/bots/webapps#using-bots-in-the-test-environment)
+         * 	@default false
+         * */
+        useTest?: boolean;
+    };
 }
 /**
  * Handler is a function with context and next function arguments

package/dist/updates.d.ts

@@ -1,6 +1,6 @@
 import { type Context } from "@gramio/contexts";
 import type { APIMethodParams, TelegramUpdate } from "@gramio/types";
-import { type CaughtMiddlewareHandler } from "middleware-io";
+import type { CaughtMiddlewareHandler } from "middleware-io";
 import { Composer } from "./composer";
 import type { AnyBot } from "./types";
 export declare class Updates {

package/dist/webhook/adapters.d.ts

@@ -3,7 +3,8 @@ import { Response } from "undici";
 import type { MaybePromise } from "../types";
 export interface FrameworkHandler {
     update: MaybePromise<TelegramUpdate>;
-    header?: string;
+    header: string;
+    unauthorized: () => unknown;
     response?: () => unknown;
 }
 export type FrameworkAdapter = (...args: any[]) => FrameworkHandler;
@@ -11,30 +12,43 @@ export declare const frameworks: {
     elysia: ({ body, headers }: any) => {
         update: any;
         header: any;
+        unauthorized: () => Response;
     };
-    fastify: (request: any) => {
+    fastify: (request: any, reply: any) => {
         update: any;
         header: any;
+        unauthorized: () => any;
     };
     hono: (c: any) => {
         update: any;
         header: any;
+        unauthorized: () => any;
     };
-    express: (req: any) => {
+    express: (req: any, res: any) => {
         update: any;
         header: any;
+        unauthorized: () => any;
     };
     koa: (ctx: any) => {
         update: any;
         header: any;
+        unauthorized: () => void;
     };
-    http: (req: any) => {
+    http: (req: any, res: any) => {
         update: Promise<TelegramUpdate>;
         header: any;
+        unauthorized: () => any;
     };
-    stdHTTP: (req: any) => {
+    "std/http": (req: any) => {
         update: any;
         header: any;
         response: () => Response;
+        unauthorized: () => Response;
+    };
+    "Bun.serve": (req: any) => {
+        update: any;
+        header: any;
+        response: () => Response;
+        unauthorized: () => Response;
     };
 };

package/dist/webhook/adapters.js

@@ -3,28 +3,37 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.frameworks = void 0;
 const undici_1 = require("undici");
 const SECRET_TOKEN_HEADER = "X-Telegram-Bot-Api-Secret-Token";
+const WRONG_TOKEN_ERROR = "secret token is invalid";
 exports.frameworks = {
     elysia: ({ body, headers }) => ({
         update: body,
         header: headers[SECRET_TOKEN_HEADER],
+        unauthorized: () => new undici_1.Response(WRONG_TOKEN_ERROR, { status: 401 }),
     }),
-    fastify: (request) => ({
+    fastify: (request, reply) => ({
         update: request.body,
         header: request.headers[SECRET_TOKEN_HEADER],
+        unauthorized: () => reply.code(401).send(WRONG_TOKEN_ERROR),
     }),
     hono: (c) => ({
         update: c.req.json(),
         header: c.req.header(SECRET_TOKEN_HEADER),
+        unauthorized: () => c.text(WRONG_TOKEN_ERROR, 401),
     }),
-    express: (req) => ({
+    express: (req, res) => ({
         update: req.body,
         header: req.header(SECRET_TOKEN_HEADER),
+        unauthorized: () => res.status(401).send(WRONG_TOKEN_ERROR),
     }),
     koa: (ctx) => ({
         update: ctx.request.body,
         header: ctx.get(SECRET_TOKEN_HEADER),
+        unauthorized: () => {
+            ctx.status === 401;
+            ctx.body = WRONG_TOKEN_ERROR;
+        },
     }),
-    http: (req) => ({
+    http: (req, res) => ({
         update: new Promise((resolve) => {
             let body = "";
             req.on("data", (chunk) => {
@@ -33,10 +42,18 @@ exports.frameworks = {
             req.on("end", () => resolve(JSON.parse(body)));
         }),
         header: req.headers[SECRET_TOKEN_HEADER.toLowerCase()],
+        unauthorized: () => res.writeHead(401).end(WRONG_TOKEN_ERROR),
     }),
-    stdHTTP: (req) => ({
+    "std/http": (req) => ({
         update: req.json(),
         header: req.headers.get(SECRET_TOKEN_HEADER),
-        response: () => new undici_1.Response(null, { status: 200 }),
+        response: () => new undici_1.Response("ok!"),
+        unauthorized: () => new undici_1.Response(WRONG_TOKEN_ERROR, { status: 401 }),
+    }),
+    "Bun.serve": (req) => ({
+        update: req.json(),
+        header: req.headers.get(SECRET_TOKEN_HEADER),
+        response: () => new undici_1.Response("ok!"),
+        unauthorized: () => new undici_1.Response(WRONG_TOKEN_ERROR, { status: 401 }),
     }),
 };

package/dist/webhook/index.d.ts

@@ -30,35 +30,48 @@ export type WebhookHandlers = keyof typeof frameworks;
  * });
  * ```
  */
-export declare function webhookHandler<Framework extends keyof typeof frameworks>(bot: Bot, framework: Framework): ReturnType<{
+export declare function webhookHandler<Framework extends keyof typeof frameworks>(bot: Bot, framework: Framework, secretToken?: string): ReturnType<{
     elysia: ({ body, headers }: any) => {
         update: any;
         header: any;
+        unauthorized: () => import("undici").Response;
     };
-    fastify: (request: any) => {
+    fastify: (request: any, reply: any) => {
         update: any;
         header: any;
+        unauthorized: () => any;
     };
     hono: (c: any) => {
         update: any;
         header: any;
+        unauthorized: () => any;
     };
-    express: (req: any) => {
+    express: (req: any, res: any) => {
         update: any;
         header: any;
+        unauthorized: () => any;
     };
     koa: (ctx: any) => {
         update: any;
         header: any;
+        unauthorized: () => void;
     };
-    http: (req: any) => {
+    http: (req: any, res: any) => {
         update: Promise<import("@gramio/types").TelegramUpdate>;
         header: any;
+        unauthorized: () => any;
     };
-    stdHTTP: (req: any) => {
+    "std/http": (req: any) => {
         update: any;
         header: any;
         response: () => import("undici").Response;
+        unauthorized: () => import("undici").Response;
+    };
+    "Bun.serve": (req: any) => {
+        update: any;
+        header: any;
+        response: () => import("undici").Response;
+        unauthorized: () => import("undici").Response;
     };
 }[Framework]> extends {
     response: () => any;

package/dist/webhook/index.js

@@ -30,11 +30,15 @@ const adapters_1 = require("./adapters");
  * });
  * ```
  */
-function webhookHandler(bot, framework) {
+function webhookHandler(bot, framework, secretToken) {
     const frameworkAdapter = adapters_1.frameworks[framework];
     return (async (...args) => {
         // @ts-expect-error
-        const { update, response } = frameworkAdapter(...args);
+        const { update, response, header, unauthorized } = frameworkAdapter(
+        // @ts-expect-error
+        ...args);
+        if (secretToken && header !== secretToken)
+            return unauthorized();
         await bot.updates.handleUpdate(await update);
         if (response)
             return response();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gramio",
-  "version": "0.0.35",
+  "version": "0.0.37",
   "description": "Powerful Telegram Bot API framework",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -27,19 +27,19 @@
   "license": "ISC",
   "devDependencies": {
     "@biomejs/biome": "1.7.3",
-    "@types/node": "^20.12.9",
+    "@types/node": "^20.12.12",
     "typescript": "^5.4.5"
   },
   "dependencies": {
     "@gramio/callback-data": "^0.0.3",
     "@gramio/contexts": "^0.0.15",
     "@gramio/files": "^0.0.8",
-    "@gramio/format": "^0.1.0",
-    "@gramio/keyboards": "^0.3.1",
+    "@gramio/format": "^0.1.2",
+    "@gramio/keyboards": "^0.3.2",
     "@gramio/types": "^7.3.4",
     "inspectable": "^3.0.1",
     "middleware-io": "^2.8.1",
-    "undici": "^6.16.1"
+    "undici": "^6.17.0"
   },
   "files": [
     "dist"