gramio 0.0.33 → 0.0.36

package/README.md

@@ -1,46 +1,46 @@
-# GramIO
-
-<div align="center">
-
-[![Bot API](https://img.shields.io/badge/Bot%20API-7.3-blue?logo=telegram&style=flat&labelColor=000&color=3b82f6)](https://core.telegram.org/bots/api)
-[![npm](https://img.shields.io/npm/v/gramio?logo=npm&style=flat&labelColor=000&color=3b82f6)](https://www.npmjs.org/package/@gramio/core)
-[![JSR](https://jsr.io/badges/@gramio/core)](https://jsr.io/@gramio/core)
-[![JSR Score](https://jsr.io/badges/@gramio/core/score)](https://jsr.io/@gramio/core)
-
-</div>
-
-TypeScript/JavaScript Telegram Bot API Framework for create your bots with convenience!
-
-✨ **Extensible** - Our plugin and hook system is awesome
-
-🛡️ **Type-safe** - Written in TypeScript with love ❤️
-
-🌐 **Multi-runtime** - Works on [Node.js](https://nodejs.org/), [Bun](https://bun.sh/) and [Deno](https://deno.com/)\*
-
-⚙️ **Code-generated** - Many parts are code-generated (for example, [code-generated and auto-published Telegram Bot API types](https://github.com/gramiojs/types))
-
-**Deno\*** [windows-specific issue with undici](https://github.com/denoland/deno/issues/19532)
-
-## [Get started](https://gramio.dev/get-started)
-
-To create your new bot, you just need to write it to the console:
-
-```bash [npm]
-npm create gramio ./bot
-```
-
-and GramIO customize your project the way you want it!
-
-### Example
-
-```typescript
-import { Bot } from "gramio";
-
-const bot = new Bot()
-    .command("start", (context) => context.send("Hello!"))
-    .onStart(({ info }) => console.log(`✨ Bot ${info.username} was started!`));
-
-bot.start();
-```
-
-For more, please see [documentation](https://gramio.dev).
+# GramIO
+
+<div align="center">
+
+[![Bot API](https://img.shields.io/badge/Bot%20API-7.3-blue?logo=telegram&style=flat&labelColor=000&color=3b82f6)](https://core.telegram.org/bots/api)
+[![npm](https://img.shields.io/npm/v/gramio?logo=npm&style=flat&labelColor=000&color=3b82f6)](https://www.npmjs.org/package/@gramio/core)
+[![JSR](https://jsr.io/badges/@gramio/core)](https://jsr.io/@gramio/core)
+[![JSR Score](https://jsr.io/badges/@gramio/core/score)](https://jsr.io/@gramio/core)
+
+</div>
+
+TypeScript/JavaScript Telegram Bot API Framework for create your bots with convenience!
+
+✨ **Extensible** - Our plugin and hook system is awesome
+
+🛡️ **Type-safe** - Written in TypeScript with love ❤️
+
+🌐 **Multi-runtime** - Works on [Node.js](https://nodejs.org/), [Bun](https://bun.sh/) and [Deno](https://deno.com/)\*
+
+⚙️ **Code-generated** - Many parts are code-generated (for example, [code-generated and auto-published Telegram Bot API types](https://github.com/gramiojs/types))
+
+**Deno\*** [windows-specific issue with undici](https://github.com/denoland/deno/issues/19532)
+
+## [Get started](https://gramio.dev/get-started)
+
+To create your new bot, you just need to write it to the console:
+
+```bash [npm]
+npm create gramio ./bot
+```
+
+and GramIO customize your project the way you want it!
+
+### Example
+
+```typescript
+import { Bot } from "gramio";
+
+const bot = new Bot(process.env.TOKEN as string)
+    .command("start", (context) => context.send("Hello!"))
+    .onStart(({ info }) => console.log(`✨ Bot ${info.username} was started!`));
+
+bot.start();
+```
+
+For more, please see [documentation](https://gramio.dev).

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);
@@ -213,8 +215,8 @@ 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 res = await fetch(url);
-            const buffer = await res.arrayBuffer();
+            const res = await (0, undici_1.request)(url);
+            const buffer = await res.body.arrayBuffer();
             if (path) {
                 await promises_1.default.writeFile(path, node_buffer_1.Buffer.from(buffer));
                 return path;
@@ -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/plugin.js

@@ -156,7 +156,7 @@ let Plugin = (() => {
         }
         /** Register handler to one or many Updates */
         on(updateName, handler) {
-            this.on(updateName, handler);
+            this._.composer.on(updateName, handler);
             return this;
         }
         /** Register handler to any Updates */

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

@@ -1,25 +1,54 @@
 import type { TelegramUpdate } from "@gramio/types";
+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;
 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, res: any) => {
+        update: Promise<TelegramUpdate>;
+        header: any;
+        unauthorized: () => 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

@@ -1,22 +1,59 @@
 "use strict";
 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, res) => ({
+        update: new Promise((resolve) => {
+            let body = "";
+            req.on("data", (chunk) => {
+                body += chunk.toString();
+            });
+            req.on("end", () => resolve(JSON.parse(body)));
+        }),
+        header: req.headers[SECRET_TOKEN_HEADER.toLowerCase()],
+        unauthorized: () => res.writeHead(401).end(WRONG_TOKEN_ERROR),
+    }),
+    "std/http": (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 }),
+    }),
+    "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,4 +30,49 @@ export type WebhookHandlers = keyof typeof frameworks;
  * });
  * ```
  */
-export declare function webhookHandler(bot: Bot, framework: keyof typeof frameworks): (...args: any[]) => Promise<void>;
+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, reply: any) => {
+        update: any;
+        header: any;
+        unauthorized: () => any;
+    };
+    hono: (c: any) => {
+        update: any;
+        header: any;
+        unauthorized: () => any;
+    };
+    express: (req: any, res: any) => {
+        update: any;
+        header: any;
+        unauthorized: () => any;
+    };
+    koa: (ctx: any) => {
+        update: any;
+        header: any;
+        unauthorized: () => void;
+    };
+    http: (req: any, res: any) => {
+        update: Promise<import("@gramio/types").TelegramUpdate>;
+        header: any;
+        unauthorized: () => 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;
+} ? (...args: Parameters<(typeof frameworks)[Framework]>) => ReturnType<ReturnType<(typeof frameworks)[Framework]>["response"]> : (...args: Parameters<(typeof frameworks)[Framework]>) => void;

package/dist/webhook/index.js

@@ -30,11 +30,18 @@ const adapters_1 = require("./adapters");
  * });
  * ```
  */
-function webhookHandler(bot, framework) {
+function webhookHandler(bot, framework, secretToken) {
     const frameworkAdapter = adapters_1.frameworks[framework];
-    return async (...args) => {
-        const { update } = frameworkAdapter(...args);
+    return (async (...args) => {
+        // @ts-expect-error
+        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();
+    });
 }
 exports.webhookHandler = webhookHandler;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gramio",
-  "version": "0.0.33",
+  "version": "0.0.36",
   "description": "Powerful Telegram Bot API framework",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,25 +20,26 @@
     "lint": "bunx @biomejs/biome check ./src",
     "lint:fix": "bun lint --apply",
     "prepublishOnly": "tsc",
-    "jsr": "bun scripts/release-jsr.ts"
+    "jsr": "bun scripts/release-jsr.ts",
+    "try-deno": "deno publish --unstable-sloppy-imports --dry-run --allow-slow-types --allow-dirty"
   },
   "author": "kravets",
   "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"

package/dist/TelegramError.d.ts

@@ -1,8 +0,0 @@
-import { APIMethodParams, APIMethods, TelegramAPIResponseError, TelegramResponseParameters } from "@gramio/types";
-export declare class TelegramError<T extends keyof APIMethods> extends Error {
-    method: T;
-    params: APIMethodParams<T>;
-    code: number;
-    payload?: TelegramResponseParameters;
-    constructor(error: TelegramAPIResponseError, method: T, params: APIMethodParams<T>);
-}

package/dist/TelegramError.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TelegramError = void 0;
-class TelegramError extends Error {
-    method;
-    params;
-    code;
-    payload;
-    constructor(error, method, params) {
-        super(error.description);
-        this.name = method;
-        this.method = method;
-        this.params = params;
-        this.code = error.error_code;
-        if (error.parameters)
-            this.payload = error.parameters;
-    }
-}
-exports.TelegramError = TelegramError;