gramio 0.0.18 → 0.0.20

package/dist/bot.d.ts

@@ -1,13 +1,14 @@
 import { Context, ContextType, MaybeArray, UpdateName } from "@gramio/contexts";
 import type { APIMethodParams, APIMethods, TelegramUser } from "@gramio/types";
 import { Plugin } from "./plugin";
-import { BotOptions, DeriveDefinitions, ErrorDefinitions, Handler, Hooks } from "./types";
+import { BotOptions, DeriveDefinitions, ErrorDefinitions, Handler, Hooks, MaybePromise } from "./types";
 import { Updates } from "./updates";
 export declare class Bot<Errors extends ErrorDefinitions = {}, Derives extends DeriveDefinitions = DeriveDefinitions> {
     __Derives: Derives;
     readonly options: BotOptions;
     info: TelegramUser | undefined;
     readonly api: APIMethods;
+    private lazyloadPlugins;
     private dependencies;
     private errorsDefinitions;
     private errorHandler;
@@ -69,9 +70,13 @@ export declare class Bot<Errors extends ErrorDefinitions = {}, Derives extends D
         [K in Update]: Awaited<ReturnType<Handler>>;
     }>;
     onStart(handler: Hooks.OnStart): this;
+    preRequest<Methods extends keyof APIMethods, Handler extends Hooks.PreRequest<Methods>>(methods: MaybeArray<Methods>, handler: Handler): this;
+    preRequest(handler: Hooks.PreRequest): this;
     on<T extends UpdateName>(updateName: MaybeArray<T>, handler: Handler<ContextType<typeof this, T> & Derives["global"] & Derives[T]>): this;
     use(handler: Handler<Context<typeof this> & Derives["global"]>): this;
