gramio 0.0.23 → 0.0.25

package/dist/bot.d.ts

@@ -72,14 +72,19 @@ 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"]>;
     reaction(trigger: MaybeArray<TelegramReactionTypeEmojiEmoji>, handler: (context: ContextType<typeof this, "message_reaction"> & Derives["global"] & Derives["message_reaction"]) => unknown): this;
     callbackQuery<Trigger extends CallbackData | string | RegExp>(trigger: Trigger, handler: (context: Omit<ContextType<typeof this, "callback_query">, "data"> & Derives["global"] & Derives["callback_query"] & {
-        data: Trigger extends CallbackData ? ReturnType<Trigger["unpack"]> : RegExpMatchArray | null;
+        queryData: Trigger extends CallbackData ? ReturnType<Trigger["unpack"]> : RegExpMatchArray | null;
     }) => unknown): this;
     hears<Ctx = ContextType<typeof this, "message"> & Derives["global"] & Derives["message"]>(trigger: RegExp | string | ((context: Ctx) => boolean), handler: (context: Ctx & {
         args: RegExpMatchArray | null;
@@ -89,9 +94,12 @@ export declare class Bot<Errors extends ErrorDefinitions = {}, Derives extends D
     }) => unknown, options?: Omit<SetMyCommandsParams, "commands"> & Omit<TelegramBotCommand, "command">): this;
     /** Currently not isolated!!! */
     group(grouped: (bot: typeof this) => Bot<any, any>): Bot<any, any>;
+    init(): Promise<void>;
     start({ webhook, dropPendingUpdates, allowedUpdates, }?: {
         webhook?: Omit<APIMethodParams<"setWebhook">, "drop_pending_updates" | "allowed_updates">;
         dropPendingUpdates?: boolean;
         allowedUpdates?: NonNullable<APIMethodParams<"getUpdates">>["allowed_updates"];
-    }): Promise<TelegramUser>;
+    }): Promise<TelegramUser | undefined>;
+    /** Currently does not implement graceful shutdown */
+    stop(): Promise<void>;
 }

package/dist/bot.js

@@ -82,8 +82,11 @@ let Bot = (() => {
         updates = new updates_1.Updates(this, this.errorHandler.bind(this));
         hooks = {
             preRequest: [],
+            onResponse: [],
+            onResponseError: [],
             onError: [],
             onStart: [],
+            onStop: [],
         };
         constructor(token, options) {
             if (!token || typeof token !== "string")
@@ -109,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 = {}) {
@@ -142,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;
         }
         /**
@@ -218,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)) {
@@ -241,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;
@@ -276,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);
             }
@@ -316,7 +391,7 @@ let Bot = (() => {
                 if (trigger instanceof RegExp && !trigger.test(context.data))
                     return next();
                 // @ts-expect-error
-                context.data = trigger.unpack(context.data);
+                context.queryData = trigger.unpack(context.data);
                 //@ts-expect-error
                 return handler(context);
             });
@@ -364,9 +439,12 @@ let Bot = (() => {
         group(grouped) {
             return grouped(this);
         }
-        async start({ webhook, dropPendingUpdates, allowedUpdates, } = {}) {
+        async init() {
             await Promise.all(this.lazyloadPlugins.map(async (plugin) => this.extend(await plugin)));
             this.info = await this.api.getMe();
+        }
+        async start({ webhook, dropPendingUpdates, allowedUpdates, } = {}) {
+            await this.init();
             if (!webhook) {
                 await this.api.deleteWebhook({
                     drop_pending_updates: dropPendingUpdates,
@@ -376,6 +454,7 @@ let Bot = (() => {
                 });
                 this.runImmutableHooks("onStart", {
                     plugins: this.dependencies,
+                    // biome-ignore lint/style/noNonNullAssertion: bot.init() guarantees this.info
                     info: this.info,
                     updatesFrom: "long-polling",
                 });
@@ -390,11 +469,24 @@ let Bot = (() => {
             });
             this.runImmutableHooks("onStart", {
                 plugins: this.dependencies,
+                // biome-ignore lint/style/noNonNullAssertion: bot.init() guarantees this.info
                 info: this.info,
                 updatesFrom: "webhook",
             });
             return this.info;
         }
+        /** Currently does not implement graceful shutdown */
+        async stop() {
+            if (this.updates.isStarted)
+                this.updates.stopPolling();
+            else
+                await this.api.deleteWebhook();
+            await this.runImmutableHooks("onStop", {
+                plugins: this.dependencies,
+                // biome-ignore lint/style/noNonNullAssertion: bot.init() guarantees this.info
+                info: this.info,
+            });
+        }
     };
     return Bot = _classThis;
 })();

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>>;
@@ -37,10 +44,19 @@ export declare namespace Hooks {
         info: TelegramUser;
         updatesFrom: "webhook" | "long-polling";
     }) => unknown;
+    type OnStop = (context: {
+        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[];
     }
 }
 export type ErrorDefinitions = Record<string, Error>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gramio",
-  "version": "0.0.23",
+  "version": "0.0.25",
   "description": "Powerful Telegram Bot API framework",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -30,7 +30,7 @@
     "typescript": "^5.4.3"
   },
   "dependencies": {
-    "@gramio/callback-data": "^0.0.1",
+    "@gramio/callback-data": "^0.0.2",
     "@gramio/contexts": "^0.0.7",
     "@gramio/files": "^0.0.3",
     "@gramio/format": "^0.0.8",