gramio 0.0.35 → 0.0.36

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.js

@@ -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);
@@ -539,8 +541,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/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.36",
   "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/format": "^0.1.1",
     "@gramio/keyboards": "^0.3.1",
     "@gramio/types": "^7.3.4",
     "inspectable": "^3.0.1",
     "middleware-io": "^2.8.1",
-    "undici": "^6.16.1"
+    "undici": "^6.17.0"
   },
   "files": [
     "dist"