gramio 0.0.24 → 0.0.26

package/README.md

@@ -1,7 +1,7 @@
 # GramIO
 
-Work in progress
+Work in progress.
 
-Currently support Bot API 7.1
+Currently support Bot API 7.2
 
 See [Documentation](https://gramio.netlify.app/)

package/dist/bot.d.ts

@@ -72,8 +72,13 @@ export declare class Bot<Errors extends ErrorDefinitions = {}, Derives extends D
         [K in Update]: Awaited<ReturnType<Handler>>;
     }>;
     onStart(handler: Hooks.OnStart): this;
+    onStop(handler: Hooks.OnStop): this;
     preRequest<Methods extends keyof APIMethods, Handler extends Hooks.PreRequest<Methods>>(methods: MaybeArray<Methods>, handler: Handler): this;
     preRequest(handler: Hooks.PreRequest): this;
+    onResponse<Methods extends keyof APIMethods, Handler extends Hooks.OnResponse<Methods>>(methods: MaybeArray<Methods>, handler: Handler): this;
+    onResponse(handler: Hooks.OnResponse): this;
+    onResponseError<Methods extends keyof APIMethods, Handler extends Hooks.OnResponseError<Methods>>(methods: MaybeArray<Methods>, handler: Handler): this;
+    onResponseError(handler: Hooks.OnResponseError): 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<any, any>>(plugin: MaybePromise<NewPlugin>): Bot<Errors & NewPlugin["Errors"], Derives & NewPlugin["Derives"]>;

package/dist/bot.js