-    extend<NewPlugin extends Plugin>(plugin: NewPlugin): Bot<Errors & NewPlugin["Errors"], Derives & NewPlugin["Derives"]>;
+    extend<NewPlugin extends Plugin>(plugin: MaybePromise<NewPlugin>): Bot<Errors & NewPlugin["Errors"], Derives & NewPlugin["Derives"]>;
+    hears<Ctx = ContextType<typeof this, "message"> & Derives["global"] & Derives["message"]>(trigger: RegExp | string | ((context: Ctx) => boolean), handler: (context: Ctx) => unknown): void;
+    command(command: string, handler: (context: ContextType<typeof this, "message"> & Derives["global"] & Derives["message"]) => unknown): void;
     start({ webhook, dropPendingUpdates, allowedUpdates, }?: {
         webhook?: Omit<APIMethodParams<"setWebhook">, "drop_pending_updates" | "allowed_updates">;
         dropPendingUpdates?: boolean;

package/dist/bot.js

@@ -37,7 +37,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Bot = void 0;
 const files_1 = require("@gramio/files");
 const format_1 = require("@gramio/format");
-const form_data_encoder_1 = require("form-data-encoder");
 const inspectable_1 = require("inspectable");
 const undici_1 = require("undici");
 const errors_1 = require("./errors");
@@ -64,6 +63,7 @@ let Bot = (() => {
         api = new Proxy({}, {
             get: (_target, method) => (args) => this._callApi(method, args),
         });
+        lazyloadPlugins = [];
         dependencies = [];
         errorsDefinitions = {
             TELEGRAM: errors_1.TelegramError,
@@ -79,20 +79,22 @@ let Bot = (() => {
         updates = new updates_1.Updates(this, this.errorHandler.bind(this));
         hooks = {
             preRequest: [
-                (ctx) => {
-                    if (!ctx.params)
-                        return ctx;
-                    const formattable = format_1.FormattableMap[ctx.method];
+                (context) => {
+                    if (!context.params)
+                        return context;
+                    const formattable = format_1.FormattableMap[context.method];
                     // @ts-ignore add AnyTelegramMethod to @gramio/format
                     if (formattable)
-                        ctx.params = formattable(ctx.params);
-                    return ctx;
+                        context.params = formattable(context.params);
+                    return context;
                 },
             ],
             onError: [],
             onStart: [],
         };
         constructor(token, options) {
+            if (!token || typeof token !== "string")
+                throw new Error(`Token is ${typeof token} but it should be a string!`);
             this.options = { ...options, token };
         }
         async runHooks(type, context) {
@@ -113,7 +115,6 @@ let Bot = (() => {
             const url = `https://api.telegram.org/bot${this.options.token}/${method}`;
             const reqOptions = {
                 method: "POST",
-                duplex: "half",
             };
             const context = await this.runHooks("preRequest", 
             // TODO: fix type error
@@ -126,9 +127,7 @@ let Bot = (() => {
             params = context.params;
             if (params && (0, files_1.isMediaUpload)(method, params)) {
                 const formData = await (0, files_1.convertJsonToFormData)(method, params);
-                const encoder = new form_data_encoder_1.FormDataEncoder(formData);
-                reqOptions.body = encoder.encode();
-                reqOptions.headers = encoder.headers;
+                reqOptions.body = formData;
             }
             else {
                 reqOptions.headers = {
@@ -136,8 +135,8 @@ let Bot = (() => {
                 };
                 reqOptions.body = JSON.stringify(params);
             }
-            const response = await (0, undici_1.fetch)(url, reqOptions);
-            const data = (await response.json());
+            const response = await (0, undici_1.request)(url, reqOptions);
+            const data = (await response.body.json());
             if (!data.ok)
                 throw new errors_1.TelegramError(data, method, params);
             return data.result;
@@ -214,6 +213,29 @@ let Bot = (() => {
             this.hooks.onStart.push(handler);
             return this;
         }
+        preRequest(methodsOrHandler, handler) {
+            if (typeof methodsOrHandler === "string" ||
+                Array.isArray(methodsOrHandler)) {
+                // TODO: error
+                if (!handler)
+                    throw new Error("TODO:");
+                const methods = typeof methodsOrHandler === "string"
+                    ? [methodsOrHandler]
+                    : methodsOrHandler;
+                // TODO: remove error
+                // @ts-expect-error
+                this.hooks.preRequest.push(async (context) => {
+                    // TODO: remove ts-ignore
+                    // @ts-expect-error
+                    if (methods.includes(context.method))
+                        return handler(context);
+                    return context;
+                });
+            }
+            else
+                this.hooks.preRequest.push(methodsOrHandler);
+            return this;
+        }
         on(updateName, handler) {
             this.updates.on(updateName, handler);
             return this;
@@ -223,6 +245,10 @@ let Bot = (() => {
             return this;
         }
         extend(plugin) {
+            if (plugin instanceof Promise) {
+                this.lazyloadPlugins.push(plugin);
+                return this;
+            }
             if (plugin.dependencies.some((dep) => !this.dependencies.includes(dep)))
                 throw new Error(`The «${plugin.name}» plugin needs dependencies registered before: ${plugin.dependencies
                     .filter((dep) => !this.dependencies.includes(dep))
@@ -241,8 +267,38 @@ let Bot = (() => {
             this.dependencies.push(plugin.name);
             return this;
         }
+        hears(trigger, handler) {
+            this.on("message", (context, next) => {
+                if ((typeof trigger === "string" && context.text === trigger) ||
+                    // @ts-expect-error
+                    (typeof trigger === "function" && trigger(context)) ||
+                    (trigger instanceof RegExp &&
+                        context.text &&
+                        trigger.test(context.text))) {
+                    // TODO: remove
+                    //@ts-expect-error
+                    return handler(context);
+                }
+                return next();
+            });
+        }
+        command(command, handler) {
+            this.on("message", (context, next) => {
+                if (context.entities?.some((entity) => {
+                    if (entity.type !== "bot_command" || entity.offset > 0)
+                        return false;
+                    const cmd = context.text
+                        ?.slice(1, entity.length)
+                        // biome-ignore lint/style/noNonNullAssertion: <explanation>
+                        ?.replace(`@${this.info.username}`, "");
+                    return cmd && cmd === command;
+                }))
+                    return handler(context);
+                return next();
+            });
+        }
         async start({ webhook, dropPendingUpdates, allowedUpdates, } = {}) {
-            //TODO: maybe it useless??
+            await Promise.all(this.lazyloadPlugins.map(async (plugin) => this.extend(await plugin)));
             this.info = await this.api.getMe();
             if (!webhook) {
                 await this.api.deleteWebhook({

package/dist/types.d.ts

@@ -14,17 +14,17 @@ interface ErrorHandlerParams<Ctx extends Context<BotLike>, Kind extends string,
 type AnyTelegramError = {
     [APIMethod in keyof APIMethods]: TelegramError<APIMethod>;
 }[keyof APIMethods];
-type AnyTelegramMethod = {
-    [APIMethod in keyof APIMethods]: {
+type AnyTelegramMethod<Methods extends keyof APIMethods> = {
+    [APIMethod in Methods]: {
         method: APIMethod;
         params: APIMethodParams<APIMethod>;
     };
-}[keyof APIMethods];
+}[Methods];
 export type MaybePromise<T> = Promise<T> | T;
 export declare namespace Hooks {
     type Derive<Ctx> = (context: Ctx) => MaybePromise<Record<string, unknown>>;
-    type PreRequestContext = AnyTelegramMethod;
-    type PreRequest = (ctx: PreRequestContext) => MaybePromise<PreRequestContext>;
+    type PreRequestContext<Methods extends keyof APIMethods> = AnyTelegramMethod<Methods>;
+    type PreRequest<Methods extends keyof APIMethods = keyof APIMethods> = (ctx: PreRequestContext<Methods>) => MaybePromise<PreRequestContext<Methods>>;
     type OnErrorContext<Ctx extends Context<BotLike>, T extends ErrorDefinitions> = ErrorHandlerParams<Ctx, "TELEGRAM", AnyTelegramError> | ErrorHandlerParams<Ctx, "UNKNOWN", Error> | {
         [K in keyof T]: ErrorHandlerParams<Ctx, K & string, T[K & string]>;
     }[keyof T];

package/dist/updates.js

@@ -32,7 +32,7 @@ class Updates {
         this.offset = data.update_id + 1;
         const UpdateContext = contexts_1.contextsMappings[updateType];
         if (!UpdateContext)
-            return;
+            throw new Error(updateType);
         try {
             let context = new UpdateContext({
                 bot: this.bot,
@@ -74,8 +74,8 @@ class Updates {
     async startFetchLoop(params = {}) {
         while (this.isStarted) {
             const updates = await this.bot.api.getUpdates({
-                offset: this.offset,
                 ...params,
+                offset: this.offset,
             });
             for await (const update of updates) {
                 //TODO: update errors

package/dist/webhook/adapters.d.ts

@@ -1,6 +1,7 @@
 import { TelegramUpdate } from "@gramio/types";
+import { MaybePromise } from "../types";
 export interface FrameworkHandler {
-    update: TelegramUpdate;
+    update: MaybePromise<TelegramUpdate>;
     header?: string;
 }
 export type FrameworkAdapter = (...args: any[]) => FrameworkHandler;
@@ -13,4 +14,12 @@ export declare const frameworks: {
         update: any;
         header: any;
     };
+    hono: (c: any) => {
+        update: any;
+        header: any;
+    };
+    express: (req: any) => {
+        update: any;
+        header: any;
+    };
 };

package/dist/webhook/adapters.js

@@ -11,4 +11,12 @@ exports.frameworks = {
         update: request.body,
         header: request.headers[SECRET_TOKEN_HEADER],
     }),
+    hono: (c) => ({
+        update: c.req.json(),
+        header: c.req.header(SECRET_TOKEN_HEADER)
+    }),
+    express: (req) => ({
+        update: req.body,
+        header: req.header(SECRET_TOKEN_HEADER)
+    })
 };

package/dist/webhook/index.js

@@ -6,7 +6,7 @@ function webhookHandler(bot, framework) {
     const frameworkAdapter = adapters_1.frameworks[framework];
     return async (...args) => {
         const { update } = frameworkAdapter(...args);
-        await bot.updates.handleUpdate(update);
+        await bot.updates.handleUpdate(await update);
     };
 }
 exports.webhookHandler = webhookHandler;

package/package.json

@@ -1,45 +1,44 @@
 {
-    "name": "gramio",
-    "version": "0.0.18",
-    "description": "Powerful Telegram Bot API framework",
-    "main": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "keywords": [
-        "telegram",
-        "telegram-bot",
-        "telegram-bot-api",
-        "bot",
-        "framework",
-        "types",
-        "client",
-        "webhook",
-        "long-polling"
-    ],
-    "scripts": {
-        "type": "tsc --noEmit",
-        "lint": "bun check ./src",
-        "lint:fix": "bun lint --apply",
-        "prepublishOnly": "tsc && bunx tsc-alias"
-    },
-    "author": "kravets",
-    "license": "ISC",
-    "devDependencies": {
-        "@biomejs/biome": "1.5.3",
-        "@gramio/types": "^7.1.4",
-        "@types/node": "^20.11.20",
-        "typescript": "^5.3.3"
-    },
-    "dependencies": {
-        "@gramio/contexts": "^0.0.6",
-        "@gramio/files": "^0.0.3",
-        "@gramio/format": "^0.0.8",
-        "@gramio/keyboards": "^0.2.0",
-        "form-data-encoder": "^4.0.2",
-        "inspectable": "^3.0.0",
-        "middleware-io": "^2.8.1",
-        "undici": "^6.6.2"
-    },
-    "files": [
-        "dist"
-    ]
+  "name": "gramio",
+  "version": "0.0.20",
+  "description": "Powerful Telegram Bot API framework",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "keywords": [
+    "telegram",
+    "telegram-bot",
+    "telegram-bot-api",
+    "bot",
+    "framework",
+    "types",
+    "client",
+    "webhook",
+    "long-polling"
+  ],
+  "scripts": {
+    "type": "tsc --noEmit",
+    "lint": "bun check ./src",
+    "lint:fix": "bun lint --apply",
+    "prepublishOnly": "tsc && bunx tsc-alias"
+  },
+  "author": "kravets",
+  "license": "ISC",
+  "devDependencies": {
+    "@biomejs/biome": "1.5.3",
+    "@gramio/types": "^7.1.6",
+    "@types/node": "^20.11.25",
+    "typescript": "^5.4.2"
+  },
+  "dependencies": {
+    "@gramio/contexts": "^0.0.7",
+    "@gramio/files": "^0.0.3",
+    "@gramio/format": "^0.0.8",
+    "@gramio/keyboards": "^0.2.0",
+    "inspectable": "^3.0.0",
+    "middleware-io": "^2.8.1",
+    "undici": "^6.7.1"
+  },
+  "files": [
+    "dist"
+  ]
 }