@@ -82,6 +82,8 @@ let Bot = (() => {
         updates = new updates_1.Updates(this, this.errorHandler.bind(this));
         hooks = {
             preRequest: [],
+            onResponse: [],
+            onResponseError: [],
             onError: [],
             onStart: [],
             onStop: [],
@@ -110,11 +112,11 @@ let Bot = (() => {
             }
             return data;
         }
-        async runImmutableHooks(type, context) {
+        async runImmutableHooks(type, ...context) {
             for await (const hook of this.hooks[type]) {
                 //TODO: solve that later
                 //@ts-expect-error
-                await hook(context);
+                await hook(...context);
             }
         }
         async _callApi(method, params = {}) {
@@ -143,8 +145,20 @@ let Bot = (() => {
             }
             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);
+            if (!data.ok) {
+                const err = new errors_1.TelegramError(data, method, params);
+                // @ts-expect-error
+                this.runImmutableHooks("onResponseError", err, this.api);
+                throw err;
+            }
+            this.runImmutableHooks("onResponse", 
+            // TODO: fix type error
+            // @ts-expect-error
+            {
+                method,
+                params,
+                response: data.result,
+            });
             return data.result;
         }
         /**
@@ -219,6 +233,10 @@ let Bot = (() => {
             this.hooks.onStart.push(handler);
             return this;
         }
+        onStop(handler) {
+            this.hooks.onStop.push(handler);
+            return this;
+        }
         preRequest(methodsOrHandler, handler) {
             if (typeof methodsOrHandler === "string" ||
                 Array.isArray(methodsOrHandler)) {
@@ -242,6 +260,48 @@ let Bot = (() => {
                 this.hooks.preRequest.push(methodsOrHandler);
             return this;
         }
+        onResponse(methodsOrHandler, handler) {
+            if (typeof methodsOrHandler === "string" ||
+                Array.isArray(methodsOrHandler)) {
+                // TODO: error
+                if (!handler)
+                    throw new Error("TODO:");
+                const methods = typeof methodsOrHandler === "string"
+                    ? [methodsOrHandler]
+                    : methodsOrHandler;
+                this.hooks.onResponse.push(async (context) => {
+                    // TODO: remove ts-ignore
+                    // @ts-expect-error
+                    if (methods.includes(context.method))
+                        return handler(context);
+                    return context;
+                });
+            }
+            else
+                this.hooks.onResponse.push(methodsOrHandler);
+            return this;
+        }
+        onResponseError(methodsOrHandler, handler) {
+            if (typeof methodsOrHandler === "string" ||
+                Array.isArray(methodsOrHandler)) {
+                // TODO: error
+                if (!handler)
+                    throw new Error("TODO:");
+                const methods = typeof methodsOrHandler === "string"
+                    ? [methodsOrHandler]
+                    : methodsOrHandler;
+                this.hooks.onResponseError.push(async (context) => {
+                    // TODO: remove ts-ignore
+                    // @ts-expect-error
+                    if (methods.includes(context.method))
+                        return handler(context);
+                    return context;
+                });
+            }
+            else
+                this.hooks.onResponseError.push(methodsOrHandler);
+            return this;
+        }
         on(updateName, handler) {
             this.updates.on(updateName, handler);
             return this;
@@ -277,6 +337,20 @@ let Bot = (() => {
                 else
                     this.preRequest(updateName, preRequest);
             }
+            for (const value of plugin.onResponses) {
+                const [onResponse, updateName] = value;
+                if (!updateName)
+                    this.onResponse(onResponse);
+                else
+                    this.onResponse(updateName, onResponse);
+            }
+            for (const value of plugin.onResponseErrors) {
+                const [onResponseError, updateName] = value;
+                if (!updateName)
+                    this.onResponseError(onResponseError);
+                else
+                    this.onResponseError(updateName, onResponseError);
+            }
             for (const handler of plugin.groups) {
                 this.group(handler);
             }
@@ -323,7 +397,7 @@ let Bot = (() => {
             });
         }
         hears(trigger, handler) {
-            return this.on("message", (context, next) => {
+            return this.on(["message", "business_message"], (context, next) => {
                 if ((typeof trigger === "string" && context.text === trigger) ||
                     // @ts-expect-error
                     (typeof trigger === "function" && trigger(context)) ||
@@ -343,7 +417,7 @@ let Bot = (() => {
         command(command, handler, options) {
             if (command.startsWith("/"))
                 throw new Error("Do not use / in command name");
-            return this.on("message", (context, next) => {
+            return this.on(["message", "business_message"], (context, next) => {
                 // TODO: change to find
                 if (context.entities?.some((entity) => {
                     if (entity.type !== "bot_command" || entity.offset > 0)

package/dist/plugin.d.ts

@@ -10,6 +10,14 @@ export declare class Plugin<Errors extends ErrorDefinitions = {}, Derives extend
         Hooks.PreRequest<any>,
         MaybeArray<keyof APIMethods> | undefined
     ][];
+    onResponses: [
+        Hooks.OnResponse<any>,
+        MaybeArray<keyof APIMethods> | undefined
+    ][];
+    onResponseErrors: [
+        Hooks.OnResponseError<any>,
+        MaybeArray<keyof APIMethods> | undefined
+    ][];
     groups: ((bot: Bot<any, any>) => Bot<any, any>)[];
     name: string;
     errorsDefinitions: Record<string, {
@@ -37,4 +45,8 @@ 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;
+    onResponse<Methods extends keyof APIMethods, Handler extends Hooks.OnResponse<Methods>>(methods: MaybeArray<Methods>, handler: Handler): this;
+    onResponse(handler: Hooks.OnResponse): this;
+    onResponseError<Methods extends keyof APIMethods, Handler extends Hooks.OnResponseError<Methods>>(methods: MaybeArray<Methods>, handler: Handler): this;
+    onResponseError(handler: Hooks.OnResponseError): this;
 }

package/dist/plugin.js

@@ -61,6 +61,8 @@ let Plugin = (() => {
         Derives;
         derives = [];
         preRequests = [];
+        onResponses = [];
+        onResponseErrors = [];
         groups = [];
         name;
         errorsDefinitions = {};
@@ -102,6 +104,24 @@ let Plugin = (() => {
                 this.preRequests.push([methodsOrHandler, undefined]);
             return this;
         }
+        onResponse(methodsOrHandler, handler) {
+            if ((typeof methodsOrHandler === "string" ||
+                Array.isArray(methodsOrHandler)) &&
+                handler)
+                this.onResponses.push([handler, methodsOrHandler]);
+            else if (typeof methodsOrHandler === "function")
+                this.onResponses.push([methodsOrHandler, undefined]);
+            return this;
+        }
+        onResponseError(methodsOrHandler, handler) {
+            if ((typeof methodsOrHandler === "string" ||
+                Array.isArray(methodsOrHandler)) &&
+                handler)
+                this.onResponseErrors.push([handler, methodsOrHandler]);
+            else if (typeof methodsOrHandler === "function")
+                this.onResponseErrors.push([methodsOrHandler, undefined]);
+            return this;
+        }
     };
     return Plugin = _classThis;
 })();

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import type { BotLike, Context, UpdateName } from "@gramio/contexts";
-import type { APIMethodParams, APIMethods, TelegramUser } from "@gramio/types";
+import type { APIMethodParams, APIMethodReturn, APIMethods, TelegramUser } from "@gramio/types";
 import type { NextMiddleware } from "middleware-io";
 import type { TelegramError } from "./errors";
 export interface BotOptions {
@@ -14,15 +14,22 @@ interface ErrorHandlerParams<Ctx extends Context<BotLike>, Kind extends string,
     kind: Kind;
     error: Err;
 }
-type AnyTelegramError = {
-    [APIMethod in keyof APIMethods]: TelegramError<APIMethod>;
-}[keyof APIMethods];
+type AnyTelegramError<Methods extends keyof APIMethods = keyof APIMethods> = {
+    [APIMethod in Methods]: TelegramError<APIMethod>;
+}[Methods];
 type AnyTelegramMethod<Methods extends keyof APIMethods> = {
     [APIMethod in Methods]: {
         method: APIMethod;
         params: APIMethodParams<APIMethod>;
     };
 }[Methods];
+type AnyTelegramMethodWithReturn<Methods extends keyof APIMethods> = {
+    [APIMethod in Methods]: {
+        method: APIMethod;
+        params: APIMethodParams<APIMethod>;
+        response: APIMethodReturn<APIMethod>;
+    };
+}[Methods];
 export type MaybePromise<T> = Promise<T> | T;
 export declare namespace Hooks {
     type Derive<Ctx> = (context: Ctx) => MaybePromise<Record<string, unknown>>;
@@ -41,8 +48,12 @@ export declare namespace Hooks {
         plugins: string[];
         info: TelegramUser;
     }) => unknown;
+    type OnResponseError<Methods extends keyof APIMethods = keyof APIMethods> = (context: AnyTelegramError<Methods>, api: BotLike["api"]) => unknown;
+    type OnResponse<Methods extends keyof APIMethods = keyof APIMethods> = (context: AnyTelegramMethodWithReturn<Methods>) => unknown;
     interface Store<T extends ErrorDefinitions> {
         preRequest: PreRequest[];
+        onResponse: OnResponse[];
+        onResponseError: OnResponseError[];
         onError: OnError<T>[];
         onStart: OnStart[];
         onStop: OnStop[];

package/dist/updates.js

@@ -37,20 +37,20 @@ class Updates {
             let context = new UpdateContext({
                 bot: this.bot,
                 update: data,
-                //@ts-expect-error
                 payload: data[updateType],
                 type: updateType,
                 updateId: data.update_id,
             });
             if ("isEvent" in context && context.isEvent() && context.eventType) {
+                // @ts-expect-error contextsMappings is any
                 context = new contexts_1.contextsMappings[context.eventType]({
                     bot: this.bot,
                     update: data,
-                    //@ts-expect-error
                     payload: data.message ??
                         data.edited_message ??
                         data.channel_post ??
-                        data.edited_channel_post,
+                        data.edited_channel_post ??
+                        data.business_message,
                     type: context.eventType,
                     updateId: data.update_id,
                 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gramio",
-  "version": "0.0.24",
+  "version": "0.0.26",
   "description": "Powerful Telegram Bot API framework",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -24,20 +24,20 @@
   "author": "kravets",
   "license": "ISC",
   "devDependencies": {
-    "@biomejs/biome": "1.6.2",
-    "@gramio/types": "^7.1.7",
-    "@types/node": "^20.11.30",
+    "@biomejs/biome": "1.6.4",
+    "@types/node": "^20.12.4",
     "typescript": "^5.4.3"
   },
   "dependencies": {
     "@gramio/callback-data": "^0.0.2",
-    "@gramio/contexts": "^0.0.7",
-    "@gramio/files": "^0.0.3",
+    "@gramio/contexts": "^0.0.8",
+    "@gramio/files": "^0.0.4",
     "@gramio/format": "^0.0.8",
-    "@gramio/keyboards": "^0.2.2",
+    "@gramio/keyboards": "^0.2.3",
+    "@gramio/types": "^7.2.1",
     "inspectable": "^3.0.0",
     "middleware-io": "^2.8.1",
-    "undici": "^6.10.1"
+    "undici": "^6.11.1"
   },
   "files": [
     "dist"